SConscript revision 11988:665cd5f8b52b
12158SN/A# -*- mode:python -*-
22158SN/A
32158SN/A# Copyright (c) 2004-2005 The Regents of The University of Michigan
42158SN/A# All rights reserved.
52158SN/A#
62158SN/A# Redistribution and use in source and binary forms, with or without
72158SN/A# modification, are permitted provided that the following conditions are
82158SN/A# met: redistributions of source code must retain the above copyright
92158SN/A# notice, this list of conditions and the following disclaimer;
102158SN/A# redistributions in binary form must reproduce the above copyright
112158SN/A# notice, this list of conditions and the following disclaimer in the
122158SN/A# documentation and/or other materials provided with the distribution;
132158SN/A# neither the name of the copyright holders nor the names of its
142158SN/A# contributors may be used to endorse or promote products derived from
152158SN/A# this software without specific prior written permission.
162158SN/A#
172158SN/A# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
182158SN/A# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
192158SN/A# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
202158SN/A# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
212158SN/A# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
222158SN/A# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
232158SN/A# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
242158SN/A# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
252158SN/A# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
262158SN/A# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
272665Ssaidi@eecs.umich.edu# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
282665Ssaidi@eecs.umich.edu#
292760Sbinkertn@umich.edu# Authors: Nathan Binkert
302158SN/A
312158SN/Aimport array
323567Sgblack@eecs.umich.eduimport bisect
333567Sgblack@eecs.umich.eduimport imp
342432SN/Aimport marshal
352158SN/Aimport os
363536Sgblack@eecs.umich.eduimport re
372215SN/Aimport subprocess
382158SN/Aimport sys
392158SN/Aimport zlib
402158SN/A
412521SN/Afrom os.path import basename, dirname, exists, isdir, isfile, join as joinpath
424762Snate@binkert.org
432158SN/Aimport SCons
442158SN/A
452158SN/A# This file defines how to build a particular configuration of gem5
462158SN/A# based on variable settings in the 'env' build environment.
472158SN/A
482158SN/AImport('*')
492158SN/A
502158SN/A# Children need to see the environment
512158SN/AExport('env')
522158SN/A
532158SN/Abuild_env = [(opt, env[opt]) for opt in export_vars]
542158SN/A
552158SN/Afrom m5.util import code_formatter, compareVersions
562158SN/A
572158SN/A########################################################################
582158SN/A# Code for adding source files of various types
594762Snate@binkert.org#
602158SN/A# When specifying a source file of some type, a set of guards can be
614762Snate@binkert.org# specified for that file.  When get() is used to find the files, if
622158SN/A# get specifies a set of filters, only files that match those filters
632158SN/A# will be accepted (unspecified filters on files are assumed to be
644762Snate@binkert.org# false).  Current filters are:
652158SN/A#     main -- specifies the gem5 main() function
664762Snate@binkert.org#     skip_lib -- do not put this file into the gem5 library
672158SN/A#     skip_no_python -- do not put this file into a no_python library
682158SN/A#       as it embeds compiled Python
692158SN/A#     <unittest> -- unit tests use filters based on the unit test name
702521SN/A#
712521SN/A# A parent can now be specified for a source file and default filter
722158SN/A# values will be retrieved recursively from parents (children override
732158SN/A# parents).
742158SN/A#
752158SN/Adef guarded_source_iterator(sources, **guards):
762158SN/A    '''Iterate over a set of sources, gated by a set of guards.'''
772158SN/A    for src in sources:
782158SN/A        for flag,value in guards.iteritems():
792158SN/A            # if the flag is found and has a different value, skip
802158SN/A            # this file
812158SN/A            if src.all_guards.get(flag, False) != value:
822158SN/A                break
832158SN/A        else:
842158SN/A            yield src
852158SN/A
862158SN/Aclass SourceMeta(type):
872158SN/A    '''Meta class for source files that keeps track of all files of a
882158SN/A    particular type and has a get function for finding all functions
892158SN/A    of a certain type that match a set of guards'''
902158SN/A    def __init__(cls, name, bases, dict):
912158SN/A        super(SourceMeta, cls).__init__(name, bases, dict)
922158SN/A        cls.all = []
932158SN/A
942158SN/A    def get(cls, **guards):
952158SN/A        '''Find all files that match the specified guards.  If a source
962158SN/A        file does not specify a flag, the default is False'''
972158SN/A        for s in guarded_source_iterator(cls.all, **guards):
982158SN/A            yield s
992158SN/A
1002158SN/Aclass SourceFile(object):
1012158SN/A    '''Base object that encapsulates the notion of a source file.
1022158SN/A    This includes, the source node, target node, various manipulations
1032158SN/A    of those.  A source file also specifies a set of guards which
1042521SN/A    describing which builds the source file applies to.  A parent can
1052521SN/A    also be specified to get default guards from'''
1062158SN/A    __metaclass__ = SourceMeta
1072158SN/A    def __init__(self, source, parent=None, **guards):
1082158SN/A        self.guards = guards
1092158SN/A        self.parent = parent
1102158SN/A
1112158SN/A        tnode = source
1122158SN/A        if not isinstance(source, SCons.Node.FS.File):
1132521SN/A            tnode = File(source)
1142521SN/A
1152549SN/A        self.tnode = tnode
1162521SN/A        self.snode = tnode.srcnode()
1172549SN/A
1182158SN/A        for base in type(self).__mro__:
1192158SN/A            if issubclass(base, SourceFile):
1202158SN/A                base.all.append(self)
1212158SN/A
1222158SN/A    @property
1232158SN/A    def filename(self):
1242158SN/A        return str(self.tnode)
1252158SN/A
1262158SN/A    @property
1272158SN/A    def dirname(self):
1282158SN/A        return dirname(self.filename)
1292158SN/A
1302158SN/A    @property
1312158SN/A    def basename(self):
1322158SN/A        return basename(self.filename)
1332158SN/A
1342158SN/A    @property
1352158SN/A    def extname(self):
1362158SN/A        index = self.basename.rfind('.')
1372158SN/A        if index <= 0:
1382158SN/A            # dot files aren't extensions
1392158SN/A            return self.basename, None
1402158SN/A
1412158SN/A        return self.basename[:index], self.basename[index+1:]
1422158SN/A
1432158SN/A    @property
1442158SN/A    def all_guards(self):
1452158SN/A        '''find all guards for this object getting default values
1462158SN/A        recursively from its parents'''
1472158SN/A        guards = {}
1482158SN/A        if self.parent:
1492158SN/A            guards.update(self.parent.guards)
1502158SN/A        guards.update(self.guards)
1512158SN/A        return guards
1522158SN/A
1532158SN/A    def __lt__(self, other): return self.filename < other.filename
1542158SN/A    def __le__(self, other): return self.filename <= other.filename
1552158SN/A    def __gt__(self, other): return self.filename > other.filename
1562158SN/A    def __ge__(self, other): return self.filename >= other.filename
1572158SN/A    def __eq__(self, other): return self.filename == other.filename
1582158SN/A    def __ne__(self, other): return self.filename != other.filename
1592158SN/A
1602158SN/A    @staticmethod
1612158SN/A    def done():
1622158SN/A        def disabled(cls, name, *ignored):
1632158SN/A            raise RuntimeError("Additional SourceFile '%s'" % name,\
1642158SN/A                  "declared, but targets deps are already fixed.")
1652158SN/A        SourceFile.__init__ = disabled
1662158SN/A
1672158SN/A
1682158SN/Aclass Source(SourceFile):
1692158SN/A    current_group = None
1702158SN/A    source_groups = { None : [] }
1712158SN/A
1722158SN/A    @classmethod
1732158SN/A    def set_group(cls, group):
1742521SN/A        if not group in Source.source_groups:
1752521SN/A            Source.source_groups[group] = []
1762158SN/A        Source.current_group = group
1772158SN/A
1782158SN/A    '''Add a c/c++ source file to the build'''
1792521SN/A    def __init__(self, source, Werror=True, **guards):
1802158SN/A        '''specify the source file, and any guards'''
1812158SN/A        super(Source, self).__init__(source, **guards)
1822158SN/A
1832158SN/A        self.Werror = Werror
1842158SN/A
1852158SN/A        Source.source_groups[Source.current_group].append(self)
1862158SN/A
1872158SN/Aclass PySource(SourceFile):
1882158SN/A    '''Add a python source file to the named package'''
1892158SN/A    invalid_sym_char = re.compile('[^A-z0-9_]')
1902158SN/A    modules = {}
1912158SN/A    tnodes = {}
1922158SN/A    symnames = {}
1932521SN/A
1942158SN/A    def __init__(self, package, source, **guards):
1952158SN/A        '''specify the python package, the source file, and any guards'''
1962158SN/A        super(PySource, self).__init__(source, **guards)
1972158SN/A
1982158SN/A        modname,ext = self.extname
1992158SN/A        assert ext == 'py'
2002158SN/A
2012158SN/A        if package:
2022158SN/A            path = package.split('.')
2032158SN/A        else:
2042158SN/A            path = []
2052158SN/A
2062158SN/A        modpath = path[:]
2072158SN/A        if modname != '__init__':
2082158SN/A            modpath += [ modname ]
2092158SN/A        modpath = '.'.join(modpath)
2102158SN/A
2112158SN/A        arcpath = path + [ self.basename ]
2122158SN/A        abspath = self.snode.abspath
2132158SN/A        if not exists(abspath):
2142158SN/A            abspath = self.tnode.abspath
2154762Snate@binkert.org
2164762Snate@binkert.org        self.package = package
2172158SN/A        self.modname = modname
2184762Snate@binkert.org        self.modpath = modpath
2192158SN/A        self.arcname = joinpath(*arcpath)
220        self.abspath = abspath
221        self.compiled = File(self.filename + 'c')
222        self.cpp = File(self.filename + '.cc')
223        self.symname = PySource.invalid_sym_char.sub('_', modpath)
224
225        PySource.modules[modpath] = self
226        PySource.tnodes[self.tnode] = self
227        PySource.symnames[self.symname] = self
228
229class SimObject(PySource):
230    '''Add a SimObject python file as a python source object and add
231    it to a list of sim object modules'''
232
233    fixed = False
234    modnames = []
235
236    def __init__(self, source, **guards):
237        '''Specify the source file and any guards (automatically in
238        the m5.objects package)'''
239        super(SimObject, self).__init__('m5.objects', source, **guards)
240        if self.fixed:
241            raise AttributeError, "Too late to call SimObject now."
242
243        bisect.insort_right(SimObject.modnames, self.modname)
244
245class ProtoBuf(SourceFile):
246    '''Add a Protocol Buffer to build'''
247
248    def __init__(self, source, **guards):
249        '''Specify the source file, and any guards'''
250        super(ProtoBuf, self).__init__(source, **guards)
251
252        # Get the file name and the extension
253        modname,ext = self.extname
254        assert ext == 'proto'
255
256        # Currently, we stick to generating the C++ headers, so we
257        # only need to track the source and header.
258        self.cc_file = File(modname + '.pb.cc')
259        self.hh_file = File(modname + '.pb.h')
260
261class UnitTest(object):
262    '''Create a UnitTest'''
263
264    all = []
265    def __init__(self, target, *sources, **kwargs):
266        '''Specify the target name and any sources.  Sources that are
267        not SourceFiles are evalued with Source().  All files are
268        guarded with a guard of the same name as the UnitTest
269        target.'''
270
271        srcs = []
272        for src in sources:
273            if not isinstance(src, SourceFile):
274                src = Source(src, skip_lib=True)
275            src.guards[target] = True
276            srcs.append(src)
277
278        self.sources = srcs
279        self.target = target
280        self.main = kwargs.get('main', False)
281        UnitTest.all.append(self)
282
283# Children should have access
284Export('Source')
285Export('PySource')
286Export('SimObject')
287Export('ProtoBuf')
288Export('UnitTest')
289
290########################################################################
291#
292# Debug Flags
293#
294debug_flags = {}
295def DebugFlag(name, desc=None):
296    if name in debug_flags:
297        raise AttributeError, "Flag %s already specified" % name
298    debug_flags[name] = (name, (), desc)
299
300def CompoundFlag(name, flags, desc=None):
301    if name in debug_flags:
302        raise AttributeError, "Flag %s already specified" % name
303
304    compound = tuple(flags)
305    debug_flags[name] = (name, compound, desc)
306
307Export('DebugFlag')
308Export('CompoundFlag')
309
310########################################################################
311#
312# Set some compiler variables
313#
314
315# Include file paths are rooted in this directory.  SCons will
316# automatically expand '.' to refer to both the source directory and
317# the corresponding build directory to pick up generated include
318# files.
319env.Append(CPPPATH=Dir('.'))
320
321for extra_dir in extras_dir_list:
322    env.Append(CPPPATH=Dir(extra_dir))
323
324# Workaround for bug in SCons version > 0.97d20071212
325# Scons bug id: 2006 gem5 Bug id: 308
326for root, dirs, files in os.walk(base_dir, topdown=True):
327    Dir(root[len(base_dir) + 1:])
328
329########################################################################
330#
331# Walk the tree and execute all SConscripts in subdirectories
332#
333
334here = Dir('.').srcnode().abspath
335for root, dirs, files in os.walk(base_dir, topdown=True):
336    if root == here:
337        # we don't want to recurse back into this SConscript
338        continue
339
340    if 'SConscript' in files:
341        build_dir = joinpath(env['BUILDDIR'], root[len(base_dir) + 1:])
342        Source.set_group(build_dir)
343        SConscript(joinpath(root, 'SConscript'), variant_dir=build_dir)
344
345for extra_dir in extras_dir_list:
346    prefix_len = len(dirname(extra_dir)) + 1
347
348    # Also add the corresponding build directory to pick up generated
349    # include files.
350    env.Append(CPPPATH=Dir(joinpath(env['BUILDDIR'], extra_dir[prefix_len:])))
351
352    for root, dirs, files in os.walk(extra_dir, topdown=True):
353        # if build lives in the extras directory, don't walk down it
354        if 'build' in dirs:
355            dirs.remove('build')
356
357        if 'SConscript' in files:
358            build_dir = joinpath(env['BUILDDIR'], root[prefix_len:])
359            SConscript(joinpath(root, 'SConscript'), variant_dir=build_dir)
360
361for opt in export_vars:
362    env.ConfigFile(opt)
363
364def makeTheISA(source, target, env):
365    isas = [ src.get_contents() for src in source ]
366    target_isa = env['TARGET_ISA']
367    def define(isa):
368        return isa.upper() + '_ISA'
369
370    def namespace(isa):
371        return isa[0].upper() + isa[1:].lower() + 'ISA'
372
373
374    code = code_formatter()
375    code('''\
376#ifndef __CONFIG_THE_ISA_HH__
377#define __CONFIG_THE_ISA_HH__
378
379''')
380
381    # create defines for the preprocessing and compile-time determination
382    for i,isa in enumerate(isas):
383        code('#define $0 $1', define(isa), i + 1)
384    code()
385
386    # create an enum for any run-time determination of the ISA, we
387    # reuse the same name as the namespaces
388    code('enum class Arch {')
389    for i,isa in enumerate(isas):
390        if i + 1 == len(isas):
391            code('  $0 = $1', namespace(isa), define(isa))
392        else:
393            code('  $0 = $1,', namespace(isa), define(isa))
394    code('};')
395
396    code('''
397
398#define THE_ISA ${{define(target_isa)}}
399#define TheISA ${{namespace(target_isa)}}
400#define THE_ISA_STR "${{target_isa}}"
401
402#endif // __CONFIG_THE_ISA_HH__''')
403
404    code.write(str(target[0]))
405
406env.Command('config/the_isa.hh', map(Value, all_isa_list),
407            MakeAction(makeTheISA, Transform("CFG ISA", 0)))
408
409def makeTheGPUISA(source, target, env):
410    isas = [ src.get_contents() for src in source ]
411    target_gpu_isa = env['TARGET_GPU_ISA']
412    def define(isa):
413        return isa.upper() + '_ISA'
414
415    def namespace(isa):
416        return isa[0].upper() + isa[1:].lower() + 'ISA'
417
418
419    code = code_formatter()
420    code('''\
421#ifndef __CONFIG_THE_GPU_ISA_HH__
422#define __CONFIG_THE_GPU_ISA_HH__
423
424''')
425
426    # create defines for the preprocessing and compile-time determination
427    for i,isa in enumerate(isas):
428        code('#define $0 $1', define(isa), i + 1)
429    code()
430
431    # create an enum for any run-time determination of the ISA, we
432    # reuse the same name as the namespaces
433    code('enum class GPUArch {')
434    for i,isa in enumerate(isas):
435        if i + 1 == len(isas):
436            code('  $0 = $1', namespace(isa), define(isa))
437        else:
438            code('  $0 = $1,', namespace(isa), define(isa))
439    code('};')
440
441    code('''
442
443#define THE_GPU_ISA ${{define(target_gpu_isa)}}
444#define TheGpuISA ${{namespace(target_gpu_isa)}}
445#define THE_GPU_ISA_STR "${{target_gpu_isa}}"
446
447#endif // __CONFIG_THE_GPU_ISA_HH__''')
448
449    code.write(str(target[0]))
450
451env.Command('config/the_gpu_isa.hh', map(Value, all_gpu_isa_list),
452            MakeAction(makeTheGPUISA, Transform("CFG ISA", 0)))
453
454########################################################################
455#
456# Prevent any SimObjects from being added after this point, they
457# should all have been added in the SConscripts above
458#
459SimObject.fixed = True
460
461class DictImporter(object):
462    '''This importer takes a dictionary of arbitrary module names that
463    map to arbitrary filenames.'''
464    def __init__(self, modules):
465        self.modules = modules
466        self.installed = set()
467
468    def __del__(self):
469        self.unload()
470
471    def unload(self):
472        import sys
473        for module in self.installed:
474            del sys.modules[module]
475        self.installed = set()
476
477    def find_module(self, fullname, path):
478        if fullname == 'm5.defines':
479            return self
480
481        if fullname == 'm5.objects':
482            return self
483
484        if fullname.startswith('_m5'):
485            return None
486
487        source = self.modules.get(fullname, None)
488        if source is not None and fullname.startswith('m5.objects'):
489            return self
490
491        return None
492
493    def load_module(self, fullname):
494        mod = imp.new_module(fullname)
495        sys.modules[fullname] = mod
496        self.installed.add(fullname)
497
498        mod.__loader__ = self
499        if fullname == 'm5.objects':
500            mod.__path__ = fullname.split('.')
501            return mod
502
503        if fullname == 'm5.defines':
504            mod.__dict__['buildEnv'] = m5.util.SmartDict(build_env)
505            return mod
506
507        source = self.modules[fullname]
508        if source.modname == '__init__':
509            mod.__path__ = source.modpath
510        mod.__file__ = source.abspath
511
512        exec file(source.abspath, 'r') in mod.__dict__
513
514        return mod
515
516import m5.SimObject
517import m5.params
518from m5.util import code_formatter
519
520m5.SimObject.clear()
521m5.params.clear()
522
523# install the python importer so we can grab stuff from the source
524# tree itself.  We can't have SimObjects added after this point or
525# else we won't know about them for the rest of the stuff.
526importer = DictImporter(PySource.modules)
527sys.meta_path[0:0] = [ importer ]
528
529# import all sim objects so we can populate the all_objects list
530# make sure that we're working with a list, then let's sort it
531for modname in SimObject.modnames:
532    exec('from m5.objects import %s' % modname)
533
534# we need to unload all of the currently imported modules so that they
535# will be re-imported the next time the sconscript is run
536importer.unload()
537sys.meta_path.remove(importer)
538
539sim_objects = m5.SimObject.allClasses
540all_enums = m5.params.allEnums
541
542for name,obj in sorted(sim_objects.iteritems()):
543    for param in obj._params.local.values():
544        # load the ptype attribute now because it depends on the
545        # current version of SimObject.allClasses, but when scons
546        # actually uses the value, all versions of
547        # SimObject.allClasses will have been loaded
548        param.ptype
549
550########################################################################
551#
552# calculate extra dependencies
553#
554module_depends = ["m5", "m5.SimObject", "m5.params"]
555depends = [ PySource.modules[dep].snode for dep in module_depends ]
556depends.sort(key = lambda x: x.name)
557
558########################################################################
559#
560# Commands for the basic automatically generated python files
561#
562
563# Generate Python file containing a dict specifying the current
564# buildEnv flags.
565def makeDefinesPyFile(target, source, env):
566    build_env = source[0].get_contents()
567
568    code = code_formatter()
569    code("""
570import _m5.core
571import m5.util
572
573buildEnv = m5.util.SmartDict($build_env)
574
575compileDate = _m5.core.compileDate
576_globals = globals()
577for key,val in _m5.core.__dict__.iteritems():
578    if key.startswith('flag_'):
579        flag = key[5:]
580        _globals[flag] = val
581del _globals
582""")
583    code.write(target[0].abspath)
584
585defines_info = Value(build_env)
586# Generate a file with all of the compile options in it
587env.Command('python/m5/defines.py', defines_info,
588            MakeAction(makeDefinesPyFile, Transform("DEFINES", 0)))
589PySource('m5', 'python/m5/defines.py')
590
591# Generate python file containing info about the M5 source code
592def makeInfoPyFile(target, source, env):
593    code = code_formatter()
594    for src in source:
595        data = ''.join(file(src.srcnode().abspath, 'r').xreadlines())
596        code('$src = ${{repr(data)}}')
597    code.write(str(target[0]))
598
599# Generate a file that wraps the basic top level files
600env.Command('python/m5/info.py',
601            [ '#/COPYING', '#/LICENSE', '#/README', ],
602            MakeAction(makeInfoPyFile, Transform("INFO")))
603PySource('m5', 'python/m5/info.py')
604
605########################################################################
606#
607# Create all of the SimObject param headers and enum headers
608#
609
610def createSimObjectParamStruct(target, source, env):
611    assert len(target) == 1 and len(source) == 1
612
613    name = str(source[0].get_contents())
614    obj = sim_objects[name]
615
616    code = code_formatter()
617    obj.cxx_param_decl(code)
618    code.write(target[0].abspath)
619
620def createSimObjectCxxConfig(is_header):
621    def body(target, source, env):
622        assert len(target) == 1 and len(source) == 1
623
624        name = str(source[0].get_contents())
625        obj = sim_objects[name]
626
627        code = code_formatter()
628        obj.cxx_config_param_file(code, is_header)
629        code.write(target[0].abspath)
630    return body
631
632def createEnumStrings(target, source, env):
633    assert len(target) == 1 and len(source) == 1
634
635    name = str(source[0].get_contents())
636    obj = all_enums[name]
637
638    code = code_formatter()
639    obj.cxx_def(code)
640    if env['USE_PYTHON']:
641        obj.pybind_def(code)
642    code.write(target[0].abspath)
643
644def createEnumDecls(target, source, env):
645    assert len(target) == 1 and len(source) == 1
646
647    name = str(source[0].get_contents())
648    obj = all_enums[name]
649
650    code = code_formatter()
651    obj.cxx_decl(code)
652    code.write(target[0].abspath)
653
654def createSimObjectPyBindWrapper(target, source, env):
655    name = source[0].get_contents()
656    obj = sim_objects[name]
657
658    code = code_formatter()
659    obj.pybind_decl(code)
660    code.write(target[0].abspath)
661
662# Generate all of the SimObject param C++ struct header files
663params_hh_files = []
664for name,simobj in sorted(sim_objects.iteritems()):
665    py_source = PySource.modules[simobj.__module__]
666    extra_deps = [ py_source.tnode ]
667
668    hh_file = File('params/%s.hh' % name)
669    params_hh_files.append(hh_file)
670    env.Command(hh_file, Value(name),
671                MakeAction(createSimObjectParamStruct, Transform("SO PARAM")))
672    env.Depends(hh_file, depends + extra_deps)
673
674# C++ parameter description files
675if GetOption('with_cxx_config'):
676    for name,simobj in sorted(sim_objects.iteritems()):
677        py_source = PySource.modules[simobj.__module__]
678        extra_deps = [ py_source.tnode ]
679
680        cxx_config_hh_file = File('cxx_config/%s.hh' % name)
681        cxx_config_cc_file = File('cxx_config/%s.cc' % name)
682        env.Command(cxx_config_hh_file, Value(name),
683                    MakeAction(createSimObjectCxxConfig(True),
684                    Transform("CXXCPRHH")))
685        env.Command(cxx_config_cc_file, Value(name),
686                    MakeAction(createSimObjectCxxConfig(False),
687                    Transform("CXXCPRCC")))
688        env.Depends(cxx_config_hh_file, depends + extra_deps +
689                    [File('params/%s.hh' % name), File('sim/cxx_config.hh')])
690        env.Depends(cxx_config_cc_file, depends + extra_deps +
691                    [cxx_config_hh_file])
692        Source(cxx_config_cc_file)
693
694    cxx_config_init_cc_file = File('cxx_config/init.cc')
695
696    def createCxxConfigInitCC(target, source, env):
697        assert len(target) == 1 and len(source) == 1
698
699        code = code_formatter()
700
701        for name,simobj in sorted(sim_objects.iteritems()):
702            if not hasattr(simobj, 'abstract') or not simobj.abstract:
703                code('#include "cxx_config/${name}.hh"')
704        code()
705        code('void cxxConfigInit()')
706        code('{')
707        code.indent()
708        for name,simobj in sorted(sim_objects.iteritems()):
709            not_abstract = not hasattr(simobj, 'abstract') or \
710                not simobj.abstract
711            if not_abstract and 'type' in simobj.__dict__:
712                code('cxx_config_directory["${name}"] = '
713                     '${name}CxxConfigParams::makeDirectoryEntry();')
714        code.dedent()
715        code('}')
716        code.write(target[0].abspath)
717
718    py_source = PySource.modules[simobj.__module__]
719    extra_deps = [ py_source.tnode ]
720    env.Command(cxx_config_init_cc_file, Value(name),
721        MakeAction(createCxxConfigInitCC, Transform("CXXCINIT")))
722    cxx_param_hh_files = ["cxx_config/%s.hh" % simobj
723        for name,simobj in sorted(sim_objects.iteritems())
724        if not hasattr(simobj, 'abstract') or not simobj.abstract]
725    Depends(cxx_config_init_cc_file, cxx_param_hh_files +
726            [File('sim/cxx_config.hh')])
727    Source(cxx_config_init_cc_file)
728
729# Generate all enum header files
730for name,enum in sorted(all_enums.iteritems()):
731    py_source = PySource.modules[enum.__module__]
732    extra_deps = [ py_source.tnode ]
733
734    cc_file = File('enums/%s.cc' % name)
735    env.Command(cc_file, Value(name),
736                MakeAction(createEnumStrings, Transform("ENUM STR")))
737    env.Depends(cc_file, depends + extra_deps)
738    Source(cc_file)
739
740    hh_file = File('enums/%s.hh' % name)
741    env.Command(hh_file, Value(name),
742                MakeAction(createEnumDecls, Transform("ENUMDECL")))
743    env.Depends(hh_file, depends + extra_deps)
744
745# Generate SimObject Python bindings wrapper files
746if env['USE_PYTHON']:
747    for name,simobj in sorted(sim_objects.iteritems()):
748        py_source = PySource.modules[simobj.__module__]
749        extra_deps = [ py_source.tnode ]
750        cc_file = File('python/_m5/param_%s.cc' % name)
751        env.Command(cc_file, Value(name),
752                    MakeAction(createSimObjectPyBindWrapper,
753                               Transform("SO PyBind")))
754        env.Depends(cc_file, depends + extra_deps)
755        Source(cc_file)
756
757# Build all protocol buffers if we have got protoc and protobuf available
758if env['HAVE_PROTOBUF']:
759    for proto in ProtoBuf.all:
760        # Use both the source and header as the target, and the .proto
761        # file as the source. When executing the protoc compiler, also
762        # specify the proto_path to avoid having the generated files
763        # include the path.
764        env.Command([proto.cc_file, proto.hh_file], proto.tnode,
765                    MakeAction('$PROTOC --cpp_out ${TARGET.dir} '
766                               '--proto_path ${SOURCE.dir} $SOURCE',
767                               Transform("PROTOC")))
768
769        # Add the C++ source file
770        Source(proto.cc_file, **proto.guards)
771elif ProtoBuf.all:
772    print 'Got protobuf to build, but lacks support!'
773    Exit(1)
774
775#
776# Handle debug flags
777#
778def makeDebugFlagCC(target, source, env):
779    assert(len(target) == 1 and len(source) == 1)
780
781    code = code_formatter()
782
783    # delay definition of CompoundFlags until after all the definition
784    # of all constituent SimpleFlags
785    comp_code = code_formatter()
786
787    # file header
788    code('''
789/*
790 * DO NOT EDIT THIS FILE! Automatically generated by SCons.
791 */
792
793#include "base/debug.hh"
794
795namespace Debug {
796
797''')
798
799    for name, flag in sorted(source[0].read().iteritems()):
800        n, compound, desc = flag
801        assert n == name
802
803        if not compound:
804            code('SimpleFlag $name("$name", "$desc");')
805        else:
806            comp_code('CompoundFlag $name("$name", "$desc",')
807            comp_code.indent()
808            last = len(compound) - 1
809            for i,flag in enumerate(compound):
810                if i != last:
811                    comp_code('&$flag,')
812                else:
813                    comp_code('&$flag);')
814            comp_code.dedent()
815
816    code.append(comp_code)
817    code()
818    code('} // namespace Debug')
819
820    code.write(str(target[0]))
821
822def makeDebugFlagHH(target, source, env):
823    assert(len(target) == 1 and len(source) == 1)
824
825    val = eval(source[0].get_contents())
826    name, compound, desc = val
827
828    code = code_formatter()
829
830    # file header boilerplate
831    code('''\
832/*
833 * DO NOT EDIT THIS FILE! Automatically generated by SCons.
834 */
835
836#ifndef __DEBUG_${name}_HH__
837#define __DEBUG_${name}_HH__
838
839namespace Debug {
840''')
841
842    if compound:
843        code('class CompoundFlag;')
844    code('class SimpleFlag;')
845
846    if compound:
847        code('extern CompoundFlag $name;')
848        for flag in compound:
849            code('extern SimpleFlag $flag;')
850    else:
851        code('extern SimpleFlag $name;')
852
853    code('''
854}
855
856#endif // __DEBUG_${name}_HH__
857''')
858
859    code.write(str(target[0]))
860
861for name,flag in sorted(debug_flags.iteritems()):
862    n, compound, desc = flag
863    assert n == name
864
865    hh_file = 'debug/%s.hh' % name
866    env.Command(hh_file, Value(flag),
867                MakeAction(makeDebugFlagHH, Transform("TRACING", 0)))
868
869env.Command('debug/flags.cc', Value(debug_flags),
870            MakeAction(makeDebugFlagCC, Transform("TRACING", 0)))
871Source('debug/flags.cc')
872
873# version tags
874tags = \
875env.Command('sim/tags.cc', None,
876            MakeAction('util/cpt_upgrader.py --get-cc-file > $TARGET',
877                       Transform("VER TAGS")))
878env.AlwaysBuild(tags)
879
880# Embed python files.  All .py files that have been indicated by a
881# PySource() call in a SConscript need to be embedded into the M5
882# library.  To do that, we compile the file to byte code, marshal the
883# byte code, compress it, and then generate a c++ file that
884# inserts the result into an array.
885def embedPyFile(target, source, env):
886    def c_str(string):
887        if string is None:
888            return "0"
889        return '"%s"' % string
890
891    '''Action function to compile a .py into a code object, marshal
892    it, compress it, and stick it into an asm file so the code appears
893    as just bytes with a label in the data section'''
894
895    src = file(str(source[0]), 'r').read()
896
897    pysource = PySource.tnodes[source[0]]
898    compiled = compile(src, pysource.abspath, 'exec')
899    marshalled = marshal.dumps(compiled)
900    compressed = zlib.compress(marshalled)
901    data = compressed
902    sym = pysource.symname
903
904    code = code_formatter()
905    code('''\
906#include "sim/init.hh"
907
908namespace {
909
910const uint8_t data_${sym}[] = {
911''')
912    code.indent()
913    step = 16
914    for i in xrange(0, len(data), step):
915        x = array.array('B', data[i:i+step])
916        code(''.join('%d,' % d for d in x))
917    code.dedent()
918
919    code('''};
920
921EmbeddedPython embedded_${sym}(
922    ${{c_str(pysource.arcname)}},
923    ${{c_str(pysource.abspath)}},
924    ${{c_str(pysource.modpath)}},
925    data_${sym},
926    ${{len(data)}},
927    ${{len(marshalled)}});
928
929} // anonymous namespace
930''')
931    code.write(str(target[0]))
932
933for source in PySource.all:
934    env.Command(source.cpp, source.tnode,
935                MakeAction(embedPyFile, Transform("EMBED PY")))
936    Source(source.cpp, skip_no_python=True)
937
938########################################################################
939#
940# Define binaries.  Each different build type (debug, opt, etc.) gets
941# a slightly different build environment.
942#
943
944# List of constructed environments to pass back to SConstruct
945date_source = Source('base/date.cc', skip_lib=True)
946
947# Capture this directory for the closure makeEnv, otherwise when it is
948# called, it won't know what directory it should use.
949variant_dir = Dir('.').path
950def variant(*path):
951    return os.path.join(variant_dir, *path)
952def variantd(*path):
953    return variant(*path)+'/'
954
955# Function to create a new build environment as clone of current
956# environment 'env' with modified object suffix and optional stripped
957# binary.  Additional keyword arguments are appended to corresponding
958# build environment vars.
959def makeEnv(env, label, objsfx, strip = False, **kwargs):
960    # SCons doesn't know to append a library suffix when there is a '.' in the
961    # name.  Use '_' instead.
962    libname = variant('gem5_' + label)
963    exename = variant('gem5.' + label)
964    secondary_exename = variant('m5.' + label)
965
966    new_env = env.Clone(OBJSUFFIX=objsfx, SHOBJSUFFIX=objsfx + 's')
967    new_env.Label = label
968    new_env.Append(**kwargs)
969
970    if env['GCC']:
971        # The address sanitizer is available for gcc >= 4.8
972        if GetOption('with_asan'):
973            if GetOption('with_ubsan') and \
974                    compareVersions(env['GCC_VERSION'], '4.9') >= 0:
975                new_env.Append(CCFLAGS=['-fsanitize=address,undefined',
976                                        '-fno-omit-frame-pointer'])
977                new_env.Append(LINKFLAGS='-fsanitize=address,undefined')
978            else:
979                new_env.Append(CCFLAGS=['-fsanitize=address',
980                                        '-fno-omit-frame-pointer'])
981                new_env.Append(LINKFLAGS='-fsanitize=address')
982        # Only gcc >= 4.9 supports UBSan, so check both the version
983        # and the command-line option before adding the compiler and
984        # linker flags.
985        elif GetOption('with_ubsan') and \
986                compareVersions(env['GCC_VERSION'], '4.9') >= 0:
987            new_env.Append(CCFLAGS='-fsanitize=undefined')
988            new_env.Append(LINKFLAGS='-fsanitize=undefined')
989
990
991    if env['CLANG']:
992        # We require clang >= 3.1, so there is no need to check any
993        # versions here.
994        if GetOption('with_ubsan'):
995            if GetOption('with_asan'):
996                new_env.Append(CCFLAGS=['-fsanitize=address,undefined',
997                                        '-fno-omit-frame-pointer'])
998                new_env.Append(LINKFLAGS='-fsanitize=address,undefined')
999            else:
1000                new_env.Append(CCFLAGS='-fsanitize=undefined')
1001                new_env.Append(LINKFLAGS='-fsanitize=undefined')
1002
1003        elif GetOption('with_asan'):
1004            new_env.Append(CCFLAGS=['-fsanitize=address',
1005                                    '-fno-omit-frame-pointer'])
1006            new_env.Append(LINKFLAGS='-fsanitize=address')
1007
1008    werror_env = new_env.Clone()
1009    # Treat warnings as errors but white list some warnings that we
1010    # want to allow (e.g., deprecation warnings).
1011    werror_env.Append(CCFLAGS=['-Werror',
1012                               '-Wno-error=deprecated-declarations',
1013                               '-Wno-error=deprecated',
1014                               ])
1015
1016    def make_obj(source, static, extra_deps = None):
1017        '''This function adds the specified source to the correct
1018        build environment, and returns the corresponding SCons Object
1019        nodes'''
1020
1021        if source.Werror:
1022            env = werror_env
1023        else:
1024            env = new_env
1025
1026        if static:
1027            obj = env.StaticObject(source.tnode)
1028        else:
1029            obj = env.SharedObject(source.tnode)
1030
1031        if extra_deps:
1032            env.Depends(obj, extra_deps)
1033
1034        return obj
1035
1036    lib_guards = {'main': False, 'skip_lib': False}
1037
1038    # Without Python, leave out all Python content from the library
1039    # builds.  The option doesn't affect gem5 built as a program
1040    if GetOption('without_python'):
1041        lib_guards['skip_no_python'] = False
1042
1043    static_objs = []
1044    shared_objs = []
1045    for s in guarded_source_iterator(Source.source_groups[None], **lib_guards):
1046        static_objs.append(make_obj(s, True))
1047        shared_objs.append(make_obj(s, False))
1048
1049    partial_objs = []
1050    for group, all_srcs in Source.source_groups.iteritems():
1051        # If these are the ungrouped source files, skip them.
1052        if not group:
1053            continue
1054
1055        # Get a list of the source files compatible with the current guards.
1056        srcs = [ s for s in guarded_source_iterator(all_srcs, **lib_guards) ]
1057        # If there aren't any left, skip this group.
1058        if not srcs:
1059            continue
1060
1061        # Set up the static partially linked objects.
1062        source_objs = [ make_obj(s, True) for s in srcs ]
1063        file_name = new_env.subst("${OBJPREFIX}lib${OBJSUFFIX}.partial")
1064        target = File(joinpath(group, file_name))
1065        partial = env.PartialStatic(target=target, source=source_objs)
1066        static_objs.append(partial)
1067
1068        # Set up the shared partially linked objects.
1069        source_objs = [ make_obj(s, False) for s in srcs ]
1070        file_name = new_env.subst("${SHOBJPREFIX}lib${SHOBJSUFFIX}.partial")
1071        target = File(joinpath(group, file_name))
1072        partial = env.PartialShared(target=target, source=source_objs)
1073        shared_objs.append(partial)
1074
1075    static_date = make_obj(date_source, static=True, extra_deps=static_objs)
1076    static_objs.append(static_date)
1077
1078    shared_date = make_obj(date_source, static=False, extra_deps=shared_objs)
1079    shared_objs.append(shared_date)
1080
1081    # First make a library of everything but main() so other programs can
1082    # link against m5.
1083    static_lib = new_env.StaticLibrary(libname, static_objs)
1084    shared_lib = new_env.SharedLibrary(libname, shared_objs)
1085
1086    # Now link a stub with main() and the static library.
1087    main_objs = [ make_obj(s, True) for s in Source.get(main=True) ]
1088
1089    for test in UnitTest.all:
1090        flags = { test.target : True }
1091        test_sources = Source.get(**flags)
1092        test_objs = [ make_obj(s, static=True) for s in test_sources ]
1093        if test.main:
1094            test_objs += main_objs
1095        path = variant('unittest/%s.%s' % (test.target, label))
1096        new_env.Program(path, test_objs + static_objs)
1097
1098    progname = exename
1099    if strip:
1100        progname += '.unstripped'
1101
1102    targets = new_env.Program(progname, main_objs + static_objs)
1103
1104    if strip:
1105        if sys.platform == 'sunos5':
1106            cmd = 'cp $SOURCE $TARGET; strip $TARGET'
1107        else:
1108            cmd = 'strip $SOURCE -o $TARGET'
1109        targets = new_env.Command(exename, progname,
1110                    MakeAction(cmd, Transform("STRIP")))
1111
1112    new_env.Command(secondary_exename, exename,
1113            MakeAction('ln $SOURCE $TARGET', Transform("HARDLINK")))
1114
1115    new_env.M5Binary = targets[0]
1116    return new_env
1117
1118# Start out with the compiler flags common to all compilers,
1119# i.e. they all use -g for opt and -g -pg for prof
1120ccflags = {'debug' : [], 'opt' : ['-g'], 'fast' : [], 'prof' : ['-g', '-pg'],
1121           'perf' : ['-g']}
1122
1123# Start out with the linker flags common to all linkers, i.e. -pg for
1124# prof, and -lprofiler for perf. The -lprofile flag is surrounded by
1125# no-as-needed and as-needed as the binutils linker is too clever and
1126# simply doesn't link to the library otherwise.
1127ldflags = {'debug' : [], 'opt' : [], 'fast' : [], 'prof' : ['-pg'],
1128           'perf' : ['-Wl,--no-as-needed', '-lprofiler', '-Wl,--as-needed']}
1129
1130# For Link Time Optimization, the optimisation flags used to compile
1131# individual files are decoupled from those used at link time
1132# (i.e. you can compile with -O3 and perform LTO with -O0), so we need
1133# to also update the linker flags based on the target.
1134if env['GCC']:
1135    if sys.platform == 'sunos5':
1136        ccflags['debug'] += ['-gstabs+']
1137    else:
1138        ccflags['debug'] += ['-ggdb3']
1139    ldflags['debug'] += ['-O0']
1140    # opt, fast, prof and perf all share the same cc flags, also add
1141    # the optimization to the ldflags as LTO defers the optimization
1142    # to link time
1143    for target in ['opt', 'fast', 'prof', 'perf']:
1144        ccflags[target] += ['-O3']
1145        ldflags[target] += ['-O3']
1146
1147    ccflags['fast'] += env['LTO_CCFLAGS']
1148    ldflags['fast'] += env['LTO_LDFLAGS']
1149elif env['CLANG']:
1150    ccflags['debug'] += ['-g', '-O0']
1151    # opt, fast, prof and perf all share the same cc flags
1152    for target in ['opt', 'fast', 'prof', 'perf']:
1153        ccflags[target] += ['-O3']
1154else:
1155    print 'Unknown compiler, please fix compiler options'
1156    Exit(1)
1157
1158
1159# To speed things up, we only instantiate the build environments we
1160# need.  We try to identify the needed environment for each target; if
1161# we can't, we fall back on instantiating all the environments just to
1162# be safe.
1163target_types = ['debug', 'opt', 'fast', 'prof', 'perf']
1164obj2target = {'do': 'debug', 'o': 'opt', 'fo': 'fast', 'po': 'prof',
1165              'gpo' : 'perf'}
1166
1167def identifyTarget(t):
1168    ext = t.split('.')[-1]
1169    if ext in target_types:
1170        return ext
1171    if obj2target.has_key(ext):
1172        return obj2target[ext]
1173    match = re.search(r'/tests/([^/]+)/', t)
1174    if match and match.group(1) in target_types:
1175        return match.group(1)
1176    return 'all'
1177
1178needed_envs = [identifyTarget(target) for target in BUILD_TARGETS]
1179if 'all' in needed_envs:
1180    needed_envs += target_types
1181
1182def makeEnvirons(target, source, env):
1183    # cause any later Source() calls to be fatal, as a diagnostic.
1184    Source.done()
1185
1186    envList = []
1187
1188    # Debug binary
1189    if 'debug' in needed_envs:
1190        envList.append(
1191            makeEnv(env, 'debug', '.do',
1192                    CCFLAGS = Split(ccflags['debug']),
1193                    CPPDEFINES = ['DEBUG', 'TRACING_ON=1'],
1194                    LINKFLAGS = Split(ldflags['debug'])))
1195
1196    # Optimized binary
1197    if 'opt' in needed_envs:
1198        envList.append(
1199            makeEnv(env, 'opt', '.o',
1200                    CCFLAGS = Split(ccflags['opt']),
1201                    CPPDEFINES = ['TRACING_ON=1'],
1202                    LINKFLAGS = Split(ldflags['opt'])))
1203
1204    # "Fast" binary
1205    if 'fast' in needed_envs:
1206        envList.append(
1207            makeEnv(env, 'fast', '.fo', strip = True,
1208                    CCFLAGS = Split(ccflags['fast']),
1209                    CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'],
1210                    LINKFLAGS = Split(ldflags['fast'])))
1211
1212    # Profiled binary using gprof
1213    if 'prof' in needed_envs:
1214        envList.append(
1215            makeEnv(env, 'prof', '.po',
1216                    CCFLAGS = Split(ccflags['prof']),
1217                    CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'],
1218                    LINKFLAGS = Split(ldflags['prof'])))
1219
1220    # Profiled binary using google-pprof
1221    if 'perf' in needed_envs:
1222        envList.append(
1223            makeEnv(env, 'perf', '.gpo',
1224                    CCFLAGS = Split(ccflags['perf']),
1225                    CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'],
1226                    LINKFLAGS = Split(ldflags['perf'])))
1227
1228    # Set up the regression tests for each build.
1229    for e in envList:
1230        SConscript(os.path.join(env.root.abspath, 'tests', 'SConscript'),
1231                   variant_dir = variantd('tests', e.Label),
1232                   exports = { 'env' : e }, duplicate = False)
1233
1234# The MakeEnvirons Builder defers the full dependency collection until
1235# after processing the ISA definition (due to dynamically generated
1236# source files).  Add this dependency to all targets so they will wait
1237# until the environments are completely set up.  Otherwise, a second
1238# process (e.g. -j2 or higher) will try to compile the requested target,
1239# not know how, and fail.
1240env.Append(BUILDERS = {'MakeEnvirons' :
1241                        Builder(action=MakeAction(makeEnvirons,
1242                                                  Transform("ENVIRONS", 1)))})
1243
1244isa_target = env['PHONY_BASE'] + '-deps'
1245environs   = env['PHONY_BASE'] + '-environs'
1246env.Depends('#all-deps',     isa_target)
1247env.Depends('#all-environs', environs)
1248env.ScanISA(isa_target, File('arch/%s/generated/inc.d' % env['TARGET_ISA']))
1249envSetup = env.MakeEnvirons(environs, isa_target)
1250
1251# make sure no -deps targets occur before all ISAs are complete
1252env.Depends(isa_target, '#all-isas')
1253# likewise for -environs targets and all the -deps targets
1254env.Depends(environs, '#all-deps')
1255