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