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     # create defines for the preprocessing and compile-time determination
 383     for i,isa in enumerate(isas):
 384         code('#define $0 $1', define(isa), i + 1)
 385     code()
 386
 387     # create an enum for any run-time determination of the ISA, we
 388     # reuse the same name as the namespaces
 389     code('enum class Arch {')
 390     for i,isa in enumerate(isas):
 391         if i + 1 == len(isas):
 392             code('  $0 = $1', namespace(isa), define(isa))
 393         else:
 394             code('  $0 = $1,', namespace(isa), define(isa))
 395     code('};')
 396
 397     code('''
 398
 399 #define THE_ISA ${{define(target_isa)}}
 400 #define TheISA ${{namespace(target_isa)}}
 401 #define THE_ISA_STR "${{target_isa}}"
 402
 403 #endif // __CONFIG_THE_ISA_HH__''')
 404
 405     code.write(str(target[0]))
 406
 407 env.Command('config/the_isa.hh', map(Value, all_isa_list),
 408             MakeAction(makeTheISA, Transform("CFG ISA", 0)))
 409
 410 ########################################################################
 411 #
 412 # Prevent any SimObjects from being added after this point, they
 413 # should all have been added in the SConscripts above
 414 #
 415 SimObject.fixed = True
 416
 417 class DictImporter(object):
 418     '''This importer takes a dictionary of arbitrary module names that
 419     map to arbitrary filenames.'''
 420     def __init__(self, modules):
 421         self.modules = modules
 422         self.installed = set()
 423
 424     def __del__(self):
 425         self.unload()
 426
 427     def unload(self):
 428         import sys
 429         for module in self.installed:
 430             del sys.modules[module]
 431         self.installed = set()
 432
 433     def find_module(self, fullname, path):
 434         if fullname == 'm5.defines':
 435             return self
 436
 437         if fullname == 'm5.objects':
 438             return self
 439
 440         if fullname.startswith('m5.internal'):
 441             return None
 442
 443         source = self.modules.get(fullname, None)
 444         if source is not None and fullname.startswith('m5.objects'):
 445             return self
 446
 447         return None
 448
 449     def load_module(self, fullname):
 450         mod = imp.new_module(fullname)
 451         sys.modules[fullname] = mod
 452         self.installed.add(fullname)
 453
 454         mod.__loader__ = self
 455         if fullname == 'm5.objects':
 456             mod.__path__ = fullname.split('.')
 457             return mod
 458
 459         if fullname == 'm5.defines':
 460             mod.__dict__['buildEnv'] = m5.util.SmartDict(build_env)
 461             return mod
 462
 463         source = self.modules[fullname]
 464         if source.modname == '__init__':
 465             mod.__path__ = source.modpath
 466         mod.__file__ = source.abspath
 467
 468         exec file(source.abspath, 'r') in mod.__dict__
 469
 470         return mod
 471
 472 import m5.SimObject
 473 import m5.params
 474 from m5.util import code_formatter
 475
 476 m5.SimObject.clear()
 477 m5.params.clear()
 478
 479 # install the python importer so we can grab stuff from the source
 480 # tree itself.  We can't have SimObjects added after this point or
 481 # else we won't know about them for the rest of the stuff.
 482 importer = DictImporter(PySource.modules)
 483 sys.meta_path[0:0] = [ importer ]
 484
 485 # import all sim objects so we can populate the all_objects list
 486 # make sure that we're working with a list, then let's sort it
 487 for modname in SimObject.modnames:
 488     exec('from m5.objects import %s' % modname)
 489
 490 # we need to unload all of the currently imported modules so that they
 491 # will be re-imported the next time the sconscript is run
 492 importer.unload()
 493 sys.meta_path.remove(importer)
 494
 495 sim_objects = m5.SimObject.allClasses
 496 all_enums = m5.params.allEnums
 497
 498 if m5.SimObject.noCxxHeader:
 499     print >> sys.stderr, \
 500         "warning: At least one SimObject lacks a header specification. " \
 501         "This can cause unexpected results in the generated SWIG " \
 502         "wrappers."
 503
 504 # Find param types that need to be explicitly wrapped with swig.
 505 # These will be recognized because the ParamDesc will have a
 506 # swig_decl() method.  Most param types are based on types that don't
 507 # need this, either because they're based on native types (like Int)
 508 # or because they're SimObjects (which get swigged independently).
 509 # For now the only things handled here are VectorParam types.
 510 params_to_swig = {}
 511 for name,obj in sorted(sim_objects.iteritems()):
 512     for param in obj._params.local.values():
 513         # load the ptype attribute now because it depends on the
 514         # current version of SimObject.allClasses, but when scons
 515         # actually uses the value, all versions of
 516         # SimObject.allClasses will have been loaded
 517         param.ptype
 518
 519         if not hasattr(param, 'swig_decl'):
 520             continue
 521         pname = param.ptype_str
 522         if pname not in params_to_swig:
 523             params_to_swig[pname] = param
 524
 525 ########################################################################
 526 #
 527 # calculate extra dependencies
 528 #
 529 module_depends = ["m5", "m5.SimObject", "m5.params"]
 530 depends = [ PySource.modules[dep].snode for dep in module_depends ]
 531 depends.sort(key = lambda x: x.name)
 532
 533 ########################################################################
 534 #
 535 # Commands for the basic automatically generated python files
 536 #
 537
 538 # Generate Python file containing a dict specifying the current
 539 # buildEnv flags.
 540 def makeDefinesPyFile(target, source, env):
 541     build_env = source[0].get_contents()
 542
 543     code = code_formatter()
 544     code("""
 545 import m5.internal
 546 import m5.util
 547
 548 buildEnv = m5.util.SmartDict($build_env)
 549
 550 compileDate = m5.internal.core.compileDate
 551 _globals = globals()
 552 for key,val in m5.internal.core.__dict__.iteritems():
 553     if key.startswith('flag_'):
 554         flag = key[5:]
 555         _globals[flag] = val
 556 del _globals
 557 """)
 558     code.write(target[0].abspath)
 559
 560 defines_info = Value(build_env)
 561 # Generate a file with all of the compile options in it
 562 env.Command('python/m5/defines.py', defines_info,
 563             MakeAction(makeDefinesPyFile, Transform("DEFINES", 0)))
 564 PySource('m5', 'python/m5/defines.py')
 565
 566 # Generate python file containing info about the M5 source code
 567 def makeInfoPyFile(target, source, env):
 568     code = code_formatter()
 569     for src in source:
 570         data = ''.join(file(src.srcnode().abspath, 'r').xreadlines())
 571         code('$src = ${{repr(data)}}')
 572     code.write(str(target[0]))
 573
 574 # Generate a file that wraps the basic top level files
 575 env.Command('python/m5/info.py',
 576             [ '#/COPYING', '#/LICENSE', '#/README', ],
 577             MakeAction(makeInfoPyFile, Transform("INFO")))
 578 PySource('m5', 'python/m5/info.py')
 579
 580 ########################################################################
 581 #
 582 # Create all of the SimObject param headers and enum headers
 583 #
 584
 585 def createSimObjectParamStruct(target, source, env):
 586     assert len(target) == 1 and len(source) == 1
 587
 588     name = str(source[0].get_contents())
 589     obj = sim_objects[name]
 590
 591     code = code_formatter()
 592     obj.cxx_param_decl(code)
 593     code.write(target[0].abspath)
 594
 595 def createSimObjectCxxConfig(is_header):
 596     def body(target, source, env):
 597         assert len(target) == 1 and len(source) == 1
 598
 599         name = str(source[0].get_contents())
 600         obj = sim_objects[name]
 601
 602         code = code_formatter()
 603         obj.cxx_config_param_file(code, is_header)
 604         code.write(target[0].abspath)
 605     return body
 606
 607 def createParamSwigWrapper(target, source, env):
 608     assert len(target) == 1 and len(source) == 1
 609
 610     name = str(source[0].get_contents())
 611     param = params_to_swig[name]
 612
 613     code = code_formatter()
 614     param.swig_decl(code)
 615     code.write(target[0].abspath)
 616
 617 def createEnumStrings(target, source, env):
 618     assert len(target) == 1 and len(source) == 1
 619
 620     name = str(source[0].get_contents())
 621     obj = all_enums[name]
 622
 623     code = code_formatter()
 624     obj.cxx_def(code)
 625     code.write(target[0].abspath)
 626
 627 def createEnumDecls(target, source, env):
 628     assert len(target) == 1 and len(source) == 1
 629
 630     name = str(source[0].get_contents())
 631     obj = all_enums[name]
 632
 633     code = code_formatter()
 634     obj.cxx_decl(code)
 635     code.write(target[0].abspath)
 636
 637 def createEnumSwigWrapper(target, source, env):
 638     assert len(target) == 1 and len(source) == 1
 639
 640     name = str(source[0].get_contents())
 641     obj = all_enums[name]
 642
 643     code = code_formatter()
 644     obj.swig_decl(code)
 645     code.write(target[0].abspath)
 646
 647 def createSimObjectSwigWrapper(target, source, env):
 648     name = source[0].get_contents()
 649     obj = sim_objects[name]
 650
 651     code = code_formatter()
 652     obj.swig_decl(code)
 653     code.write(target[0].abspath)
 654
 655 # dummy target for generated code
 656 # we start out with all the Source files so they get copied to build/*/ also.
 657 SWIG = env.Dummy('swig', [s.tnode for s in Source.get()])
 658
 659 # Generate all of the SimObject param C++ struct header files
 660 params_hh_files = []
 661 for name,simobj in sorted(sim_objects.iteritems()):
 662     py_source = PySource.modules[simobj.__module__]
 663     extra_deps = [ py_source.tnode ]
 664
 665     hh_file = File('params/%s.hh' % name)
 666     params_hh_files.append(hh_file)
 667     env.Command(hh_file, Value(name),
 668                 MakeAction(createSimObjectParamStruct, Transform("SO PARAM")))
 669     env.Depends(hh_file, depends + extra_deps)
 670     env.Depends(SWIG, hh_file)
 671
 672 # C++ parameter description files
 673 if GetOption('with_cxx_config'):
 674     for name,simobj in sorted(sim_objects.iteritems()):
 675         py_source = PySource.modules[simobj.__module__]
 676         extra_deps = [ py_source.tnode ]
 677
 678         cxx_config_hh_file = File('cxx_config/%s.hh' % name)
 679         cxx_config_cc_file = File('cxx_config/%s.cc' % name)
 680         env.Command(cxx_config_hh_file, Value(name),
 681                     MakeAction(createSimObjectCxxConfig(True),
 682                     Transform("CXXCPRHH")))
 683         env.Command(cxx_config_cc_file, Value(name),
 684                     MakeAction(createSimObjectCxxConfig(False),
 685                     Transform("CXXCPRCC")))
 686         env.Depends(cxx_config_hh_file, depends + extra_deps +
 687                     [File('params/%s.hh' % name), File('sim/cxx_config.hh')])
 688         env.Depends(cxx_config_cc_file, depends + extra_deps +
 689                     [cxx_config_hh_file])
 690         Source(cxx_config_cc_file)
 691
 692     cxx_config_init_cc_file = File('cxx_config/init.cc')
 693
 694     def createCxxConfigInitCC(target, source, env):
 695         assert len(target) == 1 and len(source) == 1
 696
 697         code = code_formatter()
 698
 699         for name,simobj in sorted(sim_objects.iteritems()):
 700             if not hasattr(simobj, 'abstract') or not simobj.abstract:
 701                 code('#include "cxx_config/${name}.hh"')
 702         code()
 703         code('void cxxConfigInit()')
 704         code('{')
 705         code.indent()
 706         for name,simobj in sorted(sim_objects.iteritems()):
 707             not_abstract = not hasattr(simobj, 'abstract') or \
 708                 not simobj.abstract
 709             if not_abstract and 'type' in simobj.__dict__:
 710                 code('cxx_config_directory["${name}"] = '
 711                      '${name}CxxConfigParams::makeDirectoryEntry();')
 712         code.dedent()
 713         code('}')
 714         code.write(target[0].abspath)
 715
 716     py_source = PySource.modules[simobj.__module__]
 717     extra_deps = [ py_source.tnode ]
 718     env.Command(cxx_config_init_cc_file, Value(name),
 719         MakeAction(createCxxConfigInitCC, Transform("CXXCINIT")))
 720     cxx_param_hh_files = ["cxx_config/%s.hh" % simobj
 721         for name,simobj in sorted(sim_objects.iteritems())
 722         if not hasattr(simobj, 'abstract') or not simobj.abstract]
 723     Depends(cxx_config_init_cc_file, cxx_param_hh_files +
 724             [File('sim/cxx_config.hh')])
 725     Source(cxx_config_init_cc_file)
 726
 727 # Generate any needed param SWIG wrapper files
 728 params_i_files = []
 729 for name,param in sorted(params_to_swig.iteritems()):
 730     i_file = File('python/m5/internal/%s.i' % (param.swig_module_name()))
 731     params_i_files.append(i_file)
 732     env.Command(i_file, Value(name),
 733                 MakeAction(createParamSwigWrapper, Transform("SW PARAM")))
 734     env.Depends(i_file, depends)
 735     env.Depends(SWIG, i_file)
 736     SwigSource('m5.internal', i_file)
 737
 738 # Generate all enum header files
 739 for name,enum in sorted(all_enums.iteritems()):
 740     py_source = PySource.modules[enum.__module__]
 741     extra_deps = [ py_source.tnode ]
 742
 743     cc_file = File('enums/%s.cc' % name)
 744     env.Command(cc_file, Value(name),
 745                 MakeAction(createEnumStrings, Transform("ENUM STR")))
 746     env.Depends(cc_file, depends + extra_deps)
 747     env.Depends(SWIG, cc_file)
 748     Source(cc_file)
 749
 750     hh_file = File('enums/%s.hh' % name)
 751     env.Command(hh_file, Value(name),
 752                 MakeAction(createEnumDecls, Transform("ENUMDECL")))
 753     env.Depends(hh_file, depends + extra_deps)
 754     env.Depends(SWIG, hh_file)
 755
 756     i_file = File('python/m5/internal/enum_%s.i' % name)
 757     env.Command(i_file, Value(name),
 758                 MakeAction(createEnumSwigWrapper, Transform("ENUMSWIG")))
 759     env.Depends(i_file, depends + extra_deps)
 760     env.Depends(SWIG, i_file)
 761     SwigSource('m5.internal', i_file)
 762
 763 # Generate SimObject SWIG wrapper files
 764 for name,simobj in sorted(sim_objects.iteritems()):
 765     py_source = PySource.modules[simobj.__module__]
 766     extra_deps = [ py_source.tnode ]
 767     i_file = File('python/m5/internal/param_%s.i' % name)
 768     env.Command(i_file, Value(name),
 769                 MakeAction(createSimObjectSwigWrapper, Transform("SO SWIG")))
 770     env.Depends(i_file, depends + extra_deps)
 771     SwigSource('m5.internal', i_file)
 772
 773 # Generate the main swig init file
 774 def makeEmbeddedSwigInit(target, source, env):
 775     code = code_formatter()
 776     module = source[0].get_contents()
 777     code('''\
 778 #include "sim/init.hh"
 779
 780 extern "C" {
 781     void init_${module}();
 782 }
 783
 784 EmbeddedSwig embed_swig_${module}(init_${module});
 785 ''')
 786     code.write(str(target[0]))
 787
 788 # Build all swig modules
 789 for swig in SwigSource.all:
 790     env.Command([swig.cc_source.tnode, swig.py_source.tnode], swig.tnode,
 791                 MakeAction('$SWIG $SWIGFLAGS -outdir ${TARGETS[1].dir} '
 792                 '-o ${TARGETS[0]} $SOURCES', Transform("SWIG")))
 793     cc_file = str(swig.tnode)
 794     init_file = '%s/%s_init.cc' % (dirname(cc_file), basename(cc_file))
 795     env.Command(init_file, Value(swig.module),
 796                 MakeAction(makeEmbeddedSwigInit, Transform("EMBED SW")))
 797     env.Depends(SWIG, init_file)
 798     Source(init_file, **swig.guards)
 799
 800 # Build all protocol buffers if we have got protoc and protobuf available
 801 if env['HAVE_PROTOBUF']:
 802     for proto in ProtoBuf.all:
 803         # Use both the source and header as the target, and the .proto
 804         # file as the source. When executing the protoc compiler, also
 805         # specify the proto_path to avoid having the generated files
 806         # include the path.
 807         env.Command([proto.cc_file, proto.hh_file], proto.tnode,
 808                     MakeAction('$PROTOC --cpp_out ${TARGET.dir} '
 809                                '--proto_path ${SOURCE.dir} $SOURCE',
 810                                Transform("PROTOC")))
 811
 812         env.Depends(SWIG, [proto.cc_file, proto.hh_file])
 813         # Add the C++ source file
 814         Source(proto.cc_file, **proto.guards)
 815 elif ProtoBuf.all:
 816     print 'Got protobuf to build, but lacks support!'
 817     Exit(1)
 818
 819 #
 820 # Handle debug flags
 821 #
 822 def makeDebugFlagCC(target, source, env):
 823     assert(len(target) == 1 and len(source) == 1)
 824
 825     code = code_formatter()
 826
 827     # delay definition of CompoundFlags until after all the definition
 828     # of all constituent SimpleFlags
 829     comp_code = code_formatter()
 830
 831     # file header
 832     code('''
 833 /*
 834  * DO NOT EDIT THIS FILE! Automatically generated by SCons.
 835  */
 836
 837 #include "base/debug.hh"
 838
 839 namespace Debug {
 840
 841 ''')
 842
 843     for name, flag in sorted(source[0].read().iteritems()):
 844         n, compound, desc = flag
 845         assert n == name
 846
 847         if not compound:
 848             code('SimpleFlag $name("$name", "$desc");')
 849         else:
 850             comp_code('CompoundFlag $name("$name", "$desc",')
 851             comp_code.indent()
 852             last = len(compound) - 1
 853             for i,flag in enumerate(compound):
 854                 if i != last:
 855                     comp_code('&$flag,')
 856                 else:
 857                     comp_code('&$flag);')
 858             comp_code.dedent()
 859
 860     code.append(comp_code)
 861     code()
 862     code('} // namespace Debug')
 863
 864     code.write(str(target[0]))
 865
 866 def makeDebugFlagHH(target, source, env):
 867     assert(len(target) == 1 and len(source) == 1)
 868
 869     val = eval(source[0].get_contents())
 870     name, compound, desc = val
 871
 872     code = code_formatter()
 873
 874     # file header boilerplate
 875     code('''\
 876 /*
 877  * DO NOT EDIT THIS FILE! Automatically generated by SCons.
 878  */
 879
 880 #ifndef __DEBUG_${name}_HH__
 881 #define __DEBUG_${name}_HH__
 882
 883 namespace Debug {
 884 ''')
 885
 886     if compound:
 887         code('class CompoundFlag;')
 888     code('class SimpleFlag;')
 889
 890     if compound:
 891         code('extern CompoundFlag $name;')
 892         for flag in compound:
 893             code('extern SimpleFlag $flag;')
 894     else:
 895         code('extern SimpleFlag $name;')
 896
 897     code('''
 898 }
 899
 900 #endif // __DEBUG_${name}_HH__
 901 ''')
 902
 903     code.write(str(target[0]))
 904
 905 for name,flag in sorted(debug_flags.iteritems()):
 906     n, compound, desc = flag
 907     assert n == name
 908
 909     hh_file = 'debug/%s.hh' % name
 910     env.Command(hh_file, Value(flag),
 911                 MakeAction(makeDebugFlagHH, Transform("TRACING", 0)))
 912     env.Depends(SWIG, hh_file)
 913
 914 env.Command('debug/flags.cc', Value(debug_flags),
 915             MakeAction(makeDebugFlagCC, Transform("TRACING", 0)))
 916 env.Depends(SWIG, 'debug/flags.cc')
 917 Source('debug/flags.cc')
 918
 919 # version tags
 920 env.Command('sim/tags.cc', None,
 921             MakeAction('util/cpt_upgrader.py --get-cc-file > $TARGET',
 922                        Transform("VER TAGS")))
 923
 924 # Embed python files.  All .py files that have been indicated by a
 925 # PySource() call in a SConscript need to be embedded into the M5
 926 # library.  To do that, we compile the file to byte code, marshal the
 927 # byte code, compress it, and then generate a c++ file that
 928 # inserts the result into an array.
 929 def embedPyFile(target, source, env):
 930     def c_str(string):
 931         if string is None:
 932             return "0"
 933         return '"%s"' % string
 934
 935     '''Action function to compile a .py into a code object, marshal
 936     it, compress it, and stick it into an asm file so the code appears
 937     as just bytes with a label in the data section'''
 938
 939     src = file(str(source[0]), 'r').read()
 940
 941     pysource = PySource.tnodes[source[0]]
 942     compiled = compile(src, pysource.abspath, 'exec')
 943     marshalled = marshal.dumps(compiled)
 944     compressed = zlib.compress(marshalled)
 945     data = compressed
 946     sym = pysource.symname
 947
 948     code = code_formatter()
 949     code('''\
 950 #include "sim/init.hh"
 951
 952 namespace {
 953
 954 const uint8_t data_${sym}[] = {
 955 ''')
 956     code.indent()
 957     step = 16
 958     for i in xrange(0, len(data), step):
 959         x = array.array('B', data[i:i+step])
 960         code(''.join('%d,' % d for d in x))
 961     code.dedent()
 962
 963     code('''};
 964
 965 EmbeddedPython embedded_${sym}(
 966     ${{c_str(pysource.arcname)}},
 967     ${{c_str(pysource.abspath)}},
 968     ${{c_str(pysource.modpath)}},
 969     data_${sym},
 970     ${{len(data)}},
 971     ${{len(marshalled)}});
 972
 973 } // anonymous namespace
 974 ''')
 975     code.write(str(target[0]))
 976
 977 for source in PySource.all:
 978     env.Command(source.cpp, source.tnode,
 979                 MakeAction(embedPyFile, Transform("EMBED PY")))
 980     env.Depends(SWIG, source.cpp)
 981     Source(source.cpp, skip_no_python=True)
 982
 983 ########################################################################
 984 #
 985 # Define binaries.  Each different build type (debug, opt, etc.) gets
 986 # a slightly different build environment.
 987 #
 988
 989 # List of constructed environments to pass back to SConstruct
 990 date_source = Source('base/date.cc', skip_lib=True)
 991
 992 # Capture this directory for the closure makeEnv, otherwise when it is
 993 # called, it won't know what directory it should use.
 994 variant_dir = Dir('.').path
 995 def variant(*path):
 996     return os.path.join(variant_dir, *path)
 997 def variantd(*path):
 998     return variant(*path)+'/'
 999
1000 # Function to create a new build environment as clone of current
1001 # environment 'env' with modified object suffix and optional stripped
1002 # binary.  Additional keyword arguments are appended to corresponding
1003 # build environment vars.
1004 def makeEnv(env, label, objsfx, strip = False, **kwargs):
1005     # SCons doesn't know to append a library suffix when there is a '.' in the
1006     # name.  Use '_' instead.
1007     libname = variant('gem5_' + label)
1008     exename = variant('gem5.' + label)
1009     secondary_exename = variant('m5.' + label)
1010
1011     new_env = env.Clone(OBJSUFFIX=objsfx, SHOBJSUFFIX=objsfx + 's')
1012     new_env.Label = label
1013     new_env.Append(**kwargs)
1014
1015     swig_env = new_env.Clone()
1016
1017     # Both gcc and clang have issues with unused labels and values in
1018     # the SWIG generated code
1019     swig_env.Append(CCFLAGS=['-Wno-unused-label', '-Wno-unused-value'])
1020
1021     # Add additional warnings here that should not be applied to
1022     # the SWIG generated code
1023     new_env.Append(CXXFLAGS=['-Wmissing-declarations',
1024                              '-Wdelete-non-virtual-dtor'])
1025
1026     if env['GCC']:
1027         # Depending on the SWIG version, we also need to supress
1028         # warnings about uninitialized variables and missing field
1029         # initializers.
1030         swig_env.Append(CCFLAGS=['-Wno-uninitialized',
1031                                  '-Wno-missing-field-initializers',
1032                                  '-Wno-unused-but-set-variable',
1033                                  '-Wno-maybe-uninitialized'])
1034
1035         # Only gcc >= 4.9 supports UBSan, so check both the version
1036         # and the command-line option before adding the compiler and
1037         # linker flags.
1038         if GetOption('with_ubsan') and \
1039                 compareVersions(env['GCC_VERSION'], '4.9') >= 0:
1040             new_env.Append(CCFLAGS='-fsanitize=undefined')
1041             new_env.Append(LINKFLAGS='-fsanitize=undefined')
1042
1043     if env['CLANG']:
1044         swig_env.Append(CCFLAGS=[
1045                 # Some versions of SWIG can return uninitialized values
1046                 '-Wno-sometimes-uninitialized',
1047                 # Register storage is requested in a lot of places in
1048                 # SWIG-generated code.
1049                 '-Wno-deprecated-register',
1050                 ])
1051
1052         # All supported clang versions have support for UBSan, so if
1053         # asked to use it, append the compiler and linker flags.
1054         if GetOption('with_ubsan'):
1055             new_env.Append(CCFLAGS='-fsanitize=undefined')
1056             new_env.Append(LINKFLAGS='-fsanitize=undefined')
1057
1058     werror_env = new_env.Clone()
1059     # Treat warnings as errors but white list some warnings that we
1060     # want to allow (e.g., deprecation warnings).
1061     werror_env.Append(CCFLAGS=['-Werror',
1062                                '-Wno-error=deprecated-declarations',
1063                                '-Wno-error=deprecated',
1064                                ])
1065
1066     def make_obj(source, static, extra_deps = None):
1067         '''This function adds the specified source to the correct
1068         build environment, and returns the corresponding SCons Object
1069         nodes'''
1070
1071         if source.swig:
1072             env = swig_env
1073         elif source.Werror:
1074             env = werror_env
1075         else:
1076             env = new_env
1077
1078         if static:
1079             obj = env.StaticObject(source.tnode)
1080         else:
1081             obj = env.SharedObject(source.tnode)
1082
1083         if extra_deps:
1084             env.Depends(obj, extra_deps)
1085
1086         return obj
1087
1088     lib_guards = {'main': False, 'skip_lib': False}
1089
1090     # Without Python, leave out all SWIG and Python content from the
1091     # library builds.  The option doesn't affect gem5 built as a program
1092     if GetOption('without_python'):
1093         lib_guards['skip_no_python'] = False
1094
1095     static_objs = [ make_obj(s, True) for s in Source.get(**lib_guards) ]
1096     shared_objs = [ make_obj(s, False) for s in Source.get(**lib_guards) ]
1097
1098     static_date = make_obj(date_source, static=True, extra_deps=static_objs)
1099     static_objs.append(static_date)
1100
1101     shared_date = make_obj(date_source, static=False, extra_deps=shared_objs)
1102     shared_objs.append(shared_date)
1103
1104     # First make a library of everything but main() so other programs can
1105     # link against m5.
1106     static_lib = new_env.StaticLibrary(libname, static_objs)
1107     shared_lib = new_env.SharedLibrary(libname, shared_objs)
1108
1109     # Now link a stub with main() and the static library.
1110     main_objs = [ make_obj(s, True) for s in Source.get(main=True) ]
1111
1112     for test in UnitTest.all:
1113         flags = { test.target : True }
1114         test_sources = Source.get(**flags)
1115         test_objs = [ make_obj(s, static=True) for s in test_sources ]
1116         if test.main:
1117             test_objs += main_objs
1118         path = variant('unittest/%s.%s' % (test.target, label))
1119         new_env.Program(path, test_objs + static_objs)
1120
1121     progname = exename
1122     if strip:
1123         progname += '.unstripped'
1124
1125     targets = new_env.Program(progname, main_objs + static_objs)
1126
1127     if strip:
1128         if sys.platform == 'sunos5':
1129             cmd = 'cp $SOURCE $TARGET; strip $TARGET'
1130         else:
1131             cmd = 'strip $SOURCE -o $TARGET'
1132         targets = new_env.Command(exename, progname,
1133                     MakeAction(cmd, Transform("STRIP")))
1134
1135     new_env.Command(secondary_exename, exename,
1136             MakeAction('ln $SOURCE $TARGET', Transform("HARDLINK")))
1137
1138     new_env.M5Binary = targets[0]
1139     return new_env
1140
1141 # Start out with the compiler flags common to all compilers,
1142 # i.e. they all use -g for opt and -g -pg for prof
1143 ccflags = {'debug' : [], 'opt' : ['-g'], 'fast' : [], 'prof' : ['-g', '-pg'],
1144            'perf' : ['-g']}
1145
1146 # Start out with the linker flags common to all linkers, i.e. -pg for
1147 # prof, and -lprofiler for perf. The -lprofile flag is surrounded by
1148 # no-as-needed and as-needed as the binutils linker is too clever and
1149 # simply doesn't link to the library otherwise.
1150 ldflags = {'debug' : [], 'opt' : [], 'fast' : [], 'prof' : ['-pg'],
1151            'perf' : ['-Wl,--no-as-needed', '-lprofiler', '-Wl,--as-needed']}
1152
1153 # For Link Time Optimization, the optimisation flags used to compile
1154 # individual files are decoupled from those used at link time
1155 # (i.e. you can compile with -O3 and perform LTO with -O0), so we need
1156 # to also update the linker flags based on the target.
1157 if env['GCC']:
1158     if sys.platform == 'sunos5':
1159         ccflags['debug'] += ['-gstabs+']
1160     else:
1161         ccflags['debug'] += ['-ggdb3']
1162     ldflags['debug'] += ['-O0']
1163     # opt, fast, prof and perf all share the same cc flags, also add
1164     # the optimization to the ldflags as LTO defers the optimization
1165     # to link time
1166     for target in ['opt', 'fast', 'prof', 'perf']:
1167         ccflags[target] += ['-O3']
1168         ldflags[target] += ['-O3']
1169
1170     ccflags['fast'] += env['LTO_CCFLAGS']
1171     ldflags['fast'] += env['LTO_LDFLAGS']
1172 elif env['CLANG']:
1173     ccflags['debug'] += ['-g', '-O0']
1174     # opt, fast, prof and perf all share the same cc flags
1175     for target in ['opt', 'fast', 'prof', 'perf']:
1176         ccflags[target] += ['-O3']
1177 else:
1178     print 'Unknown compiler, please fix compiler options'
1179     Exit(1)
1180
1181
1182 # To speed things up, we only instantiate the build environments we
1183 # need.  We try to identify the needed environment for each target; if
1184 # we can't, we fall back on instantiating all the environments just to
1185 # be safe.
1186 target_types = ['debug', 'opt', 'fast', 'prof', 'perf']
1187 obj2target = {'do': 'debug', 'o': 'opt', 'fo': 'fast', 'po': 'prof',
1188               'gpo' : 'perf'}
1189
1190 def identifyTarget(t):
1191     ext = t.split('.')[-1]
1192     if ext in target_types:
1193         return ext
1194     if obj2target.has_key(ext):
1195         return obj2target[ext]
1196     match = re.search(r'/tests/([^/]+)/', t)
1197     if match and match.group(1) in target_types:
1198         return match.group(1)
1199     return 'all'
1200
1201 needed_envs = [identifyTarget(target) for target in BUILD_TARGETS]
1202 if 'all' in needed_envs:
1203     needed_envs += target_types
1204
1205 gem5_root = Dir('.').up().up().abspath
1206 def makeEnvirons(target, source, env):
1207     # cause any later Source() calls to be fatal, as a diagnostic.
1208     Source.done()
1209
1210     envList = []
1211
1212     # Debug binary
1213     if 'debug' in needed_envs:
1214         envList.append(
1215             makeEnv(env, 'debug', '.do',
1216                     CCFLAGS = Split(ccflags['debug']),
1217                     CPPDEFINES = ['DEBUG', 'TRACING_ON=1'],
1218                     LINKFLAGS = Split(ldflags['debug'])))
1219
1220     # Optimized binary
1221     if 'opt' in needed_envs:
1222         envList.append(
1223             makeEnv(env, 'opt', '.o',
1224                     CCFLAGS = Split(ccflags['opt']),
1225                     CPPDEFINES = ['TRACING_ON=1'],
1226                     LINKFLAGS = Split(ldflags['opt'])))
1227
1228     # "Fast" binary
1229     if 'fast' in needed_envs:
1230         envList.append(
1231             makeEnv(env, 'fast', '.fo', strip = True,
1232                     CCFLAGS = Split(ccflags['fast']),
1233                     CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'],
1234                     LINKFLAGS = Split(ldflags['fast'])))
1235
1236     # Profiled binary using gprof
1237     if 'prof' in needed_envs:
1238         envList.append(
1239             makeEnv(env, 'prof', '.po',
1240                     CCFLAGS = Split(ccflags['prof']),
1241                     CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'],
1242                     LINKFLAGS = Split(ldflags['prof'])))
1243
1244     # Profiled binary using google-pprof
1245     if 'perf' in needed_envs:
1246         envList.append(
1247             makeEnv(env, 'perf', '.gpo',
1248                     CCFLAGS = Split(ccflags['perf']),
1249                     CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'],
1250                     LINKFLAGS = Split(ldflags['perf'])))
1251
1252     # Set up the regression tests for each build.
1253     for e in envList:
1254         SConscript(os.path.join(gem5_root, 'tests', 'SConscript'),
1255                    variant_dir = variantd('tests', e.Label),
1256                    exports = { 'env' : e }, duplicate = False)
1257
1258 # The MakeEnvirons Builder defers the full dependency collection until
1259 # after processing the ISA definition (due to dynamically generated
1260 # source files).  Add this dependency to all targets so they will wait
1261 # until the environments are completely set up.  Otherwise, a second
1262 # process (e.g. -j2 or higher) will try to compile the requested target,
1263 # not know how, and fail.
1264 env.Append(BUILDERS = {'MakeEnvirons' :
1265                         Builder(action=MakeAction(makeEnvirons,
1266                                                   Transform("ENVIRONS", 1)))})
1267
1268 isa_target = env['PHONY_BASE'] + '-deps'
1269 environs   = env['PHONY_BASE'] + '-environs'
1270 env.Depends('#all-deps',     isa_target)
1271 env.Depends('#all-environs', environs)
1272 env.ScanISA(isa_target, File('arch/%s/generated/inc.d' % env['TARGET_ISA']))
1273 envSetup = env.MakeEnvirons(environs, isa_target)
1274
1275 # make sure no -deps targets occur before all ISAs are complete
1276 env.Depends(isa_target, '#all-isas')
1277 # likewise for -environs targets and all the -deps targets
1278 env.Depends(environs, '#all-deps')