SConstruct

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