X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2FSConscript;h=8dccd0900085a0435247bd8d02516c02de47d212;hb=8573a69d8f7bf7b3f074e3e0ac64994801c551be;hp=0ee144747683547c53af18679a2d98b832865bc0;hpb=e3d8d43b176d3a1eb69a5e5d16469d42292e514a;p=gem5.git

diff --git a/src/SConscript b/src/SConscript
index 0ee144747..8dccd0900 100755
--- 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,47 +51,97 @@ Export('env')
 
 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
 #
+# 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
+#     <unittest> -- 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)
-        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:]
 
         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
+            return self.basename, None
+
+        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
     def __gt__(self, other): return self.filename > other.filename
@@ -101,14 +151,12 @@ class SourceFile(object):
         
 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'''
@@ -117,8 +165,9 @@ class PySource(SourceFile):
     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'
@@ -158,8 +207,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."
 
@@ -168,8 +219,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, **guards)
 
         modname,ext = self.extname
         assert ext == 'i'
@@ -178,42 +230,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)
+        self.py_source = PySource(package, py_file, parent=self)
+
+class ProtoBuf(SourceFile):
+    '''Add a Protocol Buffer to build'''
 
-unit_tests = []
-def UnitTest(target, sources):
-    if not isinstance(sources, (list, tuple)):
-        sources = [ sources ]
+    def __init__(self, source, **guards):
+        '''Specify the source file, and any guards'''
+        super(ProtoBuf, self).__init__(source, **guards)
 
-    sources = [ Source(src, skip_lib=True) for src in sources ]
-    unit_tests.append((target, sources))
+        # 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(joinpath(self.dirname, modname + '.pb.cc'))
+        self.hh_file = File(joinpath(self.dirname, 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')
 
 ########################################################################
@@ -231,7 +314,7 @@ for extra_dir in extras_dir_list:
     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:])
 
@@ -253,6 +336,10 @@ for root, dirs, files in os.walk(base_dir, topdown=True):
 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)
@@ -284,6 +371,7 @@ def makeTheISA(source, target, env):
 
 #define THE_ISA ${{define(target_isa)}}
 #define TheISA ${{namespace(target_isa)}}
+#define THE_ISA_STR "${{target_isa}}"
 
 #endif // __CONFIG_THE_ISA_HH__''')
 
@@ -380,7 +468,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
@@ -392,8 +492,8 @@ 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
 
 ########################################################################
 #
@@ -410,7 +510,7 @@ depends = [ PySource.modules[dep].snode 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 = code_formatter()
     code("""
@@ -418,7 +518,6 @@ import m5.internal
 import m5.util
 
 buildEnv = m5.util.SmartDict($build_env)
-hgRev = '$hg_info'
 
 compileDate = m5.internal.core.compileDate
 _globals = globals()
@@ -430,7 +529,7 @@ del _globals
 """)
     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,
             MakeAction(makeDefinesPyFile, Transform("DEFINES", 0)))
@@ -446,7 +545,7 @@ def makeInfoPyFile(target, source, env):
 
 # 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')
 
@@ -455,24 +554,23 @@ 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)
 
@@ -486,7 +584,7 @@ def createEnumStrings(target, source, env):
     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())
@@ -496,25 +594,25 @@ def createEnumParam(target, source, env):
     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__]
@@ -523,16 +621,16 @@ 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),
-                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)
 
@@ -549,54 +647,25 @@ for name,enum in sorted(all_enums.iteritems()):
 
     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,simobj in sim_objects.iteritems():
+    py_source = PySource.modules[simobj.__module__]
+    extra_deps = [ py_source.tnode ]
 
-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 + extra_deps)
+    SwigSource('m5.internal', i_file)
 
 # Generate the main swig init file
 def makeEmbeddedSwigInit(target, source, env):
@@ -618,86 +687,40 @@ for swig in SwigSource.all:
     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)
-
-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)
-    code = code_formatter()
-
-    allFlags = getFlags(source)
-
-    code('basic = [')
-    code.indent()
-    for flag, compound, desc in allFlags:
-        if not compound:
-            code("'$flag',")
-    code(']')
-    code.dedent()
-    code()
-
-    code('compound = [')
-    code.indent()
-    code("'All',")
-    for flag, compound, desc in allFlags:
-        if compound:
-            code("'$flag',")
-    code("]")
-    code.dedent()
-    code()
-
-    code("all = frozenset(basic + compound)")
-    code()
-
-    code('compoundMap = {')
-    code.indent()
-    all = tuple([flag for flag,compound,desc in allFlags if not compound])
-    code("'All' : $all,")
-    for flag, compound, desc in allFlags:
-        if compound:
-            code("'$flag' : $compound,")
-    code('}')
-    code.dedent()
-    code()
-
-    code('descriptions = {')
-    code.indent()
-    code("'All' : 'All flags',")
-    for flag, compound, desc in allFlags:
-        code("'$flag' : '$desc',")
-    code("}")
-    code.dedent()
+    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")))
+
+        # Add the C++ source file
+        Source(proto.cc_file, **proto.guards)
+elif ProtoBuf.all:
+    print 'Got protobuf to build, but lacks support!'
+    Exit(1)
 
-    code.write(str(target[0]))
+#
+# Handle debug flags
+#
+def makeDebugFlagCC(target, source, env):
+    assert(len(target) == 1 and len(source) == 1)
 
-def traceFlagsCC(target, source, env):
-    assert(len(target) == 1)
+    val = eval(source[0].get_contents())
+    name, compound, desc = val
+    compound = list(sorted(compound))
 
-    allFlags = getFlags(source)
     code = code_formatter()
 
     # file header
@@ -706,75 +729,39 @@ def traceFlagsCC(target, source, env):
  * DO NOT EDIT THIS FILE! Automatically generated
  */
 
-#include "base/traceflags.hh"
-
-using namespace Trace;
-
-const char *Trace::flagStrings[] =
-{''')
-
-    code.indent()
-    # 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:
-            code('"$flag",')
-
-    code('"All",')
-    for flag, compound, desc in allFlags:
-        if compound:
-            code('"$flag",')
-    code.dedent()
-
-    code('''\
-};
-
-const int Trace::numFlagStrings = ${{len(allFlags) + 1}};
-
+#include "base/debug.hh"
 ''')
 
-    # 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])
-    code('static const Flags AllMap[] = {')
-    code.indent()
-    for flag, compound, desc in allFlags:
-        if not compound:
-            code('$flag,')
-    code.dedent()
-    code('};')
+    for flag in compound:
+        code('#include "debug/$flag.hh"')
+    code()
+    code('namespace Debug {')
     code()
 
-    for flag, compound, desc in allFlags:
-        if not compound:
-            continue
-        code('static const Flags ${flag}Map[] = {')
+    if not compound:
+        code('SimpleFlag $name("$name", "$desc");')
+    else:
+        code('CompoundFlag $name("$name", "$desc",')
         code.indent()
-        for flag in compound:
-            code('$flag,')
-        code('(Flags)-1')
+        last = len(compound) - 1
+        for i,flag in enumerate(compound):
+            if i != last:
+                code('$flag,')
+            else:
+                code('$flag);')
         code.dedent()
-        code('};')
-        code()
 
-    # Finally the compoundFlags[] array maps the compound flags
-    # to their individual arrays/
-    code('const Flags *Trace::compoundFlags[] = {')
-    code.indent()
-    code('AllMap,')
-    for flag, compound, desc in allFlags:
-        if compound:
-            code('${flag}Map,')
-    # file trailer
-    code.dedent()
-    code('};')
+    code()
+    code('} // namespace Debug')
 
     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)
+
+    val = eval(source[0].get_contents())
+    name, compound, desc = val
 
-    allFlags = getFlags(source)
     code = code_formatter()
 
     # file header boilerplate
@@ -782,76 +769,43 @@ def traceFlagsHH(target, source, env):
 /*
  * DO NOT EDIT THIS FILE!
  *
- * Automatically generated from traceflags.py
+ * Automatically generated by SCons
  */
 
-#ifndef __BASE_TRACE_FLAGS_HH__
-#define __BASE_TRACE_FLAGS_HH__
+#ifndef __DEBUG_${name}_HH__
+#define __DEBUG_${name}_HH__
 
-namespace Trace {
-
-enum Flags {''')
+namespace Debug {
+''')
 
-    # Generate the enum.  Base flags come first, then compound flags.
-    idx = 0
-    code.indent()
-    for flag, compound, desc in allFlags:
-        if not compound:
-            code('$flag = $idx,')
-            idx += 1
+    if compound:
+        code('class CompoundFlag;')
+    code('class SimpleFlag;')
 
-    numBaseFlags = idx
-    code('NumFlags = $idx,')
-    code.dedent()
-    code()
+    if compound:
+        code('extern CompoundFlag $name;')
+        for flag in compound:
+            code('extern SimpleFlag $flag;')
+    else:
+        code('extern SimpleFlag $name;')
 
-    # put a comment in here to separate base from compound flags
     code('''
-// 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.''')
-
-    code.indent()
-    code('All = $idx,')
-    idx += 1
-    for flag, compound, desc in allFlags:
-        if compound:
-            code('$flag = $idx,')
-            idx += 1
-
-    numCompoundFlags = idx - numBaseFlags
-    code('NumCompoundFlags = $numCompoundFlags')
-    code.dedent()
-
-    # trailer boilerplate
-    code('''\
-}; // enum Flags
-
-// Array of strings for SimpleEnumParam
-extern const char *flagStrings[];
-extern const int numFlagStrings;
-
-// 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[];
-
-} // namespace Trace
+}
 
-#endif // __BASE_TRACE_FLAGS_HH__
+#endif // __DEBUG_${name}_HH__
 ''')
 
     code.write(str(target[0]))
 
-flags = map(Value, trace_flags.values())
-env.Command('base/traceflags.py', flags, 
-            MakeAction(traceFlagsPy, Transform("TRACING", 0)))
-PySource('m5', 'base/traceflags.py')
+for name,flag in sorted(debug_flags.iteritems()):
+    n, compound, desc = flag
+    assert n == name
 
-env.Command('base/traceflags.hh', flags,
-            MakeAction(traceFlagsHH, Transform("TRACING", 0)))
-env.Command('base/traceflags.cc', flags, 
-            MakeAction(traceFlagsCC, Transform("TRACING", 0)))
-Source('base/traceflags.cc')
+    env.Command('debug/%s.hh' % name, Value(flag),
+                MakeAction(makeDebugFlagHH, Transform("TRACING", 0)))
+    env.Command('debug/%s.cc' % name, Value(flag),
+                MakeAction(makeDebugFlagCC, Transform("TRACING", 0)))
+    Source('debug/%s.cc' % name)
 
 # Embed python files.  All .py files that have been indicated by a
 # PySource() call in a SConscript need to be embedded into the M5
@@ -883,7 +837,7 @@ def embedPyFile(target, source, env):
 
 namespace {
 
-const char data_${sym}[] = {
+const uint8_t data_${sym}[] = {
 ''')
     code.indent()
     step = 16
@@ -929,8 +883,9 @@ date_source = Source('base/date.cc', skip_lib=True)
 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
@@ -938,10 +893,34 @@ def makeEnv(label, objsfx, strip = False, **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 missing field initializers.
+        swig_env.Append(CCFLAGS='-Wno-missing-field-initializers')
+
+        if compareVersions(env['GCC_VERSION'], '4.6') >= 0:
+            swig_env.Append(CCFLAGS='-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')
+    if env['CLANG']:
+        # Always enable the warning for deletion of derived classes
+        # with non-virtual destructors
+        new_env.Append(CXXFLAGS=['-Wdelete-non-virtual-dtor'])
 
     werror_env = new_env.Clone()
     werror_env.Append(CCFLAGS='-Werror')
@@ -968,8 +947,10 @@ 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)]
+    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)
@@ -982,17 +963,23 @@ 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
+        testname = "unittest/%s.%s" % (test.target, label)
+        new_env.Program(testname, 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':
@@ -1001,52 +988,110 @@ def makeEnv(label, objsfx, strip = False, **kwargs):
             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)
 
-# Debug binary
-ccflags = {}
+# 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'])
+
+# 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
+
+# Debug binary
+if 'debug' in needed_envs:
+    makeEnv('debug', '.do',
+            CCFLAGS = Split(ccflags['debug']),
+            CPPDEFINES = ['DEBUG', 'TRACING_ON=1'],
+            LINKFLAGS = Split(ldflags['debug']))
 
 # 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'],
+            LINKFLAGS = Split(ldflags['opt']))
 
 # "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')
+if 'fast' in needed_envs:
+    makeEnv('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:
+    makeEnv('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:
+    makeEnv('perf', '.gpo',
+            CCFLAGS = Split(ccflags['perf']),
+            CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'],
+            LINKFLAGS = Split(ldflags['perf']))
 
 Return('envList')