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