SConstruct

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