SConstruct

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