SConstruct

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