src/SConscript

   1 # -*- mode:python -*-
   2
   3 # Copyright (c) 2004-2005 The Regents of The University of Michigan
   4 # All rights reserved.
   5 #
   6 # Redistribution and use in source and binary forms, with or without
   7 # modification, are permitted provided that the following conditions are
   8 # met: redistributions of source code must retain the above copyright
   9 # notice, this list of conditions and the following disclaimer;
  10 # redistributions in binary form must reproduce the above copyright
  11 # notice, this list of conditions and the following disclaimer in the
  12 # documentation and/or other materials provided with the distribution;
  13 # neither the name of the copyright holders nor the names of its
  14 # contributors may be used to endorse or promote products derived from
  15 # this software without specific prior written permission.
  16 #
  17 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28 #
  29 # Authors: Nathan Binkert
  30
  31 import array
  32 import bisect
  33 import imp
  34 import marshal
  35 import os
  36 import re
  37 import sys
  38 import zlib
  39
  40 from os.path import basename, dirname, exists, isdir, isfile, join as joinpath
  41
  42 import SCons
  43
  44 # This file defines how to build a particular configuration of gem5
  45 # based on variable settings in the 'env' build environment.
  46
  47 Import('*')
  48
  49 # Children need to see the environment
  50 Export('env')
  51
  52 build_env = [(opt, env[opt]) for opt in export_vars]
  53
  54 from m5.util import code_formatter, compareVersions
  55
  56 ########################################################################
  57 # Code for adding source files of various types
  58 #
  59 # When specifying a source file of some type, a set of guards can be
  60 # specified for that file.  When get() is used to find the files, if
  61 # get specifies a set of filters, only files that match those filters
  62 # will be accepted (unspecified filters on files are assumed to be
  63 # false).  Current filters are:
  64 #     main -- specifies the gem5 main() function
  65 #     skip_lib -- do not put this file into the gem5 library
  66 #     <unittest> -- unit tests use filters based on the unit test name
  67 #
  68 # A parent can now be specified for a source file and default filter
  69 # values will be retrieved recursively from parents (children override
  70 # parents).
  71 #
  72 class SourceMeta(type):
  73     '''Meta class for source files that keeps track of all files of a
  74     particular type and has a get function for finding all functions
  75     of a certain type that match a set of guards'''
  76     def __init__(cls, name, bases, dict):
  77         super(SourceMeta, cls).__init__(name, bases, dict)
  78         cls.all = []
  79
  80     def get(cls, **guards):
  81         '''Find all files that match the specified guards.  If a source
  82         file does not specify a flag, the default is False'''
  83         for src in cls.all:
  84             for flag,value in guards.iteritems():
  85                 # if the flag is found and has a different value, skip
  86                 # this file
  87                 if src.all_guards.get(flag, False) != value:
  88                     break
  89             else:
  90                 yield src
  91
  92 class SourceFile(object):
  93     '''Base object that encapsulates the notion of a source file.
  94     This includes, the source node, target node, various manipulations
  95     of those.  A source file also specifies a set of guards which
  96     describing which builds the source file applies to.  A parent can
  97     also be specified to get default guards from'''
  98     __metaclass__ = SourceMeta
  99     def __init__(self, source, parent=None, **guards):
 100         self.guards = guards
 101         self.parent = parent
 102
 103         tnode = source
 104         if not isinstance(source, SCons.Node.FS.File):
 105             tnode = File(source)
 106
 107         self.tnode = tnode
 108         self.snode = tnode.srcnode()
 109
 110         for base in type(self).__mro__:
 111             if issubclass(base, SourceFile):
 112                 base.all.append(self)
 113
 114     @property
 115     def filename(self):
 116         return str(self.tnode)
 117
 118     @property
 119     def dirname(self):
 120         return dirname(self.filename)
 121
 122     @property
 123     def basename(self):
 124         return basename(self.filename)
 125
 126     @property
 127     def extname(self):
 128         index = self.basename.rfind('.')
 129         if index <= 0:
 130             # dot files aren't extensions
 131             return self.basename, None
 132
 133         return self.basename[:index], self.basename[index+1:]
 134
 135     @property
 136     def all_guards(self):
 137         '''find all guards for this object getting default values
 138         recursively from its parents'''
 139         guards = {}
 140         if self.parent:
 141             guards.update(self.parent.guards)
 142         guards.update(self.guards)
 143         return guards
 144
 145     def __lt__(self, other): return self.filename < other.filename
 146     def __le__(self, other): return self.filename <= other.filename
 147     def __gt__(self, other): return self.filename > other.filename
 148     def __ge__(self, other): return self.filename >= other.filename
 149     def __eq__(self, other): return self.filename == other.filename
 150     def __ne__(self, other): return self.filename != other.filename
 151
 152 class Source(SourceFile):
 153     '''Add a c/c++ source file to the build'''
 154     def __init__(self, source, Werror=True, swig=False, **guards):
 155         '''specify the source file, and any guards'''
 156         super(Source, self).__init__(source, **guards)
 157
 158         self.Werror = Werror
 159         self.swig = swig
 160
 161 class PySource(SourceFile):
 162     '''Add a python source file to the named package'''
 163     invalid_sym_char = re.compile('[^A-z0-9_]')
 164     modules = {}
 165     tnodes = {}
 166     symnames = {}
 167
 168     def __init__(self, package, source, **guards):
 169         '''specify the python package, the source file, and any guards'''
 170         super(PySource, self).__init__(source, **guards)
 171
 172         modname,ext = self.extname
 173         assert ext == 'py'
 174
 175         if package:
 176             path = package.split('.')
 177         else:
 178             path = []
 179
 180         modpath = path[:]
 181         if modname != '__init__':
 182             modpath += [ modname ]
 183         modpath = '.'.join(modpath)
 184
 185         arcpath = path + [ self.basename ]
 186         abspath = self.snode.abspath
 187         if not exists(abspath):
 188             abspath = self.tnode.abspath
 189
 190         self.package = package
 191         self.modname = modname
 192         self.modpath = modpath
 193         self.arcname = joinpath(*arcpath)
 194         self.abspath = abspath
 195         self.compiled = File(self.filename + 'c')
 196         self.cpp = File(self.filename + '.cc')
 197         self.symname = PySource.invalid_sym_char.sub('_', modpath)
 198
 199         PySource.modules[modpath] = self
 200         PySource.tnodes[self.tnode] = self
 201         PySource.symnames[self.symname] = self
 202
 203 class SimObject(PySource):
 204     '''Add a SimObject python file as a python source object and add
 205     it to a list of sim object modules'''
 206
 207     fixed = False
 208     modnames = []
 209
 210     def __init__(self, source, **guards):
 211         '''Specify the source file and any guards (automatically in
 212         the m5.objects package)'''
 213         super(SimObject, self).__init__('m5.objects', source, **guards)
 214         if self.fixed:
 215             raise AttributeError, "Too late to call SimObject now."
 216
 217         bisect.insort_right(SimObject.modnames, self.modname)
 218
 219 class SwigSource(SourceFile):
 220     '''Add a swig file to build'''
 221
 222     def __init__(self, package, source, **guards):
 223         '''Specify the python package, the source file, and any guards'''
 224         super(SwigSource, self).__init__(source, **guards)
 225
 226         modname,ext = self.extname
 227         assert ext == 'i'
 228
 229         self.module = modname
 230         cc_file = joinpath(self.dirname, modname + '_wrap.cc')
 231         py_file = joinpath(self.dirname, modname + '.py')
 232
 233         self.cc_source = Source(cc_file, swig=True, parent=self)
 234         self.py_source = PySource(package, py_file, parent=self)
 235
 236 class UnitTest(object):
 237     '''Create a UnitTest'''
 238
 239     all = []
 240     def __init__(self, target, *sources, **kwargs):
 241         '''Specify the target name and any sources.  Sources that are
 242         not SourceFiles are evalued with Source().  All files are
 243         guarded with a guard of the same name as the UnitTest
 244         target.'''
 245
 246         srcs = []
 247         for src in sources:
 248             if not isinstance(src, SourceFile):
 249                 src = Source(src, skip_lib=True)
 250             src.guards[target] = True
 251             srcs.append(src)
 252
 253         self.sources = srcs
 254         self.target = target
 255         self.main = kwargs.get('main', False)
 256         UnitTest.all.append(self)
 257
 258 # Children should have access
 259 Export('Source')
 260 Export('PySource')
 261 Export('SimObject')
 262 Export('SwigSource')
 263 Export('UnitTest')
 264
 265 ########################################################################
 266 #
 267 # Debug Flags
 268 #
 269 debug_flags = {}
 270 def DebugFlag(name, desc=None):
 271     if name in debug_flags:
 272         raise AttributeError, "Flag %s already specified" % name
 273     debug_flags[name] = (name, (), desc)
 274
 275 def CompoundFlag(name, flags, desc=None):
 276     if name in debug_flags:
 277         raise AttributeError, "Flag %s already specified" % name
 278
 279     compound = tuple(flags)
 280     debug_flags[name] = (name, compound, desc)
 281
 282 Export('DebugFlag')
 283 Export('CompoundFlag')
 284
 285 ########################################################################
 286 #
 287 # Set some compiler variables
 288 #
 289
 290 # Include file paths are rooted in this directory.  SCons will
 291 # automatically expand '.' to refer to both the source directory and
 292 # the corresponding build directory to pick up generated include
 293 # files.
 294 env.Append(CPPPATH=Dir('.'))
 295
 296 for extra_dir in extras_dir_list:
 297     env.Append(CPPPATH=Dir(extra_dir))
 298
 299 # Workaround for bug in SCons version > 0.97d20071212
 300 # Scons bug id: 2006 gem5 Bug id: 308
 301 for root, dirs, files in os.walk(base_dir, topdown=True):
 302     Dir(root[len(base_dir) + 1:])
 303
 304 ########################################################################
 305 #
 306 # Walk the tree and execute all SConscripts in subdirectories
 307 #
 308
 309 here = Dir('.').srcnode().abspath
 310 for root, dirs, files in os.walk(base_dir, topdown=True):
 311     if root == here:
 312         # we don't want to recurse back into this SConscript
 313         continue
 314
 315     if 'SConscript' in files:
 316         build_dir = joinpath(env['BUILDDIR'], root[len(base_dir) + 1:])
 317         SConscript(joinpath(root, 'SConscript'), variant_dir=build_dir)
 318
 319 for extra_dir in extras_dir_list:
 320     prefix_len = len(dirname(extra_dir)) + 1
 321     for root, dirs, files in os.walk(extra_dir, topdown=True):
 322         # if build lives in the extras directory, don't walk down it
 323         if 'build' in dirs:
 324             dirs.remove('build')
 325
 326         if 'SConscript' in files:
 327             build_dir = joinpath(env['BUILDDIR'], root[prefix_len:])
 328             SConscript(joinpath(root, 'SConscript'), variant_dir=build_dir)
 329
 330 for opt in export_vars:
 331     env.ConfigFile(opt)
 332
 333 def makeTheISA(source, target, env):
 334     isas = [ src.get_contents() for src in source ]
 335     target_isa = env['TARGET_ISA']
 336     def define(isa):
 337         return isa.upper() + '_ISA'
 338
 339     def namespace(isa):
 340         return isa[0].upper() + isa[1:].lower() + 'ISA'
 341
 342
 343     code = code_formatter()
 344     code('''\
 345 #ifndef __CONFIG_THE_ISA_HH__
 346 #define __CONFIG_THE_ISA_HH__
 347
 348 ''')
 349
 350     for i,isa in enumerate(isas):
 351         code('#define $0 $1', define(isa), i + 1)
 352
 353     code('''
 354
 355 #define THE_ISA ${{define(target_isa)}}
 356 #define TheISA ${{namespace(target_isa)}}
 357 #define THE_ISA_STR "${{target_isa}}"
 358
 359 #endif // __CONFIG_THE_ISA_HH__''')
 360
 361     code.write(str(target[0]))
 362
 363 env.Command('config/the_isa.hh', map(Value, all_isa_list),
 364             MakeAction(makeTheISA, Transform("CFG ISA", 0)))
 365
 366 ########################################################################
 367 #
 368 # Prevent any SimObjects from being added after this point, they
 369 # should all have been added in the SConscripts above
 370 #
 371 SimObject.fixed = True
 372
 373 class DictImporter(object):
 374     '''This importer takes a dictionary of arbitrary module names that
 375     map to arbitrary filenames.'''
 376     def __init__(self, modules):
 377         self.modules = modules
 378         self.installed = set()
 379
 380     def __del__(self):
 381         self.unload()
 382
 383     def unload(self):
 384         import sys
 385         for module in self.installed:
 386             del sys.modules[module]
 387         self.installed = set()
 388
 389     def find_module(self, fullname, path):
 390         if fullname == 'm5.defines':
 391             return self
 392
 393         if fullname == 'm5.objects':
 394             return self
 395
 396         if fullname.startswith('m5.internal'):
 397             return None
 398
 399         source = self.modules.get(fullname, None)
 400         if source is not None and fullname.startswith('m5.objects'):
 401             return self
 402
 403         return None
 404
 405     def load_module(self, fullname):
 406         mod = imp.new_module(fullname)
 407         sys.modules[fullname] = mod
 408         self.installed.add(fullname)
 409
 410         mod.__loader__ = self
 411         if fullname == 'm5.objects':
 412             mod.__path__ = fullname.split('.')
 413             return mod
 414
 415         if fullname == 'm5.defines':
 416             mod.__dict__['buildEnv'] = m5.util.SmartDict(build_env)
 417             return mod
 418
 419         source = self.modules[fullname]
 420         if source.modname == '__init__':
 421             mod.__path__ = source.modpath
 422         mod.__file__ = source.abspath
 423
 424         exec file(source.abspath, 'r') in mod.__dict__
 425
 426         return mod
 427
 428 import m5.SimObject
 429 import m5.params
 430 from m5.util import code_formatter
 431
 432 m5.SimObject.clear()
 433 m5.params.clear()
 434
 435 # install the python importer so we can grab stuff from the source
 436 # tree itself.  We can't have SimObjects added after this point or
 437 # else we won't know about them for the rest of the stuff.
 438 importer = DictImporter(PySource.modules)
 439 sys.meta_path[0:0] = [ importer ]
 440
 441 # import all sim objects so we can populate the all_objects list
 442 # make sure that we're working with a list, then let's sort it
 443 for modname in SimObject.modnames:
 444     exec('from m5.objects import %s' % modname)
 445
 446 # we need to unload all of the currently imported modules so that they
 447 # will be re-imported the next time the sconscript is run
 448 importer.unload()
 449 sys.meta_path.remove(importer)
 450
 451 sim_objects = m5.SimObject.allClasses
 452 all_enums = m5.params.allEnums
 453
 454 # Find param types that need to be explicitly wrapped with swig.
 455 # These will be recognized because the ParamDesc will have a
 456 # swig_decl() method.  Most param types are based on types that don't
 457 # need this, either because they're based on native types (like Int)
 458 # or because they're SimObjects (which get swigged independently).
 459 # For now the only things handled here are VectorParam types.
 460 params_to_swig = {}
 461 for name,obj in sorted(sim_objects.iteritems()):
 462     for param in obj._params.local.values():
 463         # load the ptype attribute now because it depends on the
 464         # current version of SimObject.allClasses, but when scons
 465         # actually uses the value, all versions of
 466         # SimObject.allClasses will have been loaded
 467         param.ptype
 468
 469         if not hasattr(param, 'swig_decl'):
 470             continue
 471         pname = param.ptype_str
 472         if pname not in params_to_swig:
 473             params_to_swig[pname] = param
 474
 475 ########################################################################
 476 #
 477 # calculate extra dependencies
 478 #
 479 module_depends = ["m5", "m5.SimObject", "m5.params"]
 480 depends = [ PySource.modules[dep].snode for dep in module_depends ]
 481
 482 ########################################################################
 483 #
 484 # Commands for the basic automatically generated python files
 485 #
 486
 487 # Generate Python file containing a dict specifying the current
 488 # buildEnv flags.
 489 def makeDefinesPyFile(target, source, env):
 490     build_env = source[0].get_contents()
 491
 492     code = code_formatter()
 493     code("""
 494 import m5.internal
 495 import m5.util
 496
 497 buildEnv = m5.util.SmartDict($build_env)
 498
 499 compileDate = m5.internal.core.compileDate
 500 _globals = globals()
 501 for key,val in m5.internal.core.__dict__.iteritems():
 502     if key.startswith('flag_'):
 503         flag = key[5:]
 504         _globals[flag] = val
 505 del _globals
 506 """)
 507     code.write(target[0].abspath)
 508
 509 defines_info = Value(build_env)
 510 # Generate a file with all of the compile options in it
 511 env.Command('python/m5/defines.py', defines_info,
 512             MakeAction(makeDefinesPyFile, Transform("DEFINES", 0)))
 513 PySource('m5', 'python/m5/defines.py')
 514
 515 # Generate python file containing info about the M5 source code
 516 def makeInfoPyFile(target, source, env):
 517     code = code_formatter()
 518     for src in source:
 519         data = ''.join(file(src.srcnode().abspath, 'r').xreadlines())
 520         code('$src = ${{repr(data)}}')
 521     code.write(str(target[0]))
 522
 523 # Generate a file that wraps the basic top level files
 524 env.Command('python/m5/info.py',
 525             [ '#/COPYING', '#/LICENSE', '#/README', ],
 526             MakeAction(makeInfoPyFile, Transform("INFO")))
 527 PySource('m5', 'python/m5/info.py')
 528
 529 ########################################################################
 530 #
 531 # Create all of the SimObject param headers and enum headers
 532 #
 533
 534 def createSimObjectParamStruct(target, source, env):
 535     assert len(target) == 1 and len(source) == 1
 536
 537     name = str(source[0].get_contents())
 538     obj = sim_objects[name]
 539
 540     code = code_formatter()
 541     obj.cxx_param_decl(code)
 542     code.write(target[0].abspath)
 543
 544 def createParamSwigWrapper(target, source, env):
 545     assert len(target) == 1 and len(source) == 1
 546
 547     name = str(source[0].get_contents())
 548     param = params_to_swig[name]
 549
 550     code = code_formatter()
 551     param.swig_decl(code)
 552     code.write(target[0].abspath)
 553
 554 def createEnumStrings(target, source, env):
 555     assert len(target) == 1 and len(source) == 1
 556
 557     name = str(source[0].get_contents())
 558     obj = all_enums[name]
 559
 560     code = code_formatter()
 561     obj.cxx_def(code)
 562     code.write(target[0].abspath)
 563
 564 def createEnumDecls(target, source, env):
 565     assert len(target) == 1 and len(source) == 1
 566
 567     name = str(source[0].get_contents())
 568     obj = all_enums[name]
 569
 570     code = code_formatter()
 571     obj.cxx_decl(code)
 572     code.write(target[0].abspath)
 573
 574 def createEnumSwigWrapper(target, source, env):
 575     assert len(target) == 1 and len(source) == 1
 576
 577     name = str(source[0].get_contents())
 578     obj = all_enums[name]
 579
 580     code = code_formatter()
 581     obj.swig_decl(code)
 582     code.write(target[0].abspath)
 583
 584 def createSimObjectSwigWrapper(target, source, env):
 585     name = source[0].get_contents()
 586     obj = sim_objects[name]
 587
 588     code = code_formatter()
 589     obj.swig_decl(code)
 590     code.write(target[0].abspath)
 591
 592 # Generate all of the SimObject param C++ struct header files
 593 params_hh_files = []
 594 for name,simobj in sorted(sim_objects.iteritems()):
 595     py_source = PySource.modules[simobj.__module__]
 596     extra_deps = [ py_source.tnode ]
 597
 598     hh_file = File('params/%s.hh' % name)
 599     params_hh_files.append(hh_file)
 600     env.Command(hh_file, Value(name),
 601                 MakeAction(createSimObjectParamStruct, Transform("SO PARAM")))
 602     env.Depends(hh_file, depends + extra_deps)
 603
 604 # Generate any needed param SWIG wrapper files
 605 params_i_files = []
 606 for name,param in params_to_swig.iteritems():
 607     i_file = File('python/m5/internal/%s.i' % (param.swig_module_name()))
 608     params_i_files.append(i_file)
 609     env.Command(i_file, Value(name),
 610                 MakeAction(createParamSwigWrapper, Transform("SW PARAM")))
 611     env.Depends(i_file, depends)
 612     SwigSource('m5.internal', i_file)
 613
 614 # Generate all enum header files
 615 for name,enum in sorted(all_enums.iteritems()):
 616     py_source = PySource.modules[enum.__module__]
 617     extra_deps = [ py_source.tnode ]
 618
 619     cc_file = File('enums/%s.cc' % name)
 620     env.Command(cc_file, Value(name),
 621                 MakeAction(createEnumStrings, Transform("ENUM STR")))
 622     env.Depends(cc_file, depends + extra_deps)
 623     Source(cc_file)
 624
 625     hh_file = File('enums/%s.hh' % name)
 626     env.Command(hh_file, Value(name),
 627                 MakeAction(createEnumDecls, Transform("ENUMDECL")))
 628     env.Depends(hh_file, depends + extra_deps)
 629
 630     i_file = File('python/m5/internal/enum_%s.i' % name)
 631     env.Command(i_file, Value(name),
 632                 MakeAction(createEnumSwigWrapper, Transform("ENUMSWIG")))
 633     env.Depends(i_file, depends + extra_deps)
 634     SwigSource('m5.internal', i_file)
 635
 636 # Generate SimObject SWIG wrapper files
 637 for name in sim_objects.iterkeys():
 638     i_file = File('python/m5/internal/param_%s.i' % name)
 639     env.Command(i_file, Value(name),
 640                 MakeAction(createSimObjectSwigWrapper, Transform("SO SWIG")))
 641     env.Depends(i_file, depends)
 642     SwigSource('m5.internal', i_file)
 643
 644 # Generate the main swig init file
 645 def makeEmbeddedSwigInit(target, source, env):
 646     code = code_formatter()
 647     module = source[0].get_contents()
 648     code('''\
 649 #include "sim/init.hh"
 650
 651 extern "C" {
 652     void init_${module}();
 653 }
 654
 655 EmbeddedSwig embed_swig_${module}(init_${module});
 656 ''')
 657     code.write(str(target[0]))
 658
 659 # Build all swig modules
 660 for swig in SwigSource.all:
 661     env.Command([swig.cc_source.tnode, swig.py_source.tnode], swig.tnode,
 662                 MakeAction('$SWIG $SWIGFLAGS -outdir ${TARGETS[1].dir} '
 663                 '-o ${TARGETS[0]} $SOURCES', Transform("SWIG")))
 664     cc_file = str(swig.tnode)
 665     init_file = '%s/%s_init.cc' % (dirname(cc_file), basename(cc_file))
 666     env.Command(init_file, Value(swig.module),
 667                 MakeAction(makeEmbeddedSwigInit, Transform("EMBED SW")))
 668     Source(init_file, **swig.guards)
 669
 670 #
 671 # Handle debug flags
 672 #
 673 def makeDebugFlagCC(target, source, env):
 674     assert(len(target) == 1 and len(source) == 1)
 675
 676     val = eval(source[0].get_contents())
 677     name, compound, desc = val
 678     compound = list(sorted(compound))
 679
 680     code = code_formatter()
 681
 682     # file header
 683     code('''
 684 /*
 685  * DO NOT EDIT THIS FILE! Automatically generated
 686  */
 687
 688 #include "base/debug.hh"
 689 ''')
 690
 691     for flag in compound:
 692         code('#include "debug/$flag.hh"')
 693     code()
 694     code('namespace Debug {')
 695     code()
 696
 697     if not compound:
 698         code('SimpleFlag $name("$name", "$desc");')
 699     else:
 700         code('CompoundFlag $name("$name", "$desc",')
 701         code.indent()
 702         last = len(compound) - 1
 703         for i,flag in enumerate(compound):
 704             if i != last:
 705                 code('$flag,')
 706             else:
 707                 code('$flag);')
 708         code.dedent()
 709
 710     code()
 711     code('} // namespace Debug')
 712
 713     code.write(str(target[0]))
 714
 715 def makeDebugFlagHH(target, source, env):
 716     assert(len(target) == 1 and len(source) == 1)
 717
 718     val = eval(source[0].get_contents())
 719     name, compound, desc = val
 720
 721     code = code_formatter()
 722
 723     # file header boilerplate
 724     code('''\
 725 /*
 726  * DO NOT EDIT THIS FILE!
 727  *
 728  * Automatically generated by SCons
 729  */
 730
 731 #ifndef __DEBUG_${name}_HH__
 732 #define __DEBUG_${name}_HH__
 733
 734 namespace Debug {
 735 ''')
 736
 737     if compound:
 738         code('class CompoundFlag;')
 739     code('class SimpleFlag;')
 740
 741     if compound:
 742         code('extern CompoundFlag $name;')
 743         for flag in compound:
 744             code('extern SimpleFlag $flag;')
 745     else:
 746         code('extern SimpleFlag $name;')
 747
 748     code('''
 749 }
 750
 751 #endif // __DEBUG_${name}_HH__
 752 ''')
 753
 754     code.write(str(target[0]))
 755
 756 for name,flag in sorted(debug_flags.iteritems()):
 757     n, compound, desc = flag
 758     assert n == name
 759
 760     env.Command('debug/%s.hh' % name, Value(flag),
 761                 MakeAction(makeDebugFlagHH, Transform("TRACING", 0)))
 762     env.Command('debug/%s.cc' % name, Value(flag),
 763                 MakeAction(makeDebugFlagCC, Transform("TRACING", 0)))
 764     Source('debug/%s.cc' % name)
 765
 766 # Embed python files.  All .py files that have been indicated by a
 767 # PySource() call in a SConscript need to be embedded into the M5
 768 # library.  To do that, we compile the file to byte code, marshal the
 769 # byte code, compress it, and then generate a c++ file that
 770 # inserts the result into an array.
 771 def embedPyFile(target, source, env):
 772     def c_str(string):
 773         if string is None:
 774             return "0"
 775         return '"%s"' % string
 776
 777     '''Action function to compile a .py into a code object, marshal
 778     it, compress it, and stick it into an asm file so the code appears
 779     as just bytes with a label in the data section'''
 780
 781     src = file(str(source[0]), 'r').read()
 782
 783     pysource = PySource.tnodes[source[0]]
 784     compiled = compile(src, pysource.abspath, 'exec')
 785     marshalled = marshal.dumps(compiled)
 786     compressed = zlib.compress(marshalled)
 787     data = compressed
 788     sym = pysource.symname
 789
 790     code = code_formatter()
 791     code('''\
 792 #include "sim/init.hh"
 793
 794 namespace {
 795
 796 const uint8_t data_${sym}[] = {
 797 ''')
 798     code.indent()
 799     step = 16
 800     for i in xrange(0, len(data), step):
 801         x = array.array('B', data[i:i+step])
 802         code(''.join('%d,' % d for d in x))
 803     code.dedent()
 804
 805     code('''};
 806
 807 EmbeddedPython embedded_${sym}(
 808     ${{c_str(pysource.arcname)}},
 809     ${{c_str(pysource.abspath)}},
 810     ${{c_str(pysource.modpath)}},
 811     data_${sym},
 812     ${{len(data)}},
 813     ${{len(marshalled)}});
 814
 815 } // anonymous namespace
 816 ''')
 817     code.write(str(target[0]))
 818
 819 for source in PySource.all:
 820     env.Command(source.cpp, source.tnode,
 821                 MakeAction(embedPyFile, Transform("EMBED PY")))
 822     Source(source.cpp)
 823
 824 ########################################################################
 825 #
 826 # Define binaries.  Each different build type (debug, opt, etc.) gets
 827 # a slightly different build environment.
 828 #
 829
 830 # List of constructed environments to pass back to SConstruct
 831 envList = []
 832
 833 date_source = Source('base/date.cc', skip_lib=True)
 834
 835 # Function to create a new build environment as clone of current
 836 # environment 'env' with modified object suffix and optional stripped
 837 # binary.  Additional keyword arguments are appended to corresponding
 838 # build environment vars.
 839 def makeEnv(label, objsfx, strip = False, **kwargs):
 840     # SCons doesn't know to append a library suffix when there is a '.' in the
 841     # name.  Use '_' instead.
 842     libname = 'gem5_' + label
 843     exename = 'gem5.' + label
 844     secondary_exename = 'm5.' + label
 845
 846     new_env = env.Clone(OBJSUFFIX=objsfx, SHOBJSUFFIX=objsfx + 's')
 847     new_env.Label = label
 848     new_env.Append(**kwargs)
 849
 850     swig_env = new_env.Clone()
 851     swig_env.Append(CCFLAGS='-Werror')
 852     if env['GCC']:
 853         swig_env.Append(CCFLAGS=['-Wno-uninitialized', '-Wno-sign-compare',
 854                                  '-Wno-parentheses', '-Wno-unused-label',
 855                                  '-Wno-unused-value'])
 856         if compareVersions(env['GCC_VERSION'], '4.6') >= 0:
 857             swig_env.Append(CCFLAGS='-Wno-unused-but-set-variable')
 858     if env['CLANG']:
 859         swig_env.Append(CCFLAGS=['-Wno-unused-label', '-Wno-unused-value'])
 860
 861     werror_env = new_env.Clone()
 862     werror_env.Append(CCFLAGS='-Werror')
 863
 864     def make_obj(source, static, extra_deps = None):
 865         '''This function adds the specified source to the correct
 866         build environment, and returns the corresponding SCons Object
 867         nodes'''
 868
 869         if source.swig:
 870             env = swig_env
 871         elif source.Werror:
 872             env = werror_env
 873         else:
 874             env = new_env
 875
 876         if static:
 877             obj = env.StaticObject(source.tnode)
 878         else:
 879             obj = env.SharedObject(source.tnode)
 880
 881         if extra_deps:
 882             env.Depends(obj, extra_deps)
 883
 884         return obj
 885
 886     static_objs = \
 887         [ make_obj(s, True) for s in Source.get(main=False, skip_lib=False) ]
 888     shared_objs = \
 889         [ make_obj(s, False) for s in Source.get(main=False, skip_lib=False) ]
 890
 891     static_date = make_obj(date_source, static=True, extra_deps=static_objs)
 892     static_objs.append(static_date)
 893
 894     shared_date = make_obj(date_source, static=False, extra_deps=shared_objs)
 895     shared_objs.append(shared_date)
 896
 897     # First make a library of everything but main() so other programs can
 898     # link against m5.
 899     static_lib = new_env.StaticLibrary(libname, static_objs)
 900     shared_lib = new_env.SharedLibrary(libname, shared_objs)
 901
 902     # Now link a stub with main() and the static library.
 903     main_objs = [ make_obj(s, True) for s in Source.get(main=True) ]
 904
 905     for test in UnitTest.all:
 906         flags = { test.target : True }
 907         test_sources = Source.get(**flags)
 908         test_objs = [ make_obj(s, static=True) for s in test_sources ]
 909         if test.main:
 910             test_objs += main_objs
 911         testname = "unittest/%s.%s" % (test.target, label)
 912         new_env.Program(testname, test_objs + static_objs)
 913
 914     progname = exename
 915     if strip:
 916         progname += '.unstripped'
 917
 918     targets = new_env.Program(progname, main_objs + static_objs)
 919
 920     if strip:
 921         if sys.platform == 'sunos5':
 922             cmd = 'cp $SOURCE $TARGET; strip $TARGET'
 923         else:
 924             cmd = 'strip $SOURCE -o $TARGET'
 925         targets = new_env.Command(exename, progname,
 926                     MakeAction(cmd, Transform("STRIP")))
 927
 928     new_env.Command(secondary_exename, exename,
 929             MakeAction('ln $SOURCE $TARGET', Transform("HARDLINK")))
 930
 931     new_env.M5Binary = targets[0]
 932     envList.append(new_env)
 933
 934 # Start out with the compiler flags common to all compilers,
 935 # i.e. they all use -g for opt and -g -pg for prof
 936 ccflags = {'debug' : [], 'opt' : ['-g'], 'fast' : [], 'prof' : ['-g', '-pg'],
 937            'perf' : ['-g']}
 938
 939 # Start out with the linker flags common to all linkers, i.e. -pg for
 940 # prof, and -lprofiler for perf. The -lprofile flag is surrounded by
 941 # no-as-needed and as-needed as the binutils linker is too clever and
 942 # simply doesn't link to the library otherwise.
 943 ldflags = {'debug' : [], 'opt' : [], 'fast' : [], 'prof' : ['-pg'],
 944            'perf' : ['-Wl,--no-as-needed', '-lprofiler', '-Wl,--as-needed']}
 945
 946 if env['GCC']:
 947     if sys.platform == 'sunos5':
 948         ccflags['debug'] += ['-gstabs+']
 949     else:
 950         ccflags['debug'] += ['-ggdb3']
 951     ldflags['debug'] += ['-O0']
 952     # opt, fast, prof and perf all share the same cc flags
 953     for target in ['opt', 'fast', 'prof', 'perf']:
 954         ccflags[target] += ['-O3']
 955 elif env['SUNCC']:
 956     ccflags['debug'] += ['-g0']
 957     ccflags['opt'] += ['-O']
 958     for target in ['fast', 'prof', 'perf']:
 959         ccflags[target] += ['-fast']
 960 elif env['ICC']:
 961     ccflags['debug'] += ['-g', '-O0']
 962     ccflags['opt'] += ['-O']
 963     for target in ['fast', 'prof', 'perf']:
 964         ccflags[target] += ['-fast']
 965 elif env['CLANG']:
 966     ccflags['debug'] += ['-g', '-O0']
 967     # opt, fast, prof and perf all share the same cc flags
 968     for target in ['opt', 'fast', 'prof', 'perf']:
 969         ccflags[target] += ['-O3']
 970 else:
 971     print 'Unknown compiler, please fix compiler options'
 972     Exit(1)
 973
 974
 975 # To speed things up, we only instantiate the build environments we
 976 # need.  We try to identify the needed environment for each target; if
 977 # we can't, we fall back on instantiating all the environments just to
 978 # be safe.
 979 target_types = ['debug', 'opt', 'fast', 'prof', 'perf']
 980 obj2target = {'do': 'debug', 'o': 'opt', 'fo': 'fast', 'po': 'prof',
 981               'gpo' : 'perf'}
 982
 983 def identifyTarget(t):
 984     ext = t.split('.')[-1]
 985     if ext in target_types:
 986         return ext
 987     if obj2target.has_key(ext):
 988         return obj2target[ext]
 989     match = re.search(r'/tests/([^/]+)/', t)
 990     if match and match.group(1) in target_types:
 991         return match.group(1)
 992     return 'all'
 993
 994 needed_envs = [identifyTarget(target) for target in BUILD_TARGETS]
 995 if 'all' in needed_envs:
 996     needed_envs += target_types
 997
 998 # Debug binary
 999 if 'debug' in needed_envs:
1000     makeEnv('debug', '.do',
1001             CCFLAGS = Split(ccflags['debug']),
1002             CPPDEFINES = ['DEBUG', 'TRACING_ON=1'],
1003             LINKFLAGS = Split(ldflags['debug']))
1004
1005 # Optimized binary
1006 if 'opt' in needed_envs:
1007     makeEnv('opt', '.o',
1008             CCFLAGS = Split(ccflags['opt']),
1009             CPPDEFINES = ['TRACING_ON=1'],
1010             LINKFLAGS = Split(ldflags['opt']))
1011
1012 # "Fast" binary
1013 if 'fast' in needed_envs:
1014     makeEnv('fast', '.fo', strip = True,
1015             CCFLAGS = Split(ccflags['fast']),
1016             CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'],
1017             LINKFLAGS = Split(ldflags['fast']))
1018
1019 # Profiled binary using gprof
1020 if 'prof' in needed_envs:
1021     makeEnv('prof', '.po',
1022             CCFLAGS = Split(ccflags['prof']),
1023             CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'],
1024             LINKFLAGS = Split(ldflags['prof']))
1025
1026 # Profiled binary using google-pprof
1027 if 'perf' in needed_envs:
1028     makeEnv('perf', '.gpo',
1029             CCFLAGS = Split(ccflags['perf']),
1030             CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'],
1031             LINKFLAGS = Split(ldflags['perf']))
1032
1033 Return('envList')