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