X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2FSConscript;h=85bebc3ca031bb497672bfb199ba95cd075b58ca;hb=2d2006ddb3df926d79d0d744af81e8260f5c466c;hp=687709ac136bbcfe78306e31469ece4a3d631b96;hpb=9a8cb7db7e86c25a755f2e2817a0385b13e3ac32;p=gem5.git diff --git a/src/SConscript b/src/SConscript old mode 100644 new mode 100755 index 687709ac1..85bebc3ca --- a/src/SConscript +++ b/src/SConscript @@ -41,7 +41,7 @@ from os.path import basename, dirname, exists, isdir, isfile, join as joinpath import SCons -# This file defines how to build a particular configuration of M5 +# This file defines how to build a particular configuration of gem5 # based on variable settings in the 'env' build environment. Import('*') @@ -51,44 +51,98 @@ Export('env') build_env = [(opt, env[opt]) for opt in export_vars] +from m5.util import code_formatter, compareVersions + ######################################################################## # Code for adding source files of various types # +# When specifying a source file of some type, a set of guards can be +# specified for that file. When get() is used to find the files, if +# get specifies a set of filters, only files that match those filters +# will be accepted (unspecified filters on files are assumed to be +# false). Current filters are: +# main -- specifies the gem5 main() function +# skip_lib -- do not put this file into the gem5 library +# skip_no_python -- do not put this file into a no_python library +# as it embeds compiled Python +# -- unit tests use filters based on the unit test name +# +# A parent can now be specified for a source file and default filter +# values will be retrieved recursively from parents (children override +# parents). +# class SourceMeta(type): + '''Meta class for source files that keeps track of all files of a + particular type and has a get function for finding all functions + of a certain type that match a set of guards''' def __init__(cls, name, bases, dict): super(SourceMeta, cls).__init__(name, bases, dict) cls.all = [] - def get(cls, **kwargs): + def get(cls, **guards): + '''Find all files that match the specified guards. If a source + file does not specify a flag, the default is False''' for src in cls.all: - for attr,value in kwargs.iteritems(): - if getattr(src, attr) != value: + for flag,value in guards.iteritems(): + # if the flag is found and has a different value, skip + # this file + if src.all_guards.get(flag, False) != value: break else: yield src class SourceFile(object): + '''Base object that encapsulates the notion of a source file. + This includes, the source node, target node, various manipulations + of those. A source file also specifies a set of guards which + describing which builds the source file applies to. A parent can + also be specified to get default guards from''' __metaclass__ = SourceMeta - def __init__(self, source): + def __init__(self, source, parent=None, **guards): + self.guards = guards + self.parent = parent + tnode = source if not isinstance(source, SCons.Node.FS.File): tnode = File(source) self.tnode = tnode self.snode = tnode.srcnode() - self.filename = str(tnode) - self.dirname = dirname(self.filename) - self.basename = basename(self.filename) + + for base in type(self).__mro__: + if issubclass(base, SourceFile): + base.all.append(self) + + @property + def filename(self): + return str(self.tnode) + + @property + def dirname(self): + return dirname(self.filename) + + @property + def basename(self): + return basename(self.filename) + + @property + def extname(self): index = self.basename.rfind('.') if index <= 0: # dot files aren't extensions - self.extname = self.basename, None - else: - self.extname = self.basename[:index], self.basename[index+1:] + return self.basename, None - for base in type(self).__mro__: - if issubclass(base, SourceFile): - bisect.insort_right(base.all, self) + return self.basename[:index], self.basename[index+1:] + + @property + def all_guards(self): + '''find all guards for this object getting default values + recursively from its parents''' + guards = {} + if self.parent: + guards.update(self.parent.guards) + guards.update(self.guards) + return guards def __lt__(self, other): return self.filename < other.filename def __le__(self, other): return self.filename <= other.filename @@ -96,17 +150,23 @@ class SourceFile(object): def __ge__(self, other): return self.filename >= other.filename def __eq__(self, other): return self.filename == other.filename def __ne__(self, other): return self.filename != other.filename - + + @staticmethod + def done(): + def disabled(cls, name, *ignored): + raise RuntimeError("Additional SourceFile '%s'" % name,\ + "declared, but targets deps are already fixed.") + SourceFile.__init__ = disabled + + class Source(SourceFile): '''Add a c/c++ source file to the build''' - def __init__(self, source, Werror=True, swig=False, bin_only=False, - skip_lib=False): - super(Source, self).__init__(source) + def __init__(self, source, Werror=True, swig=False, **guards): + '''specify the source file, and any guards''' + super(Source, self).__init__(source, **guards) self.Werror = Werror self.swig = swig - self.bin_only = bin_only - self.skip_lib = bin_only or skip_lib class PySource(SourceFile): '''Add a python source file to the named package''' @@ -114,9 +174,10 @@ class PySource(SourceFile): modules = {} tnodes = {} symnames = {} - - def __init__(self, package, source): - super(PySource, self).__init__(source) + + def __init__(self, package, source, **guards): + '''specify the python package, the source file, and any guards''' + super(PySource, self).__init__(source, **guards) modname,ext = self.extname assert ext == 'py' @@ -132,18 +193,18 @@ class PySource(SourceFile): modpath = '.'.join(modpath) arcpath = path + [ self.basename ] - debugname = self.snode.abspath - if not exists(debugname): - debugname = self.tnode.abspath + abspath = self.snode.abspath + if not exists(abspath): + abspath = self.tnode.abspath self.package = package self.modname = modname self.modpath = modpath self.arcname = joinpath(*arcpath) - self.debugname = debugname + self.abspath = abspath self.compiled = File(self.filename + 'c') - self.assembly = File(self.filename + '.s') - self.symname = "PyEMB_" + PySource.invalid_sym_char.sub('_', modpath) + self.cpp = File(self.filename + '.cc') + self.symname = PySource.invalid_sym_char.sub('_', modpath) PySource.modules[modpath] = self PySource.tnodes[self.tnode] = self @@ -156,8 +217,10 @@ class SimObject(PySource): fixed = False modnames = [] - def __init__(self, source): - super(SimObject, self).__init__('m5.objects', source) + def __init__(self, source, **guards): + '''Specify the source file and any guards (automatically in + the m5.objects package)''' + super(SimObject, self).__init__('m5.objects', source, **guards) if self.fixed: raise AttributeError, "Too late to call SimObject now." @@ -166,8 +229,9 @@ class SimObject(PySource): class SwigSource(SourceFile): '''Add a swig file to build''' - def __init__(self, package, source): - super(SwigSource, self).__init__(source) + def __init__(self, package, source, **guards): + '''Specify the python package, the source file, and any guards''' + super(SwigSource, self).__init__(source, skip_no_python=True, **guards) modname,ext = self.extname assert ext == 'i' @@ -176,42 +240,73 @@ class SwigSource(SourceFile): cc_file = joinpath(self.dirname, modname + '_wrap.cc') py_file = joinpath(self.dirname, modname + '.py') - self.cc_source = Source(cc_file, swig=True) - self.py_source = PySource(package, py_file) + self.cc_source = Source(cc_file, swig=True, parent=self, **guards) + self.py_source = PySource(package, py_file, parent=self, **guards) -unit_tests = [] -def UnitTest(target, sources): - if not isinstance(sources, (list, tuple)): - sources = [ sources ] +class ProtoBuf(SourceFile): + '''Add a Protocol Buffer to build''' - sources = [ Source(src, skip_lib=True) for src in sources ] - unit_tests.append((target, sources)) + def __init__(self, source, **guards): + '''Specify the source file, and any guards''' + super(ProtoBuf, self).__init__(source, **guards) + + # Get the file name and the extension + modname,ext = self.extname + assert ext == 'proto' + + # Currently, we stick to generating the C++ headers, so we + # only need to track the source and header. + self.cc_file = File(modname + '.pb.cc') + self.hh_file = File(modname + '.pb.h') + +class UnitTest(object): + '''Create a UnitTest''' + + all = [] + def __init__(self, target, *sources, **kwargs): + '''Specify the target name and any sources. Sources that are + not SourceFiles are evalued with Source(). All files are + guarded with a guard of the same name as the UnitTest + target.''' + + srcs = [] + for src in sources: + if not isinstance(src, SourceFile): + src = Source(src, skip_lib=True) + src.guards[target] = True + srcs.append(src) + + self.sources = srcs + self.target = target + self.main = kwargs.get('main', False) + UnitTest.all.append(self) # Children should have access Export('Source') Export('PySource') Export('SimObject') Export('SwigSource') +Export('ProtoBuf') Export('UnitTest') ######################################################################## # -# Trace Flags +# Debug Flags # -trace_flags = {} -def TraceFlag(name, desc=None): - if name in trace_flags: +debug_flags = {} +def DebugFlag(name, desc=None): + if name in debug_flags: raise AttributeError, "Flag %s already specified" % name - trace_flags[name] = (name, (), desc) + debug_flags[name] = (name, (), desc) def CompoundFlag(name, flags, desc=None): - if name in trace_flags: + if name in debug_flags: raise AttributeError, "Flag %s already specified" % name compound = tuple(flags) - trace_flags[name] = (name, compound, desc) + debug_flags[name] = (name, compound, desc) -Export('TraceFlag') +Export('DebugFlag') Export('CompoundFlag') ######################################################################## @@ -228,11 +323,8 @@ env.Append(CPPPATH=Dir('.')) for extra_dir in extras_dir_list: env.Append(CPPPATH=Dir(extra_dir)) -# Add a flag defining what THE_ISA should be for all compilation -env.Append(CPPDEFINES=[('THE_ISA','%s_ISA' % env['TARGET_ISA'].upper())]) - # Workaround for bug in SCons version > 0.97d20071212 -# Scons bug id: 2006 M5 Bug id: 308 +# Scons bug id: 2006 gem5 Bug id: 308 for root, dirs, files in os.walk(base_dir, topdown=True): Dir(root[len(base_dir) + 1:]) @@ -249,18 +341,72 @@ for root, dirs, files in os.walk(base_dir, topdown=True): if 'SConscript' in files: build_dir = joinpath(env['BUILDDIR'], root[len(base_dir) + 1:]) - SConscript(joinpath(root, 'SConscript'), build_dir=build_dir) + SConscript(joinpath(root, 'SConscript'), variant_dir=build_dir) for extra_dir in extras_dir_list: prefix_len = len(dirname(extra_dir)) + 1 + + # Also add the corresponding build directory to pick up generated + # include files. + env.Append(CPPPATH=Dir(joinpath(env['BUILDDIR'], extra_dir[prefix_len:]))) + for root, dirs, files in os.walk(extra_dir, topdown=True): + # if build lives in the extras directory, don't walk down it + if 'build' in dirs: + dirs.remove('build') + if 'SConscript' in files: build_dir = joinpath(env['BUILDDIR'], root[prefix_len:]) - SConscript(joinpath(root, 'SConscript'), build_dir=build_dir) + SConscript(joinpath(root, 'SConscript'), variant_dir=build_dir) for opt in export_vars: env.ConfigFile(opt) +def makeTheISA(source, target, env): + isas = [ src.get_contents() for src in source ] + target_isa = env['TARGET_ISA'] + def define(isa): + return isa.upper() + '_ISA' + + def namespace(isa): + return isa[0].upper() + isa[1:].lower() + 'ISA' + + + code = code_formatter() + code('''\ +#ifndef __CONFIG_THE_ISA_HH__ +#define __CONFIG_THE_ISA_HH__ + +''') + + # create defines for the preprocessing and compile-time determination + for i,isa in enumerate(isas): + code('#define $0 $1', define(isa), i + 1) + code() + + # create an enum for any run-time determination of the ISA, we + # reuse the same name as the namespaces + code('enum class Arch {') + for i,isa in enumerate(isas): + if i + 1 == len(isas): + code(' $0 = $1', namespace(isa), define(isa)) + else: + code(' $0 = $1,', namespace(isa), define(isa)) + code('};') + + code(''' + +#define THE_ISA ${{define(target_isa)}} +#define TheISA ${{namespace(target_isa)}} +#define THE_ISA_STR "${{target_isa}}" + +#endif // __CONFIG_THE_ISA_HH__''') + + code.write(str(target[0])) + +env.Command('config/the_isa.hh', map(Value, all_isa_list), + MakeAction(makeTheISA, Transform("CFG ISA", 0))) + ######################################################################## # # Prevent any SimObjects from being added after this point, they @@ -317,14 +463,15 @@ class DictImporter(object): source = self.modules[fullname] if source.modname == '__init__': mod.__path__ = source.modpath - mod.__file__ = source.snode.abspath + mod.__file__ = source.abspath - exec file(source.snode.abspath, 'r') in mod.__dict__ + exec file(source.abspath, 'r') in mod.__dict__ return mod import m5.SimObject import m5.params +from m5.util import code_formatter m5.SimObject.clear() m5.params.clear() @@ -348,7 +495,19 @@ sys.meta_path.remove(importer) sim_objects = m5.SimObject.allClasses all_enums = m5.params.allEnums -all_params = {} +if m5.SimObject.noCxxHeader: + print >> sys.stderr, \ + "warning: At least one SimObject lacks a header specification. " \ + "This can cause unexpected results in the generated SWIG " \ + "wrappers." + +# Find param types that need to be explicitly wrapped with swig. +# These will be recognized because the ParamDesc will have a +# swig_decl() method. Most param types are based on types that don't +# need this, either because they're based on native types (like Int) +# or because they're SimObjects (which get swigged independently). +# For now the only things handled here are VectorParam types. +params_to_swig = {} for name,obj in sorted(sim_objects.iteritems()): for param in obj._params.local.values(): # load the ptype attribute now because it depends on the @@ -360,15 +519,15 @@ for name,obj in sorted(sim_objects.iteritems()): if not hasattr(param, 'swig_decl'): continue pname = param.ptype_str - if pname not in all_params: - all_params[pname] = param + if pname not in params_to_swig: + params_to_swig[pname] = param ######################################################################## # # calculate extra dependencies # module_depends = ["m5", "m5.SimObject", "m5.params"] -depends = [ PySource.modules[dep].tnode for dep in module_depends ] +depends = [ PySource.modules[dep].snode for dep in module_depends ] ######################################################################## # @@ -378,104 +537,125 @@ depends = [ PySource.modules[dep].tnode for dep in module_depends ] # Generate Python file containing a dict specifying the current # buildEnv flags. def makeDefinesPyFile(target, source, env): - build_env, hg_info = [ x.get_contents() for x in source ] + build_env = source[0].get_contents() - code = m5.util.code_formatter() + code = code_formatter() code(""" import m5.internal import m5.util buildEnv = m5.util.SmartDict($build_env) -hgRev = '$hg_info' compileDate = m5.internal.core.compileDate -for k,v in m5.internal.core.__dict__.iteritems(): - if k.startswith('flag_'): - setattr(buildEnv, k[5:], v) +_globals = globals() +for key,val in m5.internal.core.__dict__.iteritems(): + if key.startswith('flag_'): + flag = key[5:] + _globals[flag] = val +del _globals """) - code.write(str(target[0])) + code.write(target[0].abspath) -defines_info = [ Value(build_env), Value(env['HG_INFO']) ] +defines_info = Value(build_env) # Generate a file with all of the compile options in it -env.Command('python/m5/defines.py', defines_info, makeDefinesPyFile) +env.Command('python/m5/defines.py', defines_info, + MakeAction(makeDefinesPyFile, Transform("DEFINES", 0))) PySource('m5', 'python/m5/defines.py') # Generate python file containing info about the M5 source code def makeInfoPyFile(target, source, env): - f = file(str(target[0]), 'w') + code = code_formatter() for src in source: data = ''.join(file(src.srcnode().abspath, 'r').xreadlines()) - print >>f, "%s = %s" % (src, repr(data)) - f.close() + code('$src = ${{repr(data)}}') + code.write(str(target[0])) # Generate a file that wraps the basic top level files env.Command('python/m5/info.py', - [ '#/AUTHORS', '#/LICENSE', '#/README', '#/RELEASE_NOTES' ], - makeInfoPyFile) + [ '#/COPYING', '#/LICENSE', '#/README', ], + MakeAction(makeInfoPyFile, Transform("INFO"))) PySource('m5', 'python/m5/info.py') -# Generate the __init__.py file for m5.objects -def makeObjectsInitFile(target, source, env): - f = file(str(target[0]), 'w') - print >>f, 'from params import *' - print >>f, 'from m5.SimObject import *' - for module in source: - print >>f, 'from %s import *' % module.get_contents() - f.close() - -# Generate an __init__.py file for the objects package -env.Command('python/m5/objects/__init__.py', - map(Value, SimObject.modnames), - makeObjectsInitFile) -PySource('m5.objects', 'python/m5/objects/__init__.py') - ######################################################################## # # Create all of the SimObject param headers and enum headers # -def createSimObjectParam(target, source, env): +def createSimObjectParamStruct(target, source, env): assert len(target) == 1 and len(source) == 1 - hh_file = file(target[0].abspath, 'w') name = str(source[0].get_contents()) obj = sim_objects[name] - print >>hh_file, obj.cxx_decl() - hh_file.close() + code = code_formatter() + obj.cxx_param_decl(code) + code.write(target[0].abspath) + +def createSimObjectCxxConfig(is_header): + def body(target, source, env): + assert len(target) == 1 and len(source) == 1 -def createSwigParam(target, source, env): + name = str(source[0].get_contents()) + obj = sim_objects[name] + + code = code_formatter() + obj.cxx_config_param_file(code, is_header) + code.write(target[0].abspath) + return body + +def createParamSwigWrapper(target, source, env): assert len(target) == 1 and len(source) == 1 - i_file = file(target[0].abspath, 'w') name = str(source[0].get_contents()) - param = all_params[name] + param = params_to_swig[name] - for line in param.swig_decl(): - print >>i_file, line - i_file.close() + code = code_formatter() + param.swig_decl(code) + code.write(target[0].abspath) def createEnumStrings(target, source, env): assert len(target) == 1 and len(source) == 1 - cc_file = file(target[0].abspath, 'w') name = str(source[0].get_contents()) obj = all_enums[name] - print >>cc_file, obj.cxx_def() - cc_file.close() + code = code_formatter() + obj.cxx_def(code) + code.write(target[0].abspath) -def createEnumParam(target, source, env): +def createEnumDecls(target, source, env): assert len(target) == 1 and len(source) == 1 - hh_file = file(target[0].abspath, 'w') name = str(source[0].get_contents()) obj = all_enums[name] - print >>hh_file, obj.cxx_decl() - hh_file.close() + code = code_formatter() + obj.cxx_decl(code) + code.write(target[0].abspath) + +def createEnumSwigWrapper(target, source, env): + assert len(target) == 1 and len(source) == 1 + + name = str(source[0].get_contents()) + obj = all_enums[name] + + code = code_formatter() + obj.swig_decl(code) + code.write(target[0].abspath) + +def createSimObjectSwigWrapper(target, source, env): + name = source[0].get_contents() + obj = sim_objects[name] + + code = code_formatter() + obj.swig_decl(code) + code.write(target[0].abspath) + +# dummy target for generated code +# we start out with all the Source files so they get copied to build/*/ also. +SWIG = env.Dummy('swig', [s.tnode for s in Source.get()]) -# Generate all of the SimObject param struct header files +# Generate all of the SimObject param C++ struct header files params_hh_files = [] for name,simobj in sorted(sim_objects.iteritems()): py_source = PySource.modules[simobj.__module__] @@ -483,21 +663,76 @@ for name,simobj in sorted(sim_objects.iteritems()): hh_file = File('params/%s.hh' % name) params_hh_files.append(hh_file) - env.Command(hh_file, Value(name), createSimObjectParam) + env.Command(hh_file, Value(name), + MakeAction(createSimObjectParamStruct, Transform("SO PARAM"))) env.Depends(hh_file, depends + extra_deps) + env.Depends(SWIG, hh_file) + +# C++ parameter description files +if GetOption('with_cxx_config'): + for name,simobj in sorted(sim_objects.iteritems()): + py_source = PySource.modules[simobj.__module__] + extra_deps = [ py_source.tnode ] + + cxx_config_hh_file = File('cxx_config/%s.hh' % name) + cxx_config_cc_file = File('cxx_config/%s.cc' % name) + env.Command(cxx_config_hh_file, Value(name), + MakeAction(createSimObjectCxxConfig(True), + Transform("CXXCPRHH"))) + env.Command(cxx_config_cc_file, Value(name), + MakeAction(createSimObjectCxxConfig(False), + Transform("CXXCPRCC"))) + env.Depends(cxx_config_hh_file, depends + extra_deps + + [File('params/%s.hh' % name), File('sim/cxx_config.hh')]) + env.Depends(cxx_config_cc_file, depends + extra_deps + + [cxx_config_hh_file]) + Source(cxx_config_cc_file) + + cxx_config_init_cc_file = File('cxx_config/init.cc') + + def createCxxConfigInitCC(target, source, env): + assert len(target) == 1 and len(source) == 1 + + code = code_formatter() + + for name,simobj in sorted(sim_objects.iteritems()): + if not hasattr(simobj, 'abstract') or not simobj.abstract: + code('#include "cxx_config/${name}.hh"') + code() + code('void cxxConfigInit()') + code('{') + code.indent() + for name,simobj in sorted(sim_objects.iteritems()): + not_abstract = not hasattr(simobj, 'abstract') or \ + not simobj.abstract + if not_abstract and 'type' in simobj.__dict__: + code('cxx_config_directory["${name}"] = ' + '${name}CxxConfigParams::makeDirectoryEntry();') + code.dedent() + code('}') + code.write(target[0].abspath) -# Generate any parameter header files needed + py_source = PySource.modules[simobj.__module__] + extra_deps = [ py_source.tnode ] + env.Command(cxx_config_init_cc_file, Value(name), + MakeAction(createCxxConfigInitCC, Transform("CXXCINIT"))) + cxx_param_hh_files = ["cxx_config/%s.hh" % simobj + for simobj in sorted(sim_objects.itervalues()) + if not hasattr(simobj, 'abstract') or not simobj.abstract] + Depends(cxx_config_init_cc_file, cxx_param_hh_files + + [File('sim/cxx_config.hh')]) + Source(cxx_config_init_cc_file) + +# Generate any needed param SWIG wrapper files params_i_files = [] -for name,param in all_params.iteritems(): - if isinstance(param, m5.params.VectorParamDesc): - ext = 'vptype' - else: - ext = 'ptype' - - i_file = File('params/%s_%s.i' % (name, ext)) +for name,param in params_to_swig.iteritems(): + i_file = File('python/m5/internal/%s.i' % (param.swig_module_name())) params_i_files.append(i_file) - env.Command(i_file, Value(name), createSwigParam) + env.Command(i_file, Value(name), + MakeAction(createParamSwigWrapper, Transform("SW PARAM"))) env.Depends(i_file, depends) + env.Depends(SWIG, i_file) + SwigSource('m5.internal', i_file) # Generate all enum header files for name,enum in sorted(all_enums.iteritems()): @@ -505,442 +740,240 @@ for name,enum in sorted(all_enums.iteritems()): extra_deps = [ py_source.tnode ] cc_file = File('enums/%s.cc' % name) - env.Command(cc_file, Value(name), createEnumStrings) + env.Command(cc_file, Value(name), + MakeAction(createEnumStrings, Transform("ENUM STR"))) env.Depends(cc_file, depends + extra_deps) + env.Depends(SWIG, cc_file) Source(cc_file) hh_file = File('enums/%s.hh' % name) - env.Command(hh_file, Value(name), createEnumParam) + env.Command(hh_file, Value(name), + MakeAction(createEnumDecls, Transform("ENUMDECL"))) env.Depends(hh_file, depends + extra_deps) + env.Depends(SWIG, hh_file) -# Build the big monolithic swigged params module (wraps all SimObject -# param structs and enum structs) -def buildParams(target, source, env): - names = [ s.get_contents() for s in source ] - objs = [ sim_objects[name] for name in names ] - out = file(target[0].abspath, 'w') - - ordered_objs = [] - obj_seen = set() - def order_obj(obj): - name = str(obj) - if name in obj_seen: - return - - obj_seen.add(name) - if str(obj) != 'SimObject': - order_obj(obj.__bases__[0]) - - ordered_objs.append(obj) - - for obj in objs: - order_obj(obj) - - enums = set() - predecls = [] - pd_seen = set() - - def add_pds(*pds): - for pd in pds: - if pd not in pd_seen: - predecls.append(pd) - pd_seen.add(pd) - - for obj in ordered_objs: - params = obj._params.local.values() - for param in params: - ptype = param.ptype - if issubclass(ptype, m5.params.Enum): - if ptype not in enums: - enums.add(ptype) - pds = param.swig_predecls() - if isinstance(pds, (list, tuple)): - add_pds(*pds) - else: - add_pds(pds) - - print >>out, '%module params' - - print >>out, '%{' - for obj in ordered_objs: - print >>out, '#include "params/%s.hh"' % obj - print >>out, '%}' - - for pd in predecls: - print >>out, pd - - enums = list(enums) - enums.sort() - for enum in enums: - print >>out, '%%include "enums/%s.hh"' % enum.__name__ - print >>out - - for obj in ordered_objs: - if obj.swig_objdecls: - for decl in obj.swig_objdecls: - print >>out, decl - continue - - class_path = obj.cxx_class.split('::') - classname = class_path[-1] - namespaces = class_path[:-1] - namespaces.reverse() - - code = '' - - if namespaces: - code += '// avoid name conflicts\n' - sep_string = '_COLONS_' - flat_name = sep_string.join(class_path) - code += '%%rename(%s) %s;\n' % (flat_name, classname) - - code += '// stop swig from creating/wrapping default ctor/dtor\n' - code += '%%nodefault %s;\n' % classname - code += 'class %s ' % classname - if obj._base: - code += ': public %s' % obj._base.cxx_class - code += ' {};\n' + i_file = File('python/m5/internal/enum_%s.i' % name) + env.Command(i_file, Value(name), + MakeAction(createEnumSwigWrapper, Transform("ENUMSWIG"))) + env.Depends(i_file, depends + extra_deps) + env.Depends(SWIG, i_file) + SwigSource('m5.internal', i_file) - for ns in namespaces: - new_code = 'namespace %s {\n' % ns - new_code += code - new_code += '}\n' - code = new_code - - print >>out, code - - print >>out, '%%include "src/sim/sim_object_params.hh"' % obj - for obj in ordered_objs: - print >>out, '%%include "params/%s.hh"' % obj +# Generate SimObject SWIG wrapper files +for name,simobj in sim_objects.iteritems(): + py_source = PySource.modules[simobj.__module__] + extra_deps = [ py_source.tnode ] -params_file = File('params/params.i') -names = sorted(sim_objects.keys()) -env.Command(params_file, map(Value, names), buildParams) -env.Depends(params_file, params_hh_files + params_i_files + depends) -SwigSource('m5.objects', params_file) + i_file = File('python/m5/internal/param_%s.i' % name) + env.Command(i_file, Value(name), + MakeAction(createSimObjectSwigWrapper, Transform("SO SWIG"))) + env.Depends(i_file, depends + extra_deps) + SwigSource('m5.internal', i_file) +# Generate the main swig init file +def makeEmbeddedSwigInit(target, source, env): + code = code_formatter() + module = source[0].get_contents() + code('''\ +#include "sim/init.hh" + +extern "C" { + void init_${module}(); +} + +EmbeddedSwig embed_swig_${module}(init_${module}); +''') + code.write(str(target[0])) + # Build all swig modules for swig in SwigSource.all: env.Command([swig.cc_source.tnode, swig.py_source.tnode], swig.tnode, - '$SWIG $SWIGFLAGS -outdir ${TARGETS[1].dir} ' - '-o ${TARGETS[0]} $SOURCES') - env.Depends(swig.py_source.tnode, swig.tnode) - env.Depends(swig.cc_source.tnode, swig.tnode) - -# Generate the main swig init file -def makeSwigInit(target, source, env): - f = file(str(target[0]), 'w') - print >>f, 'extern "C" {' - for module in source: - print >>f, ' void init_%s();' % module.get_contents() - print >>f, '}' - print >>f, 'void initSwig() {' - for module in source: - print >>f, ' init_%s();' % module.get_contents() - print >>f, '}' - f.close() - -env.Command('python/swig/init.cc', - map(Value, sorted(s.module for s in SwigSource.all)), - makeSwigInit) -Source('python/swig/init.cc') - -def getFlags(source_flags): - flagsMap = {} - flagsList = [] - for s in source_flags: - val = eval(s.get_contents()) - name, compound, desc = val - flagsList.append(val) - flagsMap[name] = bool(compound) - - for name, compound, desc in flagsList: - for flag in compound: - if flag not in flagsMap: - raise AttributeError, "Trace flag %s not found" % flag - if flagsMap[flag]: - raise AttributeError, \ - "Compound flag can't point to another compound flag" - - flagsList.sort() - return flagsList - - -# Generate traceflags.py -def traceFlagsPy(target, source, env): - assert(len(target) == 1) - - f = file(str(target[0]), 'w') - - allFlags = getFlags(source) - - print >>f, 'basic = [' - for flag, compound, desc in allFlags: - if not compound: - print >>f, " '%s'," % flag - print >>f, " ]" - print >>f - - print >>f, 'compound = [' - print >>f, " 'All'," - for flag, compound, desc in allFlags: - if compound: - print >>f, " '%s'," % flag - print >>f, " ]" - print >>f - - print >>f, "all = frozenset(basic + compound)" - print >>f - - print >>f, 'compoundMap = {' - all = tuple([flag for flag,compound,desc in allFlags if not compound]) - print >>f, " 'All' : %s," % (all, ) - for flag, compound, desc in allFlags: - if compound: - print >>f, " '%s' : %s," % (flag, compound) - print >>f, " }" - print >>f - - print >>f, 'descriptions = {' - print >>f, " 'All' : 'All flags'," - for flag, compound, desc in allFlags: - print >>f, " '%s' : '%s'," % (flag, desc) - print >>f, " }" - - f.close() + MakeAction('$SWIG $SWIGFLAGS -outdir ${TARGETS[1].dir} ' + '-o ${TARGETS[0]} $SOURCES', Transform("SWIG"))) + cc_file = str(swig.tnode) + init_file = '%s/%s_init.cc' % (dirname(cc_file), basename(cc_file)) + env.Command(init_file, Value(swig.module), + MakeAction(makeEmbeddedSwigInit, Transform("EMBED SW"))) + env.Depends(SWIG, init_file) + Source(init_file, **swig.guards) + +# Build all protocol buffers if we have got protoc and protobuf available +if env['HAVE_PROTOBUF']: + for proto in ProtoBuf.all: + # Use both the source and header as the target, and the .proto + # file as the source. When executing the protoc compiler, also + # specify the proto_path to avoid having the generated files + # include the path. + env.Command([proto.cc_file, proto.hh_file], proto.tnode, + MakeAction('$PROTOC --cpp_out ${TARGET.dir} ' + '--proto_path ${SOURCE.dir} $SOURCE', + Transform("PROTOC"))) + + env.Depends(SWIG, [proto.cc_file, proto.hh_file]) + # Add the C++ source file + Source(proto.cc_file, **proto.guards) +elif ProtoBuf.all: + print 'Got protobuf to build, but lacks support!' + Exit(1) -def traceFlagsCC(target, source, env): - assert(len(target) == 1) +# +# Handle debug flags +# +def makeDebugFlagCC(target, source, env): + assert(len(target) == 1 and len(source) == 1) - f = file(str(target[0]), 'w') + code = code_formatter() - allFlags = getFlags(source) + # delay definition of CompoundFlags until after all the definition + # of all constituent SimpleFlags + comp_code = code_formatter() # file header - print >>f, ''' + code(''' /* - * DO NOT EDIT THIS FILE! Automatically generated + * DO NOT EDIT THIS FILE! Automatically generated by SCons. */ -#include "base/traceflags.hh" +#include "base/debug.hh" -using namespace Trace; +namespace Debug { -const char *Trace::flagStrings[] = -{''' +''') - # The string array is used by SimpleEnumParam to map the strings - # provided by the user to enum values. - for flag, compound, desc in allFlags: - if not compound: - print >>f, ' "%s",' % flag - - print >>f, ' "All",' - for flag, compound, desc in allFlags: - if compound: - print >>f, ' "%s",' % flag - - print >>f, '};' - print >>f - print >>f, 'const int Trace::numFlagStrings = %d;' % (len(allFlags) + 1) - print >>f - - # - # Now define the individual compound flag arrays. There is an array - # for each compound flag listing the component base flags. - # - all = tuple([flag for flag,compound,desc in allFlags if not compound]) - print >>f, 'static const Flags AllMap[] = {' - for flag, compound, desc in allFlags: - if not compound: - print >>f, " %s," % flag - print >>f, '};' - print >>f + for name, flag in sorted(source[0].read().iteritems()): + n, compound, desc = flag + assert n == name - for flag, compound, desc in allFlags: if not compound: - continue - print >>f, 'static const Flags %sMap[] = {' % flag - for flag in compound: - print >>f, " %s," % flag - print >>f, " (Flags)-1" - print >>f, '};' - print >>f - - # - # Finally the compoundFlags[] array maps the compound flags - # to their individual arrays/ - # - print >>f, 'const Flags *Trace::compoundFlags[] =' - print >>f, '{' - print >>f, ' AllMap,' - for flag, compound, desc in allFlags: - if compound: - print >>f, ' %sMap,' % flag - # file trailer - print >>f, '};' + code('SimpleFlag $name("$name", "$desc");') + else: + comp_code('CompoundFlag $name("$name", "$desc",') + comp_code.indent() + last = len(compound) - 1 + for i,flag in enumerate(compound): + if i != last: + comp_code('$flag,') + else: + comp_code('$flag);') + comp_code.dedent() + + code.append(comp_code) + code() + code('} // namespace Debug') - f.close() + code.write(str(target[0])) -def traceFlagsHH(target, source, env): - assert(len(target) == 1) +def makeDebugFlagHH(target, source, env): + assert(len(target) == 1 and len(source) == 1) - f = file(str(target[0]), 'w') + val = eval(source[0].get_contents()) + name, compound, desc = val - allFlags = getFlags(source) + code = code_formatter() # file header boilerplate - print >>f, ''' + code('''\ /* - * DO NOT EDIT THIS FILE! - * - * Automatically generated from traceflags.py + * DO NOT EDIT THIS FILE! Automatically generated by SCons. */ -#ifndef __BASE_TRACE_FLAGS_HH__ -#define __BASE_TRACE_FLAGS_HH__ - -namespace Trace { - -enum Flags {''' - - # Generate the enum. Base flags come first, then compound flags. - idx = 0 - for flag, compound, desc in allFlags: - if not compound: - print >>f, ' %s = %d,' % (flag, idx) - idx += 1 - - numBaseFlags = idx - print >>f, ' NumFlags = %d,' % idx - - # put a comment in here to separate base from compound flags - print >>f, ''' -// The remaining enum values are *not* valid indices for Trace::flags. -// They are "compound" flags, which correspond to sets of base -// flags, and are used by changeFlag.''' - - print >>f, ' All = %d,' % idx - idx += 1 - for flag, compound, desc in allFlags: - if compound: - print >>f, ' %s = %d,' % (flag, idx) - idx += 1 +#ifndef __DEBUG_${name}_HH__ +#define __DEBUG_${name}_HH__ - numCompoundFlags = idx - numBaseFlags - print >>f, ' NumCompoundFlags = %d' % numCompoundFlags +namespace Debug { +''') - # trailer boilerplate - print >>f, '''\ -}; // enum Flags + if compound: + code('class CompoundFlag;') + code('class SimpleFlag;') -// Array of strings for SimpleEnumParam -extern const char *flagStrings[]; -extern const int numFlagStrings; + if compound: + code('extern CompoundFlag $name;') + for flag in compound: + code('extern SimpleFlag $flag;') + else: + code('extern SimpleFlag $name;') -// Array of arraay pointers: for each compound flag, gives the list of -// base flags to set. Inidividual flag arrays are terminated by -1. -extern const Flags *compoundFlags[]; + code(''' +} -/* namespace Trace */ } +#endif // __DEBUG_${name}_HH__ +''') -#endif // __BASE_TRACE_FLAGS_HH__ -''' + code.write(str(target[0])) - f.close() +for name,flag in sorted(debug_flags.iteritems()): + n, compound, desc = flag + assert n == name -flags = map(Value, trace_flags.values()) -env.Command('base/traceflags.py', flags, traceFlagsPy) -PySource('m5', 'base/traceflags.py') + hh_file = 'debug/%s.hh' % name + env.Command(hh_file, Value(flag), + MakeAction(makeDebugFlagHH, Transform("TRACING", 0))) + env.Depends(SWIG, hh_file) -env.Command('base/traceflags.hh', flags, traceFlagsHH) -env.Command('base/traceflags.cc', flags, traceFlagsCC) -Source('base/traceflags.cc') +env.Command('debug/flags.cc', Value(debug_flags), + MakeAction(makeDebugFlagCC, Transform("TRACING", 0))) +env.Depends(SWIG, 'debug/flags.cc') +Source('debug/flags.cc') -# embed python files. All .py files that have been indicated by a +# Embed python files. All .py files that have been indicated by a # PySource() call in a SConscript need to be embedded into the M5 # library. To do that, we compile the file to byte code, marshal the -# byte code, compress it, and then generate an assembly file that -# inserts the result into the data section with symbols indicating the -# beginning, and end (and with the size at the end) -def objectifyPyFile(target, source, env): +# byte code, compress it, and then generate a c++ file that +# inserts the result into an array. +def embedPyFile(target, source, env): + def c_str(string): + if string is None: + return "0" + return '"%s"' % string + '''Action function to compile a .py into a code object, marshal it, compress it, and stick it into an asm file so the code appears as just bytes with a label in the data section''' src = file(str(source[0]), 'r').read() - dst = file(str(target[0]), 'w') pysource = PySource.tnodes[source[0]] - compiled = compile(src, pysource.debugname, 'exec') + compiled = compile(src, pysource.abspath, 'exec') marshalled = marshal.dumps(compiled) compressed = zlib.compress(marshalled) data = compressed + sym = pysource.symname - # Some C/C++ compilers prepend an underscore to global symbol - # names, so if they're going to do that, we need to prepend that - # leading underscore to globals in the assembly file. - if env['LEADING_UNDERSCORE']: - sym = '_' + pysource.symname - else: - sym = pysource.symname + code = code_formatter() + code('''\ +#include "sim/init.hh" + +namespace { +const uint8_t data_${sym}[] = { +''') + code.indent() step = 16 - print >>dst, ".data" - print >>dst, ".globl %s_beg" % sym - print >>dst, ".globl %s_end" % sym - print >>dst, "%s_beg:" % sym for i in xrange(0, len(data), step): x = array.array('B', data[i:i+step]) - print >>dst, ".byte", ','.join([str(d) for d in x]) - print >>dst, "%s_end:" % sym - print >>dst, ".long %d" % len(marshalled) - -for source in PySource.all: - env.Command(source.assembly, source.tnode, objectifyPyFile) - Source(source.assembly) - -# Generate init_python.cc which creates a bunch of EmbeddedPyModule -# structs that describe the embedded python code. One such struct -# contains information about the importer that python uses to get at -# the embedded files, and then there's a list of all of the rest that -# the importer uses to load the rest on demand. -def pythonInit(target, source, env): - dst = file(str(target[0]), 'w') - - def dump_mod(sym, endchar=','): - pysource = PySource.symnames[sym] - print >>dst, ' { "%s",' % pysource.arcname - print >>dst, ' "%s",' % pysource.modpath - print >>dst, ' %s_beg, %s_end,' % (sym, sym) - print >>dst, ' %s_end - %s_beg,' % (sym, sym) - print >>dst, ' *(int *)%s_end }%s' % (sym, endchar) + code(''.join('%d,' % d for d in x)) + code.dedent() - print >>dst, '#include "sim/init.hh"' - - for sym in source: - sym = sym.get_contents() - print >>dst, "extern const char %s_beg[], %s_end[];" % (sym, sym) - - print >>dst, "const EmbeddedPyModule embeddedPyImporter = " - dump_mod("PyEMB_importer", endchar=';'); - print >>dst - - print >>dst, "const EmbeddedPyModule embeddedPyModules[] = {" - for i,sym in enumerate(source): - sym = sym.get_contents() - if sym == "PyEMB_importer": - # Skip the importer since we've already exported it - continue - dump_mod(sym) - print >>dst, " { 0, 0, 0, 0, 0, 0 }" - print >>dst, "};" - + code('''}; + +EmbeddedPython embedded_${sym}( + ${{c_str(pysource.arcname)}}, + ${{c_str(pysource.abspath)}}, + ${{c_str(pysource.modpath)}}, + data_${sym}, + ${{len(data)}}, + ${{len(marshalled)}}); + +} // anonymous namespace +''') + code.write(str(target[0])) -env.Command('sim/init_python.cc', - map(Value, (s.symname for s in PySource.all)), - pythonInit) -Source('sim/init_python.cc') +for source in PySource.all: + env.Command(source.cpp, source.tnode, + MakeAction(embedPyFile, Transform("EMBED PY"))) + env.Depends(SWIG, source.cpp) + Source(source.cpp, skip_no_python=True) ######################################################################## # @@ -949,30 +982,83 @@ Source('sim/init_python.cc') # # List of constructed environments to pass back to SConstruct -envList = [] - date_source = Source('base/date.cc', skip_lib=True) +# Capture this directory for the closure makeEnv, otherwise when it is +# called, it won't know what directory it should use. +variant_dir = Dir('.').path +def variant(*path): + return os.path.join(variant_dir, *path) +def variantd(*path): + return variant(*path)+'/' + # Function to create a new build environment as clone of current # environment 'env' with modified object suffix and optional stripped # binary. Additional keyword arguments are appended to corresponding # build environment vars. -def makeEnv(label, objsfx, strip = False, **kwargs): +def makeEnv(env, label, objsfx, strip = False, **kwargs): # SCons doesn't know to append a library suffix when there is a '.' in the # name. Use '_' instead. - libname = 'm5_' + label - exename = 'm5.' + label + libname = variant('gem5_' + label) + exename = variant('gem5.' + label) + secondary_exename = variant('m5.' + label) new_env = env.Clone(OBJSUFFIX=objsfx, SHOBJSUFFIX=objsfx + 's') new_env.Label = label new_env.Append(**kwargs) swig_env = new_env.Clone() - swig_env.Append(CCFLAGS='-Werror') + + # Both gcc and clang have issues with unused labels and values in + # the SWIG generated code + swig_env.Append(CCFLAGS=['-Wno-unused-label', '-Wno-unused-value']) + + # Add additional warnings here that should not be applied to + # the SWIG generated code + new_env.Append(CXXFLAGS='-Wmissing-declarations') + if env['GCC']: - swig_env.Append(CCFLAGS='-Wno-uninitialized') - swig_env.Append(CCFLAGS='-Wno-sign-compare') - swig_env.Append(CCFLAGS='-Wno-parentheses') + # Depending on the SWIG version, we also need to supress + # warnings about uninitialized variables and missing field + # initializers. + swig_env.Append(CCFLAGS=['-Wno-uninitialized', + '-Wno-missing-field-initializers', + '-Wno-unused-but-set-variable']) + + # If gcc supports it, also warn for deletion of derived + # classes with non-virtual desctructors. For gcc >= 4.7 we + # also have to disable warnings about the SWIG code having + # potentially uninitialized variables. + if compareVersions(env['GCC_VERSION'], '4.7') >= 0: + new_env.Append(CXXFLAGS='-Wdelete-non-virtual-dtor') + swig_env.Append(CCFLAGS='-Wno-maybe-uninitialized') + + # Only gcc >= 4.9 supports UBSan, so check both the version + # and the command-line option before adding the compiler and + # linker flags. + if GetOption('with_ubsan') and \ + compareVersions(env['GCC_VERSION'], '4.9') >= 0: + new_env.Append(CCFLAGS='-fsanitize=undefined') + new_env.Append(LINKFLAGS='-fsanitize=undefined') + + if env['CLANG']: + # Always enable the warning for deletion of derived classes + # with non-virtual destructors + new_env.Append(CXXFLAGS=['-Wdelete-non-virtual-dtor']) + + swig_env.Append(CCFLAGS=[ + # Some versions of SWIG can return uninitialized values + '-Wno-sometimes-uninitialized', + # Register storage is requested in a lot of places in + # SWIG-generated code. + '-Wno-deprecated-register', + ]) + + # All supported clang versions have support for UBSan, so if + # asked to use it, append the compiler and linker flags. + if GetOption('with_ubsan'): + new_env.Append(CCFLAGS='-fsanitize=undefined') + new_env.Append(LINKFLAGS='-fsanitize=undefined') werror_env = new_env.Clone() werror_env.Append(CCFLAGS='-Werror') @@ -999,12 +1085,19 @@ def makeEnv(label, objsfx, strip = False, **kwargs): return obj - static_objs = [ make_obj(s, True) for s in Source.get(skip_lib=False)] - shared_objs = [ make_obj(s, False) for s in Source.get(skip_lib=False)] + lib_guards = {'main': False, 'skip_lib': False} + + # Without Python, leave out all SWIG and Python content from the + # library builds. The option doesn't affect gem5 built as a program + if GetOption('without_python'): + lib_guards['skip_no_python'] = False + + static_objs = [ make_obj(s, True) for s in Source.get(**lib_guards) ] + shared_objs = [ make_obj(s, False) for s in Source.get(**lib_guards) ] static_date = make_obj(date_source, static=True, extra_deps=static_objs) static_objs.append(static_date) - + shared_date = make_obj(date_source, static=False, extra_deps=shared_objs) shared_objs.append(shared_date) @@ -1013,70 +1106,173 @@ def makeEnv(label, objsfx, strip = False, **kwargs): static_lib = new_env.StaticLibrary(libname, static_objs) shared_lib = new_env.SharedLibrary(libname, shared_objs) - for target, sources in unit_tests: - objs = [ make_obj(s, static=True) for s in sources ] - new_env.Program("unittest/%s.%s" % (target, label), objs + static_objs) - # Now link a stub with main() and the static library. - bin_objs = [make_obj(s, True) for s in Source.get(bin_only=True) ] + main_objs = [ make_obj(s, True) for s in Source.get(main=True) ] + + for test in UnitTest.all: + flags = { test.target : True } + test_sources = Source.get(**flags) + test_objs = [ make_obj(s, static=True) for s in test_sources ] + if test.main: + test_objs += main_objs + path = variant('unittest/%s.%s' % (test.target, label)) + new_env.Program(path, test_objs + static_objs) + progname = exename if strip: progname += '.unstripped' - targets = new_env.Program(progname, bin_objs + static_objs) + targets = new_env.Program(progname, main_objs + static_objs) if strip: if sys.platform == 'sunos5': cmd = 'cp $SOURCE $TARGET; strip $TARGET' else: cmd = 'strip $SOURCE -o $TARGET' - targets = new_env.Command(exename, progname, cmd) - - new_env.M5Binary = targets[0] - envList.append(new_env) + targets = new_env.Command(exename, progname, + MakeAction(cmd, Transform("STRIP"))) + + new_env.Command(secondary_exename, exename, + MakeAction('ln $SOURCE $TARGET', Transform("HARDLINK"))) -# Debug binary -ccflags = {} + new_env.M5Binary = targets[0] + return new_env + +# Start out with the compiler flags common to all compilers, +# i.e. they all use -g for opt and -g -pg for prof +ccflags = {'debug' : [], 'opt' : ['-g'], 'fast' : [], 'prof' : ['-g', '-pg'], + 'perf' : ['-g']} + +# Start out with the linker flags common to all linkers, i.e. -pg for +# prof, and -lprofiler for perf. The -lprofile flag is surrounded by +# no-as-needed and as-needed as the binutils linker is too clever and +# simply doesn't link to the library otherwise. +ldflags = {'debug' : [], 'opt' : [], 'fast' : [], 'prof' : ['-pg'], + 'perf' : ['-Wl,--no-as-needed', '-lprofiler', '-Wl,--as-needed']} + +# For Link Time Optimization, the optimisation flags used to compile +# individual files are decoupled from those used at link time +# (i.e. you can compile with -O3 and perform LTO with -O0), so we need +# to also update the linker flags based on the target. if env['GCC']: if sys.platform == 'sunos5': - ccflags['debug'] = '-gstabs+' + ccflags['debug'] += ['-gstabs+'] else: - ccflags['debug'] = '-ggdb3' - ccflags['opt'] = '-g -O3' - ccflags['fast'] = '-O3' - ccflags['prof'] = '-O3 -g -pg' -elif env['SUNCC']: - ccflags['debug'] = '-g0' - ccflags['opt'] = '-g -O' - ccflags['fast'] = '-fast' - ccflags['prof'] = '-fast -g -pg' -elif env['ICC']: - ccflags['debug'] = '-g -O0' - ccflags['opt'] = '-g -O' - ccflags['fast'] = '-fast' - ccflags['prof'] = '-fast -g -pg' + ccflags['debug'] += ['-ggdb3'] + ldflags['debug'] += ['-O0'] + # opt, fast, prof and perf all share the same cc flags, also add + # the optimization to the ldflags as LTO defers the optimization + # to link time + for target in ['opt', 'fast', 'prof', 'perf']: + ccflags[target] += ['-O3'] + ldflags[target] += ['-O3'] + + ccflags['fast'] += env['LTO_CCFLAGS'] + ldflags['fast'] += env['LTO_LDFLAGS'] +elif env['CLANG']: + ccflags['debug'] += ['-g', '-O0'] + # opt, fast, prof and perf all share the same cc flags + for target in ['opt', 'fast', 'prof', 'perf']: + ccflags[target] += ['-O3'] else: print 'Unknown compiler, please fix compiler options' Exit(1) -makeEnv('debug', '.do', - CCFLAGS = Split(ccflags['debug']), - CPPDEFINES = ['DEBUG', 'TRACING_ON=1']) - -# Optimized binary -makeEnv('opt', '.o', - CCFLAGS = Split(ccflags['opt']), - CPPDEFINES = ['TRACING_ON=1']) - -# "Fast" binary -makeEnv('fast', '.fo', strip = True, - CCFLAGS = Split(ccflags['fast']), - CPPDEFINES = ['NDEBUG', 'TRACING_ON=0']) - -# Profiled binary -makeEnv('prof', '.po', - CCFLAGS = Split(ccflags['prof']), - CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'], - LINKFLAGS = '-pg') -Return('envList') +# To speed things up, we only instantiate the build environments we +# need. We try to identify the needed environment for each target; if +# we can't, we fall back on instantiating all the environments just to +# be safe. +target_types = ['debug', 'opt', 'fast', 'prof', 'perf'] +obj2target = {'do': 'debug', 'o': 'opt', 'fo': 'fast', 'po': 'prof', + 'gpo' : 'perf'} + +def identifyTarget(t): + ext = t.split('.')[-1] + if ext in target_types: + return ext + if obj2target.has_key(ext): + return obj2target[ext] + match = re.search(r'/tests/([^/]+)/', t) + if match and match.group(1) in target_types: + return match.group(1) + return 'all' + +needed_envs = [identifyTarget(target) for target in BUILD_TARGETS] +if 'all' in needed_envs: + needed_envs += target_types + +gem5_root = Dir('.').up().up().abspath +def makeEnvirons(target, source, env): + # cause any later Source() calls to be fatal, as a diagnostic. + Source.done() + + envList = [] + + # Debug binary + if 'debug' in needed_envs: + envList.append( + makeEnv(env, 'debug', '.do', + CCFLAGS = Split(ccflags['debug']), + CPPDEFINES = ['DEBUG', 'TRACING_ON=1'], + LINKFLAGS = Split(ldflags['debug']))) + + # Optimized binary + if 'opt' in needed_envs: + envList.append( + makeEnv(env, 'opt', '.o', + CCFLAGS = Split(ccflags['opt']), + CPPDEFINES = ['TRACING_ON=1'], + LINKFLAGS = Split(ldflags['opt']))) + + # "Fast" binary + if 'fast' in needed_envs: + envList.append( + makeEnv(env, 'fast', '.fo', strip = True, + CCFLAGS = Split(ccflags['fast']), + CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'], + LINKFLAGS = Split(ldflags['fast']))) + + # Profiled binary using gprof + if 'prof' in needed_envs: + envList.append( + makeEnv(env, 'prof', '.po', + CCFLAGS = Split(ccflags['prof']), + CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'], + LINKFLAGS = Split(ldflags['prof']))) + + # Profiled binary using google-pprof + if 'perf' in needed_envs: + envList.append( + makeEnv(env, 'perf', '.gpo', + CCFLAGS = Split(ccflags['perf']), + CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'], + LINKFLAGS = Split(ldflags['perf']))) + + # Set up the regression tests for each build. + for e in envList: + SConscript(os.path.join(gem5_root, 'tests', 'SConscript'), + variant_dir = variantd('tests', e.Label), + exports = { 'env' : e }, duplicate = False) + +# The MakeEnvirons Builder defers the full dependency collection until +# after processing the ISA definition (due to dynamically generated +# source files). Add this dependency to all targets so they will wait +# until the environments are completely set up. Otherwise, a second +# process (e.g. -j2 or higher) will try to compile the requested target, +# not know how, and fail. +env.Append(BUILDERS = {'MakeEnvirons' : + Builder(action=MakeAction(makeEnvirons, + Transform("ENVIRONS", 1)))}) + +isa_target = env['PHONY_BASE'] + '-deps' +environs = env['PHONY_BASE'] + '-environs' +env.Depends('#all-deps', isa_target) +env.Depends('#all-environs', environs) +env.ScanISA(isa_target, File('arch/%s/generated/inc.d' % env['TARGET_ISA'])) +envSetup = env.MakeEnvirons(environs, isa_target) + +# make sure no -deps targets occur before all ISAs are complete +env.Depends(isa_target, '#all-isas') +# likewise for -environs targets and all the -deps targets +env.Depends(environs, '#all-deps')