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