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('*')
build_env = [(opt, env[opt]) for opt in export_vars]
-from m5.util import code_formatter
+from m5.util import code_formatter, compareVersions
########################################################################
# Code for adding source files of various types
# 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 m5 main() function
-# skip_lib -- do not put this file into the m5 library
+# main -- specifies the gem5 main() function
+# skip_lib -- do not put this file into the gem5 library
# <unittest> -- unit tests use filters based on the unit test name
#
# A parent can now be specified for a source file and default filter
self.cc_source = Source(cc_file, swig=True, parent=self)
self.py_source = PySource(package, py_file, parent=self)
-unit_tests = []
-def UnitTest(target, sources):
- '''Create a unit test, specify the target name and a source or
- list of sources'''
- if not isinstance(sources, (list, tuple)):
- sources = [ sources ]
+class UnitTest(object):
+ '''Create a UnitTest'''
+
+ all = []
+ def __init__(self, target, *sources):
+ '''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)
- sources = [ Source(src, skip_lib=True) for src in sources ]
- unit_tests.append((target, sources))
+ self.sources = srcs
+ self.target = target
+ UnitTest.all.append(self)
# Children should have access
Export('Source')
if name in debug_flags:
raise AttributeError, "Flag %s already specified" % name
debug_flags[name] = (name, (), desc)
-TraceFlag = DebugFlag
def CompoundFlag(name, flags, desc=None):
if name in debug_flags:
debug_flags[name] = (name, compound, desc)
Export('DebugFlag')
-Export('TraceFlag')
Export('CompoundFlag')
########################################################################
env.Append(CPPPATH=Dir(extra_dir))
# 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:])
for extra_dir in extras_dir_list:
prefix_len = len(dirname(extra_dir)) + 1
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'), variant_dir=build_dir)
sim_objects = m5.SimObject.allClasses
all_enums = m5.params.allEnums
-all_params = {}
+# 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
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
########################################################################
#
# Generate a file that wraps the basic top level files
env.Command('python/m5/info.py',
- [ '#/AUTHORS', '#/LICENSE', '#/README', ],
+ [ '#/COPYING', '#/LICENSE', '#/README', ],
MakeAction(makeInfoPyFile, Transform("INFO")))
PySource('m5', 'python/m5/info.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
name = str(source[0].get_contents())
obj = sim_objects[name]
code = code_formatter()
- obj.cxx_decl(code)
+ obj.cxx_param_decl(code)
code.write(target[0].abspath)
-def createSwigParam(target, source, env):
+def createParamSwigWrapper(target, source, env):
assert len(target) == 1 and len(source) == 1
name = str(source[0].get_contents())
- param = all_params[name]
+ param = params_to_swig[name]
code = code_formatter()
- code('%module(package="m5.internal") $0_${name}', param.file_ext)
param.swig_decl(code)
code.write(target[0].abspath)
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
name = str(source[0].get_contents())
obj.cxx_decl(code)
code.write(target[0].abspath)
-def createEnumSwig(target, source, env):
+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()
- code('''\
-%module(package="m5.internal") enum_$name
+ obj.swig_decl(code)
+ code.write(target[0].abspath)
-%{
-#include "enums/$name.hh"
-%}
+def createSimObjectSwigWrapper(target, source, env):
+ name = source[0].get_contents()
+ obj = sim_objects[name]
-%include "enums/$name.hh"
-''')
+ code = code_formatter()
+ obj.swig_decl(code)
code.write(target[0].abspath)
-# 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__]
hh_file = File('params/%s.hh' % name)
params_hh_files.append(hh_file)
env.Command(hh_file, Value(name),
- MakeAction(createSimObjectParam, Transform("SO PARAM")))
+ MakeAction(createSimObjectParamStruct, Transform("SO PARAM")))
env.Depends(hh_file, depends + extra_deps)
-# Generate any parameter header files needed
+# Generate any needed param SWIG wrapper files
params_i_files = []
-for name,param in all_params.iteritems():
- i_file = File('python/m5/internal/%s_%s.i' % (param.file_ext, name))
+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),
- MakeAction(createSwigParam, Transform("SW PARAM")))
+ MakeAction(createParamSwigWrapper, Transform("SW PARAM")))
env.Depends(i_file, depends)
SwigSource('m5.internal', i_file)
hh_file = File('enums/%s.hh' % name)
env.Command(hh_file, Value(name),
- MakeAction(createEnumParam, Transform("EN PARAM")))
+ MakeAction(createEnumDecls, Transform("ENUMDECL")))
env.Depends(hh_file, depends + extra_deps)
i_file = File('python/m5/internal/enum_%s.i' % name)
env.Command(i_file, Value(name),
- MakeAction(createEnumSwig, Transform("ENUMSWIG")))
+ MakeAction(createEnumSwigWrapper, Transform("ENUMSWIG")))
env.Depends(i_file, depends + extra_deps)
SwigSource('m5.internal', i_file)
-def buildParam(target, source, env):
- name = source[0].get_contents()
- obj = sim_objects[name]
- class_path = obj.cxx_class.split('::')
- classname = class_path[-1]
- namespaces = class_path[:-1]
- params = obj._params.local.values()
-
- code = code_formatter()
-
- code('%module(package="m5.internal") param_$name')
- code()
- code('%{')
- code('#include "params/$obj.hh"')
- for param in params:
- param.cxx_predecls(code)
- code('%}')
- code()
-
- for param in params:
- param.swig_predecls(code)
-
- code()
- if obj._base:
- code('%import "python/m5/internal/param_${{obj._base}}.i"')
- code()
- obj.swig_objdecls(code)
- code()
-
- code('%include "params/$obj.hh"')
-
- code.write(target[0].abspath)
-
+# Generate SimObject SWIG wrapper files
for name in sim_objects.iterkeys():
- params_file = File('python/m5/internal/param_%s.i' % name)
- env.Command(params_file, Value(name),
- MakeAction(buildParam, Transform("BLDPARAM")))
- env.Depends(params_file, depends)
- SwigSource('m5.internal', 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)
+ SwigSource('m5.internal', i_file)
# Generate the main swig init file
def makeEmbeddedSwigInit(target, source, env):
env.Command([swig.cc_source.tnode, swig.py_source.tnode], swig.tnode,
MakeAction('$SWIG $SWIGFLAGS -outdir ${TARGETS[1].dir} '
'-o ${TARGETS[0]} $SOURCES', Transform("SWIG")))
- init_file = 'python/swig/init_%s.cc' % swig.module
+ 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")))
- Source(init_file)
+ Source(init_file, **swig.guards)
#
# Handle debug flags
namespace {
-const char data_${sym}[] = {
+const uint8_t data_${sym}[] = {
''')
code.indent()
step = 16
def makeEnv(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 = 'gem5_' + label
+ exename = 'gem5.' + label
+ secondary_exename = 'm5.' + label
new_env = env.Clone(OBJSUFFIX=objsfx, SHOBJSUFFIX=objsfx + 's')
new_env.Label = label
swig_env.Append(CCFLAGS='-Wno-uninitialized')
swig_env.Append(CCFLAGS='-Wno-sign-compare')
swig_env.Append(CCFLAGS='-Wno-parentheses')
+ swig_env.Append(CCFLAGS='-Wno-unused-label')
+ if compareVersions(env['GCC_VERSION'], '4.6') >= 0:
+ swig_env.Append(CCFLAGS='-Wno-unused-but-set-variable')
+ if env['CLANG']:
+ swig_env.Append(CCFLAGS=['-Wno-unused-label'])
+
werror_env = new_env.Clone()
werror_env.Append(CCFLAGS='-Werror')
return obj
- sources = Source.get(main=False, skip_lib=False)
- static_objs = [ make_obj(s, True) for s in sources ]
- shared_objs = [ make_obj(s, False) for s in sources ]
+ static_objs = \
+ [ make_obj(s, True) for s in Source.get(main=False, skip_lib=False) ]
+ shared_objs = \
+ [ make_obj(s, False) for s in Source.get(main=False, skip_lib=False) ]
static_date = make_obj(date_source, static=True, extra_deps=static_objs)
static_objs.append(static_date)
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.
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 ]
+ testname = "unittest/%s.%s" % (test.target, label)
+ new_env.Program(testname, test_objs + static_objs)
+
progname = exename
if strip:
progname += '.unstripped'
cmd = 'strip $SOURCE -o $TARGET'
targets = new_env.Command(exename, progname,
MakeAction(cmd, Transform("STRIP")))
-
+
+ new_env.Command(secondary_exename, exename,
+ MakeAction('ln $SOURCE $TARGET', Transform("HARDLINK")))
+
new_env.M5Binary = targets[0]
envList.append(new_env)
ccflags['opt'] = '-g -O'
ccflags['fast'] = '-fast'
ccflags['prof'] = '-fast -g -pg'
+elif env['CLANG']:
+ ccflags['debug'] = '-g -O0'
+ ccflags['opt'] = '-g -O3'
+ ccflags['fast'] = '-O3'
+ ccflags['prof'] = '-O3 -g -pg'
else:
print 'Unknown compiler, please fix compiler options'
Exit(1)
-makeEnv('debug', '.do',
- CCFLAGS = Split(ccflags['debug']),
- CPPDEFINES = ['DEBUG', 'TRACING_ON=1'])
+
+# 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']
+obj2target = {'do': 'debug', 'o': 'opt', 'fo': 'fast', 'po': 'prof'}
+
+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
+
+# Debug binary
+if 'debug' in needed_envs:
+ 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'])
+if 'opt' in needed_envs:
+ 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'])
+if 'fast' in needed_envs:
+ 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')
+if 'prof' in needed_envs:
+ makeEnv('prof', '.po',
+ CCFLAGS = Split(ccflags['prof']),
+ CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'],
+ LINKFLAGS = '-pg')
Return('envList')