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 ProtoBuf(SourceFile):
 237     '''Add a Protocol Buffer to build'''
 238
 239     def __init__(self, source, **guards):
 240         '''Specify the source file, and any guards'''
 241         super(ProtoBuf, self).__init__(source, **guards)
 242
 243         # Get the file name and the extension
 244         modname,ext = self.extname
 245         assert ext == 'proto'
 246
 247         # Currently, we stick to generating the C++ headers, so we
 248         # only need to track the source and header.
 249         self.cc_file = File(joinpath(self.dirname, modname + '.pb.cc'))
 250         self.hh_file = File(joinpath(self.dirname, modname + '.pb.h'))
 251
 252 class UnitTest(object):
 253     '''Create a UnitTest'''
 254
 255     all = []
 256     def __init__(self, target, *sources, **kwargs):
 257         '''Specify the target name and any sources.  Sources that are
 258         not SourceFiles are evalued with Source().  All files are
 259         guarded with a guard of the same name as the UnitTest
 260         target.'''
 261
 262         srcs = []
 263         for src in sources:
 264             if not isinstance(src, SourceFile):
 265                 src = Source(src, skip_lib=True)
 266             src.guards[target] = True
 267             srcs.append(src)
 268
 269         self.sources = srcs
 270         self.target = target
 271         self.main = kwargs.get('main', False)
 272         UnitTest.all.append(self)
 273
 274 # Children should have access
 275 Export('Source')
 276 Export('PySource')
 277 Export('SimObject')
 278 Export('SwigSource')
 279 Export('ProtoBuf')
 280 Export('UnitTest')
 281
 282 ########################################################################
 283 #
 284 # Debug Flags
 285 #
 286 debug_flags = {}
 287 def DebugFlag(name, desc=None):
 288     if name in debug_flags:
 289         raise AttributeError, "Flag %s already specified" % name
 290     debug_flags[name] = (name, (), desc)
 291
 292 def CompoundFlag(name, flags, desc=None):
 293     if name in debug_flags:
 294         raise AttributeError, "Flag %s already specified" % name
 295
 296     compound = tuple(flags)
 297     debug_flags[name] = (name, compound, desc)
 298
 299 Export('DebugFlag')
 300 Export('CompoundFlag')
 301
 302 ########################################################################
 303 #
 304 # Set some compiler variables
 305 #
 306
 307 # Include file paths are rooted in this directory.  SCons will
 308 # automatically expand '.' to refer to both the source directory and
 309 # the corresponding build directory to pick up generated include
 310 # files.
 311 env.Append(CPPPATH=Dir('.'))
 312
 313 for extra_dir in extras_dir_list:
 314     env.Append(CPPPATH=Dir(extra_dir))
 315
 316 # Workaround for bug in SCons version > 0.97d20071212
 317 # Scons bug id: 2006 gem5 Bug id: 308
 318 for root, dirs, files in os.walk(base_dir, topdown=True):
 319     Dir(root[len(base_dir) + 1:])
 320
 321 ########################################################################
 322 #
 323 # Walk the tree and execute all SConscripts in subdirectories
 324 #
 325
 326 here = Dir('.').srcnode().abspath
 327 for root, dirs, files in os.walk(base_dir, topdown=True):
 328     if root == here:
 329         # we don't want to recurse back into this SConscript
 330         continue
 331
 332     if 'SConscript' in files:
 333         build_dir = joinpath(env['BUILDDIR'], root[len(base_dir) + 1:])
 334         SConscript(joinpath(root, 'SConscript'), variant_dir=build_dir)
 335
 336 for extra_dir in extras_dir_list:
 337     prefix_len = len(dirname(extra_dir)) + 1
 338     for root, dirs, files in os.walk(extra_dir, topdown=True):
 339         # if build lives in the extras directory, don't walk down it
 340         if 'build' in dirs:
 341             dirs.remove('build')
 342
 343         if 'SConscript' in files:
 344             build_dir = joinpath(env['BUILDDIR'], root[prefix_len:])
 345             SConscript(joinpath(root, 'SConscript'), variant_dir=build_dir)
 346
 347 for opt in export_vars:
 348     env.ConfigFile(opt)
 349
 350 def makeTheISA(source, target, env):
 351     isas = [ src.get_contents() for src in source ]
 352     target_isa = env['TARGET_ISA']
 353     def define(isa):
 354         return isa.upper() + '_ISA'
 355
 356     def namespace(isa):
 357         return isa[0].upper() + isa[1:].lower() + 'ISA'
 358
 359
 360     code = code_formatter()
 361     code('''\
 362 #ifndef __CONFIG_THE_ISA_HH__
 363 #define __CONFIG_THE_ISA_HH__
 364
 365 ''')
 366
 367     for i,isa in enumerate(isas):
 368         code('#define $0 $1', define(isa), i + 1)
 369
 370     code('''
 371
 372 #define THE_ISA ${{define(target_isa)}}
 373 #define TheISA ${{namespace(target_isa)}}
 374 #define THE_ISA_STR "${{target_isa}}"
 375
 376 #endif // __CONFIG_THE_ISA_HH__''')
 377
 378     code.write(str(target[0]))
 379
 380 env.Command('config/the_isa.hh', map(Value, all_isa_list),
 381             MakeAction(makeTheISA, Transform("CFG ISA", 0)))
 382
 383 ########################################################################
 384 #
 385 # Prevent any SimObjects from being added after this point, they
 386 # should all have been added in the SConscripts above
 387 #
 388 SimObject.fixed = True
 389
 390 class DictImporter(object):
 391     '''This importer takes a dictionary of arbitrary module names that
 392     map to arbitrary filenames.'''
 393     def __init__(self, modules):
 394         self.modules = modules
 395         self.installed = set()
 396
 397     def __del__(self):
 398         self.unload()
 399
 400     def unload(self):
 401         import sys
 402         for module in self.installed:
 403             del sys.modules[module]
 404         self.installed = set()
 405
 406     def find_module(self, fullname, path):
 407         if fullname == 'm5.defines':
 408             return self
 409
 410         if fullname == 'm5.objects':
 411             return self
 412
 413         if fullname.startswith('m5.internal'):
 414             return None
 415
 416         source = self.modules.get(fullname, None)
 417         if source is not None and fullname.startswith('m5.objects'):
 418             return self
 419
 420         return None
 421
 422     def load_module(self, fullname):
 423         mod = imp.new_module(fullname)
 424         sys.modules[fullname] = mod
 425         self.installed.add(fullname)
 426
 427         mod.__loader__ = self
 428         if fullname == 'm5.objects':
 429             mod.__path__ = fullname.split('.')
 430             return mod
 431
 432         if fullname == 'm5.defines':
 433             mod.__dict__['buildEnv'] = m5.util.SmartDict(build_env)
 434             return mod
 435
 436         source = self.modules[fullname]
 437         if source.modname == '__init__':
 438             mod.__path__ = source.modpath
 439         mod.__file__ = source.abspath
 440
 441         exec file(source.abspath, 'r') in mod.__dict__
 442
 443         return mod
 444
 445 import m5.SimObject
 446 import m5.params
 447 from m5.util import code_formatter
 448
 449 m5.SimObject.clear()
 450 m5.params.clear()
 451
 452 # install the python importer so we can grab stuff from the source
 453 # tree itself.  We can't have SimObjects added after this point or
 454 # else we won't know about them for the rest of the stuff.
 455 importer = DictImporter(PySource.modules)
 456 sys.meta_path[0:0] = [ importer ]
 457
 458 # import all sim objects so we can populate the all_objects list
 459 # make sure that we're working with a list, then let's sort it
 460 for modname in SimObject.modnames:
 461     exec('from m5.objects import %s' % modname)
 462
 463 # we need to unload all of the currently imported modules so that they
 464 # will be re-imported the next time the sconscript is run
 465 importer.unload()
 466 sys.meta_path.remove(importer)
 467
 468 sim_objects = m5.SimObject.allClasses
 469 all_enums = m5.params.allEnums
 470
 471 if m5.SimObject.noCxxHeader:
 472     print >> sys.stderr, \
 473         "warning: At least one SimObject lacks a header specification. " \
 474         "This can cause unexpected results in the generated SWIG " \
 475         "wrappers."
 476
 477 # Find param types that need to be explicitly wrapped with swig.
 478 # These will be recognized because the ParamDesc will have a
 479 # swig_decl() method.  Most param types are based on types that don't
 480 # need this, either because they're based on native types (like Int)
 481 # or because they're SimObjects (which get swigged independently).
 482 # For now the only things handled here are VectorParam types.
 483 params_to_swig = {}
 484 for name,obj in sorted(sim_objects.iteritems()):
 485     for param in obj._params.local.values():
 486         # load the ptype attribute now because it depends on the
 487         # current version of SimObject.allClasses, but when scons
 488         # actually uses the value, all versions of
 489         # SimObject.allClasses will have been loaded
 490         param.ptype
 491
 492         if not hasattr(param, 'swig_decl'):
 493             continue
 494         pname = param.ptype_str
 495         if pname not in params_to_swig:
 496             params_to_swig[pname] = param
 497
 498 ########################################################################
 499 #
 500 # calculate extra dependencies
 501 #
 502 module_depends = ["m5", "m5.SimObject", "m5.params"]
 503 depends = [ PySource.modules[dep].snode for dep in module_depends ]
 504
 505 ########################################################################
 506 #
 507 # Commands for the basic automatically generated python files
 508 #
 509
 510 # Generate Python file containing a dict specifying the current
 511 # buildEnv flags.
 512 def makeDefinesPyFile(target, source, env):
 513     build_env = source[0].get_contents()
 514
 515     code = code_formatter()
 516     code("""
 517 import m5.internal
 518 import m5.util
 519
 520 buildEnv = m5.util.SmartDict($build_env)
 521
 522 compileDate = m5.internal.core.compileDate
 523 _globals = globals()
 524 for key,val in m5.internal.core.__dict__.iteritems():
 525     if key.startswith('flag_'):
 526         flag = key[5:]
 527         _globals[flag] = val
 528 del _globals
 529 """)
 530     code.write(target[0].abspath)
 531
 532 defines_info = Value(build_env)
 533 # Generate a file with all of the compile options in it
 534 env.Command('python/m5/defines.py', defines_info,
 535             MakeAction(makeDefinesPyFile, Transform("DEFINES", 0)))
 536 PySource('m5', 'python/m5/defines.py')
 537
 538 # Generate python file containing info about the M5 source code
 539 def makeInfoPyFile(target, source, env):
 540     code = code_formatter()
 541     for src in source:
 542         data = ''.join(file(src.srcnode().abspath, 'r').xreadlines())
 543         code('$src = ${{repr(data)}}')
 544     code.write(str(target[0]))
 545
 546 # Generate a file that wraps the basic top level files
 547 env.Command('python/m5/info.py',
 548             [ '#/COPYING', '#/LICENSE', '#/README', ],
 549             MakeAction(makeInfoPyFile, Transform("INFO")))
 550 PySource('m5', 'python/m5/info.py')
 551
 552 ########################################################################
 553 #
 554 # Create all of the SimObject param headers and enum headers
 555 #
 556
 557 def createSimObjectParamStruct(target, source, env):
 558     assert len(target) == 1 and len(source) == 1
 559
 560     name = str(source[0].get_contents())
 561     obj = sim_objects[name]
 562
 563     code = code_formatter()
 564     obj.cxx_param_decl(code)
 565     code.write(target[0].abspath)
 566
 567 def createParamSwigWrapper(target, source, env):
 568     assert len(target) == 1 and len(source) == 1
 569
 570     name = str(source[0].get_contents())
 571     param = params_to_swig[name]
 572
 573     code = code_formatter()
 574     param.swig_decl(code)
 575     code.write(target[0].abspath)
 576
 577 def createEnumStrings(target, source, env):
 578     assert len(target) == 1 and len(source) == 1
 579
 580     name = str(source[0].get_contents())
 581     obj = all_enums[name]
 582
 583     code = code_formatter()
 584     obj.cxx_def(code)
 585     code.write(target[0].abspath)
 586
 587 def createEnumDecls(target, source, env):
 588     assert len(target) == 1 and len(source) == 1
 589
 590     name = str(source[0].get_contents())
 591     obj = all_enums[name]
 592
 593     code = code_formatter()
 594     obj.cxx_decl(code)
 595     code.write(target[0].abspath)
 596
 597 def createEnumSwigWrapper(target, source, env):
 598     assert len(target) == 1 and len(source) == 1
 599
 600     name = str(source[0].get_contents())
 601     obj = all_enums[name]
 602
 603     code = code_formatter()
 604     obj.swig_decl(code)
 605     code.write(target[0].abspath)
 606
 607 def createSimObjectSwigWrapper(target, source, env):
 608     name = source[0].get_contents()
 609     obj = sim_objects[name]
 610
 611     code = code_formatter()
 612     obj.swig_decl(code)
 613     code.write(target[0].abspath)
 614
 615 # Generate all of the SimObject param C++ struct header files
 616 params_hh_files = []
 617 for name,simobj in sorted(sim_objects.iteritems()):
 618     py_source = PySource.modules[simobj.__module__]
 619     extra_deps = [ py_source.tnode ]
 620
 621     hh_file = File('params/%s.hh' % name)
 622     params_hh_files.append(hh_file)
 623     env.Command(hh_file, Value(name),
 624                 MakeAction(createSimObjectParamStruct, Transform("SO PARAM")))
 625     env.Depends(hh_file, depends + extra_deps)
 626
 627 # Generate any needed param SWIG wrapper files
 628 params_i_files = []
 629 for name,param in params_to_swig.iteritems():
 630     i_file = File('python/m5/internal/%s.i' % (param.swig_module_name()))
 631     params_i_files.append(i_file)
 632     env.Command(i_file, Value(name),
 633                 MakeAction(createParamSwigWrapper, Transform("SW PARAM")))
 634     env.Depends(i_file, depends)
 635     SwigSource('m5.internal', i_file)
 636
 637 # Generate all enum header files
 638 for name,enum in sorted(all_enums.iteritems()):
 639     py_source = PySource.modules[enum.__module__]
 640     extra_deps = [ py_source.tnode ]
 641
 642     cc_file = File('enums/%s.cc' % name)
 643     env.Command(cc_file, Value(name),
 644                 MakeAction(createEnumStrings, Transform("ENUM STR")))
 645     env.Depends(cc_file, depends + extra_deps)
 646     Source(cc_file)
 647
 648     hh_file = File('enums/%s.hh' % name)
 649     env.Command(hh_file, Value(name),
 650                 MakeAction(createEnumDecls, Transform("ENUMDECL")))
 651     env.Depends(hh_file, depends + extra_deps)
 652
 653     i_file = File('python/m5/internal/enum_%s.i' % name)
 654     env.Command(i_file, Value(name),
 655                 MakeAction(createEnumSwigWrapper, Transform("ENUMSWIG")))
 656     env.Depends(i_file, depends + extra_deps)
 657     SwigSource('m5.internal', i_file)
 658
 659 # Generate SimObject SWIG wrapper files
 660 for name,simobj in sim_objects.iteritems():
 661     py_source = PySource.modules[simobj.__module__]
 662     extra_deps = [ py_source.tnode ]
 663
 664     i_file = File('python/m5/internal/param_%s.i' % name)
 665     env.Command(i_file, Value(name),
 666                 MakeAction(createSimObjectSwigWrapper, Transform("SO SWIG")))
 667     env.Depends(i_file, depends + extra_deps)
 668     SwigSource('m5.internal', i_file)
 669
 670 # Generate the main swig init file
 671 def makeEmbeddedSwigInit(target, source, env):
 672     code = code_formatter()
 673     module = source[0].get_contents()
 674     code('''\
 675 #include "sim/init.hh"
 676
 677 extern "C" {
 678     void init_${module}();
 679 }
 680
 681 EmbeddedSwig embed_swig_${module}(init_${module});
 682 ''')
 683     code.write(str(target[0]))
 684
 685 # Build all swig modules
 686 for swig in SwigSource.all:
 687     env.Command([swig.cc_source.tnode, swig.py_source.tnode], swig.tnode,
 688                 MakeAction('$SWIG $SWIGFLAGS -outdir ${TARGETS[1].dir} '
 689                 '-o ${TARGETS[0]} $SOURCES', Transform("SWIG")))
 690     cc_file = str(swig.tnode)
 691     init_file = '%s/%s_init.cc' % (dirname(cc_file), basename(cc_file))
 692     env.Command(init_file, Value(swig.module),
 693                 MakeAction(makeEmbeddedSwigInit, Transform("EMBED SW")))
 694     Source(init_file, **swig.guards)
 695
 696 # Build all protocol buffers if we have got protoc and protobuf available
 697 if env['HAVE_PROTOBUF']:
 698     for proto in ProtoBuf.all:
 699         # Use both the source and header as the target, and the .proto
 700         # file as the source. When executing the protoc compiler, also
 701         # specify the proto_path to avoid having the generated files
 702         # include the path.
 703         env.Command([proto.cc_file, proto.hh_file], proto.tnode,
 704                     MakeAction('$PROTOC --cpp_out ${TARGET.dir} '
 705                                '--proto_path ${SOURCE.dir} $SOURCE',
 706                                Transform("PROTOC")))
 707
 708         # Add the C++ source file
 709         Source(proto.cc_file, **proto.guards)
 710 elif ProtoBuf.all:
 711     print 'Got protobuf to build, but lacks support!'
 712     Exit(1)
 713
 714 #
 715 # Handle debug flags
 716 #
 717 def makeDebugFlagCC(target, source, env):
 718     assert(len(target) == 1 and len(source) == 1)
 719
 720     val = eval(source[0].get_contents())
 721     name, compound, desc = val
 722     compound = list(sorted(compound))
 723
 724     code = code_formatter()
 725
 726     # file header
 727     code('''
 728 /*
 729  * DO NOT EDIT THIS FILE! Automatically generated
 730  */
 731
 732 #include "base/debug.hh"
 733 ''')
 734
 735     for flag in compound:
 736         code('#include "debug/$flag.hh"')
 737     code()
 738     code('namespace Debug {')
 739     code()
 740
 741     if not compound:
 742         code('SimpleFlag $name("$name", "$desc");')
 743     else:
 744         code('CompoundFlag $name("$name", "$desc",')
 745         code.indent()
 746         last = len(compound) - 1
 747         for i,flag in enumerate(compound):
 748             if i != last:
 749                 code('$flag,')
 750             else:
 751                 code('$flag);')
 752         code.dedent()
 753
 754     code()
 755     code('} // namespace Debug')
 756
 757     code.write(str(target[0]))
 758
 759 def makeDebugFlagHH(target, source, env):
 760     assert(len(target) == 1 and len(source) == 1)
 761
 762     val = eval(source[0].get_contents())
 763     name, compound, desc = val
 764
 765     code = code_formatter()
 766
 767     # file header boilerplate
 768     code('''\
 769 /*
 770  * DO NOT EDIT THIS FILE!
 771  *
 772  * Automatically generated by SCons
 773  */
 774
 775 #ifndef __DEBUG_${name}_HH__
 776 #define __DEBUG_${name}_HH__
 777
 778 namespace Debug {
 779 ''')
 780
 781     if compound:
 782         code('class CompoundFlag;')
 783     code('class SimpleFlag;')
 784
 785     if compound:
 786         code('extern CompoundFlag $name;')
 787         for flag in compound:
 788             code('extern SimpleFlag $flag;')
 789     else:
 790         code('extern SimpleFlag $name;')
 791
 792     code('''
 793 }
 794
 795 #endif // __DEBUG_${name}_HH__
 796 ''')
 797
 798     code.write(str(target[0]))
 799
 800 for name,flag in sorted(debug_flags.iteritems()):
 801     n, compound, desc = flag
 802     assert n == name
 803
 804     env.Command('debug/%s.hh' % name, Value(flag),
 805                 MakeAction(makeDebugFlagHH, Transform("TRACING", 0)))
 806     env.Command('debug/%s.cc' % name, Value(flag),
 807                 MakeAction(makeDebugFlagCC, Transform("TRACING", 0)))
 808     Source('debug/%s.cc' % name)
 809
 810 # Embed python files.  All .py files that have been indicated by a
 811 # PySource() call in a SConscript need to be embedded into the M5
 812 # library.  To do that, we compile the file to byte code, marshal the
 813 # byte code, compress it, and then generate a c++ file that
 814 # inserts the result into an array.
 815 def embedPyFile(target, source, env):
 816     def c_str(string):
 817         if string is None:
 818             return "0"
 819         return '"%s"' % string
 820
 821     '''Action function to compile a .py into a code object, marshal
 822     it, compress it, and stick it into an asm file so the code appears
 823     as just bytes with a label in the data section'''
 824
 825     src = file(str(source[0]), 'r').read()
 826
 827     pysource = PySource.tnodes[source[0]]
 828     compiled = compile(src, pysource.abspath, 'exec')
 829     marshalled = marshal.dumps(compiled)
 830     compressed = zlib.compress(marshalled)
 831     data = compressed
 832     sym = pysource.symname
 833
 834     code = code_formatter()
 835     code('''\
 836 #include "sim/init.hh"
 837
 838 namespace {
 839
 840 const uint8_t data_${sym}[] = {
 841 ''')
 842     code.indent()
 843     step = 16
 844     for i in xrange(0, len(data), step):
 845         x = array.array('B', data[i:i+step])
 846         code(''.join('%d,' % d for d in x))
 847     code.dedent()
 848
 849     code('''};
 850
 851 EmbeddedPython embedded_${sym}(
 852     ${{c_str(pysource.arcname)}},
 853     ${{c_str(pysource.abspath)}},
 854     ${{c_str(pysource.modpath)}},
 855     data_${sym},
 856     ${{len(data)}},
 857     ${{len(marshalled)}});
 858
 859 } // anonymous namespace
 860 ''')
 861     code.write(str(target[0]))
 862
 863 for source in PySource.all:
 864     env.Command(source.cpp, source.tnode,
 865                 MakeAction(embedPyFile, Transform("EMBED PY")))
 866     Source(source.cpp)
 867
 868 ########################################################################
 869 #
 870 # Define binaries.  Each different build type (debug, opt, etc.) gets
 871 # a slightly different build environment.
 872 #
 873
 874 # List of constructed environments to pass back to SConstruct
 875 envList = []
 876
 877 date_source = Source('base/date.cc', skip_lib=True)
 878
 879 # Function to create a new build environment as clone of current
 880 # environment 'env' with modified object suffix and optional stripped
 881 # binary.  Additional keyword arguments are appended to corresponding
 882 # build environment vars.
 883 def makeEnv(label, objsfx, strip = False, **kwargs):
 884     # SCons doesn't know to append a library suffix when there is a '.' in the
 885     # name.  Use '_' instead.
 886     libname = 'gem5_' + label
 887     exename = 'gem5.' + label
 888     secondary_exename = 'm5.' + label
 889
 890     new_env = env.Clone(OBJSUFFIX=objsfx, SHOBJSUFFIX=objsfx + 's')
 891     new_env.Label = label
 892     new_env.Append(**kwargs)
 893
 894     swig_env = new_env.Clone()
 895
 896     # Both gcc and clang have issues with unused labels and values in
 897     # the SWIG generated code
 898     swig_env.Append(CCFLAGS=['-Wno-unused-label', '-Wno-unused-value'])
 899
 900     # Add additional warnings here that should not be applied to
 901     # the SWIG generated code
 902     new_env.Append(CXXFLAGS='-Wmissing-declarations')
 903
 904     if env['GCC']:
 905         # Depending on the SWIG version, we also need to supress
 906         # warnings about uninitialized variables and missing field
 907         # initializers.
 908         swig_env.Append(CCFLAGS=['-Wno-uninitialized',
 909                                  '-Wno-missing-field-initializers'])
 910
 911         if compareVersions(env['GCC_VERSION'], '4.6') >= 0:
 912             swig_env.Append(CCFLAGS='-Wno-unused-but-set-variable')
 913
 914         # If gcc supports it, also warn for deletion of derived
 915         # classes with non-virtual desctructors. For gcc >= 4.7 we
 916         # also have to disable warnings about the SWIG code having
 917         # potentially uninitialized variables.
 918         if compareVersions(env['GCC_VERSION'], '4.7') >= 0:
 919             new_env.Append(CXXFLAGS='-Wdelete-non-virtual-dtor')
 920             swig_env.Append(CCFLAGS='-Wno-maybe-uninitialized')
 921     if env['CLANG']:
 922         # Always enable the warning for deletion of derived classes
 923         # with non-virtual destructors
 924         new_env.Append(CXXFLAGS=['-Wdelete-non-virtual-dtor'])
 925
 926     werror_env = new_env.Clone()
 927     werror_env.Append(CCFLAGS='-Werror')
 928
 929     def make_obj(source, static, extra_deps = None):
 930         '''This function adds the specified source to the correct
 931         build environment, and returns the corresponding SCons Object
 932         nodes'''
 933
 934         if source.swig:
 935             env = swig_env
 936         elif source.Werror:
 937             env = werror_env
 938         else:
 939             env = new_env
 940
 941         if static:
 942             obj = env.StaticObject(source.tnode)
 943         else:
 944             obj = env.SharedObject(source.tnode)
 945
 946         if extra_deps:
 947             env.Depends(obj, extra_deps)
 948
 949         return obj
 950
 951     static_objs = \
 952         [ make_obj(s, True) for s in Source.get(main=False, skip_lib=False) ]
 953     shared_objs = \
 954         [ make_obj(s, False) for s in Source.get(main=False, skip_lib=False) ]
 955
 956     static_date = make_obj(date_source, static=True, extra_deps=static_objs)
 957     static_objs.append(static_date)
 958
 959     shared_date = make_obj(date_source, static=False, extra_deps=shared_objs)
 960     shared_objs.append(shared_date)
 961
 962     # First make a library of everything but main() so other programs can
 963     # link against m5.
 964     static_lib = new_env.StaticLibrary(libname, static_objs)
 965     shared_lib = new_env.SharedLibrary(libname, shared_objs)
 966
 967     # Now link a stub with main() and the static library.
 968     main_objs = [ make_obj(s, True) for s in Source.get(main=True) ]
 969
 970     for test in UnitTest.all:
 971         flags = { test.target : True }
 972         test_sources = Source.get(**flags)
 973         test_objs = [ make_obj(s, static=True) for s in test_sources ]
 974         if test.main:
 975             test_objs += main_objs
 976         testname = "unittest/%s.%s" % (test.target, label)
 977         new_env.Program(testname, test_objs + static_objs)
 978
 979     progname = exename
 980     if strip:
 981         progname += '.unstripped'
 982
 983     targets = new_env.Program(progname, main_objs + static_objs)
 984
 985     if strip:
 986         if sys.platform == 'sunos5':
 987             cmd = 'cp $SOURCE $TARGET; strip $TARGET'
 988         else:
 989             cmd = 'strip $SOURCE -o $TARGET'
 990         targets = new_env.Command(exename, progname,
 991                     MakeAction(cmd, Transform("STRIP")))
 992
 993     new_env.Command(secondary_exename, exename,
 994             MakeAction('ln $SOURCE $TARGET', Transform("HARDLINK")))
 995
 996     new_env.M5Binary = targets[0]
 997     envList.append(new_env)
 998
 999 # Start out with the compiler flags common to all compilers,
1000 # i.e. they all use -g for opt and -g -pg for prof
1001 ccflags = {'debug' : [], 'opt' : ['-g'], 'fast' : [], 'prof' : ['-g', '-pg'],
1002            'perf' : ['-g']}
1003
1004 # Start out with the linker flags common to all linkers, i.e. -pg for
1005 # prof, and -lprofiler for perf. The -lprofile flag is surrounded by
1006 # no-as-needed and as-needed as the binutils linker is too clever and
1007 # simply doesn't link to the library otherwise.
1008 ldflags = {'debug' : [], 'opt' : [], 'fast' : [], 'prof' : ['-pg'],
1009            'perf' : ['-Wl,--no-as-needed', '-lprofiler', '-Wl,--as-needed']}
1010
1011 # For Link Time Optimization, the optimisation flags used to compile
1012 # individual files are decoupled from those used at link time
1013 # (i.e. you can compile with -O3 and perform LTO with -O0), so we need
1014 # to also update the linker flags based on the target.
1015 if env['GCC']:
1016     if sys.platform == 'sunos5':
1017         ccflags['debug'] += ['-gstabs+']
1018     else:
1019         ccflags['debug'] += ['-ggdb3']
1020     ldflags['debug'] += ['-O0']
1021     # opt, fast, prof and perf all share the same cc flags, also add
1022     # the optimization to the ldflags as LTO defers the optimization
1023     # to link time
1024     for target in ['opt', 'fast', 'prof', 'perf']:
1025         ccflags[target] += ['-O3']
1026         ldflags[target] += ['-O3']
1027
1028     ccflags['fast'] += env['LTO_CCFLAGS']
1029     ldflags['fast'] += env['LTO_LDFLAGS']
1030 elif env['CLANG']:
1031     ccflags['debug'] += ['-g', '-O0']
1032     # opt, fast, prof and perf all share the same cc flags
1033     for target in ['opt', 'fast', 'prof', 'perf']:
1034         ccflags[target] += ['-O3']
1035 else:
1036     print 'Unknown compiler, please fix compiler options'
1037     Exit(1)
1038
1039
1040 # To speed things up, we only instantiate the build environments we
1041 # need.  We try to identify the needed environment for each target; if
1042 # we can't, we fall back on instantiating all the environments just to
1043 # be safe.
1044 target_types = ['debug', 'opt', 'fast', 'prof', 'perf']
1045 obj2target = {'do': 'debug', 'o': 'opt', 'fo': 'fast', 'po': 'prof',
1046               'gpo' : 'perf'}
1047
1048 def identifyTarget(t):
1049     ext = t.split('.')[-1]
1050     if ext in target_types:
1051         return ext
1052     if obj2target.has_key(ext):
1053         return obj2target[ext]
1054     match = re.search(r'/tests/([^/]+)/', t)
1055     if match and match.group(1) in target_types:
1056         return match.group(1)
1057     return 'all'
1058
1059 needed_envs = [identifyTarget(target) for target in BUILD_TARGETS]
1060 if 'all' in needed_envs:
1061     needed_envs += target_types
1062
1063 # Debug binary
1064 if 'debug' in needed_envs:
1065     makeEnv('debug', '.do',
1066             CCFLAGS = Split(ccflags['debug']),
1067             CPPDEFINES = ['DEBUG', 'TRACING_ON=1'],
1068             LINKFLAGS = Split(ldflags['debug']))
1069
1070 # Optimized binary
1071 if 'opt' in needed_envs:
1072     makeEnv('opt', '.o',
1073             CCFLAGS = Split(ccflags['opt']),
1074             CPPDEFINES = ['TRACING_ON=1'],
1075             LINKFLAGS = Split(ldflags['opt']))
1076
1077 # "Fast" binary
1078 if 'fast' in needed_envs:
1079     makeEnv('fast', '.fo', strip = True,
1080             CCFLAGS = Split(ccflags['fast']),
1081             CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'],
1082             LINKFLAGS = Split(ldflags['fast']))
1083
1084 # Profiled binary using gprof
1085 if 'prof' in needed_envs:
1086     makeEnv('prof', '.po',
1087             CCFLAGS = Split(ccflags['prof']),
1088             CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'],
1089             LINKFLAGS = Split(ldflags['prof']))
1090
1091 # Profiled binary using google-pprof
1092 if 'perf' in needed_envs:
1093     makeEnv('perf', '.gpo',
1094             CCFLAGS = Split(ccflags['perf']),
1095             CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'],
1096             LINKFLAGS = Split(ldflags['perf']))
1097
1098 Return('envList')