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 #     skip_no_python -- do not put this file into a no_python library
  67 #       as it embeds compiled Python
  68 #     <unittest> -- unit tests use filters based on the unit test name
  69 #
  70 # A parent can now be specified for a source file and default filter
  71 # values will be retrieved recursively from parents (children override
  72 # parents).
  73 #
  74 class SourceMeta(type):
  75     '''Meta class for source files that keeps track of all files of a
  76     particular type and has a get function for finding all functions
  77     of a certain type that match a set of guards'''
  78     def __init__(cls, name, bases, dict):
  79         super(SourceMeta, cls).__init__(name, bases, dict)
  80         cls.all = []
  81
  82     def get(cls, **guards):
  83         '''Find all files that match the specified guards.  If a source
  84         file does not specify a flag, the default is False'''
  85         for src in cls.all:
  86             for flag,value in guards.iteritems():
  87                 # if the flag is found and has a different value, skip
  88                 # this file
  89                 if src.all_guards.get(flag, False) != value:
  90                     break
  91             else:
  92                 yield src
  93
  94 class SourceFile(object):
  95     '''Base object that encapsulates the notion of a source file.
  96     This includes, the source node, target node, various manipulations
  97     of those.  A source file also specifies a set of guards which
  98     describing which builds the source file applies to.  A parent can
  99     also be specified to get default guards from'''
 100     __metaclass__ = SourceMeta
 101     def __init__(self, source, parent=None, **guards):
 102         self.guards = guards
 103         self.parent = parent
 104
 105         tnode = source
 106         if not isinstance(source, SCons.Node.FS.File):
 107             tnode = File(source)
 108
 109         self.tnode = tnode
 110         self.snode = tnode.srcnode()
 111
 112         for base in type(self).__mro__:
 113             if issubclass(base, SourceFile):
 114                 base.all.append(self)
 115
 116     @property
 117     def filename(self):
 118         return str(self.tnode)
 119
 120     @property
 121     def dirname(self):
 122         return dirname(self.filename)
 123
 124     @property
 125     def basename(self):
 126         return basename(self.filename)
 127
 128     @property
 129     def extname(self):
 130         index = self.basename.rfind('.')
 131         if index <= 0:
 132             # dot files aren't extensions
 133             return self.basename, None
 134
 135         return self.basename[:index], self.basename[index+1:]
 136
 137     @property
 138     def all_guards(self):
 139         '''find all guards for this object getting default values
 140         recursively from its parents'''
 141         guards = {}
 142         if self.parent:
 143             guards.update(self.parent.guards)
 144         guards.update(self.guards)
 145         return guards
 146
 147     def __lt__(self, other): return self.filename < other.filename
 148     def __le__(self, other): return self.filename <= other.filename
 149     def __gt__(self, other): return self.filename > other.filename
 150     def __ge__(self, other): return self.filename >= other.filename
 151     def __eq__(self, other): return self.filename == other.filename
 152     def __ne__(self, other): return self.filename != other.filename
 153
 154     @staticmethod
 155     def done():
 156         def disabled(cls, name, *ignored):
 157             raise RuntimeError("Additional SourceFile '%s'" % name,\
 158                   "declared, but targets deps are already fixed.")
 159         SourceFile.__init__ = disabled
 160
 161
 162 class Source(SourceFile):
 163     '''Add a c/c++ source file to the build'''
 164     def __init__(self, source, Werror=True, swig=False, **guards):
 165         '''specify the source file, and any guards'''
 166         super(Source, self).__init__(source, **guards)
 167
 168         self.Werror = Werror
 169         self.swig = swig
 170
 171 class PySource(SourceFile):
 172     '''Add a python source file to the named package'''
 173     invalid_sym_char = re.compile('[^A-z0-9_]')
 174     modules = {}
 175     tnodes = {}
 176     symnames = {}
 177
 178     def __init__(self, package, source, **guards):
 179         '''specify the python package, the source file, and any guards'''
 180         super(PySource, self).__init__(source, **guards)
 181
 182         modname,ext = self.extname
 183         assert ext == 'py'
 184
 185         if package:
 186             path = package.split('.')
 187         else:
 188             path = []
 189
 190         modpath = path[:]
 191         if modname != '__init__':
 192             modpath += [ modname ]
 193         modpath = '.'.join(modpath)
 194
 195         arcpath = path + [ self.basename ]
 196         abspath = self.snode.abspath
 197         if not exists(abspath):
 198             abspath = self.tnode.abspath
 199
 200         self.package = package
 201         self.modname = modname
 202         self.modpath = modpath
 203         self.arcname = joinpath(*arcpath)
 204         self.abspath = abspath
 205         self.compiled = File(self.filename + 'c')
 206         self.cpp = File(self.filename + '.cc')
 207         self.symname = PySource.invalid_sym_char.sub('_', modpath)
 208
 209         PySource.modules[modpath] = self
 210         PySource.tnodes[self.tnode] = self
 211         PySource.symnames[self.symname] = self
 212
 213 class SimObject(PySource):
 214     '''Add a SimObject python file as a python source object and add
 215     it to a list of sim object modules'''
 216
 217     fixed = False
 218     modnames = []
 219
 220     def __init__(self, source, **guards):
 221         '''Specify the source file and any guards (automatically in
 222         the m5.objects package)'''
 223         super(SimObject, self).__init__('m5.objects', source, **guards)
 224         if self.fixed:
 225             raise AttributeError, "Too late to call SimObject now."
 226
 227         bisect.insort_right(SimObject.modnames, self.modname)
 228
 229 class SwigSource(SourceFile):
 230     '''Add a swig file to build'''
 231
 232     def __init__(self, package, source, **guards):
 233         '''Specify the python package, the source file, and any guards'''
 234         super(SwigSource, self).__init__(source, skip_no_python=True, **guards)
 235
 236         modname,ext = self.extname
 237         assert ext == 'i'
 238
 239         self.module = modname
 240         cc_file = joinpath(self.dirname, modname + '_wrap.cc')
 241         py_file = joinpath(self.dirname, modname + '.py')
 242
 243         self.cc_source = Source(cc_file, swig=True, parent=self, **guards)
 244         self.py_source = PySource(package, py_file, parent=self, **guards)
 245
 246 class ProtoBuf(SourceFile):
 247     '''Add a Protocol Buffer to build'''
 248
 249     def __init__(self, source, **guards):
 250         '''Specify the source file, and any guards'''
 251         super(ProtoBuf, self).__init__(source, **guards)
 252
 253         # Get the file name and the extension
 254         modname,ext = self.extname
 255         assert ext == 'proto'
 256
 257         # Currently, we stick to generating the C++ headers, so we
 258         # only need to track the source and header.
 259         self.cc_file = File(modname + '.pb.cc')
 260         self.hh_file = File(modname + '.pb.h')
 261
 262 class UnitTest(object):
 263     '''Create a UnitTest'''
 264
 265     all = []
 266     def __init__(self, target, *sources, **kwargs):
 267         '''Specify the target name and any sources.  Sources that are
 268         not SourceFiles are evalued with Source().  All files are
 269         guarded with a guard of the same name as the UnitTest
 270         target.'''
 271
 272         srcs = []
 273         for src in sources:
 274             if not isinstance(src, SourceFile):
 275                 src = Source(src, skip_lib=True)
 276             src.guards[target] = True
 277             srcs.append(src)
 278
 279         self.sources = srcs
 280         self.target = target
 281         self.main = kwargs.get('main', False)
 282         UnitTest.all.append(self)
 283
 284 # Children should have access
 285 Export('Source')
 286 Export('PySource')
 287 Export('SimObject')
 288 Export('SwigSource')
 289 Export('ProtoBuf')
 290 Export('UnitTest')
 291
 292 ########################################################################
 293 #
 294 # Debug Flags
 295 #
 296 debug_flags = {}
 297 def DebugFlag(name, desc=None):
 298     if name in debug_flags:
 299         raise AttributeError, "Flag %s already specified" % name
 300     debug_flags[name] = (name, (), desc)
 301
 302 def CompoundFlag(name, flags, desc=None):
 303     if name in debug_flags:
 304         raise AttributeError, "Flag %s already specified" % name
 305
 306     compound = tuple(flags)
 307     debug_flags[name] = (name, compound, desc)
 308
 309 Export('DebugFlag')
 310 Export('CompoundFlag')
 311
 312 ########################################################################
 313 #
 314 # Set some compiler variables
 315 #
 316
 317 # Include file paths are rooted in this directory.  SCons will
 318 # automatically expand '.' to refer to both the source directory and
 319 # the corresponding build directory to pick up generated include
 320 # files.
 321 env.Append(CPPPATH=Dir('.'))
 322
 323 for extra_dir in extras_dir_list:
 324     env.Append(CPPPATH=Dir(extra_dir))
 325
 326 # Workaround for bug in SCons version > 0.97d20071212
 327 # Scons bug id: 2006 gem5 Bug id: 308
 328 for root, dirs, files in os.walk(base_dir, topdown=True):
 329     Dir(root[len(base_dir) + 1:])
 330
 331 ########################################################################
 332 #
 333 # Walk the tree and execute all SConscripts in subdirectories
 334 #
 335
 336 here = Dir('.').srcnode().abspath
 337 for root, dirs, files in os.walk(base_dir, topdown=True):
 338     if root == here:
 339         # we don't want to recurse back into this SConscript
 340         continue
 341
 342     if 'SConscript' in files:
 343         build_dir = joinpath(env['BUILDDIR'], root[len(base_dir) + 1:])
 344         SConscript(joinpath(root, 'SConscript'), variant_dir=build_dir)
 345
 346 for extra_dir in extras_dir_list:
 347     prefix_len = len(dirname(extra_dir)) + 1
 348
 349     # Also add the corresponding build directory to pick up generated
 350     # include files.
 351     env.Append(CPPPATH=Dir(joinpath(env['BUILDDIR'], extra_dir[prefix_len:])))
 352
 353     for root, dirs, files in os.walk(extra_dir, topdown=True):
 354         # if build lives in the extras directory, don't walk down it
 355         if 'build' in dirs:
 356             dirs.remove('build')
 357
 358         if 'SConscript' in files:
 359             build_dir = joinpath(env['BUILDDIR'], root[prefix_len:])
 360             SConscript(joinpath(root, 'SConscript'), variant_dir=build_dir)
 361
 362 for opt in export_vars:
 363     env.ConfigFile(opt)
 364
 365 def makeTheISA(source, target, env):
 366     isas = [ src.get_contents() for src in source ]
 367     target_isa = env['TARGET_ISA']
 368     def define(isa):
 369         return isa.upper() + '_ISA'
 370
 371     def namespace(isa):
 372         return isa[0].upper() + isa[1:].lower() + 'ISA'
 373
 374
 375     code = code_formatter()
 376     code('''\
 377 #ifndef __CONFIG_THE_ISA_HH__
 378 #define __CONFIG_THE_ISA_HH__
 379
 380 ''')
 381
 382     for i,isa in enumerate(isas):
 383         code('#define $0 $1', define(isa), i + 1)
 384
 385     code('''
 386
 387 #define THE_ISA ${{define(target_isa)}}
 388 #define TheISA ${{namespace(target_isa)}}
 389 #define THE_ISA_STR "${{target_isa}}"
 390
 391 #endif // __CONFIG_THE_ISA_HH__''')
 392
 393     code.write(str(target[0]))
 394
 395 env.Command('config/the_isa.hh', map(Value, all_isa_list),
 396             MakeAction(makeTheISA, Transform("CFG ISA", 0)))
 397
 398 ########################################################################
 399 #
 400 # Prevent any SimObjects from being added after this point, they
 401 # should all have been added in the SConscripts above
 402 #
 403 SimObject.fixed = True
 404
 405 class DictImporter(object):
 406     '''This importer takes a dictionary of arbitrary module names that
 407     map to arbitrary filenames.'''
 408     def __init__(self, modules):
 409         self.modules = modules
 410         self.installed = set()
 411
 412     def __del__(self):
 413         self.unload()
 414
 415     def unload(self):
 416         import sys
 417         for module in self.installed:
 418             del sys.modules[module]
 419         self.installed = set()
 420
 421     def find_module(self, fullname, path):
 422         if fullname == 'm5.defines':
 423             return self
 424
 425         if fullname == 'm5.objects':
 426             return self
 427
 428         if fullname.startswith('m5.internal'):
 429             return None
 430
 431         source = self.modules.get(fullname, None)
 432         if source is not None and fullname.startswith('m5.objects'):
 433             return self
 434
 435         return None
 436
 437     def load_module(self, fullname):
 438         mod = imp.new_module(fullname)
 439         sys.modules[fullname] = mod
 440         self.installed.add(fullname)
 441
 442         mod.__loader__ = self
 443         if fullname == 'm5.objects':
 444             mod.__path__ = fullname.split('.')
 445             return mod
 446
 447         if fullname == 'm5.defines':
 448             mod.__dict__['buildEnv'] = m5.util.SmartDict(build_env)
 449             return mod
 450
 451         source = self.modules[fullname]
 452         if source.modname == '__init__':
 453             mod.__path__ = source.modpath
 454         mod.__file__ = source.abspath
 455
 456         exec file(source.abspath, 'r') in mod.__dict__
 457
 458         return mod
 459
 460 import m5.SimObject
 461 import m5.params
 462 from m5.util import code_formatter
 463
 464 m5.SimObject.clear()
 465 m5.params.clear()
 466
 467 # install the python importer so we can grab stuff from the source
 468 # tree itself.  We can't have SimObjects added after this point or
 469 # else we won't know about them for the rest of the stuff.
 470 importer = DictImporter(PySource.modules)
 471 sys.meta_path[0:0] = [ importer ]
 472
 473 # import all sim objects so we can populate the all_objects list
 474 # make sure that we're working with a list, then let's sort it
 475 for modname in SimObject.modnames:
 476     exec('from m5.objects import %s' % modname)
 477
 478 # we need to unload all of the currently imported modules so that they
 479 # will be re-imported the next time the sconscript is run
 480 importer.unload()
 481 sys.meta_path.remove(importer)
 482
 483 sim_objects = m5.SimObject.allClasses
 484 all_enums = m5.params.allEnums
 485
 486 if m5.SimObject.noCxxHeader:
 487     print >> sys.stderr, \
 488         "warning: At least one SimObject lacks a header specification. " \
 489         "This can cause unexpected results in the generated SWIG " \
 490         "wrappers."
 491
 492 # Find param types that need to be explicitly wrapped with swig.
 493 # These will be recognized because the ParamDesc will have a
 494 # swig_decl() method.  Most param types are based on types that don't
 495 # need this, either because they're based on native types (like Int)
 496 # or because they're SimObjects (which get swigged independently).
 497 # For now the only things handled here are VectorParam types.
 498 params_to_swig = {}
 499 for name,obj in sorted(sim_objects.iteritems()):
 500     for param in obj._params.local.values():
 501         # load the ptype attribute now because it depends on the
 502         # current version of SimObject.allClasses, but when scons
 503         # actually uses the value, all versions of
 504         # SimObject.allClasses will have been loaded
 505         param.ptype
 506
 507         if not hasattr(param, 'swig_decl'):
 508             continue
 509         pname = param.ptype_str
 510         if pname not in params_to_swig:
 511             params_to_swig[pname] = param
 512
 513 ########################################################################
 514 #
 515 # calculate extra dependencies
 516 #
 517 module_depends = ["m5", "m5.SimObject", "m5.params"]
 518 depends = [ PySource.modules[dep].snode for dep in module_depends ]
 519
 520 ########################################################################
 521 #
 522 # Commands for the basic automatically generated python files
 523 #
 524
 525 # Generate Python file containing a dict specifying the current
 526 # buildEnv flags.
 527 def makeDefinesPyFile(target, source, env):
 528     build_env = source[0].get_contents()
 529
 530     code = code_formatter()
 531     code("""
 532 import m5.internal
 533 import m5.util
 534
 535 buildEnv = m5.util.SmartDict($build_env)
 536
 537 compileDate = m5.internal.core.compileDate
 538 _globals = globals()
 539 for key,val in m5.internal.core.__dict__.iteritems():
 540     if key.startswith('flag_'):
 541         flag = key[5:]
 542         _globals[flag] = val
 543 del _globals
 544 """)
 545     code.write(target[0].abspath)
 546
 547 defines_info = Value(build_env)
 548 # Generate a file with all of the compile options in it
 549 env.Command('python/m5/defines.py', defines_info,
 550             MakeAction(makeDefinesPyFile, Transform("DEFINES", 0)))
 551 PySource('m5', 'python/m5/defines.py')
 552
 553 # Generate python file containing info about the M5 source code
 554 def makeInfoPyFile(target, source, env):
 555     code = code_formatter()
 556     for src in source:
 557         data = ''.join(file(src.srcnode().abspath, 'r').xreadlines())
 558         code('$src = ${{repr(data)}}')
 559     code.write(str(target[0]))
 560
 561 # Generate a file that wraps the basic top level files
 562 env.Command('python/m5/info.py',
 563             [ '#/COPYING', '#/LICENSE', '#/README', ],
 564             MakeAction(makeInfoPyFile, Transform("INFO")))
 565 PySource('m5', 'python/m5/info.py')
 566
 567 ########################################################################
 568 #
 569 # Create all of the SimObject param headers and enum headers
 570 #
 571
 572 def createSimObjectParamStruct(target, source, env):
 573     assert len(target) == 1 and len(source) == 1
 574
 575     name = str(source[0].get_contents())
 576     obj = sim_objects[name]
 577
 578     code = code_formatter()
 579     obj.cxx_param_decl(code)
 580     code.write(target[0].abspath)
 581
 582 def createSimObjectCxxConfig(is_header):
 583     def body(target, source, env):
 584         assert len(target) == 1 and len(source) == 1
 585
 586         name = str(source[0].get_contents())
 587         obj = sim_objects[name]
 588
 589         code = code_formatter()
 590         obj.cxx_config_param_file(code, is_header)
 591         code.write(target[0].abspath)
 592     return body
 593
 594 def createParamSwigWrapper(target, source, env):
 595     assert len(target) == 1 and len(source) == 1
 596
 597     name = str(source[0].get_contents())
 598     param = params_to_swig[name]
 599
 600     code = code_formatter()
 601     param.swig_decl(code)
 602     code.write(target[0].abspath)
 603
 604 def createEnumStrings(target, source, env):
 605     assert len(target) == 1 and len(source) == 1
 606
 607     name = str(source[0].get_contents())
 608     obj = all_enums[name]
 609
 610     code = code_formatter()
 611     obj.cxx_def(code)
 612     code.write(target[0].abspath)
 613
 614 def createEnumDecls(target, source, env):
 615     assert len(target) == 1 and len(source) == 1
 616
 617     name = str(source[0].get_contents())
 618     obj = all_enums[name]
 619
 620     code = code_formatter()
 621     obj.cxx_decl(code)
 622     code.write(target[0].abspath)
 623
 624 def createEnumSwigWrapper(target, source, env):
 625     assert len(target) == 1 and len(source) == 1
 626
 627     name = str(source[0].get_contents())
 628     obj = all_enums[name]
 629
 630     code = code_formatter()
 631     obj.swig_decl(code)
 632     code.write(target[0].abspath)
 633
 634 def createSimObjectSwigWrapper(target, source, env):
 635     name = source[0].get_contents()
 636     obj = sim_objects[name]
 637
 638     code = code_formatter()
 639     obj.swig_decl(code)
 640     code.write(target[0].abspath)
 641
 642 # dummy target for generated code
 643 # we start out with all the Source files so they get copied to build/*/ also.
 644 SWIG = env.Dummy('swig', [s.tnode for s in Source.get()])
 645
 646 # Generate all of the SimObject param C++ struct header files
 647 params_hh_files = []
 648 for name,simobj in sorted(sim_objects.iteritems()):
 649     py_source = PySource.modules[simobj.__module__]
 650     extra_deps = [ py_source.tnode ]
 651
 652     hh_file = File('params/%s.hh' % name)
 653     params_hh_files.append(hh_file)
 654     env.Command(hh_file, Value(name),
 655                 MakeAction(createSimObjectParamStruct, Transform("SO PARAM")))
 656     env.Depends(hh_file, depends + extra_deps)
 657     env.Depends(SWIG, hh_file)
 658
 659 # C++ parameter description files
 660 if GetOption('with_cxx_config'):
 661     for name,simobj in sorted(sim_objects.iteritems()):
 662         py_source = PySource.modules[simobj.__module__]
 663         extra_deps = [ py_source.tnode ]
 664
 665         cxx_config_hh_file = File('cxx_config/%s.hh' % name)
 666         cxx_config_cc_file = File('cxx_config/%s.cc' % name)
 667         env.Command(cxx_config_hh_file, Value(name),
 668                     MakeAction(createSimObjectCxxConfig(True),
 669                     Transform("CXXCPRHH")))
 670         env.Command(cxx_config_cc_file, Value(name),
 671                     MakeAction(createSimObjectCxxConfig(False),
 672                     Transform("CXXCPRCC")))
 673         env.Depends(cxx_config_hh_file, depends + extra_deps +
 674                     [File('params/%s.hh' % name), File('sim/cxx_config.hh')])
 675         env.Depends(cxx_config_cc_file, depends + extra_deps +
 676                     [cxx_config_hh_file])
 677         Source(cxx_config_cc_file)
 678
 679     cxx_config_init_cc_file = File('cxx_config/init.cc')
 680
 681     def createCxxConfigInitCC(target, source, env):
 682         assert len(target) == 1 and len(source) == 1
 683
 684         code = code_formatter()
 685
 686         for name,simobj in sorted(sim_objects.iteritems()):
 687             if not hasattr(simobj, 'abstract') or not simobj.abstract:
 688                 code('#include "cxx_config/${name}.hh"')
 689         code()
 690         code('void cxxConfigInit()')
 691         code('{')
 692         code.indent()
 693         for name,simobj in sorted(sim_objects.iteritems()):
 694             not_abstract = not hasattr(simobj, 'abstract') or \
 695                 not simobj.abstract
 696             if not_abstract and 'type' in simobj.__dict__:
 697                 code('cxx_config_directory["${name}"] = '
 698                      '${name}CxxConfigParams::makeDirectoryEntry();')
 699         code.dedent()
 700         code('}')
 701         code.write(target[0].abspath)
 702
 703     py_source = PySource.modules[simobj.__module__]
 704     extra_deps = [ py_source.tnode ]
 705     env.Command(cxx_config_init_cc_file, Value(name),
 706         MakeAction(createCxxConfigInitCC, Transform("CXXCINIT")))
 707     cxx_param_hh_files = ["cxx_config/%s.hh" % simobj
 708         for simobj in sorted(sim_objects.itervalues())
 709         if not hasattr(simobj, 'abstract') or not simobj.abstract]
 710     Depends(cxx_config_init_cc_file, cxx_param_hh_files +
 711             [File('sim/cxx_config.hh')])
 712     Source(cxx_config_init_cc_file)
 713
 714 # Generate any needed param SWIG wrapper files
 715 params_i_files = []
 716 for name,param in params_to_swig.iteritems():
 717     i_file = File('python/m5/internal/%s.i' % (param.swig_module_name()))
 718     params_i_files.append(i_file)
 719     env.Command(i_file, Value(name),
 720                 MakeAction(createParamSwigWrapper, Transform("SW PARAM")))
 721     env.Depends(i_file, depends)
 722     env.Depends(SWIG, i_file)
 723     SwigSource('m5.internal', i_file)
 724
 725 # Generate all enum header files
 726 for name,enum in sorted(all_enums.iteritems()):
 727     py_source = PySource.modules[enum.__module__]
 728     extra_deps = [ py_source.tnode ]
 729
 730     cc_file = File('enums/%s.cc' % name)
 731     env.Command(cc_file, Value(name),
 732                 MakeAction(createEnumStrings, Transform("ENUM STR")))
 733     env.Depends(cc_file, depends + extra_deps)
 734     env.Depends(SWIG, cc_file)
 735     Source(cc_file)
 736
 737     hh_file = File('enums/%s.hh' % name)
 738     env.Command(hh_file, Value(name),
 739                 MakeAction(createEnumDecls, Transform("ENUMDECL")))
 740     env.Depends(hh_file, depends + extra_deps)
 741     env.Depends(SWIG, hh_file)
 742
 743     i_file = File('python/m5/internal/enum_%s.i' % name)
 744     env.Command(i_file, Value(name),
 745                 MakeAction(createEnumSwigWrapper, Transform("ENUMSWIG")))
 746     env.Depends(i_file, depends + extra_deps)
 747     env.Depends(SWIG, i_file)
 748     SwigSource('m5.internal', i_file)
 749
 750 # Generate SimObject SWIG wrapper files
 751 for name,simobj in sim_objects.iteritems():
 752     py_source = PySource.modules[simobj.__module__]
 753     extra_deps = [ py_source.tnode ]
 754
 755     i_file = File('python/m5/internal/param_%s.i' % name)
 756     env.Command(i_file, Value(name),
 757                 MakeAction(createSimObjectSwigWrapper, Transform("SO SWIG")))
 758     env.Depends(i_file, depends + extra_deps)
 759     SwigSource('m5.internal', i_file)
 760
 761 # Generate the main swig init file
 762 def makeEmbeddedSwigInit(target, source, env):
 763     code = code_formatter()
 764     module = source[0].get_contents()
 765     code('''\
 766 #include "sim/init.hh"
 767
 768 extern "C" {
 769     void init_${module}();
 770 }
 771
 772 EmbeddedSwig embed_swig_${module}(init_${module});
 773 ''')
 774     code.write(str(target[0]))
 775
 776 # Build all swig modules
 777 for swig in SwigSource.all:
 778     env.Command([swig.cc_source.tnode, swig.py_source.tnode], swig.tnode,
 779                 MakeAction('$SWIG $SWIGFLAGS -outdir ${TARGETS[1].dir} '
 780                 '-o ${TARGETS[0]} $SOURCES', Transform("SWIG")))
 781     cc_file = str(swig.tnode)
 782     init_file = '%s/%s_init.cc' % (dirname(cc_file), basename(cc_file))
 783     env.Command(init_file, Value(swig.module),
 784                 MakeAction(makeEmbeddedSwigInit, Transform("EMBED SW")))
 785     env.Depends(SWIG, init_file)
 786     Source(init_file, **swig.guards)
 787
 788 # Build all protocol buffers if we have got protoc and protobuf available
 789 if env['HAVE_PROTOBUF']:
 790     for proto in ProtoBuf.all:
 791         # Use both the source and header as the target, and the .proto
 792         # file as the source. When executing the protoc compiler, also
 793         # specify the proto_path to avoid having the generated files
 794         # include the path.
 795         env.Command([proto.cc_file, proto.hh_file], proto.tnode,
 796                     MakeAction('$PROTOC --cpp_out ${TARGET.dir} '
 797                                '--proto_path ${SOURCE.dir} $SOURCE',
 798                                Transform("PROTOC")))
 799
 800         env.Depends(SWIG, [proto.cc_file, proto.hh_file])
 801         # Add the C++ source file
 802         Source(proto.cc_file, **proto.guards)
 803 elif ProtoBuf.all:
 804     print 'Got protobuf to build, but lacks support!'
 805     Exit(1)
 806
 807 #
 808 # Handle debug flags
 809 #
 810 def makeDebugFlagCC(target, source, env):
 811     assert(len(target) == 1 and len(source) == 1)
 812
 813     code = code_formatter()
 814
 815     # delay definition of CompoundFlags until after all the definition
 816     # of all constituent SimpleFlags
 817     comp_code = code_formatter()
 818
 819     # file header
 820     code('''
 821 /*
 822  * DO NOT EDIT THIS FILE! Automatically generated by SCons.
 823  */
 824
 825 #include "base/debug.hh"
 826
 827 namespace Debug {
 828
 829 ''')
 830
 831     for name, flag in sorted(source[0].read().iteritems()):
 832         n, compound, desc = flag
 833         assert n == name
 834
 835         if not compound:
 836             code('SimpleFlag $name("$name", "$desc");')
 837         else:
 838             comp_code('CompoundFlag $name("$name", "$desc",')
 839             comp_code.indent()
 840             last = len(compound) - 1
 841             for i,flag in enumerate(compound):
 842                 if i != last:
 843                     comp_code('$flag,')
 844                 else:
 845                     comp_code('$flag);')
 846             comp_code.dedent()
 847
 848     code.append(comp_code)
 849     code()
 850     code('} // namespace Debug')
 851
 852     code.write(str(target[0]))
 853
 854 def makeDebugFlagHH(target, source, env):
 855     assert(len(target) == 1 and len(source) == 1)
 856
 857     val = eval(source[0].get_contents())
 858     name, compound, desc = val
 859
 860     code = code_formatter()
 861
 862     # file header boilerplate
 863     code('''\
 864 /*
 865  * DO NOT EDIT THIS FILE! Automatically generated by SCons.
 866  */
 867
 868 #ifndef __DEBUG_${name}_HH__
 869 #define __DEBUG_${name}_HH__
 870
 871 namespace Debug {
 872 ''')
 873
 874     if compound:
 875         code('class CompoundFlag;')
 876     code('class SimpleFlag;')
 877
 878     if compound:
 879         code('extern CompoundFlag $name;')
 880         for flag in compound:
 881             code('extern SimpleFlag $flag;')
 882     else:
 883         code('extern SimpleFlag $name;')
 884
 885     code('''
 886 }
 887
 888 #endif // __DEBUG_${name}_HH__
 889 ''')
 890
 891     code.write(str(target[0]))
 892
 893 for name,flag in sorted(debug_flags.iteritems()):
 894     n, compound, desc = flag
 895     assert n == name
 896
 897     hh_file = 'debug/%s.hh' % name
 898     env.Command(hh_file, Value(flag),
 899                 MakeAction(makeDebugFlagHH, Transform("TRACING", 0)))
 900     env.Depends(SWIG, hh_file)
 901
 902 env.Command('debug/flags.cc', Value(debug_flags),
 903             MakeAction(makeDebugFlagCC, Transform("TRACING", 0)))
 904 env.Depends(SWIG, 'debug/flags.cc')
 905 Source('debug/flags.cc')
 906
 907 # Embed python files.  All .py files that have been indicated by a
 908 # PySource() call in a SConscript need to be embedded into the M5
 909 # library.  To do that, we compile the file to byte code, marshal the
 910 # byte code, compress it, and then generate a c++ file that
 911 # inserts the result into an array.
 912 def embedPyFile(target, source, env):
 913     def c_str(string):
 914         if string is None:
 915             return "0"
 916         return '"%s"' % string
 917
 918     '''Action function to compile a .py into a code object, marshal
 919     it, compress it, and stick it into an asm file so the code appears
 920     as just bytes with a label in the data section'''
 921
 922     src = file(str(source[0]), 'r').read()
 923
 924     pysource = PySource.tnodes[source[0]]
 925     compiled = compile(src, pysource.abspath, 'exec')
 926     marshalled = marshal.dumps(compiled)
 927     compressed = zlib.compress(marshalled)
 928     data = compressed
 929     sym = pysource.symname
 930
 931     code = code_formatter()
 932     code('''\
 933 #include "sim/init.hh"
 934
 935 namespace {
 936
 937 const uint8_t data_${sym}[] = {
 938 ''')
 939     code.indent()
 940     step = 16
 941     for i in xrange(0, len(data), step):
 942         x = array.array('B', data[i:i+step])
 943         code(''.join('%d,' % d for d in x))
 944     code.dedent()
 945
 946     code('''};
 947
 948 EmbeddedPython embedded_${sym}(
 949     ${{c_str(pysource.arcname)}},
 950     ${{c_str(pysource.abspath)}},
 951     ${{c_str(pysource.modpath)}},
 952     data_${sym},
 953     ${{len(data)}},
 954     ${{len(marshalled)}});
 955
 956 } // anonymous namespace
 957 ''')
 958     code.write(str(target[0]))
 959
 960 for source in PySource.all:
 961     env.Command(source.cpp, source.tnode,
 962                 MakeAction(embedPyFile, Transform("EMBED PY")))
 963     env.Depends(SWIG, source.cpp)
 964     Source(source.cpp, skip_no_python=True)
 965
 966 ########################################################################
 967 #
 968 # Define binaries.  Each different build type (debug, opt, etc.) gets
 969 # a slightly different build environment.
 970 #
 971
 972 # List of constructed environments to pass back to SConstruct
 973 date_source = Source('base/date.cc', skip_lib=True)
 974
 975 # Capture this directory for the closure makeEnv, otherwise when it is
 976 # called, it won't know what directory it should use.
 977 variant_dir = Dir('.').path
 978 def variant(*path):
 979     return os.path.join(variant_dir, *path)
 980 def variantd(*path):
 981     return variant(*path)+'/'
 982
 983 # Function to create a new build environment as clone of current
 984 # environment 'env' with modified object suffix and optional stripped
 985 # binary.  Additional keyword arguments are appended to corresponding
 986 # build environment vars.
 987 def makeEnv(env, label, objsfx, strip = False, **kwargs):
 988     # SCons doesn't know to append a library suffix when there is a '.' in the
 989     # name.  Use '_' instead.
 990     libname = variant('gem5_' + label)
 991     exename = variant('gem5.' + label)
 992     secondary_exename = variant('m5.' + label)
 993
 994     new_env = env.Clone(OBJSUFFIX=objsfx, SHOBJSUFFIX=objsfx + 's')
 995     new_env.Label = label
 996     new_env.Append(**kwargs)
 997
 998     swig_env = new_env.Clone()
 999
1000     # Both gcc and clang have issues with unused labels and values in
1001     # the SWIG generated code
1002     swig_env.Append(CCFLAGS=['-Wno-unused-label', '-Wno-unused-value'])
1003
1004     # Add additional warnings here that should not be applied to
1005     # the SWIG generated code
1006     new_env.Append(CXXFLAGS='-Wmissing-declarations')
1007
1008     if env['GCC']:
1009         # Depending on the SWIG version, we also need to supress
1010         # warnings about uninitialized variables and missing field
1011         # initializers.
1012         swig_env.Append(CCFLAGS=['-Wno-uninitialized',
1013                                  '-Wno-missing-field-initializers',
1014                                  '-Wno-unused-but-set-variable'])
1015
1016         # If gcc supports it, also warn for deletion of derived
1017         # classes with non-virtual desctructors. For gcc >= 4.7 we
1018         # also have to disable warnings about the SWIG code having
1019         # potentially uninitialized variables.
1020         if compareVersions(env['GCC_VERSION'], '4.7') >= 0:
1021             new_env.Append(CXXFLAGS='-Wdelete-non-virtual-dtor')
1022             swig_env.Append(CCFLAGS='-Wno-maybe-uninitialized')
1023
1024         # Only gcc >= 4.9 supports UBSan, so check both the version
1025         # and the command-line option before adding the compiler and
1026         # linker flags.
1027         if GetOption('with_ubsan') and \
1028                 compareVersions(env['GCC_VERSION'], '4.9') >= 0:
1029             new_env.Append(CCFLAGS='-fsanitize=undefined')
1030             new_env.Append(LINKFLAGS='-fsanitize=undefined')
1031
1032     if env['CLANG']:
1033         # Always enable the warning for deletion of derived classes
1034         # with non-virtual destructors
1035         new_env.Append(CXXFLAGS=['-Wdelete-non-virtual-dtor'])
1036
1037         swig_env.Append(CCFLAGS=[
1038                 # Some versions of SWIG can return uninitialized values
1039                 '-Wno-sometimes-uninitialized',
1040                 # Register storage is requested in a lot of places in
1041                 # SWIG-generated code.
1042                 '-Wno-deprecated-register',
1043                 ])
1044
1045         # All supported clang versions have support for UBSan, so if
1046         # asked to use it, append the compiler and linker flags.
1047         if GetOption('with_ubsan'):
1048             new_env.Append(CCFLAGS='-fsanitize=undefined')
1049             new_env.Append(LINKFLAGS='-fsanitize=undefined')
1050
1051     werror_env = new_env.Clone()
1052     werror_env.Append(CCFLAGS='-Werror')
1053
1054     def make_obj(source, static, extra_deps = None):
1055         '''This function adds the specified source to the correct
1056         build environment, and returns the corresponding SCons Object
1057         nodes'''
1058
1059         if source.swig:
1060             env = swig_env
1061         elif source.Werror:
1062             env = werror_env
1063         else:
1064             env = new_env
1065
1066         if static:
1067             obj = env.StaticObject(source.tnode)
1068         else:
1069             obj = env.SharedObject(source.tnode)
1070
1071         if extra_deps:
1072             env.Depends(obj, extra_deps)
1073
1074         return obj
1075
1076     lib_guards = {'main': False, 'skip_lib': False}
1077
1078     # Without Python, leave out all SWIG and Python content from the
1079     # library builds.  The option doesn't affect gem5 built as a program
1080     if GetOption('without_python'):
1081         lib_guards['skip_no_python'] = False
1082
1083     static_objs = [ make_obj(s, True) for s in Source.get(**lib_guards) ]
1084     shared_objs = [ make_obj(s, False) for s in Source.get(**lib_guards) ]
1085
1086     static_date = make_obj(date_source, static=True, extra_deps=static_objs)
1087     static_objs.append(static_date)
1088
1089     shared_date = make_obj(date_source, static=False, extra_deps=shared_objs)
1090     shared_objs.append(shared_date)
1091
1092     # First make a library of everything but main() so other programs can
1093     # link against m5.
1094     static_lib = new_env.StaticLibrary(libname, static_objs)
1095     shared_lib = new_env.SharedLibrary(libname, shared_objs)
1096
1097     # Now link a stub with main() and the static library.
1098     main_objs = [ make_obj(s, True) for s in Source.get(main=True) ]
1099
1100     for test in UnitTest.all:
1101         flags = { test.target : True }
1102         test_sources = Source.get(**flags)
1103         test_objs = [ make_obj(s, static=True) for s in test_sources ]
1104         if test.main:
1105             test_objs += main_objs
1106         path = variant('unittest/%s.%s' % (test.target, label))
1107         new_env.Program(path, test_objs + static_objs)
1108
1109     progname = exename
1110     if strip:
1111         progname += '.unstripped'
1112
1113     targets = new_env.Program(progname, main_objs + static_objs)
1114
1115     if strip:
1116         if sys.platform == 'sunos5':
1117             cmd = 'cp $SOURCE $TARGET; strip $TARGET'
1118         else:
1119             cmd = 'strip $SOURCE -o $TARGET'
1120         targets = new_env.Command(exename, progname,
1121                     MakeAction(cmd, Transform("STRIP")))
1122
1123     new_env.Command(secondary_exename, exename,
1124             MakeAction('ln $SOURCE $TARGET', Transform("HARDLINK")))
1125
1126     new_env.M5Binary = targets[0]
1127     return new_env
1128
1129 # Start out with the compiler flags common to all compilers,
1130 # i.e. they all use -g for opt and -g -pg for prof
1131 ccflags = {'debug' : [], 'opt' : ['-g'], 'fast' : [], 'prof' : ['-g', '-pg'],
1132            'perf' : ['-g']}
1133
1134 # Start out with the linker flags common to all linkers, i.e. -pg for
1135 # prof, and -lprofiler for perf. The -lprofile flag is surrounded by
1136 # no-as-needed and as-needed as the binutils linker is too clever and
1137 # simply doesn't link to the library otherwise.
1138 ldflags = {'debug' : [], 'opt' : [], 'fast' : [], 'prof' : ['-pg'],
1139            'perf' : ['-Wl,--no-as-needed', '-lprofiler', '-Wl,--as-needed']}
1140
1141 # For Link Time Optimization, the optimisation flags used to compile
1142 # individual files are decoupled from those used at link time
1143 # (i.e. you can compile with -O3 and perform LTO with -O0), so we need
1144 # to also update the linker flags based on the target.
1145 if env['GCC']:
1146     if sys.platform == 'sunos5':
1147         ccflags['debug'] += ['-gstabs+']
1148     else:
1149         ccflags['debug'] += ['-ggdb3']
1150     ldflags['debug'] += ['-O0']
1151     # opt, fast, prof and perf all share the same cc flags, also add
1152     # the optimization to the ldflags as LTO defers the optimization
1153     # to link time
1154     for target in ['opt', 'fast', 'prof', 'perf']:
1155         ccflags[target] += ['-O3']
1156         ldflags[target] += ['-O3']
1157
1158     ccflags['fast'] += env['LTO_CCFLAGS']
1159     ldflags['fast'] += env['LTO_LDFLAGS']
1160 elif env['CLANG']:
1161     ccflags['debug'] += ['-g', '-O0']
1162     # opt, fast, prof and perf all share the same cc flags
1163     for target in ['opt', 'fast', 'prof', 'perf']:
1164         ccflags[target] += ['-O3']
1165 else:
1166     print 'Unknown compiler, please fix compiler options'
1167     Exit(1)
1168
1169
1170 # To speed things up, we only instantiate the build environments we
1171 # need.  We try to identify the needed environment for each target; if
1172 # we can't, we fall back on instantiating all the environments just to
1173 # be safe.
1174 target_types = ['debug', 'opt', 'fast', 'prof', 'perf']
1175 obj2target = {'do': 'debug', 'o': 'opt', 'fo': 'fast', 'po': 'prof',
1176               'gpo' : 'perf'}
1177
1178 def identifyTarget(t):
1179     ext = t.split('.')[-1]
1180     if ext in target_types:
1181         return ext
1182     if obj2target.has_key(ext):
1183         return obj2target[ext]
1184     match = re.search(r'/tests/([^/]+)/', t)
1185     if match and match.group(1) in target_types:
1186         return match.group(1)
1187     return 'all'
1188
1189 needed_envs = [identifyTarget(target) for target in BUILD_TARGETS]
1190 if 'all' in needed_envs:
1191     needed_envs += target_types
1192
1193 gem5_root = Dir('.').up().up().abspath
1194 def makeEnvirons(target, source, env):
1195     # cause any later Source() calls to be fatal, as a diagnostic.
1196     Source.done()
1197
1198     envList = []
1199
1200     # Debug binary
1201     if 'debug' in needed_envs:
1202         envList.append(
1203             makeEnv(env, 'debug', '.do',
1204                     CCFLAGS = Split(ccflags['debug']),
1205                     CPPDEFINES = ['DEBUG', 'TRACING_ON=1'],
1206                     LINKFLAGS = Split(ldflags['debug'])))
1207
1208     # Optimized binary
1209     if 'opt' in needed_envs:
1210         envList.append(
1211             makeEnv(env, 'opt', '.o',
1212                     CCFLAGS = Split(ccflags['opt']),
1213                     CPPDEFINES = ['TRACING_ON=1'],
1214                     LINKFLAGS = Split(ldflags['opt'])))
1215
1216     # "Fast" binary
1217     if 'fast' in needed_envs:
1218         envList.append(
1219             makeEnv(env, 'fast', '.fo', strip = True,
1220                     CCFLAGS = Split(ccflags['fast']),
1221                     CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'],
1222                     LINKFLAGS = Split(ldflags['fast'])))
1223
1224     # Profiled binary using gprof
1225     if 'prof' in needed_envs:
1226         envList.append(
1227             makeEnv(env, 'prof', '.po',
1228                     CCFLAGS = Split(ccflags['prof']),
1229                     CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'],
1230                     LINKFLAGS = Split(ldflags['prof'])))
1231
1232     # Profiled binary using google-pprof
1233     if 'perf' in needed_envs:
1234         envList.append(
1235             makeEnv(env, 'perf', '.gpo',
1236                     CCFLAGS = Split(ccflags['perf']),
1237                     CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'],
1238                     LINKFLAGS = Split(ldflags['perf'])))
1239
1240     # Set up the regression tests for each build.
1241     for e in envList:
1242         SConscript(os.path.join(gem5_root, 'tests', 'SConscript'),
1243                    variant_dir = variantd('tests', e.Label),
1244                    exports = { 'env' : e }, duplicate = False)
1245
1246 # The MakeEnvirons Builder defers the full dependency collection until
1247 # after processing the ISA definition (due to dynamically generated
1248 # source files).  Add this dependency to all targets so they will wait
1249 # until the environments are completely set up.  Otherwise, a second
1250 # process (e.g. -j2 or higher) will try to compile the requested target,
1251 # not know how, and fail.
1252 env.Append(BUILDERS = {'MakeEnvirons' :
1253                         Builder(action=MakeAction(makeEnvirons,
1254                                                   Transform("ENVIRONS", 1)))})
1255
1256 isa_target = env['PHONY_BASE'] + '-deps'
1257 environs   = env['PHONY_BASE'] + '-environs'
1258 env.Depends('#all-deps',     isa_target)
1259 env.Depends('#all-environs', environs)
1260 env.ScanISA(isa_target, File('arch/%s/generated/inc.d' % env['TARGET_ISA']))
1261 envSetup = env.MakeEnvirons(environs, isa_target)
1262
1263 # make sure no -deps targets occur before all ISAs are complete
1264 env.Depends(isa_target, '#all-isas')
1265 # likewise for -environs targets and all the -deps targets
1266 env.Depends(environs, '#all-deps')