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