build_tools/sim_object_param_struct_hh.py - public/gem5 - Git at Google

 # Copyright 2004-2006 The Regents of The University of Michigan
 # Copyright 2010-20013 Advanced Micro Devices, Inc.
 # Copyright 2013 Mark D. Hill and David A. Wood
 # Copyright 2017-2020 ARM Limited
 # Copyright 2021 Google, Inc.
 #
 # The license below extends only to copyright in the software and shall
 # not be construed as granting a license to any other intellectual
 # property including but not limited to intellectual property relating
 # to a hardware implementation of the functionality of the software
 # licensed hereunder.  You may use the software subject to the license
 # terms below provided that you ensure that this notice is replicated
 # unmodified and in its entirety in all distributions of the software,
 # modified or unmodified, in source code or in binary form.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met: redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer;
 # redistributions in binary form must reproduce the above copyright
 # notice, this list of conditions and the following disclaimer in the
 # documentation and/or other materials provided with the distribution;
 # neither the name of the copyright holders nor the names of its
 # contributors may be used to endorse or promote products derived from
 # this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 import argparse
 import importlib
 import os.path
 import sys

 import importer

 from code_formatter import code_formatter

 parser = argparse.ArgumentParser()
 parser.add_argument("modpath", help="module the simobject belongs to")
 parser.add_argument("param_hh", help="parameter header file to generate")

 args = parser.parse_args()

 basename = os.path.basename(args.param_hh)
 sim_object_name = os.path.splitext(basename)[0]

 importer.install()
 module = importlib.import_module(args.modpath)
 sim_object = getattr(module, sim_object_name)

 from m5.objects.SimObject import SimObject
 from m5.params import Enum

 code = code_formatter()

 # The 'local' attribute restricts us to the params declared in
 # the object itself, not including inherited params (which
 # will also be inherited from the base class's param struct
 # here). Sort the params based on their key
 params = list(
     map(lambda k_v: k_v[1], sorted(sim_object._params.local.items()))
 )
 ports = sim_object._ports.local
 try:
     ptypes = [p.ptype for p in params]
 except:
     print(sim_object)
     print(params)
     raise

 warned_about_nested_templates = False


 class CxxClass(object):
     def __init__(self, sig, template_params=[]):
         # Split the signature into its constituent parts. This could
         # potentially be done with regular expressions, but
         # it's simple enough to pick appart a class signature
         # manually.
         parts = sig.split("<", 1)
         base = parts[0]
         t_args = []
         if len(parts) > 1:
             # The signature had template arguments.
             text = parts[1].rstrip(" \t\n>")
             arg = ""
             # Keep track of nesting to avoid splitting on ","s embedded
             # in the arguments themselves.
             depth = 0
             for c in text:
                 if c == "<":
                     depth = depth + 1
                     if depth > 0 and not warned_about_nested_templates:
                         warned_about_nested_templates = True
                         print(
                             "Nested template argument in cxx_class."
                             " This feature is largely untested and "
                             " may not work."
                         )
                 elif c == ">":
                     depth = depth - 1
                 elif c == "," and depth == 0:
                     t_args.append(arg.strip())
                     arg = ""
                 else:
                     arg = arg + c
             if arg:
                 t_args.append(arg.strip())
         # Split the non-template part on :: boundaries.
         class_path = base.split("::")

         # The namespaces are everything except the last part of the class path.
         self.namespaces = class_path[:-1]
         # And the class name is the last part.
         self.name = class_path[-1]

         self.template_params = template_params
         self.template_arguments = []
         # Iterate through the template arguments and their values. This
         # will likely break if parameter packs are used.
         for arg, param in zip(t_args, template_params):
             type_keys = ("class", "typename")
             # If a parameter is a type, parse it recursively. Otherwise
             # assume it's a constant, and store it verbatim.
             if any(param.strip().startswith(kw) for kw in type_keys):
                 self.template_arguments.append(CxxClass(arg))
             else:
                 self.template_arguments.append(arg)

     def declare(self, code):
         # First declare any template argument types.
         for arg in self.template_arguments:
             if isinstance(arg, CxxClass):
                 arg.declare(code)
         # Re-open the target namespace.
         for ns in self.namespaces:
             code("namespace $ns {")
         # If this is a class template...
         if self.template_params:
             code('template <${{", ".join(self.template_params)}}>')
         # The actual class declaration.
         code("class ${{self.name}};")
         # Close the target namespaces.
         for ns in reversed(self.namespaces):
             code("} // namespace $ns")


 code(
     """\
 #ifndef __PARAMS__${sim_object}__
 #define __PARAMS__${sim_object}__

 """
 )


 # The base SimObject has a couple of params that get
 # automatically set from Python without being declared through
 # the normal Param mechanism; we slip them in here (needed
 # predecls now, actual declarations below)
 if sim_object == SimObject:
     code("""#include <string>""")

 cxx_class = CxxClass(
     sim_object._value_dict["cxx_class"],
     sim_object._value_dict["cxx_template_params"],
 )

 # A forward class declaration is sufficient since we are just
 # declaring a pointer.
 cxx_class.declare(code)

 for param in params:
     param.cxx_predecls(code)
 for port in ports.values():
     port.cxx_predecls(code)
 code()

 if sim_object._base:
     code('#include "params/${{sim_object._base.type}}.hh"')
     code()

 for ptype in ptypes:
     if issubclass(ptype, Enum):
         code('#include "enums/${{ptype.__name__}}.hh"')
         code()

 code("namespace gem5")
 code("{")
 code("")

 # now generate the actual param struct
 code("struct ${sim_object}Params")
 if sim_object._base:
     code("    : public ${{sim_object._base.type}}Params")
 code("{")
 if not hasattr(sim_object, "abstract") or not sim_object.abstract:
     if "type" in sim_object.__dict__:
         code("    ${{sim_object.cxx_type}} create() const;")

 code.indent()
 if sim_object == SimObject:
     code(
         """
 SimObjectParams() {}
 virtual ~SimObjectParams() {}

 std::string name;
     """
     )

 for param in params:
     param.cxx_decl(code)
 for port in ports.values():
     port.cxx_decl(code)

 code.dedent()
 code("};")
 code()
 code("} // namespace gem5")

 code()
 code("#endif // __PARAMS__${sim_object}__")

 code.write(args.param_hh)
	# Copyright 2004-2006 The Regents of The University of Michigan
	# Copyright 2010-20013 Advanced Micro Devices, Inc.
	# Copyright 2013 Mark D. Hill and David A. Wood
	# Copyright 2017-2020 ARM Limited
	# Copyright 2021 Google, Inc.
	#
	# The license below extends only to copyright in the software and shall
	# not be construed as granting a license to any other intellectual
	# property including but not limited to intellectual property relating
	# to a hardware implementation of the functionality of the software
	# licensed hereunder. You may use the software subject to the license
	# terms below provided that you ensure that this notice is replicated
	# unmodified and in its entirety in all distributions of the software,
	# modified or unmodified, in source code or in binary form.
	#
	# Redistribution and use in source and binary forms, with or without
	# modification, are permitted provided that the following conditions are
	# met: redistributions of source code must retain the above copyright
	# notice, this list of conditions and the following disclaimer;
	# redistributions in binary form must reproduce the above copyright
	# notice, this list of conditions and the following disclaimer in the
	# documentation and/or other materials provided with the distribution;
	# neither the name of the copyright holders nor the names of its
	# contributors may be used to endorse or promote products derived from
	# this software without specific prior written permission.
	#
	# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	import argparse
	import importlib
	import os.path
	import sys

	import importer

	from code_formatter import code_formatter

	parser = argparse.ArgumentParser()
	parser.add_argument("modpath", help="module the simobject belongs to")
	parser.add_argument("param_hh", help="parameter header file to generate")

	args = parser.parse_args()

	basename = os.path.basename(args.param_hh)
	sim_object_name = os.path.splitext(basename)[0]

	importer.install()
	module = importlib.import_module(args.modpath)
	sim_object = getattr(module, sim_object_name)

	from m5.objects.SimObject import SimObject
	from m5.params import Enum

	code = code_formatter()

	# The 'local' attribute restricts us to the params declared in
	# the object itself, not including inherited params (which
	# will also be inherited from the base class's param struct
	# here). Sort the params based on their key
	params = list(
	map(lambda k_v: k_v[1], sorted(sim_object._params.local.items()))
	)
	ports = sim_object._ports.local
	try:
	ptypes = [p.ptype for p in params]
	except:
	print(sim_object)
	print(params)
	raise

	warned_about_nested_templates = False


	class CxxClass(object):
	def __init__(self, sig, template_params=[]):
	# Split the signature into its constituent parts. This could
	# potentially be done with regular expressions, but
	# it's simple enough to pick appart a class signature
	# manually.
	parts = sig.split("<", 1)
	base = parts[0]
	t_args = []
	if len(parts) > 1:
	# The signature had template arguments.
	text = parts[1].rstrip(" \t\n>")
	arg = ""
	# Keep track of nesting to avoid splitting on ","s embedded
	# in the arguments themselves.
	depth = 0
	for c in text:
	if c == "<":
	depth = depth + 1
	if depth > 0 and not warned_about_nested_templates:
	warned_about_nested_templates = True
	print(
	"Nested template argument in cxx_class."
	" This feature is largely untested and "
	" may not work."
	)
	elif c == ">":
	depth = depth - 1
	elif c == "," and depth == 0:
	t_args.append(arg.strip())
	arg = ""
	else:
	arg = arg + c
	if arg:
	t_args.append(arg.strip())
	# Split the non-template part on :: boundaries.
	class_path = base.split("::")

	# The namespaces are everything except the last part of the class path.
	self.namespaces = class_path[:-1]
	# And the class name is the last part.
	self.name = class_path[-1]

	self.template_params = template_params
	self.template_arguments = []
	# Iterate through the template arguments and their values. This
	# will likely break if parameter packs are used.
	for arg, param in zip(t_args, template_params):
	type_keys = ("class", "typename")
	# If a parameter is a type, parse it recursively. Otherwise
	# assume it's a constant, and store it verbatim.
	if any(param.strip().startswith(kw) for kw in type_keys):
	self.template_arguments.append(CxxClass(arg))
	else:
	self.template_arguments.append(arg)

	def declare(self, code):
	# First declare any template argument types.
	for arg in self.template_arguments:
	if isinstance(arg, CxxClass):
	arg.declare(code)
	# Re-open the target namespace.
	for ns in self.namespaces:
	code("namespace $ns {")
	# If this is a class template...
	if self.template_params:
	code('template <${{", ".join(self.template_params)}}>')
	# The actual class declaration.
	code("class ${{self.name}};")
	# Close the target namespaces.
	for ns in reversed(self.namespaces):
	code("} // namespace $ns")


	code(
	"""\
	#ifndef __PARAMS__${sim_object}__
	#define __PARAMS__${sim_object}__

	"""
	)


	# The base SimObject has a couple of params that get
	# automatically set from Python without being declared through
	# the normal Param mechanism; we slip them in here (needed
	# predecls now, actual declarations below)
	if sim_object == SimObject:
	code("""#include <string>""")

	cxx_class = CxxClass(
	sim_object._value_dict["cxx_class"],
	sim_object._value_dict["cxx_template_params"],
	)

	# A forward class declaration is sufficient since we are just
	# declaring a pointer.
	cxx_class.declare(code)

	for param in params:
	param.cxx_predecls(code)
	for port in ports.values():
	port.cxx_predecls(code)
	code()

	if sim_object._base:
	code('#include "params/${{sim_object._base.type}}.hh"')
	code()

	for ptype in ptypes:
	if issubclass(ptype, Enum):
	code('#include "enums/${{ptype.__name__}}.hh"')
	code()

	code("namespace gem5")
	code("{")
	code("")

	# now generate the actual param struct
	code("struct ${sim_object}Params")
	if sim_object._base:
	code(" : public ${{sim_object._base.type}}Params")
	code("{")
	if not hasattr(sim_object, "abstract") or not sim_object.abstract:
	if "type" in sim_object.__dict__:
	code(" ${{sim_object.cxx_type}} create() const;")

	code.indent()
	if sim_object == SimObject:
	code(
	"""
	SimObjectParams() {}
	virtual ~SimObjectParams() {}

	std::string name;
	"""
	)

	for param in params:
	param.cxx_decl(code)
	for port in ports.values():
	port.cxx_decl(code)

	code.dedent()
	code("};")
	code()
	code("} // namespace gem5")

	code()
	code("#endif // __PARAMS__${sim_object}__")

	code.write(args.param_hh)