SConstruct revision 11944
1# -*- mode:python -*-
2
3# Copyright (c) 2013, 2015, 2016 ARM Limited
4# All rights reserved.
5#
6# The license below extends only to copyright in the software and shall
7# not be construed as granting a license to any other intellectual
8# property including but not limited to intellectual property relating
9# to a hardware implementation of the functionality of the software
10# licensed hereunder.  You may use the software subject to the license
11# terms below provided that you ensure that this notice is replicated
12# unmodified and in its entirety in all distributions of the software,
13# modified or unmodified, in source code or in binary form.
14#
15# Copyright (c) 2011 Advanced Micro Devices, Inc.
16# Copyright (c) 2009 The Hewlett-Packard Development Company
17# Copyright (c) 2004-2005 The Regents of The University of Michigan
18# All rights reserved.
19#
20# Redistribution and use in source and binary forms, with or without
21# modification, are permitted provided that the following conditions are
22# met: redistributions of source code must retain the above copyright
23# notice, this list of conditions and the following disclaimer;
24# redistributions in binary form must reproduce the above copyright
25# notice, this list of conditions and the following disclaimer in the
26# documentation and/or other materials provided with the distribution;
27# neither the name of the copyright holders nor the names of its
28# contributors may be used to endorse or promote products derived from
29# this software without specific prior written permission.
30#
31# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
34# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
36# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
37# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
38# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
39# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
40# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
41# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42#
43# Authors: Steve Reinhardt
44#          Nathan Binkert
45
46###################################################
47#
48# SCons top-level build description (SConstruct) file.
49#
50# While in this directory ('gem5'), just type 'scons' to build the default
51# configuration (see below), or type 'scons build/<CONFIG>/<binary>'
52# to build some other configuration (e.g., 'build/ALPHA/gem5.opt' for
53# the optimized full-system version).
54#
55# You can build gem5 in a different directory as long as there is a
56# 'build/<CONFIG>' somewhere along the target path.  The build system
57# expects that all configs under the same build directory are being
58# built for the same host system.
59#
60# Examples:
61#
62#   The following two commands are equivalent.  The '-u' option tells
63#   scons to search up the directory tree for this SConstruct file.
64#   % cd <path-to-src>/gem5 ; scons build/ALPHA/gem5.debug
65#   % cd <path-to-src>/gem5/build/ALPHA; scons -u gem5.debug
66#
67#   The following two commands are equivalent and demonstrate building
68#   in a directory outside of the source tree.  The '-C' option tells
69#   scons to chdir to the specified directory to find this SConstruct
70#   file.
71#   % cd <path-to-src>/gem5 ; scons /local/foo/build/ALPHA/gem5.debug
72#   % cd /local/foo/build/ALPHA; scons -C <path-to-src>/gem5 gem5.debug
73#
74# You can use 'scons -H' to print scons options.  If you're in this
75# 'gem5' directory (or use -u or -C to tell scons where to find this
76# file), you can use 'scons -h' to print all the gem5-specific build
77# options as well.
78#
79###################################################
80
81# Check for recent-enough Python and SCons versions.
82try:
83    # Really old versions of scons only take two options for the
84    # function, so check once without the revision and once with the
85    # revision, the first instance will fail for stuff other than
86    # 0.98, and the second will fail for 0.98.0
87    EnsureSConsVersion(0, 98)
88    EnsureSConsVersion(0, 98, 1)
89except SystemExit, e:
90    print """
91For more details, see:
92    http://gem5.org/Dependencies
93"""
94    raise
95
96# We ensure the python version early because because python-config
97# requires python 2.5
98try:
99    EnsurePythonVersion(2, 5)
100except SystemExit, e:
101    print """
102You can use a non-default installation of the Python interpreter by
103rearranging your PATH so that scons finds the non-default 'python' and
104'python-config' first.
105
106For more details, see:
107    http://gem5.org/wiki/index.php/Using_a_non-default_Python_installation
108"""
109    raise
110
111# Global Python includes
112import itertools
113import os
114import re
115import shutil
116import subprocess
117import sys
118
119from os import mkdir, environ
120from os.path import abspath, basename, dirname, expanduser, normpath
121from os.path import exists,  isdir, isfile
122from os.path import join as joinpath, split as splitpath
123
124# SCons includes
125import SCons
126import SCons.Node
127
128extra_python_paths = [
129    Dir('src/python').srcnode().abspath, # gem5 includes
130    Dir('ext/ply').srcnode().abspath, # ply is used by several files
131    ]
132
133sys.path[1:1] = extra_python_paths
134
135from m5.util import compareVersions, readCommand
136from m5.util.terminal import get_termcap
137
138help_texts = {
139    "options" : "",
140    "global_vars" : "",
141    "local_vars" : ""
142}
143
144Export("help_texts")
145
146
147# There's a bug in scons in that (1) by default, the help texts from
148# AddOption() are supposed to be displayed when you type 'scons -h'
149# and (2) you can override the help displayed by 'scons -h' using the
150# Help() function, but these two features are incompatible: once
151# you've overridden the help text using Help(), there's no way to get
152# at the help texts from AddOptions.  See:
153#     http://scons.tigris.org/issues/show_bug.cgi?id=2356
154#     http://scons.tigris.org/issues/show_bug.cgi?id=2611
155# This hack lets us extract the help text from AddOptions and
156# re-inject it via Help().  Ideally someday this bug will be fixed and
157# we can just use AddOption directly.
158def AddLocalOption(*args, **kwargs):
159    col_width = 30
160
161    help = "  " + ", ".join(args)
162    if "help" in kwargs:
163        length = len(help)
164        if length >= col_width:
165            help += "\n" + " " * col_width
166        else:
167            help += " " * (col_width - length)
168        help += kwargs["help"]
169    help_texts["options"] += help + "\n"
170
171    AddOption(*args, **kwargs)
172
173AddLocalOption('--colors', dest='use_colors', action='store_true',
174               help="Add color to abbreviated scons output")
175AddLocalOption('--no-colors', dest='use_colors', action='store_false',
176               help="Don't add color to abbreviated scons output")
177AddLocalOption('--with-cxx-config', dest='with_cxx_config',
178               action='store_true',
179               help="Build with support for C++-based configuration")
180AddLocalOption('--default', dest='default', type='string', action='store',
181               help='Override which build_opts file to use for defaults')
182AddLocalOption('--ignore-style', dest='ignore_style', action='store_true',
183               help='Disable style checking hooks')
184AddLocalOption('--no-lto', dest='no_lto', action='store_true',
185               help='Disable Link-Time Optimization for fast')
186AddLocalOption('--update-ref', dest='update_ref', action='store_true',
187               help='Update test reference outputs')
188AddLocalOption('--verbose', dest='verbose', action='store_true',
189               help='Print full tool command lines')
190AddLocalOption('--without-python', dest='without_python',
191               action='store_true',
192               help='Build without Python configuration support')
193AddLocalOption('--without-tcmalloc', dest='without_tcmalloc',
194               action='store_true',
195               help='Disable linking against tcmalloc')
196AddLocalOption('--with-ubsan', dest='with_ubsan', action='store_true',
197               help='Build with Undefined Behavior Sanitizer if available')
198AddLocalOption('--with-asan', dest='with_asan', action='store_true',
199               help='Build with Address Sanitizer if available')
200
201termcap = get_termcap(GetOption('use_colors'))
202
203########################################################################
204#
205# Set up the main build environment.
206#
207########################################################################
208
209# export TERM so that clang reports errors in color
210use_vars = set([ 'AS', 'AR', 'CC', 'CXX', 'HOME', 'LD_LIBRARY_PATH',
211                 'LIBRARY_PATH', 'PATH', 'PKG_CONFIG_PATH', 'PROTOC',
212                 'PYTHONPATH', 'RANLIB', 'SWIG', 'TERM' ])
213
214use_prefixes = [
215    "ASAN_",           # address sanitizer symbolizer path and settings
216    "CCACHE_",         # ccache (caching compiler wrapper) configuration
217    "CCC_",            # clang static analyzer configuration
218    "DISTCC_",         # distcc (distributed compiler wrapper) configuration
219    "INCLUDE_SERVER_", # distcc pump server settings
220    "M5",              # M5 configuration (e.g., path to kernels)
221    ]
222
223use_env = {}
224for key,val in sorted(os.environ.iteritems()):
225    if key in use_vars or \
226            any([key.startswith(prefix) for prefix in use_prefixes]):
227        use_env[key] = val
228
229# Tell scons to avoid implicit command dependencies to avoid issues
230# with the param wrappes being compiled twice (see
231# http://scons.tigris.org/issues/show_bug.cgi?id=2811)
232main = Environment(ENV=use_env, IMPLICIT_COMMAND_DEPENDENCIES=0)
233main.Decider('MD5-timestamp')
234main.root = Dir(".")         # The current directory (where this file lives).
235main.srcdir = Dir("src")     # The source directory
236
237main_dict_keys = main.Dictionary().keys()
238
239# Check that we have a C/C++ compiler
240if not ('CC' in main_dict_keys and 'CXX' in main_dict_keys):
241    print "No C++ compiler installed (package g++ on Ubuntu and RedHat)"
242    Exit(1)
243
244# Check that swig is present
245if not 'SWIG' in main_dict_keys:
246    print "swig is not installed (package swig on Ubuntu and RedHat)"
247    Exit(1)
248
249# add useful python code PYTHONPATH so it can be used by subprocesses
250# as well
251main.AppendENVPath('PYTHONPATH', extra_python_paths)
252
253########################################################################
254#
255# Mercurial Stuff.
256#
257# If the gem5 directory is a mercurial repository, we should do some
258# extra things.
259#
260########################################################################
261
262hgdir = main.root.Dir(".hg")
263
264
265style_message = """
266You're missing the gem5 style hook, which automatically checks your code
267against the gem5 style rules on %s.
268This script will now install the hook in your %s.
269Press enter to continue, or ctrl-c to abort: """
270
271mercurial_style_message = """
272You're missing the gem5 style hook, which automatically checks your code
273against the gem5 style rules on hg commit and qrefresh commands.
274This script will now install the hook in your .hg/hgrc file.
275Press enter to continue, or ctrl-c to abort: """
276
277git_style_message = """
278You're missing the gem5 style or commit message hook. These hooks help
279to ensure that your code follows gem5's style rules on git commit.
280This script will now install the hook in your .git/hooks/ directory.
281Press enter to continue, or ctrl-c to abort: """
282
283mercurial_style_upgrade_message = """
284Your Mercurial style hooks are not up-to-date. This script will now
285try to automatically update them. A backup of your hgrc will be saved
286in .hg/hgrc.old.
287Press enter to continue, or ctrl-c to abort: """
288
289mercurial_style_hook = """
290# The following lines were automatically added by gem5/SConstruct
291# to provide the gem5 style-checking hooks
292[extensions]
293hgstyle = %s/util/hgstyle.py
294
295[hooks]
296pretxncommit.style = python:hgstyle.check_style
297pre-qrefresh.style = python:hgstyle.check_style
298# End of SConstruct additions
299
300""" % (main.root.abspath)
301
302mercurial_lib_not_found = """
303Mercurial libraries cannot be found, ignoring style hook.  If
304you are a gem5 developer, please fix this and run the style
305hook. It is important.
306"""
307
308# Check for style hook and prompt for installation if it's not there.
309# Skip this if --ignore-style was specified, there's no interactive
310# terminal to prompt, or no recognized revision control system can be
311# found.
312ignore_style = GetOption('ignore_style') or not sys.stdin.isatty()
313
314# Try wire up Mercurial to the style hooks
315if not ignore_style and hgdir.exists():
316    style_hook = True
317    style_hooks = tuple()
318    hgrc = hgdir.File('hgrc')
319    hgrc_old = hgdir.File('hgrc.old')
320    try:
321        from mercurial import ui
322        ui = ui.ui()
323        ui.readconfig(hgrc.abspath)
324        style_hooks = (ui.config('hooks', 'pretxncommit.style', None),
325                       ui.config('hooks', 'pre-qrefresh.style', None))
326        style_hook = all(style_hooks)
327        style_extension = ui.config('extensions', 'style', None)
328    except ImportError:
329        print mercurial_lib_not_found
330
331    if "python:style.check_style" in style_hooks:
332        # Try to upgrade the style hooks
333        print mercurial_style_upgrade_message
334        # continue unless user does ctrl-c/ctrl-d etc.
335        try:
336            raw_input()
337        except:
338            print "Input exception, exiting scons.\n"
339            sys.exit(1)
340        shutil.copyfile(hgrc.abspath, hgrc_old.abspath)
341        re_style_hook = re.compile(r"^([^=#]+)\.style\s*=\s*([^#\s]+).*")
342        re_style_extension = re.compile("style\s*=\s*([^#\s]+).*")
343        old, new = open(hgrc_old.abspath, 'r'), open(hgrc.abspath, 'w')
344        for l in old:
345            m_hook = re_style_hook.match(l)
346            m_ext = re_style_extension.match(l)
347            if m_hook:
348                hook, check = m_hook.groups()
349                if check != "python:style.check_style":
350                    print "Warning: %s.style is using a non-default " \
351                        "checker: %s" % (hook, check)
352                if hook not in ("pretxncommit", "pre-qrefresh"):
353                    print "Warning: Updating unknown style hook: %s" % hook
354
355                l = "%s.style = python:hgstyle.check_style\n" % hook
356            elif m_ext and m_ext.group(1) == style_extension:
357                l = "hgstyle = %s/util/hgstyle.py\n" % main.root.abspath
358
359            new.write(l)
360    elif not style_hook:
361        print mercurial_style_message,
362        # continue unless user does ctrl-c/ctrl-d etc.
363        try:
364            raw_input()
365        except:
366            print "Input exception, exiting scons.\n"
367            sys.exit(1)
368        hgrc_path = '%s/.hg/hgrc' % main.root.abspath
369        print "Adding style hook to", hgrc_path, "\n"
370        try:
371            with open(hgrc_path, 'a') as f:
372                f.write(mercurial_style_hook)
373        except:
374            print "Error updating", hgrc_path
375            sys.exit(1)
376
377def install_git_style_hooks():
378    try:
379        gitdir = Dir(readCommand(
380            ["git", "rev-parse", "--git-dir"]).strip("\n"))
381    except Exception, e:
382        print "Warning: Failed to find git repo directory: %s" % e
383        return
384
385    git_hooks = gitdir.Dir("hooks")
386    def hook_exists(hook_name):
387        hook = git_hooks.File(hook_name)
388        return hook.exists()
389
390    def hook_install(hook_name, script):
391        hook = git_hooks.File(hook_name)
392        if hook.exists():
393            print "Warning: Can't install %s, hook already exists." % hook_name
394            return
395
396        if hook.islink():
397            print "Warning: Removing broken symlink for hook %s." % hook_name
398            os.unlink(hook.get_abspath())
399
400        if not git_hooks.exists():
401            mkdir(git_hooks.get_abspath())
402            git_hooks.clear()
403
404        abs_symlink_hooks = git_hooks.islink() and \
405            os.path.isabs(os.readlink(git_hooks.get_abspath()))
406
407        # Use a relative symlink if the hooks live in the source directory,
408        # and the hooks directory is not a symlink to an absolute path.
409        if hook.is_under(main.root) and not abs_symlink_hooks:
410            script_path = os.path.relpath(
411                os.path.realpath(script.get_abspath()),
412                os.path.realpath(hook.Dir(".").get_abspath()))
413        else:
414            script_path = script.get_abspath()
415
416        try:
417            os.symlink(script_path, hook.get_abspath())
418        except:
419            print "Error updating git %s hook" % hook_name
420            raise
421
422    if hook_exists("pre-commit") and hook_exists("commit-msg"):
423        return
424
425    print git_style_message,
426    try:
427        raw_input()
428    except:
429        print "Input exception, exiting scons.\n"
430        sys.exit(1)
431
432    git_style_script = File("util/git-pre-commit.py")
433    git_msg_script = File("ext/git-commit-msg")
434
435    hook_install("pre-commit", git_style_script)
436    hook_install("commit-msg", git_msg_script)
437
438# Try to wire up git to the style hooks
439if not ignore_style and main.root.Entry(".git").exists():
440    install_git_style_hooks()
441
442###################################################
443#
444# Figure out which configurations to set up based on the path(s) of
445# the target(s).
446#
447###################################################
448
449# Find default configuration & binary.
450Default(environ.get('M5_DEFAULT_BINARY', 'build/ALPHA/gem5.debug'))
451
452# helper function: find last occurrence of element in list
453def rfind(l, elt, offs = -1):
454    for i in range(len(l)+offs, 0, -1):
455        if l[i] == elt:
456            return i
457    raise ValueError, "element not found"
458
459# Take a list of paths (or SCons Nodes) and return a list with all
460# paths made absolute and ~-expanded.  Paths will be interpreted
461# relative to the launch directory unless a different root is provided
462def makePathListAbsolute(path_list, root=GetLaunchDir()):
463    return [abspath(joinpath(root, expanduser(str(p))))
464            for p in path_list]
465
466# Each target must have 'build' in the interior of the path; the
467# directory below this will determine the build parameters.  For
468# example, for target 'foo/bar/build/ALPHA_SE/arch/alpha/blah.do' we
469# recognize that ALPHA_SE specifies the configuration because it
470# follow 'build' in the build path.
471
472# The funky assignment to "[:]" is needed to replace the list contents
473# in place rather than reassign the symbol to a new list, which
474# doesn't work (obviously!).
475BUILD_TARGETS[:] = makePathListAbsolute(BUILD_TARGETS)
476
477# Generate a list of the unique build roots and configs that the
478# collected targets reference.
479variant_paths = []
480build_root = None
481for t in BUILD_TARGETS:
482    path_dirs = t.split('/')
483    try:
484        build_top = rfind(path_dirs, 'build', -2)
485    except:
486        print "Error: no non-leaf 'build' dir found on target path", t
487        Exit(1)
488    this_build_root = joinpath('/',*path_dirs[:build_top+1])
489    if not build_root:
490        build_root = this_build_root
491    else:
492        if this_build_root != build_root:
493            print "Error: build targets not under same build root\n"\
494                  "  %s\n  %s" % (build_root, this_build_root)
495            Exit(1)
496    variant_path = joinpath('/',*path_dirs[:build_top+2])
497    if variant_path not in variant_paths:
498        variant_paths.append(variant_path)
499
500# Make sure build_root exists (might not if this is the first build there)
501if not isdir(build_root):
502    mkdir(build_root)
503main['BUILDROOT'] = build_root
504
505Export('main')
506
507main.SConsignFile(joinpath(build_root, "sconsign"))
508
509# Default duplicate option is to use hard links, but this messes up
510# when you use emacs to edit a file in the target dir, as emacs moves
511# file to file~ then copies to file, breaking the link.  Symbolic
512# (soft) links work better.
513main.SetOption('duplicate', 'soft-copy')
514
515#
516# Set up global sticky variables... these are common to an entire build
517# tree (not specific to a particular build like ALPHA_SE)
518#
519
520global_vars_file = joinpath(build_root, 'variables.global')
521
522global_vars = Variables(global_vars_file, args=ARGUMENTS)
523
524global_vars.AddVariables(
525    ('CC', 'C compiler', environ.get('CC', main['CC'])),
526    ('CXX', 'C++ compiler', environ.get('CXX', main['CXX'])),
527    ('SWIG', 'SWIG tool', environ.get('SWIG', main['SWIG'])),
528    ('PROTOC', 'protoc tool', environ.get('PROTOC', 'protoc')),
529    ('BATCH', 'Use batch pool for build and tests', False),
530    ('BATCH_CMD', 'Batch pool submission command name', 'qdo'),
531    ('M5_BUILD_CACHE', 'Cache built objects in this directory', False),
532    ('EXTRAS', 'Add extra directories to the compilation', '')
533    )
534
535# Update main environment with values from ARGUMENTS & global_vars_file
536global_vars.Update(main)
537help_texts["global_vars"] += global_vars.GenerateHelpText(main)
538
539# Save sticky variable settings back to current variables file
540global_vars.Save(global_vars_file, main)
541
542# Parse EXTRAS variable to build list of all directories where we're
543# look for sources etc.  This list is exported as extras_dir_list.
544base_dir = main.srcdir.abspath
545if main['EXTRAS']:
546    extras_dir_list = makePathListAbsolute(main['EXTRAS'].split(':'))
547else:
548    extras_dir_list = []
549
550Export('base_dir')
551Export('extras_dir_list')
552
553# the ext directory should be on the #includes path
554main.Append(CPPPATH=[Dir('ext')])
555
556def strip_build_path(path, env):
557    path = str(path)
558    variant_base = env['BUILDROOT'] + os.path.sep
559    if path.startswith(variant_base):
560        path = path[len(variant_base):]
561    elif path.startswith('build/'):
562        path = path[6:]
563    return path
564
565# Generate a string of the form:
566#   common/path/prefix/src1, src2 -> tgt1, tgt2
567# to print while building.
568class Transform(object):
569    # all specific color settings should be here and nowhere else
570    tool_color = termcap.Normal
571    pfx_color = termcap.Yellow
572    srcs_color = termcap.Yellow + termcap.Bold
573    arrow_color = termcap.Blue + termcap.Bold
574    tgts_color = termcap.Yellow + termcap.Bold
575
576    def __init__(self, tool, max_sources=99):
577        self.format = self.tool_color + (" [%8s] " % tool) \
578                      + self.pfx_color + "%s" \
579                      + self.srcs_color + "%s" \
580                      + self.arrow_color + " -> " \
581                      + self.tgts_color + "%s" \
582                      + termcap.Normal
583        self.max_sources = max_sources
584
585    def __call__(self, target, source, env, for_signature=None):
586        # truncate source list according to max_sources param
587        source = source[0:self.max_sources]
588        def strip(f):
589            return strip_build_path(str(f), env)
590        if len(source) > 0:
591            srcs = map(strip, source)
592        else:
593            srcs = ['']
594        tgts = map(strip, target)
595        # surprisingly, os.path.commonprefix is a dumb char-by-char string
596        # operation that has nothing to do with paths.
597        com_pfx = os.path.commonprefix(srcs + tgts)
598        com_pfx_len = len(com_pfx)
599        if com_pfx:
600            # do some cleanup and sanity checking on common prefix
601            if com_pfx[-1] == ".":
602                # prefix matches all but file extension: ok
603                # back up one to change 'foo.cc -> o' to 'foo.cc -> .o'
604                com_pfx = com_pfx[0:-1]
605            elif com_pfx[-1] == "/":
606                # common prefix is directory path: OK
607                pass
608            else:
609                src0_len = len(srcs[0])
610                tgt0_len = len(tgts[0])
611                if src0_len == com_pfx_len:
612                    # source is a substring of target, OK
613                    pass
614                elif tgt0_len == com_pfx_len:
615                    # target is a substring of source, need to back up to
616                    # avoid empty string on RHS of arrow
617                    sep_idx = com_pfx.rfind(".")
618                    if sep_idx != -1:
619                        com_pfx = com_pfx[0:sep_idx]
620                    else:
621                        com_pfx = ''
622                elif src0_len > com_pfx_len and srcs[0][com_pfx_len] == ".":
623                    # still splitting at file extension: ok
624                    pass
625                else:
626                    # probably a fluke; ignore it
627                    com_pfx = ''
628        # recalculate length in case com_pfx was modified
629        com_pfx_len = len(com_pfx)
630        def fmt(files):
631            f = map(lambda s: s[com_pfx_len:], files)
632            return ', '.join(f)
633        return self.format % (com_pfx, fmt(srcs), fmt(tgts))
634
635Export('Transform')
636
637# enable the regression script to use the termcap
638main['TERMCAP'] = termcap
639
640if GetOption('verbose'):
641    def MakeAction(action, string, *args, **kwargs):
642        return Action(action, *args, **kwargs)
643else:
644    MakeAction = Action
645    main['CCCOMSTR']        = Transform("CC")
646    main['CXXCOMSTR']       = Transform("CXX")
647    main['ASCOMSTR']        = Transform("AS")
648    main['SWIGCOMSTR']      = Transform("SWIG")
649    main['ARCOMSTR']        = Transform("AR", 0)
650    main['LINKCOMSTR']      = Transform("LINK", 0)
651    main['RANLIBCOMSTR']    = Transform("RANLIB", 0)
652    main['M4COMSTR']        = Transform("M4")
653    main['SHCCCOMSTR']      = Transform("SHCC")
654    main['SHCXXCOMSTR']     = Transform("SHCXX")
655Export('MakeAction')
656
657# Initialize the Link-Time Optimization (LTO) flags
658main['LTO_CCFLAGS'] = []
659main['LTO_LDFLAGS'] = []
660
661# According to the readme, tcmalloc works best if the compiler doesn't
662# assume that we're using the builtin malloc and friends. These flags
663# are compiler-specific, so we need to set them after we detect which
664# compiler we're using.
665main['TCMALLOC_CCFLAGS'] = []
666
667CXX_version = readCommand([main['CXX'],'--version'], exception=False)
668CXX_V = readCommand([main['CXX'],'-V'], exception=False)
669
670main['GCC'] = CXX_version and CXX_version.find('g++') >= 0
671main['CLANG'] = CXX_version and CXX_version.find('clang') >= 0
672if main['GCC'] + main['CLANG'] > 1:
673    print 'Error: How can we have two at the same time?'
674    Exit(1)
675
676# Set up default C++ compiler flags
677if main['GCC'] or main['CLANG']:
678    # As gcc and clang share many flags, do the common parts here
679    main.Append(CCFLAGS=['-pipe'])
680    main.Append(CCFLAGS=['-fno-strict-aliasing'])
681    # Enable -Wall and -Wextra and then disable the few warnings that
682    # we consistently violate
683    main.Append(CCFLAGS=['-Wall', '-Wundef', '-Wextra',
684                         '-Wno-sign-compare', '-Wno-unused-parameter'])
685    # We always compile using C++11
686    main.Append(CXXFLAGS=['-std=c++11'])
687    if sys.platform.startswith('freebsd'):
688        main.Append(CCFLAGS=['-I/usr/local/include'])
689        main.Append(CXXFLAGS=['-I/usr/local/include'])
690else:
691    print termcap.Yellow + termcap.Bold + 'Error' + termcap.Normal,
692    print "Don't know what compiler options to use for your compiler."
693    print termcap.Yellow + '       compiler:' + termcap.Normal, main['CXX']
694    print termcap.Yellow + '       version:' + termcap.Normal,
695    if not CXX_version:
696        print termcap.Yellow + termcap.Bold + "COMMAND NOT FOUND!" +\
697               termcap.Normal
698    else:
699        print CXX_version.replace('\n', '<nl>')
700    print "       If you're trying to use a compiler other than GCC"
701    print "       or clang, there appears to be something wrong with your"
702    print "       environment."
703    print "       "
704    print "       If you are trying to use a compiler other than those listed"
705    print "       above you will need to ease fix SConstruct and "
706    print "       src/SConscript to support that compiler."
707    Exit(1)
708
709if main['GCC']:
710    # Check for a supported version of gcc. >= 4.8 is chosen for its
711    # level of c++11 support. See
712    # http://gcc.gnu.org/projects/cxx0x.html for details.
713    gcc_version = readCommand([main['CXX'], '-dumpversion'], exception=False)
714    if compareVersions(gcc_version, "4.8") < 0:
715        print 'Error: gcc version 4.8 or newer required.'
716        print '       Installed version:', gcc_version
717        Exit(1)
718
719    main['GCC_VERSION'] = gcc_version
720
721    # gcc from version 4.8 and above generates "rep; ret" instructions
722    # to avoid performance penalties on certain AMD chips. Older
723    # assemblers detect this as an error, "Error: expecting string
724    # instruction after `rep'"
725    as_version_raw = readCommand([main['AS'], '-v', '/dev/null',
726                                  '-o', '/dev/null'],
727                                 exception=False).split()
728
729    # version strings may contain extra distro-specific
730    # qualifiers, so play it safe and keep only what comes before
731    # the first hyphen
732    as_version = as_version_raw[-1].split('-')[0] if as_version_raw else None
733
734    if not as_version or compareVersions(as_version, "2.23") < 0:
735        print termcap.Yellow + termcap.Bold + \
736            'Warning: This combination of gcc and binutils have' + \
737            ' known incompatibilities.\n' + \
738            '         If you encounter build problems, please update ' + \
739            'binutils to 2.23.' + \
740            termcap.Normal
741
742    # Make sure we warn if the user has requested to compile with the
743    # Undefined Benahvior Sanitizer and this version of gcc does not
744    # support it.
745    if GetOption('with_ubsan') and \
746            compareVersions(gcc_version, '4.9') < 0:
747        print termcap.Yellow + termcap.Bold + \
748            'Warning: UBSan is only supported using gcc 4.9 and later.' + \
749            termcap.Normal
750
751    # Add the appropriate Link-Time Optimization (LTO) flags
752    # unless LTO is explicitly turned off. Note that these flags
753    # are only used by the fast target.
754    if not GetOption('no_lto'):
755        # Pass the LTO flag when compiling to produce GIMPLE
756        # output, we merely create the flags here and only append
757        # them later
758        main['LTO_CCFLAGS'] = ['-flto=%d' % GetOption('num_jobs')]
759
760        # Use the same amount of jobs for LTO as we are running
761        # scons with
762        main['LTO_LDFLAGS'] = ['-flto=%d' % GetOption('num_jobs')]
763
764    main.Append(TCMALLOC_CCFLAGS=['-fno-builtin-malloc', '-fno-builtin-calloc',
765                                  '-fno-builtin-realloc', '-fno-builtin-free'])
766
767    # add option to check for undeclared overrides
768    if compareVersions(gcc_version, "5.0") > 0:
769        main.Append(CCFLAGS=['-Wno-error=suggest-override'])
770
771elif main['CLANG']:
772    # Check for a supported version of clang, >= 3.1 is needed to
773    # support similar features as gcc 4.8. See
774    # http://clang.llvm.org/cxx_status.html for details
775    clang_version_re = re.compile(".* version (\d+\.\d+)")
776    clang_version_match = clang_version_re.search(CXX_version)
777    if (clang_version_match):
778        clang_version = clang_version_match.groups()[0]
779        if compareVersions(clang_version, "3.1") < 0:
780            print 'Error: clang version 3.1 or newer required.'
781            print '       Installed version:', clang_version
782            Exit(1)
783    else:
784        print 'Error: Unable to determine clang version.'
785        Exit(1)
786
787    # clang has a few additional warnings that we disable, extraneous
788    # parantheses are allowed due to Ruby's printing of the AST,
789    # finally self assignments are allowed as the generated CPU code
790    # is relying on this
791    main.Append(CCFLAGS=['-Wno-parentheses',
792                         '-Wno-self-assign',
793                         # Some versions of libstdc++ (4.8?) seem to
794                         # use struct hash and class hash
795                         # interchangeably.
796                         '-Wno-mismatched-tags',
797                         ])
798
799    main.Append(TCMALLOC_CCFLAGS=['-fno-builtin'])
800
801    # On Mac OS X/Darwin we need to also use libc++ (part of XCode) as
802    # opposed to libstdc++, as the later is dated.
803    if sys.platform == "darwin":
804        main.Append(CXXFLAGS=['-stdlib=libc++'])
805        main.Append(LIBS=['c++'])
806
807    # On FreeBSD we need libthr.
808    if sys.platform.startswith('freebsd'):
809        main.Append(LIBS=['thr'])
810
811else:
812    print termcap.Yellow + termcap.Bold + 'Error' + termcap.Normal,
813    print "Don't know what compiler options to use for your compiler."
814    print termcap.Yellow + '       compiler:' + termcap.Normal, main['CXX']
815    print termcap.Yellow + '       version:' + termcap.Normal,
816    if not CXX_version:
817        print termcap.Yellow + termcap.Bold + "COMMAND NOT FOUND!" +\
818               termcap.Normal
819    else:
820        print CXX_version.replace('\n', '<nl>')
821    print "       If you're trying to use a compiler other than GCC"
822    print "       or clang, there appears to be something wrong with your"
823    print "       environment."
824    print "       "
825    print "       If you are trying to use a compiler other than those listed"
826    print "       above you will need to ease fix SConstruct and "
827    print "       src/SConscript to support that compiler."
828    Exit(1)
829
830# Set up common yacc/bison flags (needed for Ruby)
831main['YACCFLAGS'] = '-d'
832main['YACCHXXFILESUFFIX'] = '.hh'
833
834# Do this after we save setting back, or else we'll tack on an
835# extra 'qdo' every time we run scons.
836if main['BATCH']:
837    main['CC']     = main['BATCH_CMD'] + ' ' + main['CC']
838    main['CXX']    = main['BATCH_CMD'] + ' ' + main['CXX']
839    main['AS']     = main['BATCH_CMD'] + ' ' + main['AS']
840    main['AR']     = main['BATCH_CMD'] + ' ' + main['AR']
841    main['RANLIB'] = main['BATCH_CMD'] + ' ' + main['RANLIB']
842
843if sys.platform == 'cygwin':
844    # cygwin has some header file issues...
845    main.Append(CCFLAGS=["-Wno-uninitialized"])
846
847# Check for the protobuf compiler
848protoc_version = readCommand([main['PROTOC'], '--version'],
849                             exception='').split()
850
851# First two words should be "libprotoc x.y.z"
852if len(protoc_version) < 2 or protoc_version[0] != 'libprotoc':
853    print termcap.Yellow + termcap.Bold + \
854        'Warning: Protocol buffer compiler (protoc) not found.\n' + \
855        '         Please install protobuf-compiler for tracing support.' + \
856        termcap.Normal
857    main['PROTOC'] = False
858else:
859    # Based on the availability of the compress stream wrappers,
860    # require 2.1.0
861    min_protoc_version = '2.1.0'
862    if compareVersions(protoc_version[1], min_protoc_version) < 0:
863        print termcap.Yellow + termcap.Bold + \
864            'Warning: protoc version', min_protoc_version, \
865            'or newer required.\n' + \
866            '         Installed version:', protoc_version[1], \
867            termcap.Normal
868        main['PROTOC'] = False
869    else:
870        # Attempt to determine the appropriate include path and
871        # library path using pkg-config, that means we also need to
872        # check for pkg-config. Note that it is possible to use
873        # protobuf without the involvement of pkg-config. Later on we
874        # check go a library config check and at that point the test
875        # will fail if libprotobuf cannot be found.
876        if readCommand(['pkg-config', '--version'], exception=''):
877            try:
878                # Attempt to establish what linking flags to add for protobuf
879                # using pkg-config
880                main.ParseConfig('pkg-config --cflags --libs-only-L protobuf')
881            except:
882                print termcap.Yellow + termcap.Bold + \
883                    'Warning: pkg-config could not get protobuf flags.' + \
884                    termcap.Normal
885
886# Check for SWIG
887if not main.has_key('SWIG'):
888    print 'Error: SWIG utility not found.'
889    print '       Please install (see http://www.swig.org) and retry.'
890    Exit(1)
891
892# Check for appropriate SWIG version
893swig_version = readCommand([main['SWIG'], '-version'], exception='').split()
894# First 3 words should be "SWIG Version x.y.z"
895if len(swig_version) < 3 or \
896        swig_version[0] != 'SWIG' or swig_version[1] != 'Version':
897    print 'Error determining SWIG version.'
898    Exit(1)
899
900min_swig_version = '2.0.4'
901if compareVersions(swig_version[2], min_swig_version) < 0:
902    print 'Error: SWIG version', min_swig_version, 'or newer required.'
903    print '       Installed version:', swig_version[2]
904    Exit(1)
905
906# Check for known incompatibilities. The standard library shipped with
907# gcc >= 4.9 does not play well with swig versions prior to 3.0
908if main['GCC'] and compareVersions(gcc_version, '4.9') >= 0 and \
909        compareVersions(swig_version[2], '3.0') < 0:
910    print termcap.Yellow + termcap.Bold + \
911        'Warning: This combination of gcc and swig have' + \
912        ' known incompatibilities.\n' + \
913        '         If you encounter build problems, please update ' + \
914        'swig to 3.0 or later.' + \
915        termcap.Normal
916
917# Set up SWIG flags & scanner
918swig_flags=Split('-c++ -python -modern -templatereduce $_CPPINCFLAGS')
919main.Append(SWIGFLAGS=swig_flags)
920
921# Check for 'timeout' from GNU coreutils. If present, regressions will
922# be run with a time limit. We require version 8.13 since we rely on
923# support for the '--foreground' option.
924if sys.platform.startswith('freebsd'):
925    timeout_lines = readCommand(['gtimeout', '--version'],
926                                exception='').splitlines()
927else:
928    timeout_lines = readCommand(['timeout', '--version'],
929                                exception='').splitlines()
930# Get the first line and tokenize it
931timeout_version = timeout_lines[0].split() if timeout_lines else []
932main['TIMEOUT'] =  timeout_version and \
933    compareVersions(timeout_version[-1], '8.13') >= 0
934
935# filter out all existing swig scanners, they mess up the dependency
936# stuff for some reason
937scanners = []
938for scanner in main['SCANNERS']:
939    skeys = scanner.skeys
940    if skeys == '.i':
941        continue
942
943    if isinstance(skeys, (list, tuple)) and '.i' in skeys:
944        continue
945
946    scanners.append(scanner)
947
948# add the new swig scanner that we like better
949from SCons.Scanner import ClassicCPP as CPPScanner
950swig_inc_re = '^[ \t]*[%,#][ \t]*(?:include|import)[ \t]*(<|")([^>"]+)(>|")'
951scanners.append(CPPScanner("SwigScan", [ ".i" ], "CPPPATH", swig_inc_re))
952
953# replace the scanners list that has what we want
954main['SCANNERS'] = scanners
955
956# Add a custom Check function to test for structure members.
957def CheckMember(context, include, decl, member, include_quotes="<>"):
958    context.Message("Checking for member %s in %s..." %
959                    (member, decl))
960    text = """
961#include %(header)s
962int main(){
963  %(decl)s test;
964  (void)test.%(member)s;
965  return 0;
966};
967""" % { "header" : include_quotes[0] + include + include_quotes[1],
968        "decl" : decl,
969        "member" : member,
970        }
971
972    ret = context.TryCompile(text, extension=".cc")
973    context.Result(ret)
974    return ret
975
976# Platform-specific configuration.  Note again that we assume that all
977# builds under a given build root run on the same host platform.
978conf = Configure(main,
979                 conf_dir = joinpath(build_root, '.scons_config'),
980                 log_file = joinpath(build_root, 'scons_config.log'),
981                 custom_tests = {
982        'CheckMember' : CheckMember,
983        })
984
985# Check if we should compile a 64 bit binary on Mac OS X/Darwin
986try:
987    import platform
988    uname = platform.uname()
989    if uname[0] == 'Darwin' and compareVersions(uname[2], '9.0.0') >= 0:
990        if int(readCommand('sysctl -n hw.cpu64bit_capable')[0]):
991            main.Append(CCFLAGS=['-arch', 'x86_64'])
992            main.Append(CFLAGS=['-arch', 'x86_64'])
993            main.Append(LINKFLAGS=['-arch', 'x86_64'])
994            main.Append(ASFLAGS=['-arch', 'x86_64'])
995except:
996    pass
997
998# Recent versions of scons substitute a "Null" object for Configure()
999# when configuration isn't necessary, e.g., if the "--help" option is
1000# present.  Unfortuantely this Null object always returns false,
1001# breaking all our configuration checks.  We replace it with our own
1002# more optimistic null object that returns True instead.
1003if not conf:
1004    def NullCheck(*args, **kwargs):
1005        return True
1006
1007    class NullConf:
1008        def __init__(self, env):
1009            self.env = env
1010        def Finish(self):
1011            return self.env
1012        def __getattr__(self, mname):
1013            return NullCheck
1014
1015    conf = NullConf(main)
1016
1017# Cache build files in the supplied directory.
1018if main['M5_BUILD_CACHE']:
1019    print 'Using build cache located at', main['M5_BUILD_CACHE']
1020    CacheDir(main['M5_BUILD_CACHE'])
1021
1022if not GetOption('without_python'):
1023    # Find Python include and library directories for embedding the
1024    # interpreter. We rely on python-config to resolve the appropriate
1025    # includes and linker flags. ParseConfig does not seem to understand
1026    # the more exotic linker flags such as -Xlinker and -export-dynamic so
1027    # we add them explicitly below. If you want to link in an alternate
1028    # version of python, see above for instructions on how to invoke
1029    # scons with the appropriate PATH set.
1030    #
1031    # First we check if python2-config exists, else we use python-config
1032    python_config = readCommand(['which', 'python2-config'],
1033                                exception='').strip()
1034    if not os.path.exists(python_config):
1035        python_config = readCommand(['which', 'python-config'],
1036                                    exception='').strip()
1037    py_includes = readCommand([python_config, '--includes'],
1038                              exception='').split()
1039    # Strip the -I from the include folders before adding them to the
1040    # CPPPATH
1041    main.Append(CPPPATH=map(lambda inc: inc[2:], py_includes))
1042
1043    # Read the linker flags and split them into libraries and other link
1044    # flags. The libraries are added later through the call the CheckLib.
1045    py_ld_flags = readCommand([python_config, '--ldflags'],
1046        exception='').split()
1047    py_libs = []
1048    for lib in py_ld_flags:
1049         if not lib.startswith('-l'):
1050             main.Append(LINKFLAGS=[lib])
1051         else:
1052             lib = lib[2:]
1053             if lib not in py_libs:
1054                 py_libs.append(lib)
1055
1056    # verify that this stuff works
1057    if not conf.CheckHeader('Python.h', '<>'):
1058        print "Error: can't find Python.h header in", py_includes
1059        print "Install Python headers (package python-dev on Ubuntu and RedHat)"
1060        Exit(1)
1061
1062    for lib in py_libs:
1063        if not conf.CheckLib(lib):
1064            print "Error: can't find library %s required by python" % lib
1065            Exit(1)
1066
1067# On Solaris you need to use libsocket for socket ops
1068if not conf.CheckLibWithHeader(None, 'sys/socket.h', 'C++', 'accept(0,0,0);'):
1069   if not conf.CheckLibWithHeader('socket', 'sys/socket.h', 'C++', 'accept(0,0,0);'):
1070       print "Can't find library with socket calls (e.g. accept())"
1071       Exit(1)
1072
1073# Check for zlib.  If the check passes, libz will be automatically
1074# added to the LIBS environment variable.
1075if not conf.CheckLibWithHeader('z', 'zlib.h', 'C++','zlibVersion();'):
1076    print 'Error: did not find needed zlib compression library '\
1077          'and/or zlib.h header file.'
1078    print '       Please install zlib and try again.'
1079    Exit(1)
1080
1081# If we have the protobuf compiler, also make sure we have the
1082# development libraries. If the check passes, libprotobuf will be
1083# automatically added to the LIBS environment variable. After
1084# this, we can use the HAVE_PROTOBUF flag to determine if we have
1085# got both protoc and libprotobuf available.
1086main['HAVE_PROTOBUF'] = main['PROTOC'] and \
1087    conf.CheckLibWithHeader('protobuf', 'google/protobuf/message.h',
1088                            'C++', 'GOOGLE_PROTOBUF_VERIFY_VERSION;')
1089
1090# If we have the compiler but not the library, print another warning.
1091if main['PROTOC'] and not main['HAVE_PROTOBUF']:
1092    print termcap.Yellow + termcap.Bold + \
1093        'Warning: did not find protocol buffer library and/or headers.\n' + \
1094    '       Please install libprotobuf-dev for tracing support.' + \
1095    termcap.Normal
1096
1097# Check for librt.
1098have_posix_clock = \
1099    conf.CheckLibWithHeader(None, 'time.h', 'C',
1100                            'clock_nanosleep(0,0,NULL,NULL);') or \
1101    conf.CheckLibWithHeader('rt', 'time.h', 'C',
1102                            'clock_nanosleep(0,0,NULL,NULL);')
1103
1104have_posix_timers = \
1105    conf.CheckLibWithHeader([None, 'rt'], [ 'time.h', 'signal.h' ], 'C',
1106                            'timer_create(CLOCK_MONOTONIC, NULL, NULL);')
1107
1108if not GetOption('without_tcmalloc'):
1109    if conf.CheckLib('tcmalloc'):
1110        main.Append(CCFLAGS=main['TCMALLOC_CCFLAGS'])
1111    elif conf.CheckLib('tcmalloc_minimal'):
1112        main.Append(CCFLAGS=main['TCMALLOC_CCFLAGS'])
1113    else:
1114        print termcap.Yellow + termcap.Bold + \
1115              "You can get a 12% performance improvement by "\
1116              "installing tcmalloc (libgoogle-perftools-dev package "\
1117              "on Ubuntu or RedHat)." + termcap.Normal
1118
1119
1120# Detect back trace implementations. The last implementation in the
1121# list will be used by default.
1122backtrace_impls = [ "none" ]
1123
1124if conf.CheckLibWithHeader(None, 'execinfo.h', 'C',
1125                           'backtrace_symbols_fd((void*)0, 0, 0);'):
1126    backtrace_impls.append("glibc")
1127elif conf.CheckLibWithHeader('execinfo', 'execinfo.h', 'C',
1128                           'backtrace_symbols_fd((void*)0, 0, 0);'):
1129    # NetBSD and FreeBSD need libexecinfo.
1130    backtrace_impls.append("glibc")
1131    main.Append(LIBS=['execinfo'])
1132
1133if backtrace_impls[-1] == "none":
1134    default_backtrace_impl = "none"
1135    print termcap.Yellow + termcap.Bold + \
1136        "No suitable back trace implementation found." + \
1137        termcap.Normal
1138
1139if not have_posix_clock:
1140    print "Can't find library for POSIX clocks."
1141
1142# Check for <fenv.h> (C99 FP environment control)
1143have_fenv = conf.CheckHeader('fenv.h', '<>')
1144if not have_fenv:
1145    print "Warning: Header file <fenv.h> not found."
1146    print "         This host has no IEEE FP rounding mode control."
1147
1148# Check if we should enable KVM-based hardware virtualization. The API
1149# we rely on exists since version 2.6.36 of the kernel, but somehow
1150# the KVM_API_VERSION does not reflect the change. We test for one of
1151# the types as a fall back.
1152have_kvm = conf.CheckHeader('linux/kvm.h', '<>')
1153if not have_kvm:
1154    print "Info: Compatible header file <linux/kvm.h> not found, " \
1155        "disabling KVM support."
1156
1157# x86 needs support for xsave. We test for the structure here since we
1158# won't be able to run new tests by the time we know which ISA we're
1159# targeting.
1160have_kvm_xsave = conf.CheckTypeSize('struct kvm_xsave',
1161                                    '#include <linux/kvm.h>') != 0
1162
1163# Check if the requested target ISA is compatible with the host
1164def is_isa_kvm_compatible(isa):
1165    try:
1166        import platform
1167        host_isa = platform.machine()
1168    except:
1169        print "Warning: Failed to determine host ISA."
1170        return False
1171
1172    if not have_posix_timers:
1173        print "Warning: Can not enable KVM, host seems to lack support " \
1174            "for POSIX timers"
1175        return False
1176
1177    if isa == "arm":
1178        return host_isa in ( "armv7l", "aarch64" )
1179    elif isa == "x86":
1180        if host_isa != "x86_64":
1181            return False
1182
1183        if not have_kvm_xsave:
1184            print "KVM on x86 requires xsave support in kernel headers."
1185            return False
1186
1187        return True
1188    else:
1189        return False
1190
1191
1192# Check if the exclude_host attribute is available. We want this to
1193# get accurate instruction counts in KVM.
1194main['HAVE_PERF_ATTR_EXCLUDE_HOST'] = conf.CheckMember(
1195    'linux/perf_event.h', 'struct perf_event_attr', 'exclude_host')
1196
1197
1198######################################################################
1199#
1200# Finish the configuration
1201#
1202main = conf.Finish()
1203
1204######################################################################
1205#
1206# Collect all non-global variables
1207#
1208
1209# Define the universe of supported ISAs
1210all_isa_list = [ ]
1211all_gpu_isa_list = [ ]
1212Export('all_isa_list')
1213Export('all_gpu_isa_list')
1214
1215class CpuModel(object):
1216    '''The CpuModel class encapsulates everything the ISA parser needs to
1217    know about a particular CPU model.'''
1218
1219    # Dict of available CPU model objects.  Accessible as CpuModel.dict.
1220    dict = {}
1221
1222    # Constructor.  Automatically adds models to CpuModel.dict.
1223    def __init__(self, name, default=False):
1224        self.name = name           # name of model
1225
1226        # This cpu is enabled by default
1227        self.default = default
1228
1229        # Add self to dict
1230        if name in CpuModel.dict:
1231            raise AttributeError, "CpuModel '%s' already registered" % name
1232        CpuModel.dict[name] = self
1233
1234Export('CpuModel')
1235
1236# Sticky variables get saved in the variables file so they persist from
1237# one invocation to the next (unless overridden, in which case the new
1238# value becomes sticky).
1239sticky_vars = Variables(args=ARGUMENTS)
1240Export('sticky_vars')
1241
1242# Sticky variables that should be exported
1243export_vars = []
1244Export('export_vars')
1245
1246# For Ruby
1247all_protocols = []
1248Export('all_protocols')
1249protocol_dirs = []
1250Export('protocol_dirs')
1251slicc_includes = []
1252Export('slicc_includes')
1253
1254# Walk the tree and execute all SConsopts scripts that wil add to the
1255# above variables
1256if GetOption('verbose'):
1257    print "Reading SConsopts"
1258for bdir in [ base_dir ] + extras_dir_list:
1259    if not isdir(bdir):
1260        print "Error: directory '%s' does not exist" % bdir
1261        Exit(1)
1262    for root, dirs, files in os.walk(bdir):
1263        if 'SConsopts' in files:
1264            if GetOption('verbose'):
1265                print "Reading", joinpath(root, 'SConsopts')
1266            SConscript(joinpath(root, 'SConsopts'))
1267
1268all_isa_list.sort()
1269all_gpu_isa_list.sort()
1270
1271sticky_vars.AddVariables(
1272    EnumVariable('TARGET_ISA', 'Target ISA', 'alpha', all_isa_list),
1273    EnumVariable('TARGET_GPU_ISA', 'Target GPU ISA', 'hsail', all_gpu_isa_list),
1274    ListVariable('CPU_MODELS', 'CPU models',
1275                 sorted(n for n,m in CpuModel.dict.iteritems() if m.default),
1276                 sorted(CpuModel.dict.keys())),
1277    BoolVariable('EFENCE', 'Link with Electric Fence malloc debugger',
1278                 False),
1279    BoolVariable('SS_COMPATIBLE_FP',
1280                 'Make floating-point results compatible with SimpleScalar',
1281                 False),
1282    BoolVariable('USE_SSE2',
1283                 'Compile for SSE2 (-msse2) to get IEEE FP on x86 hosts',
1284                 False),
1285    BoolVariable('USE_POSIX_CLOCK', 'Use POSIX Clocks', have_posix_clock),
1286    BoolVariable('USE_FENV', 'Use <fenv.h> IEEE mode control', have_fenv),
1287    BoolVariable('CP_ANNOTATE', 'Enable critical path annotation capability', False),
1288    BoolVariable('USE_KVM', 'Enable hardware virtualized (KVM) CPU models', have_kvm),
1289    BoolVariable('BUILD_GPU', 'Build the compute-GPU model', False),
1290    EnumVariable('PROTOCOL', 'Coherence protocol for Ruby', 'None',
1291                  all_protocols),
1292    EnumVariable('BACKTRACE_IMPL', 'Post-mortem dump implementation',
1293                 backtrace_impls[-1], backtrace_impls)
1294    )
1295
1296# These variables get exported to #defines in config/*.hh (see src/SConscript).
1297export_vars += ['USE_FENV', 'SS_COMPATIBLE_FP', 'TARGET_ISA', 'TARGET_GPU_ISA',
1298                'CP_ANNOTATE', 'USE_POSIX_CLOCK', 'USE_KVM', 'PROTOCOL',
1299                'HAVE_PROTOBUF', 'HAVE_PERF_ATTR_EXCLUDE_HOST']
1300
1301###################################################
1302#
1303# Define a SCons builder for configuration flag headers.
1304#
1305###################################################
1306
1307# This function generates a config header file that #defines the
1308# variable symbol to the current variable setting (0 or 1).  The source
1309# operands are the name of the variable and a Value node containing the
1310# value of the variable.
1311def build_config_file(target, source, env):
1312    (variable, value) = [s.get_contents() for s in source]
1313    f = file(str(target[0]), 'w')
1314    print >> f, '#define', variable, value
1315    f.close()
1316    return None
1317
1318# Combine the two functions into a scons Action object.
1319config_action = MakeAction(build_config_file, Transform("CONFIG H", 2))
1320
1321# The emitter munges the source & target node lists to reflect what
1322# we're really doing.
1323def config_emitter(target, source, env):
1324    # extract variable name from Builder arg
1325    variable = str(target[0])
1326    # True target is config header file
1327    target = joinpath('config', variable.lower() + '.hh')
1328    val = env[variable]
1329    if isinstance(val, bool):
1330        # Force value to 0/1
1331        val = int(val)
1332    elif isinstance(val, str):
1333        val = '"' + val + '"'
1334
1335    # Sources are variable name & value (packaged in SCons Value nodes)
1336    return ([target], [Value(variable), Value(val)])
1337
1338config_builder = Builder(emitter = config_emitter, action = config_action)
1339
1340main.Append(BUILDERS = { 'ConfigFile' : config_builder })
1341
1342# libelf build is shared across all configs in the build root.
1343main.SConscript('ext/libelf/SConscript',
1344                variant_dir = joinpath(build_root, 'libelf'))
1345
1346# iostream3 build is shared across all configs in the build root.
1347main.SConscript('ext/iostream3/SConscript',
1348                variant_dir = joinpath(build_root, 'iostream3'))
1349
1350# libfdt build is shared across all configs in the build root.
1351main.SConscript('ext/libfdt/SConscript',
1352                variant_dir = joinpath(build_root, 'libfdt'))
1353
1354# fputils build is shared across all configs in the build root.
1355main.SConscript('ext/fputils/SConscript',
1356                variant_dir = joinpath(build_root, 'fputils'))
1357
1358# DRAMSim2 build is shared across all configs in the build root.
1359main.SConscript('ext/dramsim2/SConscript',
1360                variant_dir = joinpath(build_root, 'dramsim2'))
1361
1362# DRAMPower build is shared across all configs in the build root.
1363main.SConscript('ext/drampower/SConscript',
1364                variant_dir = joinpath(build_root, 'drampower'))
1365
1366# nomali build is shared across all configs in the build root.
1367main.SConscript('ext/nomali/SConscript',
1368                variant_dir = joinpath(build_root, 'nomali'))
1369
1370###################################################
1371#
1372# This function is used to set up a directory with switching headers
1373#
1374###################################################
1375
1376main['ALL_ISA_LIST'] = all_isa_list
1377main['ALL_GPU_ISA_LIST'] = all_gpu_isa_list
1378all_isa_deps = {}
1379def make_switching_dir(dname, switch_headers, env):
1380    # Generate the header.  target[0] is the full path of the output
1381    # header to generate.  'source' is a dummy variable, since we get the
1382    # list of ISAs from env['ALL_ISA_LIST'].
1383    def gen_switch_hdr(target, source, env):
1384        fname = str(target[0])
1385        isa = env['TARGET_ISA'].lower()
1386        try:
1387            f = open(fname, 'w')
1388            print >>f, '#include "%s/%s/%s"' % (dname, isa, basename(fname))
1389            f.close()
1390        except IOError:
1391            print "Failed to create %s" % fname
1392            raise
1393
1394    # Build SCons Action object. 'varlist' specifies env vars that this
1395    # action depends on; when env['ALL_ISA_LIST'] changes these actions
1396    # should get re-executed.
1397    switch_hdr_action = MakeAction(gen_switch_hdr,
1398                          Transform("GENERATE"), varlist=['ALL_ISA_LIST'])
1399
1400    # Instantiate actions for each header
1401    for hdr in switch_headers:
1402        env.Command(hdr, [], switch_hdr_action)
1403
1404    isa_target = Dir('.').up().name.lower().replace('_', '-')
1405    env['PHONY_BASE'] = '#'+isa_target
1406    all_isa_deps[isa_target] = None
1407
1408Export('make_switching_dir')
1409
1410def make_gpu_switching_dir(dname, switch_headers, env):
1411    # Generate the header.  target[0] is the full path of the output
1412    # header to generate.  'source' is a dummy variable, since we get the
1413    # list of ISAs from env['ALL_ISA_LIST'].
1414    def gen_switch_hdr(target, source, env):
1415        fname = str(target[0])
1416
1417        isa = env['TARGET_GPU_ISA'].lower()
1418
1419        try:
1420            f = open(fname, 'w')
1421            print >>f, '#include "%s/%s/%s"' % (dname, isa, basename(fname))
1422            f.close()
1423        except IOError:
1424            print "Failed to create %s" % fname
1425            raise
1426
1427    # Build SCons Action object. 'varlist' specifies env vars that this
1428    # action depends on; when env['ALL_ISA_LIST'] changes these actions
1429    # should get re-executed.
1430    switch_hdr_action = MakeAction(gen_switch_hdr,
1431                          Transform("GENERATE"), varlist=['ALL_ISA_GPU_LIST'])
1432
1433    # Instantiate actions for each header
1434    for hdr in switch_headers:
1435        env.Command(hdr, [], switch_hdr_action)
1436
1437Export('make_gpu_switching_dir')
1438
1439# all-isas -> all-deps -> all-environs -> all_targets
1440main.Alias('#all-isas', [])
1441main.Alias('#all-deps', '#all-isas')
1442
1443# Dummy target to ensure all environments are created before telling
1444# SCons what to actually make (the command line arguments).  We attach
1445# them to the dependence graph after the environments are complete.
1446ORIG_BUILD_TARGETS = list(BUILD_TARGETS) # force a copy; gets closure to work.
1447def environsComplete(target, source, env):
1448    for t in ORIG_BUILD_TARGETS:
1449        main.Depends('#all-targets', t)
1450
1451# Each build/* switching_dir attaches its *-environs target to #all-environs.
1452main.Append(BUILDERS = {'CompleteEnvirons' :
1453                        Builder(action=MakeAction(environsComplete, None))})
1454main.CompleteEnvirons('#all-environs', [])
1455
1456def doNothing(**ignored): pass
1457main.Append(BUILDERS = {'Dummy': Builder(action=MakeAction(doNothing, None))})
1458
1459# The final target to which all the original targets ultimately get attached.
1460main.Dummy('#all-targets', '#all-environs')
1461BUILD_TARGETS[:] = ['#all-targets']
1462
1463###################################################
1464#
1465# Define build environments for selected configurations.
1466#
1467###################################################
1468
1469for variant_path in variant_paths:
1470    if not GetOption('silent'):
1471        print "Building in", variant_path
1472
1473    # Make a copy of the build-root environment to use for this config.
1474    env = main.Clone()
1475    env['BUILDDIR'] = variant_path
1476
1477    # variant_dir is the tail component of build path, and is used to
1478    # determine the build parameters (e.g., 'ALPHA_SE')
1479    (build_root, variant_dir) = splitpath(variant_path)
1480
1481    # Set env variables according to the build directory config.
1482    sticky_vars.files = []
1483    # Variables for $BUILD_ROOT/$VARIANT_DIR are stored in
1484    # $BUILD_ROOT/variables/$VARIANT_DIR so you can nuke
1485    # $BUILD_ROOT/$VARIANT_DIR without losing your variables settings.
1486    current_vars_file = joinpath(build_root, 'variables', variant_dir)
1487    if isfile(current_vars_file):
1488        sticky_vars.files.append(current_vars_file)
1489        if not GetOption('silent'):
1490            print "Using saved variables file %s" % current_vars_file
1491    else:
1492        # Build dir-specific variables file doesn't exist.
1493
1494        # Make sure the directory is there so we can create it later
1495        opt_dir = dirname(current_vars_file)
1496        if not isdir(opt_dir):
1497            mkdir(opt_dir)
1498
1499        # Get default build variables from source tree.  Variables are
1500        # normally determined by name of $VARIANT_DIR, but can be
1501        # overridden by '--default=' arg on command line.
1502        default = GetOption('default')
1503        opts_dir = joinpath(main.root.abspath, 'build_opts')
1504        if default:
1505            default_vars_files = [joinpath(build_root, 'variables', default),
1506                                  joinpath(opts_dir, default)]
1507        else:
1508            default_vars_files = [joinpath(opts_dir, variant_dir)]
1509        existing_files = filter(isfile, default_vars_files)
1510        if existing_files:
1511            default_vars_file = existing_files[0]
1512            sticky_vars.files.append(default_vars_file)
1513            print "Variables file %s not found,\n  using defaults in %s" \
1514                  % (current_vars_file, default_vars_file)
1515        else:
1516            print "Error: cannot find variables file %s or " \
1517                  "default file(s) %s" \
1518                  % (current_vars_file, ' or '.join(default_vars_files))
1519            Exit(1)
1520
1521    # Apply current variable settings to env
1522    sticky_vars.Update(env)
1523
1524    help_texts["local_vars"] += \
1525        "Build variables for %s:\n" % variant_dir \
1526                 + sticky_vars.GenerateHelpText(env)
1527
1528    # Process variable settings.
1529
1530    if not have_fenv and env['USE_FENV']:
1531        print "Warning: <fenv.h> not available; " \
1532              "forcing USE_FENV to False in", variant_dir + "."
1533        env['USE_FENV'] = False
1534
1535    if not env['USE_FENV']:
1536        print "Warning: No IEEE FP rounding mode control in", variant_dir + "."
1537        print "         FP results may deviate slightly from other platforms."
1538
1539    if env['EFENCE']:
1540        env.Append(LIBS=['efence'])
1541
1542    if env['USE_KVM']:
1543        if not have_kvm:
1544            print "Warning: Can not enable KVM, host seems to lack KVM support"
1545            env['USE_KVM'] = False
1546        elif not is_isa_kvm_compatible(env['TARGET_ISA']):
1547            print "Info: KVM support disabled due to unsupported host and " \
1548                "target ISA combination"
1549            env['USE_KVM'] = False
1550
1551    if env['BUILD_GPU']:
1552        env.Append(CPPDEFINES=['BUILD_GPU'])
1553
1554    # Warn about missing optional functionality
1555    if env['USE_KVM']:
1556        if not main['HAVE_PERF_ATTR_EXCLUDE_HOST']:
1557            print "Warning: perf_event headers lack support for the " \
1558                "exclude_host attribute. KVM instruction counts will " \
1559                "be inaccurate."
1560
1561    # Save sticky variable settings back to current variables file
1562    sticky_vars.Save(current_vars_file, env)
1563
1564    if env['USE_SSE2']:
1565        env.Append(CCFLAGS=['-msse2'])
1566
1567    # The src/SConscript file sets up the build rules in 'env' according
1568    # to the configured variables.  It returns a list of environments,
1569    # one for each variant build (debug, opt, etc.)
1570    SConscript('src/SConscript', variant_dir = variant_path, exports = 'env')
1571
1572def pairwise(iterable):
1573    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
1574    a, b = itertools.tee(iterable)
1575    b.next()
1576    return itertools.izip(a, b)
1577
1578# Create false dependencies so SCons will parse ISAs, establish
1579# dependencies, and setup the build Environments serially. Either
1580# SCons (likely) and/or our SConscripts (possibly) cannot cope with -j
1581# greater than 1. It appears to be standard race condition stuff; it
1582# doesn't always fail, but usually, and the behaviors are different.
1583# Every time I tried to remove this, builds would fail in some
1584# creative new way. So, don't do that. You'll want to, though, because
1585# tests/SConscript takes a long time to make its Environments.
1586for t1, t2 in pairwise(sorted(all_isa_deps.iterkeys())):
1587    main.Depends('#%s-deps'     % t2, '#%s-deps'     % t1)
1588    main.Depends('#%s-environs' % t2, '#%s-environs' % t1)
1589
1590# base help text
1591Help('''
1592Usage: scons [scons options] [build variables] [target(s)]
1593
1594Extra scons options:
1595%(options)s
1596
1597Global build variables:
1598%(global_vars)s
1599
1600%(local_vars)s
1601''' % help_texts)
1602