SConstruct

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