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