gdb/make-target-delegates.py - binutils-gdb - Git at Google


            
            #!/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)
	#!/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"\sTARGET_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)