SConstruct

   1 # -*- mode:python -*-
   2
   3 # Copyright (c) 2013, 2015 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 # Check for recent-enough Python and SCons versions.
  82 try:
  83     # Really old versions of scons only take two options for the
  84     # function, so check once without the revision and once with the
  85     # revision, the first instance will fail for stuff other than
  86     # 0.98, and the second will fail for 0.98.0
  87     EnsureSConsVersion(0, 98)
  88     EnsureSConsVersion(0, 98, 1)
  89 except SystemExit, e:
  90     print """
  91 For more details, see:
  92     http://gem5.org/Dependencies
  93 """
  94     raise
  95
  96 # We ensure the python version early because because python-config
  97 # requires python 2.5
  98 try:
  99     EnsurePythonVersion(2, 5)
 100 except SystemExit, e:
 101     print """
 102 You can use a non-default installation of the Python interpreter by
 103 rearranging your PATH so that scons finds the non-default 'python' and
 104 'python-config' first.
 105
 106 For more details, see:
 107     http://gem5.org/wiki/index.php/Using_a_non-default_Python_installation
 108 """
 109     raise
 110
 111 # Global Python includes
 112 import itertools
 113 import os
 114 import re
 115 import subprocess
 116 import sys
 117
 118 from os import mkdir, environ
 119 from os.path import abspath, basename, dirname, expanduser, normpath
 120 from os.path import exists,  isdir, isfile
 121 from os.path import join as joinpath, split as splitpath
 122
 123 # SCons includes
 124 import SCons
 125 import SCons.Node
 126
 127 extra_python_paths = [
 128     Dir('src/python').srcnode().abspath, # gem5 includes
 129     Dir('ext/ply').srcnode().abspath, # ply is used by several files
 130     ]
 131
 132 sys.path[1:1] = extra_python_paths
 133
 134 from m5.util import compareVersions, readCommand
 135 from m5.util.terminal import get_termcap
 136
 137 help_texts = {
 138     "options" : "",
 139     "global_vars" : "",
 140     "local_vars" : ""
 141 }
 142
 143 Export("help_texts")
 144
 145
 146 # There's a bug in scons in that (1) by default, the help texts from
 147 # AddOption() are supposed to be displayed when you type 'scons -h'
 148 # and (2) you can override the help displayed by 'scons -h' using the
 149 # Help() function, but these two features are incompatible: once
 150 # you've overridden the help text using Help(), there's no way to get
 151 # at the help texts from AddOptions.  See:
 152 #     http://scons.tigris.org/issues/show_bug.cgi?id=2356
 153 #     http://scons.tigris.org/issues/show_bug.cgi?id=2611
 154 # This hack lets us extract the help text from AddOptions and
 155 # re-inject it via Help().  Ideally someday this bug will be fixed and
 156 # we can just use AddOption directly.
 157 def AddLocalOption(*args, **kwargs):
 158     col_width = 30
 159
 160     help = "  " + ", ".join(args)
 161     if "help" in kwargs:
 162         length = len(help)
 163         if length >= col_width:
 164             help += "\n" + " " * col_width
 165         else:
 166             help += " " * (col_width - length)
 167         help += kwargs["help"]
 168     help_texts["options"] += help + "\n"
 169
 170     AddOption(*args, **kwargs)
 171
 172 AddLocalOption('--colors', dest='use_colors', action='store_true',
 173                help="Add color to abbreviated scons output")
 174 AddLocalOption('--no-colors', dest='use_colors', action='store_false',
 175                help="Don't add color to abbreviated scons output")
 176 AddLocalOption('--with-cxx-config', dest='with_cxx_config',
 177                action='store_true',
 178                help="Build with support for C++-based configuration")
 179 AddLocalOption('--default', dest='default', type='string', action='store',
 180                help='Override which build_opts file to use for defaults')
 181 AddLocalOption('--ignore-style', dest='ignore_style', action='store_true',
 182                help='Disable style checking hooks')
 183 AddLocalOption('--no-lto', dest='no_lto', action='store_true',
 184                help='Disable Link-Time Optimization for fast')
 185 AddLocalOption('--update-ref', dest='update_ref', action='store_true',
 186                help='Update test reference outputs')
 187 AddLocalOption('--verbose', dest='verbose', action='store_true',
 188                help='Print full tool command lines')
 189 AddLocalOption('--without-python', dest='without_python',
 190                action='store_true',
 191                help='Build without Python configuration support')
 192 AddLocalOption('--without-tcmalloc', dest='without_tcmalloc',
 193                action='store_true',
 194                help='Disable linking against tcmalloc')
 195 AddLocalOption('--with-ubsan', dest='with_ubsan', action='store_true',
 196                help='Build with Undefined Behavior Sanitizer if available')
 197
 198 termcap = get_termcap(GetOption('use_colors'))
 199
 200 ########################################################################
 201 #
 202 # Set up the main build environment.
 203 #
 204 ########################################################################
 205
 206 # export TERM so that clang reports errors in color
 207 use_vars = set([ 'AS', 'AR', 'CC', 'CXX', 'HOME', 'LD_LIBRARY_PATH',
 208                  'LIBRARY_PATH', 'PATH', 'PKG_CONFIG_PATH', 'PROTOC',
 209                  'PYTHONPATH', 'RANLIB', 'SWIG', 'TERM' ])
 210
 211 use_prefixes = [
 212     "M5",           # M5 configuration (e.g., path to kernels)
 213     "DISTCC_",      # distcc (distributed compiler wrapper) configuration
 214     "CCACHE_",      # ccache (caching compiler wrapper) configuration
 215     "CCC_",         # clang static analyzer configuration
 216     ]
 217
 218 use_env = {}
 219 for key,val in sorted(os.environ.iteritems()):
 220     if key in use_vars or \
 221             any([key.startswith(prefix) for prefix in use_prefixes]):
 222         use_env[key] = val
 223
 224 # Tell scons to avoid implicit command dependencies to avoid issues
 225 # with the param wrappes being compiled twice (see
 226 # http://scons.tigris.org/issues/show_bug.cgi?id=2811)
 227 main = Environment(ENV=use_env, IMPLICIT_COMMAND_DEPENDENCIES=0)
 228 main.Decider('MD5-timestamp')
 229 main.root = Dir(".")         # The current directory (where this file lives).
 230 main.srcdir = Dir("src")     # The source directory
 231
 232 main_dict_keys = main.Dictionary().keys()
 233
 234 # Check that we have a C/C++ compiler
 235 if not ('CC' in main_dict_keys and 'CXX' in main_dict_keys):
 236     print "No C++ compiler installed (package g++ on Ubuntu and RedHat)"
 237     Exit(1)
 238
 239 # Check that swig is present
 240 if not 'SWIG' in main_dict_keys:
 241     print "swig is not installed (package swig on Ubuntu and RedHat)"
 242     Exit(1)
 243
 244 # add useful python code PYTHONPATH so it can be used by subprocesses
 245 # as well
 246 main.AppendENVPath('PYTHONPATH', extra_python_paths)
 247
 248 ########################################################################
 249 #
 250 # Mercurial Stuff.
 251 #
 252 # If the gem5 directory is a mercurial repository, we should do some
 253 # extra things.
 254 #
 255 ########################################################################
 256
 257 hgdir = main.root.Dir(".hg")
 258
 259 mercurial_style_message = """
 260 You're missing the gem5 style hook, which automatically checks your code
 261 against the gem5 style rules on hg commit and qrefresh commands.  This
 262 script will now install the hook in your .hg/hgrc file.
 263 Press enter to continue, or ctrl-c to abort: """
 264
 265 mercurial_style_hook = """
 266 # The following lines were automatically added by gem5/SConstruct
 267 # to provide the gem5 style-checking hooks
 268 [extensions]
 269 style = %s/util/style.py
 270
 271 [hooks]
 272 pretxncommit.style = python:style.check_style
 273 pre-qrefresh.style = python:style.check_style
 274 # End of SConstruct additions
 275
 276 """ % (main.root.abspath)
 277
 278 mercurial_lib_not_found = """
 279 Mercurial libraries cannot be found, ignoring style hook.  If
 280 you are a gem5 developer, please fix this and run the style
 281 hook. It is important.
 282 """
 283
 284 # Check for style hook and prompt for installation if it's not there.
 285 # Skip this if --ignore-style was specified, there's no .hg dir to
 286 # install a hook in, or there's no interactive terminal to prompt.
 287 if not GetOption('ignore_style') and hgdir.exists() and sys.stdin.isatty():
 288     style_hook = True
 289     try:
 290         from mercurial import ui
 291         ui = ui.ui()
 292         ui.readconfig(hgdir.File('hgrc').abspath)
 293         style_hook = ui.config('hooks', 'pretxncommit.style', None) and \
 294                      ui.config('hooks', 'pre-qrefresh.style', None)
 295     except ImportError:
 296         print mercurial_lib_not_found
 297
 298     if not style_hook:
 299         print mercurial_style_message,
 300         # continue unless user does ctrl-c/ctrl-d etc.
 301         try:
 302             raw_input()
 303         except:
 304             print "Input exception, exiting scons.\n"
 305             sys.exit(1)
 306         hgrc_path = '%s/.hg/hgrc' % main.root.abspath
 307         print "Adding style hook to", hgrc_path, "\n"
 308         try:
 309             hgrc = open(hgrc_path, 'a')
 310             hgrc.write(mercurial_style_hook)
 311             hgrc.close()
 312         except:
 313             print "Error updating", hgrc_path
 314             sys.exit(1)
 315
 316
 317 ###################################################
 318 #
 319 # Figure out which configurations to set up based on the path(s) of
 320 # the target(s).
 321 #
 322 ###################################################
 323
 324 # Find default configuration & binary.
 325 Default(environ.get('M5_DEFAULT_BINARY', 'build/ALPHA/gem5.debug'))
 326
 327 # helper function: find last occurrence of element in list
 328 def rfind(l, elt, offs = -1):
 329     for i in range(len(l)+offs, 0, -1):
 330         if l[i] == elt:
 331             return i
 332     raise ValueError, "element not found"
 333
 334 # Take a list of paths (or SCons Nodes) and return a list with all
 335 # paths made absolute and ~-expanded.  Paths will be interpreted
 336 # relative to the launch directory unless a different root is provided
 337 def makePathListAbsolute(path_list, root=GetLaunchDir()):
 338     return [abspath(joinpath(root, expanduser(str(p))))
 339             for p in path_list]
 340
 341 # Each target must have 'build' in the interior of the path; the
 342 # directory below this will determine the build parameters.  For
 343 # example, for target 'foo/bar/build/ALPHA_SE/arch/alpha/blah.do' we
 344 # recognize that ALPHA_SE specifies the configuration because it
 345 # follow 'build' in the build path.
 346
 347 # The funky assignment to "[:]" is needed to replace the list contents
 348 # in place rather than reassign the symbol to a new list, which
 349 # doesn't work (obviously!).
 350 BUILD_TARGETS[:] = makePathListAbsolute(BUILD_TARGETS)
 351
 352 # Generate a list of the unique build roots and configs that the
 353 # collected targets reference.
 354 variant_paths = []
 355 build_root = None
 356 for t in BUILD_TARGETS:
 357     path_dirs = t.split('/')
 358     try:
 359         build_top = rfind(path_dirs, 'build', -2)
 360     except:
 361         print "Error: no non-leaf 'build' dir found on target path", t
 362         Exit(1)
 363     this_build_root = joinpath('/',*path_dirs[:build_top+1])
 364     if not build_root:
 365         build_root = this_build_root
 366     else:
 367         if this_build_root != build_root:
 368             print "Error: build targets not under same build root\n"\
 369                   "  %s\n  %s" % (build_root, this_build_root)
 370             Exit(1)
 371     variant_path = joinpath('/',*path_dirs[:build_top+2])
 372     if variant_path not in variant_paths:
 373         variant_paths.append(variant_path)
 374
 375 # Make sure build_root exists (might not if this is the first build there)
 376 if not isdir(build_root):
 377     mkdir(build_root)
 378 main['BUILDROOT'] = build_root
 379
 380 Export('main')
 381
 382 main.SConsignFile(joinpath(build_root, "sconsign"))
 383
 384 # Default duplicate option is to use hard links, but this messes up
 385 # when you use emacs to edit a file in the target dir, as emacs moves
 386 # file to file~ then copies to file, breaking the link.  Symbolic
 387 # (soft) links work better.
 388 main.SetOption('duplicate', 'soft-copy')
 389
 390 #
 391 # Set up global sticky variables... these are common to an entire build
 392 # tree (not specific to a particular build like ALPHA_SE)
 393 #
 394
 395 global_vars_file = joinpath(build_root, 'variables.global')
 396
 397 global_vars = Variables(global_vars_file, args=ARGUMENTS)
 398
 399 global_vars.AddVariables(
 400     ('CC', 'C compiler', environ.get('CC', main['CC'])),
 401     ('CXX', 'C++ compiler', environ.get('CXX', main['CXX'])),
 402     ('SWIG', 'SWIG tool', environ.get('SWIG', main['SWIG'])),
 403     ('PROTOC', 'protoc tool', environ.get('PROTOC', 'protoc')),
 404     ('BATCH', 'Use batch pool for build and tests', False),
 405     ('BATCH_CMD', 'Batch pool submission command name', 'qdo'),
 406     ('M5_BUILD_CACHE', 'Cache built objects in this directory', False),
 407     ('EXTRAS', 'Add extra directories to the compilation', '')
 408     )
 409
 410 # Update main environment with values from ARGUMENTS & global_vars_file
 411 global_vars.Update(main)
 412 help_texts["global_vars"] += global_vars.GenerateHelpText(main)
 413
 414 # Save sticky variable settings back to current variables file
 415 global_vars.Save(global_vars_file, main)
 416
 417 # Parse EXTRAS variable to build list of all directories where we're
 418 # look for sources etc.  This list is exported as extras_dir_list.
 419 base_dir = main.srcdir.abspath
 420 if main['EXTRAS']:
 421     extras_dir_list = makePathListAbsolute(main['EXTRAS'].split(':'))
 422 else:
 423     extras_dir_list = []
 424
 425 Export('base_dir')
 426 Export('extras_dir_list')
 427
 428 # the ext directory should be on the #includes path
 429 main.Append(CPPPATH=[Dir('ext')])
 430
 431 def strip_build_path(path, env):
 432     path = str(path)
 433     variant_base = env['BUILDROOT'] + os.path.sep
 434     if path.startswith(variant_base):
 435         path = path[len(variant_base):]
 436     elif path.startswith('build/'):
 437         path = path[6:]
 438     return path
 439
 440 # Generate a string of the form:
 441 #   common/path/prefix/src1, src2 -> tgt1, tgt2
 442 # to print while building.
 443 class Transform(object):
 444     # all specific color settings should be here and nowhere else
 445     tool_color = termcap.Normal
 446     pfx_color = termcap.Yellow
 447     srcs_color = termcap.Yellow + termcap.Bold
 448     arrow_color = termcap.Blue + termcap.Bold
 449     tgts_color = termcap.Yellow + termcap.Bold
 450
 451     def __init__(self, tool, max_sources=99):
 452         self.format = self.tool_color + (" [%8s] " % tool) \
 453                       + self.pfx_color + "%s" \
 454                       + self.srcs_color + "%s" \
 455                       + self.arrow_color + " -> " \
 456                       + self.tgts_color + "%s" \
 457                       + termcap.Normal
 458         self.max_sources = max_sources
 459
 460     def __call__(self, target, source, env, for_signature=None):
 461         # truncate source list according to max_sources param
 462         source = source[0:self.max_sources]
 463         def strip(f):
 464             return strip_build_path(str(f), env)
 465         if len(source) > 0:
 466             srcs = map(strip, source)
 467         else:
 468             srcs = ['']
 469         tgts = map(strip, target)
 470         # surprisingly, os.path.commonprefix is a dumb char-by-char string
 471         # operation that has nothing to do with paths.
 472         com_pfx = os.path.commonprefix(srcs + tgts)
 473         com_pfx_len = len(com_pfx)
 474         if com_pfx:
 475             # do some cleanup and sanity checking on common prefix
 476             if com_pfx[-1] == ".":
 477                 # prefix matches all but file extension: ok
 478                 # back up one to change 'foo.cc -> o' to 'foo.cc -> .o'
 479                 com_pfx = com_pfx[0:-1]
 480             elif com_pfx[-1] == "/":
 481                 # common prefix is directory path: OK
 482                 pass
 483             else:
 484                 src0_len = len(srcs[0])
 485                 tgt0_len = len(tgts[0])
 486                 if src0_len == com_pfx_len:
 487                     # source is a substring of target, OK
 488                     pass
 489                 elif tgt0_len == com_pfx_len:
 490                     # target is a substring of source, need to back up to
 491                     # avoid empty string on RHS of arrow
 492                     sep_idx = com_pfx.rfind(".")
 493                     if sep_idx != -1:
 494                         com_pfx = com_pfx[0:sep_idx]
 495                     else:
 496                         com_pfx = ''
 497                 elif src0_len > com_pfx_len and srcs[0][com_pfx_len] == ".":
 498                     # still splitting at file extension: ok
 499                     pass
 500                 else:
 501                     # probably a fluke; ignore it
 502                     com_pfx = ''
 503         # recalculate length in case com_pfx was modified
 504         com_pfx_len = len(com_pfx)
 505         def fmt(files):
 506             f = map(lambda s: s[com_pfx_len:], files)
 507             return ', '.join(f)
 508         return self.format % (com_pfx, fmt(srcs), fmt(tgts))
 509
 510 Export('Transform')
 511
 512 # enable the regression script to use the termcap
 513 main['TERMCAP'] = termcap
 514
 515 if GetOption('verbose'):
 516     def MakeAction(action, string, *args, **kwargs):
 517         return Action(action, *args, **kwargs)
 518 else:
 519     MakeAction = Action
 520     main['CCCOMSTR']        = Transform("CC")
 521     main['CXXCOMSTR']       = Transform("CXX")
 522     main['ASCOMSTR']        = Transform("AS")
 523     main['SWIGCOMSTR']      = Transform("SWIG")
 524     main['ARCOMSTR']        = Transform("AR", 0)
 525     main['LINKCOMSTR']      = Transform("LINK", 0)
 526     main['RANLIBCOMSTR']    = Transform("RANLIB", 0)
 527     main['M4COMSTR']        = Transform("M4")
 528     main['SHCCCOMSTR']      = Transform("SHCC")
 529     main['SHCXXCOMSTR']     = Transform("SHCXX")
 530 Export('MakeAction')
 531
 532 # Initialize the Link-Time Optimization (LTO) flags
 533 main['LTO_CCFLAGS'] = []
 534 main['LTO_LDFLAGS'] = []
 535
 536 # According to the readme, tcmalloc works best if the compiler doesn't
 537 # assume that we're using the builtin malloc and friends. These flags
 538 # are compiler-specific, so we need to set them after we detect which
 539 # compiler we're using.
 540 main['TCMALLOC_CCFLAGS'] = []
 541
 542 CXX_version = readCommand([main['CXX'],'--version'], exception=False)
 543 CXX_V = readCommand([main['CXX'],'-V'], exception=False)
 544
 545 main['GCC'] = CXX_version and CXX_version.find('g++') >= 0
 546 main['CLANG'] = CXX_version and CXX_version.find('clang') >= 0
 547 if main['GCC'] + main['CLANG'] > 1:
 548     print 'Error: How can we have two at the same time?'
 549     Exit(1)
 550
 551 # Set up default C++ compiler flags
 552 if main['GCC'] or main['CLANG']:
 553     # As gcc and clang share many flags, do the common parts here
 554     main.Append(CCFLAGS=['-pipe'])
 555     main.Append(CCFLAGS=['-fno-strict-aliasing'])
 556     # Enable -Wall and then disable the few warnings that we
 557     # consistently violate
 558     main.Append(CCFLAGS=['-Wall', '-Wno-sign-compare', '-Wundef'])
 559     # We always compile using C++11
 560     main.Append(CXXFLAGS=['-std=c++11'])
 561     # Add selected sanity checks from -Wextra
 562     main.Append(CXXFLAGS=['-Wmissing-field-initializers',
 563                           '-Woverloaded-virtual'])
 564 else:
 565     print termcap.Yellow + termcap.Bold + 'Error' + termcap.Normal,
 566     print "Don't know what compiler options to use for your compiler."
 567     print termcap.Yellow + '       compiler:' + termcap.Normal, main['CXX']
 568     print termcap.Yellow + '       version:' + termcap.Normal,
 569     if not CXX_version:
 570         print termcap.Yellow + termcap.Bold + "COMMAND NOT FOUND!" +\
 571                termcap.Normal
 572     else:
 573         print CXX_version.replace('\n', '<nl>')
 574     print "       If you're trying to use a compiler other than GCC"
 575     print "       or clang, there appears to be something wrong with your"
 576     print "       environment."
 577     print "       "
 578     print "       If you are trying to use a compiler other than those listed"
 579     print "       above you will need to ease fix SConstruct and "
 580     print "       src/SConscript to support that compiler."
 581     Exit(1)
 582
 583 if main['GCC']:
 584     # Check for a supported version of gcc. >= 4.7 is chosen for its
 585     # level of c++11 support. See
 586     # http://gcc.gnu.org/projects/cxx0x.html for details.
 587     gcc_version = readCommand([main['CXX'], '-dumpversion'], exception=False)
 588     if compareVersions(gcc_version, "4.7") < 0:
 589         print 'Error: gcc version 4.7 or newer required.'
 590         print '       Installed version:', gcc_version
 591         Exit(1)
 592
 593     main['GCC_VERSION'] = gcc_version
 594
 595     # gcc from version 4.8 and above generates "rep; ret" instructions
 596     # to avoid performance penalties on certain AMD chips. Older
 597     # assemblers detect this as an error, "Error: expecting string
 598     # instruction after `rep'"
 599     if compareVersions(gcc_version, "4.8") > 0:
 600         as_version_raw = readCommand([main['AS'], '-v', '/dev/null'],
 601                                      exception=False).split()
 602
 603         # version strings may contain extra distro-specific
 604         # qualifiers, so play it safe and keep only what comes before
 605         # the first hyphen
 606         as_version = as_version_raw[-1].split('-')[0] if as_version_raw \
 607             else None
 608
 609         if not as_version or compareVersions(as_version, "2.23") < 0:
 610             print termcap.Yellow + termcap.Bold + \
 611                 'Warning: This combination of gcc and binutils have' + \
 612                 ' known incompatibilities.\n' + \
 613                 '         If you encounter build problems, please update ' + \
 614                 'binutils to 2.23.' + \
 615                 termcap.Normal
 616
 617     # Make sure we warn if the user has requested to compile with the
 618     # Undefined Benahvior Sanitizer and this version of gcc does not
 619     # support it.
 620     if GetOption('with_ubsan') and \
 621             compareVersions(gcc_version, '4.9') < 0:
 622         print termcap.Yellow + termcap.Bold + \
 623             'Warning: UBSan is only supported using gcc 4.9 and later.' + \
 624             termcap.Normal
 625
 626     # Add the appropriate Link-Time Optimization (LTO) flags
 627     # unless LTO is explicitly turned off. Note that these flags
 628     # are only used by the fast target.
 629     if not GetOption('no_lto'):
 630         # Pass the LTO flag when compiling to produce GIMPLE
 631         # output, we merely create the flags here and only append
 632         # them later
 633         main['LTO_CCFLAGS'] = ['-flto=%d' % GetOption('num_jobs')]
 634
 635         # Use the same amount of jobs for LTO as we are running
 636         # scons with
 637         main['LTO_LDFLAGS'] = ['-flto=%d' % GetOption('num_jobs')]
 638
 639     main.Append(TCMALLOC_CCFLAGS=['-fno-builtin-malloc', '-fno-builtin-calloc',
 640                                   '-fno-builtin-realloc', '-fno-builtin-free'])
 641
 642 elif main['CLANG']:
 643     # Check for a supported version of clang, >= 3.1 is needed to
 644     # support similar features as gcc 4.7. See
 645     # http://clang.llvm.org/cxx_status.html for details
 646     clang_version_re = re.compile(".* version (\d+\.\d+)")
 647     clang_version_match = clang_version_re.search(CXX_version)
 648     if (clang_version_match):
 649         clang_version = clang_version_match.groups()[0]
 650         if compareVersions(clang_version, "3.1") < 0:
 651             print 'Error: clang version 3.1 or newer required.'
 652             print '       Installed version:', clang_version
 653             Exit(1)
 654     else:
 655         print 'Error: Unable to determine clang version.'
 656         Exit(1)
 657
 658     # clang has a few additional warnings that we disable,
 659     # tautological comparisons are allowed due to unsigned integers
 660     # being compared to constants that happen to be 0, and extraneous
 661     # parantheses are allowed due to Ruby's printing of the AST,
 662     # finally self assignments are allowed as the generated CPU code
 663     # is relying on this
 664     main.Append(CCFLAGS=['-Wno-tautological-compare',
 665                          '-Wno-parentheses',
 666                          '-Wno-self-assign',
 667                          # Some versions of libstdc++ (4.8?) seem to
 668                          # use struct hash and class hash
 669                          # interchangeably.
 670                          '-Wno-mismatched-tags',
 671                          ])
 672
 673     main.Append(TCMALLOC_CCFLAGS=['-fno-builtin'])
 674
 675     # On Mac OS X/Darwin we need to also use libc++ (part of XCode) as
 676     # opposed to libstdc++, as the later is dated.
 677     if sys.platform == "darwin":
 678         main.Append(CXXFLAGS=['-stdlib=libc++'])
 679         main.Append(LIBS=['c++'])
 680
 681 else:
 682     print termcap.Yellow + termcap.Bold + 'Error' + termcap.Normal,
 683     print "Don't know what compiler options to use for your compiler."
 684     print termcap.Yellow + '       compiler:' + termcap.Normal, main['CXX']
 685     print termcap.Yellow + '       version:' + termcap.Normal,
 686     if not CXX_version:
 687         print termcap.Yellow + termcap.Bold + "COMMAND NOT FOUND!" +\
 688                termcap.Normal
 689     else:
 690         print CXX_version.replace('\n', '<nl>')
 691     print "       If you're trying to use a compiler other than GCC"
 692     print "       or clang, there appears to be something wrong with your"
 693     print "       environment."
 694     print "       "
 695     print "       If you are trying to use a compiler other than those listed"
 696     print "       above you will need to ease fix SConstruct and "
 697     print "       src/SConscript to support that compiler."
 698     Exit(1)
 699
 700 # Set up common yacc/bison flags (needed for Ruby)
 701 main['YACCFLAGS'] = '-d'
 702 main['YACCHXXFILESUFFIX'] = '.hh'
 703
 704 # Do this after we save setting back, or else we'll tack on an
 705 # extra 'qdo' every time we run scons.
 706 if main['BATCH']:
 707     main['CC']     = main['BATCH_CMD'] + ' ' + main['CC']
 708     main['CXX']    = main['BATCH_CMD'] + ' ' + main['CXX']
 709     main['AS']     = main['BATCH_CMD'] + ' ' + main['AS']
 710     main['AR']     = main['BATCH_CMD'] + ' ' + main['AR']
 711     main['RANLIB'] = main['BATCH_CMD'] + ' ' + main['RANLIB']
 712
 713 if sys.platform == 'cygwin':
 714     # cygwin has some header file issues...
 715     main.Append(CCFLAGS=["-Wno-uninitialized"])
 716
 717 # Check for the protobuf compiler
 718 protoc_version = readCommand([main['PROTOC'], '--version'],
 719                              exception='').split()
 720
 721 # First two words should be "libprotoc x.y.z"
 722 if len(protoc_version) < 2 or protoc_version[0] != 'libprotoc':
 723     print termcap.Yellow + termcap.Bold + \
 724         'Warning: Protocol buffer compiler (protoc) not found.\n' + \
 725         '         Please install protobuf-compiler for tracing support.' + \
 726         termcap.Normal
 727     main['PROTOC'] = False
 728 else:
 729     # Based on the availability of the compress stream wrappers,
 730     # require 2.1.0
 731     min_protoc_version = '2.1.0'
 732     if compareVersions(protoc_version[1], min_protoc_version) < 0:
 733         print termcap.Yellow + termcap.Bold + \
 734             'Warning: protoc version', min_protoc_version, \
 735             'or newer required.\n' + \
 736             '         Installed version:', protoc_version[1], \
 737             termcap.Normal
 738         main['PROTOC'] = False
 739     else:
 740         # Attempt to determine the appropriate include path and
 741         # library path using pkg-config, that means we also need to
 742         # check for pkg-config. Note that it is possible to use
 743         # protobuf without the involvement of pkg-config. Later on we
 744         # check go a library config check and at that point the test
 745         # will fail if libprotobuf cannot be found.
 746         if readCommand(['pkg-config', '--version'], exception=''):
 747             try:
 748                 # Attempt to establish what linking flags to add for protobuf
 749                 # using pkg-config
 750                 main.ParseConfig('pkg-config --cflags --libs-only-L protobuf')
 751             except:
 752                 print termcap.Yellow + termcap.Bold + \
 753                     'Warning: pkg-config could not get protobuf flags.' + \
 754                     termcap.Normal
 755
 756 # Check for SWIG
 757 if not main.has_key('SWIG'):
 758     print 'Error: SWIG utility not found.'
 759     print '       Please install (see http://www.swig.org) and retry.'
 760     Exit(1)
 761
 762 # Check for appropriate SWIG version
 763 swig_version = readCommand([main['SWIG'], '-version'], exception='').split()
 764 # First 3 words should be "SWIG Version x.y.z"
 765 if len(swig_version) < 3 or \
 766         swig_version[0] != 'SWIG' or swig_version[1] != 'Version':
 767     print 'Error determining SWIG version.'
 768     Exit(1)
 769
 770 min_swig_version = '2.0.4'
 771 if compareVersions(swig_version[2], min_swig_version) < 0:
 772     print 'Error: SWIG version', min_swig_version, 'or newer required.'
 773     print '       Installed version:', swig_version[2]
 774     Exit(1)
 775
 776 # Check for known incompatibilities. The standard library shipped with
 777 # gcc >= 4.9 does not play well with swig versions prior to 3.0
 778 if main['GCC'] and compareVersions(gcc_version, '4.9') >= 0 and \
 779         compareVersions(swig_version[2], '3.0') < 0:
 780     print termcap.Yellow + termcap.Bold + \
 781         'Warning: This combination of gcc and swig have' + \
 782         ' known incompatibilities.\n' + \
 783         '         If you encounter build problems, please update ' + \
 784         'swig to 3.0 or later.' + \
 785         termcap.Normal
 786
 787 # Set up SWIG flags & scanner
 788 swig_flags=Split('-c++ -python -modern -templatereduce $_CPPINCFLAGS')
 789 main.Append(SWIGFLAGS=swig_flags)
 790
 791 # Check for 'timeout' from GNU coreutils. If present, regressions will
 792 # be run with a time limit. We require version 8.13 since we rely on
 793 # support for the '--foreground' option.
 794 timeout_lines = readCommand(['timeout', '--version'],
 795                             exception='').splitlines()
 796 # Get the first line and tokenize it
 797 timeout_version = timeout_lines[0].split() if timeout_lines else []
 798 main['TIMEOUT'] =  timeout_version and \
 799     compareVersions(timeout_version[-1], '8.13') >= 0
 800
 801 # filter out all existing swig scanners, they mess up the dependency
 802 # stuff for some reason
 803 scanners = []
 804 for scanner in main['SCANNERS']:
 805     skeys = scanner.skeys
 806     if skeys == '.i':
 807         continue
 808
 809     if isinstance(skeys, (list, tuple)) and '.i' in skeys:
 810         continue
 811
 812     scanners.append(scanner)
 813
 814 # add the new swig scanner that we like better
 815 from SCons.Scanner import ClassicCPP as CPPScanner
 816 swig_inc_re = '^[ \t]*[%,#][ \t]*(?:include|import)[ \t]*(<|")([^>"]+)(>|")'
 817 scanners.append(CPPScanner("SwigScan", [ ".i" ], "CPPPATH", swig_inc_re))
 818
 819 # replace the scanners list that has what we want
 820 main['SCANNERS'] = scanners
 821
 822 # Add a custom Check function to test for structure members.
 823 def CheckMember(context, include, decl, member, include_quotes="<>"):
 824     context.Message("Checking for member %s in %s..." %
 825                     (member, decl))
 826     text = """
 827 #include %(header)s
 828 int main(){
 829   %(decl)s test;
 830   (void)test.%(member)s;
 831   return 0;
 832 };
 833 """ % { "header" : include_quotes[0] + include + include_quotes[1],
 834         "decl" : decl,
 835         "member" : member,
 836         }
 837
 838     ret = context.TryCompile(text, extension=".cc")
 839     context.Result(ret)
 840     return ret
 841
 842 # Platform-specific configuration.  Note again that we assume that all
 843 # builds under a given build root run on the same host platform.
 844 conf = Configure(main,
 845                  conf_dir = joinpath(build_root, '.scons_config'),
 846                  log_file = joinpath(build_root, 'scons_config.log'),
 847                  custom_tests = {
 848         'CheckMember' : CheckMember,
 849         })
 850
 851 # Check if we should compile a 64 bit binary on Mac OS X/Darwin
 852 try:
 853     import platform
 854     uname = platform.uname()
 855     if uname[0] == 'Darwin' and compareVersions(uname[2], '9.0.0') >= 0:
 856         if int(readCommand('sysctl -n hw.cpu64bit_capable')[0]):
 857             main.Append(CCFLAGS=['-arch', 'x86_64'])
 858             main.Append(CFLAGS=['-arch', 'x86_64'])
 859             main.Append(LINKFLAGS=['-arch', 'x86_64'])
 860             main.Append(ASFLAGS=['-arch', 'x86_64'])
 861 except:
 862     pass
 863
 864 # Recent versions of scons substitute a "Null" object for Configure()
 865 # when configuration isn't necessary, e.g., if the "--help" option is
 866 # present.  Unfortuantely this Null object always returns false,
 867 # breaking all our configuration checks.  We replace it with our own
 868 # more optimistic null object that returns True instead.
 869 if not conf:
 870     def NullCheck(*args, **kwargs):
 871         return True
 872
 873     class NullConf:
 874         def __init__(self, env):
 875             self.env = env
 876         def Finish(self):
 877             return self.env
 878         def __getattr__(self, mname):
 879             return NullCheck
 880
 881     conf = NullConf(main)
 882
 883 # Cache build files in the supplied directory.
 884 if main['M5_BUILD_CACHE']:
 885     print 'Using build cache located at', main['M5_BUILD_CACHE']
 886     CacheDir(main['M5_BUILD_CACHE'])
 887
 888 if not GetOption('without_python'):
 889     # Find Python include and library directories for embedding the
 890     # interpreter. We rely on python-config to resolve the appropriate
 891     # includes and linker flags. ParseConfig does not seem to understand
 892     # the more exotic linker flags such as -Xlinker and -export-dynamic so
 893     # we add them explicitly below. If you want to link in an alternate
 894     # version of python, see above for instructions on how to invoke
 895     # scons with the appropriate PATH set.
 896     #
 897     # First we check if python2-config exists, else we use python-config
 898     python_config = readCommand(['which', 'python2-config'],
 899                                 exception='').strip()
 900     if not os.path.exists(python_config):
 901         python_config = readCommand(['which', 'python-config'],
 902                                     exception='').strip()
 903     py_includes = readCommand([python_config, '--includes'],
 904                               exception='').split()
 905     # Strip the -I from the include folders before adding them to the
 906     # CPPPATH
 907     main.Append(CPPPATH=map(lambda inc: inc[2:], py_includes))
 908
 909     # Read the linker flags and split them into libraries and other link
 910     # flags. The libraries are added later through the call the CheckLib.
 911     py_ld_flags = readCommand([python_config, '--ldflags'],
 912         exception='').split()
 913     py_libs = []
 914     for lib in py_ld_flags:
 915          if not lib.startswith('-l'):
 916              main.Append(LINKFLAGS=[lib])
 917          else:
 918              lib = lib[2:]
 919              if lib not in py_libs:
 920                  py_libs.append(lib)
 921
 922     # verify that this stuff works
 923     if not conf.CheckHeader('Python.h', '<>'):
 924         print "Error: can't find Python.h header in", py_includes
 925         print "Install Python headers (package python-dev on Ubuntu and RedHat)"
 926         Exit(1)
 927
 928     for lib in py_libs:
 929         if not conf.CheckLib(lib):
 930             print "Error: can't find library %s required by python" % lib
 931             Exit(1)
 932
 933 # On Solaris you need to use libsocket for socket ops
 934 if not conf.CheckLibWithHeader(None, 'sys/socket.h', 'C++', 'accept(0,0,0);'):
 935    if not conf.CheckLibWithHeader('socket', 'sys/socket.h', 'C++', 'accept(0,0,0);'):
 936        print "Can't find library with socket calls (e.g. accept())"
 937        Exit(1)
 938
 939 # Check for zlib.  If the check passes, libz will be automatically
 940 # added to the LIBS environment variable.
 941 if not conf.CheckLibWithHeader('z', 'zlib.h', 'C++','zlibVersion();'):
 942     print 'Error: did not find needed zlib compression library '\
 943           'and/or zlib.h header file.'
 944     print '       Please install zlib and try again.'
 945     Exit(1)
 946
 947 # If we have the protobuf compiler, also make sure we have the
 948 # development libraries. If the check passes, libprotobuf will be
 949 # automatically added to the LIBS environment variable. After
 950 # this, we can use the HAVE_PROTOBUF flag to determine if we have
 951 # got both protoc and libprotobuf available.
 952 main['HAVE_PROTOBUF'] = main['PROTOC'] and \
 953     conf.CheckLibWithHeader('protobuf', 'google/protobuf/message.h',
 954                             'C++', 'GOOGLE_PROTOBUF_VERIFY_VERSION;')
 955
 956 # If we have the compiler but not the library, print another warning.
 957 if main['PROTOC'] and not main['HAVE_PROTOBUF']:
 958     print termcap.Yellow + termcap.Bold + \
 959         'Warning: did not find protocol buffer library and/or headers.\n' + \
 960     '       Please install libprotobuf-dev for tracing support.' + \
 961     termcap.Normal
 962
 963 # Check for librt.
 964 have_posix_clock = \
 965     conf.CheckLibWithHeader(None, 'time.h', 'C',
 966                             'clock_nanosleep(0,0,NULL,NULL);') or \
 967     conf.CheckLibWithHeader('rt', 'time.h', 'C',
 968                             'clock_nanosleep(0,0,NULL,NULL);')
 969
 970 have_posix_timers = \
 971     conf.CheckLibWithHeader([None, 'rt'], [ 'time.h', 'signal.h' ], 'C',
 972                             'timer_create(CLOCK_MONOTONIC, NULL, NULL);')
 973
 974 if not GetOption('without_tcmalloc'):
 975     if conf.CheckLib('tcmalloc'):
 976         main.Append(CCFLAGS=main['TCMALLOC_CCFLAGS'])
 977     elif conf.CheckLib('tcmalloc_minimal'):
 978         main.Append(CCFLAGS=main['TCMALLOC_CCFLAGS'])
 979     else:
 980         print termcap.Yellow + termcap.Bold + \
 981               "You can get a 12% performance improvement by "\
 982               "installing tcmalloc (libgoogle-perftools-dev package "\
 983               "on Ubuntu or RedHat)." + termcap.Normal
 984
 985 if not have_posix_clock:
 986     print "Can't find library for POSIX clocks."
 987
 988 # Check for <fenv.h> (C99 FP environment control)
 989 have_fenv = conf.CheckHeader('fenv.h', '<>')
 990 if not have_fenv:
 991     print "Warning: Header file <fenv.h> not found."
 992     print "         This host has no IEEE FP rounding mode control."
 993
 994 # Check if we should enable KVM-based hardware virtualization. The API
 995 # we rely on exists since version 2.6.36 of the kernel, but somehow
 996 # the KVM_API_VERSION does not reflect the change. We test for one of
 997 # the types as a fall back.
 998 have_kvm = conf.CheckHeader('linux/kvm.h', '<>')
 999 if not have_kvm:
1000     print "Info: Compatible header file <linux/kvm.h> not found, " \
1001         "disabling KVM support."
1002
1003 # x86 needs support for xsave. We test for the structure here since we
1004 # won't be able to run new tests by the time we know which ISA we're
1005 # targeting.
1006 have_kvm_xsave = conf.CheckTypeSize('struct kvm_xsave',
1007                                     '#include <linux/kvm.h>') != 0
1008
1009 # Check if the requested target ISA is compatible with the host
1010 def is_isa_kvm_compatible(isa):
1011     try:
1012         import platform
1013         host_isa = platform.machine()
1014     except:
1015         print "Warning: Failed to determine host ISA."
1016         return False
1017
1018     if not have_posix_timers:
1019         print "Warning: Can not enable KVM, host seems to lack support " \
1020             "for POSIX timers"
1021         return False
1022
1023     if isa == "arm":
1024         return host_isa in ( "armv7l", "aarch64" )
1025     elif isa == "x86":
1026         if host_isa != "x86_64":
1027             return False
1028
1029         if not have_kvm_xsave:
1030             print "KVM on x86 requires xsave support in kernel headers."
1031             return False
1032
1033         return True
1034     else:
1035         return False
1036
1037
1038 # Check if the exclude_host attribute is available. We want this to
1039 # get accurate instruction counts in KVM.
1040 main['HAVE_PERF_ATTR_EXCLUDE_HOST'] = conf.CheckMember(
1041     'linux/perf_event.h', 'struct perf_event_attr', 'exclude_host')
1042
1043
1044 ######################################################################
1045 #
1046 # Finish the configuration
1047 #
1048 main = conf.Finish()
1049
1050 ######################################################################
1051 #
1052 # Collect all non-global variables
1053 #
1054
1055 # Define the universe of supported ISAs
1056 all_isa_list = [ ]
1057 Export('all_isa_list')
1058
1059 class CpuModel(object):
1060     '''The CpuModel class encapsulates everything the ISA parser needs to
1061     know about a particular CPU model.'''
1062
1063     # Dict of available CPU model objects.  Accessible as CpuModel.dict.
1064     dict = {}
1065
1066     # Constructor.  Automatically adds models to CpuModel.dict.
1067     def __init__(self, name, default=False):
1068         self.name = name           # name of model
1069
1070         # This cpu is enabled by default
1071         self.default = default
1072
1073         # Add self to dict
1074         if name in CpuModel.dict:
1075             raise AttributeError, "CpuModel '%s' already registered" % name
1076         CpuModel.dict[name] = self
1077
1078 Export('CpuModel')
1079
1080 # Sticky variables get saved in the variables file so they persist from
1081 # one invocation to the next (unless overridden, in which case the new
1082 # value becomes sticky).
1083 sticky_vars = Variables(args=ARGUMENTS)
1084 Export('sticky_vars')
1085
1086 # Sticky variables that should be exported
1087 export_vars = []
1088 Export('export_vars')
1089
1090 # For Ruby
1091 all_protocols = []
1092 Export('all_protocols')
1093 protocol_dirs = []
1094 Export('protocol_dirs')
1095 slicc_includes = []
1096 Export('slicc_includes')
1097
1098 # Walk the tree and execute all SConsopts scripts that wil add to the
1099 # above variables
1100 if GetOption('verbose'):
1101     print "Reading SConsopts"
1102 for bdir in [ base_dir ] + extras_dir_list:
1103     if not isdir(bdir):
1104         print "Error: directory '%s' does not exist" % bdir
1105         Exit(1)
1106     for root, dirs, files in os.walk(bdir):
1107         if 'SConsopts' in files:
1108             if GetOption('verbose'):
1109                 print "Reading", joinpath(root, 'SConsopts')
1110             SConscript(joinpath(root, 'SConsopts'))
1111
1112 all_isa_list.sort()
1113
1114 sticky_vars.AddVariables(
1115     EnumVariable('TARGET_ISA', 'Target ISA', 'alpha', all_isa_list),
1116     ListVariable('CPU_MODELS', 'CPU models',
1117                  sorted(n for n,m in CpuModel.dict.iteritems() if m.default),
1118                  sorted(CpuModel.dict.keys())),
1119     BoolVariable('EFENCE', 'Link with Electric Fence malloc debugger',
1120                  False),
1121     BoolVariable('SS_COMPATIBLE_FP',
1122                  'Make floating-point results compatible with SimpleScalar',
1123                  False),
1124     BoolVariable('USE_SSE2',
1125                  'Compile for SSE2 (-msse2) to get IEEE FP on x86 hosts',
1126                  False),
1127     BoolVariable('USE_POSIX_CLOCK', 'Use POSIX Clocks', have_posix_clock),
1128     BoolVariable('USE_FENV', 'Use <fenv.h> IEEE mode control', have_fenv),
1129     BoolVariable('CP_ANNOTATE', 'Enable critical path annotation capability', False),
1130     BoolVariable('USE_KVM', 'Enable hardware virtualized (KVM) CPU models', have_kvm),
1131     EnumVariable('PROTOCOL', 'Coherence protocol for Ruby', 'None',
1132                   all_protocols),
1133     )
1134
1135 # These variables get exported to #defines in config/*.hh (see src/SConscript).
1136 export_vars += ['USE_FENV', 'SS_COMPATIBLE_FP', 'TARGET_ISA', 'CP_ANNOTATE',
1137                 'USE_POSIX_CLOCK', 'USE_KVM', 'PROTOCOL', 'HAVE_PROTOBUF',
1138                 'HAVE_PERF_ATTR_EXCLUDE_HOST']
1139
1140 ###################################################
1141 #
1142 # Define a SCons builder for configuration flag headers.
1143 #
1144 ###################################################
1145
1146 # This function generates a config header file that #defines the
1147 # variable symbol to the current variable setting (0 or 1).  The source
1148 # operands are the name of the variable and a Value node containing the
1149 # value of the variable.
1150 def build_config_file(target, source, env):
1151     (variable, value) = [s.get_contents() for s in source]
1152     f = file(str(target[0]), 'w')
1153     print >> f, '#define', variable, value
1154     f.close()
1155     return None
1156
1157 # Combine the two functions into a scons Action object.
1158 config_action = MakeAction(build_config_file, Transform("CONFIG H", 2))
1159
1160 # The emitter munges the source & target node lists to reflect what
1161 # we're really doing.
1162 def config_emitter(target, source, env):
1163     # extract variable name from Builder arg
1164     variable = str(target[0])
1165     # True target is config header file
1166     target = joinpath('config', variable.lower() + '.hh')
1167     val = env[variable]
1168     if isinstance(val, bool):
1169         # Force value to 0/1
1170         val = int(val)
1171     elif isinstance(val, str):
1172         val = '"' + val + '"'
1173
1174     # Sources are variable name & value (packaged in SCons Value nodes)
1175     return ([target], [Value(variable), Value(val)])
1176
1177 config_builder = Builder(emitter = config_emitter, action = config_action)
1178
1179 main.Append(BUILDERS = { 'ConfigFile' : config_builder })
1180
1181 # libelf build is shared across all configs in the build root.
1182 main.SConscript('ext/libelf/SConscript',
1183                 variant_dir = joinpath(build_root, 'libelf'))
1184
1185 # gzstream build is shared across all configs in the build root.
1186 main.SConscript('ext/gzstream/SConscript',
1187                 variant_dir = joinpath(build_root, 'gzstream'))
1188
1189 # libfdt build is shared across all configs in the build root.
1190 main.SConscript('ext/libfdt/SConscript',
1191                 variant_dir = joinpath(build_root, 'libfdt'))
1192
1193 # fputils build is shared across all configs in the build root.
1194 main.SConscript('ext/fputils/SConscript',
1195                 variant_dir = joinpath(build_root, 'fputils'))
1196
1197 # DRAMSim2 build is shared across all configs in the build root.
1198 main.SConscript('ext/dramsim2/SConscript',
1199                 variant_dir = joinpath(build_root, 'dramsim2'))
1200
1201 # DRAMPower build is shared across all configs in the build root.
1202 main.SConscript('ext/drampower/SConscript',
1203                 variant_dir = joinpath(build_root, 'drampower'))
1204
1205 ###################################################
1206 #
1207 # This function is used to set up a directory with switching headers
1208 #
1209 ###################################################
1210
1211 main['ALL_ISA_LIST'] = all_isa_list
1212 all_isa_deps = {}
1213 def make_switching_dir(dname, switch_headers, env):
1214     # Generate the header.  target[0] is the full path of the output
1215     # header to generate.  'source' is a dummy variable, since we get the
1216     # list of ISAs from env['ALL_ISA_LIST'].
1217     def gen_switch_hdr(target, source, env):
1218         fname = str(target[0])
1219         isa = env['TARGET_ISA'].lower()
1220         try:
1221             f = open(fname, 'w')
1222             print >>f, '#include "%s/%s/%s"' % (dname, isa, basename(fname))
1223             f.close()
1224         except IOError:
1225             print "Failed to create %s" % fname
1226             raise
1227
1228     # Build SCons Action object. 'varlist' specifies env vars that this
1229     # action depends on; when env['ALL_ISA_LIST'] changes these actions
1230     # should get re-executed.
1231     switch_hdr_action = MakeAction(gen_switch_hdr,
1232                           Transform("GENERATE"), varlist=['ALL_ISA_LIST'])
1233
1234     # Instantiate actions for each header
1235     for hdr in switch_headers:
1236         env.Command(hdr, [], switch_hdr_action)
1237
1238     isa_target = Dir('.').up().name.lower().replace('_', '-')
1239     env['PHONY_BASE'] = '#'+isa_target
1240     all_isa_deps[isa_target] = None
1241
1242 Export('make_switching_dir')
1243
1244 # all-isas -> all-deps -> all-environs -> all_targets
1245 main.Alias('#all-isas', [])
1246 main.Alias('#all-deps', '#all-isas')
1247
1248 # Dummy target to ensure all environments are created before telling
1249 # SCons what to actually make (the command line arguments).  We attach
1250 # them to the dependence graph after the environments are complete.
1251 ORIG_BUILD_TARGETS = list(BUILD_TARGETS) # force a copy; gets closure to work.
1252 def environsComplete(target, source, env):
1253     for t in ORIG_BUILD_TARGETS:
1254         main.Depends('#all-targets', t)
1255
1256 # Each build/* switching_dir attaches its *-environs target to #all-environs.
1257 main.Append(BUILDERS = {'CompleteEnvirons' :
1258                         Builder(action=MakeAction(environsComplete, None))})
1259 main.CompleteEnvirons('#all-environs', [])
1260
1261 def doNothing(**ignored): pass
1262 main.Append(BUILDERS = {'Dummy': Builder(action=MakeAction(doNothing, None))})
1263
1264 # The final target to which all the original targets ultimately get attached.
1265 main.Dummy('#all-targets', '#all-environs')
1266 BUILD_TARGETS[:] = ['#all-targets']
1267
1268 ###################################################
1269 #
1270 # Define build environments for selected configurations.
1271 #
1272 ###################################################
1273
1274 for variant_path in variant_paths:
1275     if not GetOption('silent'):
1276         print "Building in", variant_path
1277
1278     # Make a copy of the build-root environment to use for this config.
1279     env = main.Clone()
1280     env['BUILDDIR'] = variant_path
1281
1282     # variant_dir is the tail component of build path, and is used to
1283     # determine the build parameters (e.g., 'ALPHA_SE')
1284     (build_root, variant_dir) = splitpath(variant_path)
1285
1286     # Set env variables according to the build directory config.
1287     sticky_vars.files = []
1288     # Variables for $BUILD_ROOT/$VARIANT_DIR are stored in
1289     # $BUILD_ROOT/variables/$VARIANT_DIR so you can nuke
1290     # $BUILD_ROOT/$VARIANT_DIR without losing your variables settings.
1291     current_vars_file = joinpath(build_root, 'variables', variant_dir)
1292     if isfile(current_vars_file):
1293         sticky_vars.files.append(current_vars_file)
1294         if not GetOption('silent'):
1295             print "Using saved variables file %s" % current_vars_file
1296     else:
1297         # Build dir-specific variables file doesn't exist.
1298
1299         # Make sure the directory is there so we can create it later
1300         opt_dir = dirname(current_vars_file)
1301         if not isdir(opt_dir):
1302             mkdir(opt_dir)
1303
1304         # Get default build variables from source tree.  Variables are
1305         # normally determined by name of $VARIANT_DIR, but can be
1306         # overridden by '--default=' arg on command line.
1307         default = GetOption('default')
1308         opts_dir = joinpath(main.root.abspath, 'build_opts')
1309         if default:
1310             default_vars_files = [joinpath(build_root, 'variables', default),
1311                                   joinpath(opts_dir, default)]
1312         else:
1313             default_vars_files = [joinpath(opts_dir, variant_dir)]
1314         existing_files = filter(isfile, default_vars_files)
1315         if existing_files:
1316             default_vars_file = existing_files[0]
1317             sticky_vars.files.append(default_vars_file)
1318             print "Variables file %s not found,\n  using defaults in %s" \
1319                   % (current_vars_file, default_vars_file)
1320         else:
1321             print "Error: cannot find variables file %s or " \
1322                   "default file(s) %s" \
1323                   % (current_vars_file, ' or '.join(default_vars_files))
1324             Exit(1)
1325
1326     # Apply current variable settings to env
1327     sticky_vars.Update(env)
1328
1329     help_texts["local_vars"] += \
1330         "Build variables for %s:\n" % variant_dir \
1331                  + sticky_vars.GenerateHelpText(env)
1332
1333     # Process variable settings.
1334
1335     if not have_fenv and env['USE_FENV']:
1336         print "Warning: <fenv.h> not available; " \
1337               "forcing USE_FENV to False in", variant_dir + "."
1338         env['USE_FENV'] = False
1339
1340     if not env['USE_FENV']:
1341         print "Warning: No IEEE FP rounding mode control in", variant_dir + "."
1342         print "         FP results may deviate slightly from other platforms."
1343
1344     if env['EFENCE']:
1345         env.Append(LIBS=['efence'])
1346
1347     if env['USE_KVM']:
1348         if not have_kvm:
1349             print "Warning: Can not enable KVM, host seems to lack KVM support"
1350             env['USE_KVM'] = False
1351         elif not is_isa_kvm_compatible(env['TARGET_ISA']):
1352             print "Info: KVM support disabled due to unsupported host and " \
1353                 "target ISA combination"
1354             env['USE_KVM'] = False
1355
1356     # Warn about missing optional functionality
1357     if env['USE_KVM']:
1358         if not main['HAVE_PERF_ATTR_EXCLUDE_HOST']:
1359             print "Warning: perf_event headers lack support for the " \
1360                 "exclude_host attribute. KVM instruction counts will " \
1361                 "be inaccurate."
1362
1363     # Save sticky variable settings back to current variables file
1364     sticky_vars.Save(current_vars_file, env)
1365
1366     if env['USE_SSE2']:
1367         env.Append(CCFLAGS=['-msse2'])
1368
1369     # The src/SConscript file sets up the build rules in 'env' according
1370     # to the configured variables.  It returns a list of environments,
1371     # one for each variant build (debug, opt, etc.)
1372     SConscript('src/SConscript', variant_dir = variant_path, exports = 'env')
1373
1374 def pairwise(iterable):
1375     "s -> (s0,s1), (s1,s2), (s2, s3), ..."
1376     a, b = itertools.tee(iterable)
1377     b.next()
1378     return itertools.izip(a, b)
1379
1380 # Create false dependencies so SCons will parse ISAs, establish
1381 # dependencies, and setup the build Environments serially. Either
1382 # SCons (likely) and/or our SConscripts (possibly) cannot cope with -j
1383 # greater than 1. It appears to be standard race condition stuff; it
1384 # doesn't always fail, but usually, and the behaviors are different.
1385 # Every time I tried to remove this, builds would fail in some
1386 # creative new way. So, don't do that. You'll want to, though, because
1387 # tests/SConscript takes a long time to make its Environments.
1388 for t1, t2 in pairwise(sorted(all_isa_deps.iterkeys())):
1389     main.Depends('#%s-deps'     % t2, '#%s-deps'     % t1)
1390     main.Depends('#%s-environs' % t2, '#%s-environs' % t1)
1391
1392 # base help text
1393 Help('''
1394 Usage: scons [scons options] [build variables] [target(s)]
1395
1396 Extra scons options:
1397 %(options)s
1398
1399 Global build variables:
1400 %(global_vars)s
1401
1402 %(local_vars)s
1403 ''' % help_texts)