123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340 |
- #!/usr/bin/env python3
- # Copyright (C) 2013-2022 Free Software Foundation, Inc.
- #
- # This file is part of GDB.
- #
- # This program is free software; you can redistribute it and/or modify
- # it under the terms of the GNU General Public License as published by
- # the Free Software Foundation; either version 3 of the License, or
- # (at your option) any later version.
- #
- # This program is distributed in the hope that it will be useful,
- # but WITHOUT ANY WARRANTY; without even the implied warranty of
- # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- # GNU General Public License for more details.
- #
- # You should have received a copy of the GNU General Public License
- # along with this program. If not, see <http://www.gnu.org/licenses/>.
- # Usage:
- # make-target-delegates.py
- import re
- import gdbcopyright
- # The line we search for in target.h that marks where we should start
- # looking for methods.
- TRIGGER = re.compile(r"^struct target_ops$")
- # The end of the methods part.
- ENDER = re.compile(r"^\s*};$")
- # Match a C symbol.
- SYMBOL = "[a-zA-Z_][a-zA-Z0-9_]*"
- # Match the name part of a method in struct target_ops.
- NAME_PART = r"(?P<name>" + SYMBOL + ")\s"
- # Match the arguments to a method.
- ARGS_PART = r"(?P<args>\(.*\))"
- # We strip the indentation so here we only need the caret.
- INTRO_PART = r"^"
- POINTER_PART = r"\s*(\*)?\s*"
- # Match a C++ symbol, including scope operators and template
- # parameters. E.g., 'std::vector<something>'.
- CP_SYMBOL = r"[a-zA-Z_][a-zA-Z0-9_<>:]*"
- # Match the return type when it is "ordinary".
- SIMPLE_RETURN_PART = r"((struct|class|enum|union)\s+)?" + CP_SYMBOL
- # Match a return type.
- RETURN_PART = r"((const|volatile)\s+)?(" + SIMPLE_RETURN_PART + ")" + POINTER_PART
- # Match "virtual".
- VIRTUAL_PART = r"virtual\s"
- # Match the TARGET_DEFAULT_* attribute for a method.
- TARGET_DEFAULT_PART = r"TARGET_DEFAULT_(?P<style>[A-Z_]+)\s*\((?P<default_arg>.*)\)"
- # Match the arguments and trailing attribute of a method definition.
- # Note we don't match the trailing ";".
- METHOD_TRAILER = r"\s*" + TARGET_DEFAULT_PART + "$"
- # Match an entire method definition.
- METHOD = re.compile(
- INTRO_PART
- + VIRTUAL_PART
- + "(?P<return_type>"
- + RETURN_PART
- + ")"
- + NAME_PART
- + ARGS_PART
- + METHOD_TRAILER
- )
- # Regular expression used to dissect argument types.
- ARGTYPES = re.compile(
- "^("
- + r"(?P<E>enum\s+"
- + SYMBOL
- + r"\s*)("
- + SYMBOL
- + ")?"
- + r"|(?P<T>.*(enum\s+)?"
- + SYMBOL
- + r".*(\s|\*|&))"
- + SYMBOL
- + ")$"
- )
- # Match TARGET_DEBUG_PRINTER in an argument type.
- # This must match the whole "sub-expression" including the parens.
- TARGET_DEBUG_PRINTER = r"\s*TARGET_DEBUG_PRINTER\s*\((?P<arg>[^)]*)\)\s*"
- def scan_target_h():
- found_trigger = False
- all_the_text = ""
- with open("target.h", "r") as target_h:
- for line in target_h:
- line = line.strip()
- if not found_trigger:
- if TRIGGER.match(line):
- found_trigger = True
- elif "{" in line:
- # Skip the open brace.
- pass
- elif ENDER.match(line):
- break
- else:
- # Strip // comments.
- line = re.split("//", line)[0]
- all_the_text = all_the_text + " " + line
- if not found_trigger:
- raise "Could not find trigger line"
- # Now strip out the C comments.
- all_the_text = re.sub(r"/\*(.*?)\*/", "", all_the_text)
- # Replace sequences whitespace with a single space character.
- # We need the space because the method may have been split
- # between multiple lines, like e.g.:
- #
- # virtual std::vector<long_type_name>
- # my_long_method_name ()
- # TARGET_DEFAULT_IGNORE ();
- #
- # If we didn't preserve the space, then we'd end up with:
- #
- # virtual std::vector<long_type_name>my_long_method_name ()TARGET_DEFAULT_IGNORE ()
- #
- # ... which wouldn't later be parsed correctly.
- all_the_text = re.sub(r"\s+", " ", all_the_text)
- return all_the_text.split(";")
- # Parse arguments into a list.
- def parse_argtypes(typestr):
- # Remove the outer parens.
- typestr = re.sub(r"^\((.*)\)$", r"\1", typestr)
- result = []
- for item in re.split(r",\s*", typestr):
- if item == "void" or item == "":
- continue
- m = ARGTYPES.match(item)
- if m:
- if m.group("E"):
- onetype = m.group("E")
- else:
- onetype = m.group("T")
- else:
- onetype = item
- result.append(onetype.strip())
- return result
- # Write function header given name, return type, and argtypes.
- # Returns a list of actual argument names.
- def write_function_header(f, decl, name, return_type, argtypes):
- print(return_type, file=f, end="")
- if decl:
- if not return_type.endswith("*"):
- print(" ", file=f, end="")
- else:
- print("", file=f)
- print(name + " (", file=f, end="")
- argdecls = []
- actuals = []
- for i in range(len(argtypes)):
- val = re.sub(TARGET_DEBUG_PRINTER, "", argtypes[i])
- if not val.endswith("*") and not val.endswith("&"):
- val = val + " "
- vname = "arg" + str(i)
- val = val + vname
- argdecls.append(val)
- actuals.append(vname)
- print(", ".join(argdecls) + ")", file=f, end="")
- if decl:
- print(" override;", file=f)
- else:
- print("\n{", file=f)
- return actuals
- # Write out a declaration.
- def write_declaration(f, name, return_type, argtypes):
- write_function_header(f, True, name, return_type, argtypes)
- # Write out a delegation function.
- def write_delegator(f, name, return_type, argtypes):
- names = write_function_header(
- f, False, "target_ops::" + name, return_type, argtypes
- )
- print(" ", file=f, end="")
- if return_type != "void":
- print("return ", file=f, end="")
- print("this->beneath ()->" + name + " (", file=f, end="")
- print(", ".join(names), file=f, end="")
- print(");", file=f)
- print("}\n", file=f)
- # Write out a default function.
- def write_tdefault(f, content, style, name, return_type, argtypes):
- name = "dummy_target::" + name
- names = write_function_header(f, False, name, return_type, argtypes)
- if style == "FUNC":
- print(" ", file=f, end="")
- if return_type != "void":
- print("return ", file=f, end="")
- print(content + " (", file=f, end="")
- names.insert(0, "this")
- print(", ".join(names) + ");", file=f)
- elif style == "RETURN":
- print(" return " + content + ";", file=f)
- elif style == "NORETURN":
- print(" " + content + ";", file=f)
- elif style == "IGNORE":
- # Nothing.
- pass
- else:
- raise "unrecognized style: " + style
- print("}\n", file=f)
- def munge_type(typename):
- m = re.search(TARGET_DEBUG_PRINTER, typename)
- if m:
- return m.group("arg")
- typename = typename.rstrip()
- typename = re.sub("[ ()<>:]", "_", typename)
- typename = re.sub("[*]", "p", typename)
- typename = re.sub("&", "r", typename)
- # Identifers with double underscores are reserved to the C++
- # implementation.
- typename = re.sub("_+", "_", typename)
- # Avoid ending the function name with underscore, for
- # cosmetics. Trailing underscores appear after munging types
- # with template parameters, like e.g. "foo<int>".
- typename = re.sub("_+$", "", typename)
- return "target_debug_print_" + typename
- # Write out a debug method.
- def write_debugmethod(f, content, name, return_type, argtypes):
- debugname = "debug_target::" + name
- names = write_function_header(f, False, debugname, return_type, argtypes)
- if return_type != "void":
- print(" " + return_type + " result;", file=f)
- print(
- ' gdb_printf (gdb_stdlog, "-> %s->'
- + name
- + ' (...)\\n", this->beneath ()->shortname ());',
- file=f,
- )
- # Delegate to the beneath target.
- print(" ", file=f, end="")
- if return_type != "void":
- print("result = ", file=f, end="")
- print("this->beneath ()->" + name + " (", file=f, end="")
- print(", ".join(names), file=f, end="")
- print(");", file=f)
- # Now print the arguments.
- print(
- ' gdb_printf (gdb_stdlog, "<- %s->'
- + name
- + ' (", this->beneath ()->shortname ());',
- file=f,
- )
- for i in range(len(argtypes)):
- if i > 0:
- print(' gdb_puts (", ", gdb_stdlog);', file=f)
- printer = munge_type(argtypes[i])
- print(" " + printer + " (" + names[i] + ");", file=f)
- if return_type != "void":
- print(' gdb_puts (") = ", gdb_stdlog);', file=f)
- printer = munge_type(return_type)
- print(" " + printer + " (result);", file=f)
- print(' gdb_puts ("\\n", gdb_stdlog);', file=f)
- else:
- print(' gdb_puts (")\\n", gdb_stdlog);', file=f)
- if return_type != "void":
- print(" return result;", file=f)
- print("}\n", file=f)
- def print_class(f, class_name, delegators, entries):
- print("struct " + class_name + " : public target_ops", file=f)
- print("{", file=f)
- print(" const target_info &info () const override;", file=f)
- print("", file=f)
- print(" strata stratum () const override;", file=f)
- print("", file=f)
- for name in delegators:
- return_type = entries[name]["return_type"]
- argtypes = entries[name]["argtypes"]
- print(" ", file=f, end="")
- write_declaration(f, name, return_type, argtypes)
- print("};\n", file=f)
- delegators = []
- entries = {}
- for current_line in scan_target_h():
- # See comments in scan_target_h. Here we strip away the leading
- # and trailing whitespace.
- current_line = current_line.strip()
- m = METHOD.match(current_line)
- if not m:
- continue
- data = m.groupdict()
- data["argtypes"] = parse_argtypes(data["args"])
- data["return_type"] = data["return_type"].strip()
- entries[data["name"]] = data
- delegators.append(data["name"])
- with open("target-delegates.c", "w") as f:
- print(
- gdbcopyright.copyright(
- "make-target-delegates.py", "Boilerplate target methods for GDB"
- ),
- file=f,
- )
- print_class(f, "dummy_target", delegators, entries)
- print_class(f, "debug_target", delegators, entries)
- for name in delegators:
- tdefault = entries[name]["default_arg"]
- return_type = entries[name]["return_type"]
- style = entries[name]["style"]
- argtypes = entries[name]["argtypes"]
- write_delegator(f, name, return_type, argtypes)
- write_tdefault(f, tdefault, style, name, return_type, argtypes)
- write_debugmethod(f, tdefault, name, return_type, argtypes)
|