| # 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) |