SConstruct

   1 # -*- mode:python -*-
   2
   3 # Copyright (c) 2011 Advanced Micro Devices, Inc.
   4 # Copyright (c) 2009 The Hewlett-Packard Development Company
   5 # Copyright (c) 2004-2005 The Regents of The University of Michigan
   6 # All rights reserved.
   7 #
   8 # Redistribution and use in source and binary forms, with or without
   9 # modification, are permitted provided that the following conditions are
  10 # met: redistributions of source code must retain the above copyright
  11 # notice, this list of conditions and the following disclaimer;
  12 # redistributions in binary form must reproduce the above copyright
  13 # notice, this list of conditions and the following disclaimer in the
  14 # documentation and/or other materials provided with the distribution;
  15 # neither the name of the copyright holders nor the names of its
  16 # contributors may be used to endorse or promote products derived from
  17 # this software without specific prior written permission.
  18 #
  19 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30 #
  31 # Authors: Steve Reinhardt
  32 #          Nathan Binkert
  33
  34 ###################################################
  35 #
  36 # SCons top-level build description (SConstruct) file.
  37 #
  38 # While in this directory ('gem5'), just type 'scons' to build the default
  39 # configuration (see below), or type 'scons build/<CONFIG>/<binary>'
  40 # to build some other configuration (e.g., 'build/ALPHA/gem5.opt' for
  41 # the optimized full-system version).
  42 #
  43 # You can build gem5 in a different directory as long as there is a
  44 # 'build/<CONFIG>' somewhere along the target path.  The build system
  45 # expects that all configs under the same build directory are being
  46 # built for the same host system.
  47 #
  48 # Examples:
  49 #
  50 #   The following two commands are equivalent.  The '-u' option tells
  51 #   scons to search up the directory tree for this SConstruct file.
  52 #   % cd <path-to-src>/gem5 ; scons build/ALPHA/gem5.debug
  53 #   % cd <path-to-src>/gem5/build/ALPHA; scons -u gem5.debug
  54 #
  55 #   The following two commands are equivalent and demonstrate building
  56 #   in a directory outside of the source tree.  The '-C' option tells
  57 #   scons to chdir to the specified directory to find this SConstruct
  58 #   file.
  59 #   % cd <path-to-src>/gem5 ; scons /local/foo/build/ALPHA/gem5.debug
  60 #   % cd /local/foo/build/ALPHA; scons -C <path-to-src>/gem5 gem5.debug
  61 #
  62 # You can use 'scons -H' to print scons options.  If you're in this
  63 # 'gem5' directory (or use -u or -C to tell scons where to find this
  64 # file), you can use 'scons -h' to print all the gem5-specific build
  65 # options as well.
  66 #
  67 ###################################################
  68
  69 # Check for recent-enough Python and SCons versions.
  70 try:
  71     # Really old versions of scons only take two options for the
  72     # function, so check once without the revision and once with the
  73     # revision, the first instance will fail for stuff other than
  74     # 0.98, and the second will fail for 0.98.0
  75     EnsureSConsVersion(0, 98)
  76     EnsureSConsVersion(0, 98, 1)
  77 except SystemExit, e:
  78     print """
  79 For more details, see:
  80     http://gem5.org/Dependencies
  81 """
  82     raise
  83
  84 # We ensure the python version early because we have stuff that
  85 # requires python 2.4
  86 try:
  87     EnsurePythonVersion(2, 4)
  88 except SystemExit, e:
  89     print """
  90 You can use a non-default installation of the Python interpreter by
  91 either (1) rearranging your PATH so that scons finds the non-default
  92 'python' first or (2) explicitly invoking an alternative interpreter
  93 on the scons script.
  94
  95 For more details, see:
  96     http://gem5.org/wiki/index.php/Using_a_non-default_Python_installation
  97 """
  98     raise
  99
 100 # Global Python includes
 101 import os
 102 import re
 103 import subprocess
 104 import sys
 105
 106 from os import mkdir, environ
 107 from os.path import abspath, basename, dirname, expanduser, normpath
 108 from os.path import exists,  isdir, isfile
 109 from os.path import join as joinpath, split as splitpath
 110
 111 # SCons includes
 112 import SCons
 113 import SCons.Node
 114
 115 extra_python_paths = [
 116     Dir('src/python').srcnode().abspath, # gem5 includes
 117     Dir('ext/ply').srcnode().abspath, # ply is used by several files
 118     ]
 119
 120 sys.path[1:1] = extra_python_paths
 121
 122 from m5.util import compareVersions, readCommand
 123
 124 help_texts = {
 125     "options" : "",
 126     "global_vars" : "",
 127     "local_vars" : ""
 128 }
 129
 130 Export("help_texts")
 131
 132
 133 # There's a bug in scons in that (1) by default, the help texts from
 134 # AddOption() are supposed to be displayed when you type 'scons -h'
 135 # and (2) you can override the help displayed by 'scons -h' using the
 136 # Help() function, but these two features are incompatible: once
 137 # you've overridden the help text using Help(), there's no way to get
 138 # at the help texts from AddOptions.  See:
 139 #     http://scons.tigris.org/issues/show_bug.cgi?id=2356
 140 #     http://scons.tigris.org/issues/show_bug.cgi?id=2611
 141 # This hack lets us extract the help text from AddOptions and
 142 # re-inject it via Help().  Ideally someday this bug will be fixed and
 143 # we can just use AddOption directly.
 144 def AddLocalOption(*args, **kwargs):
 145     col_width = 30
 146
 147     help = "  " + ", ".join(args)
 148     if "help" in kwargs:
 149         length = len(help)
 150         if length >= col_width:
 151             help += "\n" + " " * col_width
 152         else:
 153             help += " " * (col_width - length)
 154         help += kwargs["help"]
 155     help_texts["options"] += help + "\n"
 156
 157     AddOption(*args, **kwargs)
 158
 159 AddLocalOption('--colors', dest='use_colors', action='store_true',
 160                help="Add color to abbreviated scons output")
 161 AddLocalOption('--no-colors', dest='use_colors', action='store_false',
 162                help="Don't add color to abbreviated scons output")
 163 AddLocalOption('--default', dest='default', type='string', action='store',
 164                help='Override which build_opts file to use for defaults')
 165 AddLocalOption('--ignore-style', dest='ignore_style', action='store_true',
 166                help='Disable style checking hooks')
 167 AddLocalOption('--update-ref', dest='update_ref', action='store_true',
 168                help='Update test reference outputs')
 169 AddLocalOption('--verbose', dest='verbose', action='store_true',
 170                help='Print full tool command lines')
 171
 172 use_colors = GetOption('use_colors')
 173 if use_colors:
 174     from m5.util.terminal import termcap
 175 elif use_colors is None:
 176     # option unspecified; default behavior is to use colors iff isatty
 177     from m5.util.terminal import tty_termcap as termcap
 178 else:
 179     from m5.util.terminal import no_termcap as termcap
 180
 181 ########################################################################
 182 #
 183 # Set up the main build environment.
 184 #
 185 ########################################################################
 186 use_vars = set([ 'AS', 'AR', 'CC', 'CXX', 'HOME', 'LD_LIBRARY_PATH', 'PATH',
 187                  'PYTHONPATH', 'RANLIB' ])
 188
 189 use_env = {}
 190 for key,val in os.environ.iteritems():
 191     if key in use_vars or key.startswith("M5"):
 192         use_env[key] = val
 193
 194 main = Environment(ENV=use_env)
 195 main.Decider('MD5-timestamp')
 196 main.SetOption('implicit_cache', 1)
 197 main.root = Dir(".")         # The current directory (where this file lives).
 198 main.srcdir = Dir("src")     # The source directory
 199
 200 # add useful python code PYTHONPATH so it can be used by subprocesses
 201 # as well
 202 main.AppendENVPath('PYTHONPATH', extra_python_paths)
 203
 204 ########################################################################
 205 #
 206 # Mercurial Stuff.
 207 #
 208 # If the gem5 directory is a mercurial repository, we should do some
 209 # extra things.
 210 #
 211 ########################################################################
 212
 213 hgdir = main.root.Dir(".hg")
 214
 215 mercurial_style_message = """
 216 You're missing the gem5 style hook, which automatically checks your code
 217 against the gem5 style rules on hg commit and qrefresh commands.  This
 218 script will now install the hook in your .hg/hgrc file.
 219 Press enter to continue, or ctrl-c to abort: """
 220
 221 mercurial_style_hook = """
 222 # The following lines were automatically added by gem5/SConstruct
 223 # to provide the gem5 style-checking hooks
 224 [extensions]
 225 style = %s/util/style.py
 226
 227 [hooks]
 228 pretxncommit.style = python:style.check_style
 229 pre-qrefresh.style = python:style.check_style
 230 # End of SConstruct additions
 231
 232 """ % (main.root.abspath)
 233
 234 mercurial_lib_not_found = """
 235 Mercurial libraries cannot be found, ignoring style hook.  If
 236 you are a gem5 developer, please fix this and run the style
 237 hook. It is important.
 238 """
 239
 240 # Check for style hook and prompt for installation if it's not there.
 241 # Skip this if --ignore-style was specified, there's no .hg dir to
 242 # install a hook in, or there's no interactive terminal to prompt.
 243 if not GetOption('ignore_style') and hgdir.exists() and sys.stdin.isatty():
 244     style_hook = True
 245     try:
 246         from mercurial import ui
 247         ui = ui.ui()
 248         ui.readconfig(hgdir.File('hgrc').abspath)
 249         style_hook = ui.config('hooks', 'pretxncommit.style', None) and \
 250                      ui.config('hooks', 'pre-qrefresh.style', None)
 251     except ImportError:
 252         print mercurial_lib_not_found
 253
 254     if not style_hook:
 255         print mercurial_style_message,
 256         # continue unless user does ctrl-c/ctrl-d etc.
 257         try:
 258             raw_input()
 259         except:
 260             print "Input exception, exiting scons.\n"
 261             sys.exit(1)
 262         hgrc_path = '%s/.hg/hgrc' % main.root.abspath
 263         print "Adding style hook to", hgrc_path, "\n"
 264         try:
 265             hgrc = open(hgrc_path, 'a')
 266             hgrc.write(mercurial_style_hook)
 267             hgrc.close()
 268         except:
 269             print "Error updating", hgrc_path
 270             sys.exit(1)
 271
 272
 273 ###################################################
 274 #
 275 # Figure out which configurations to set up based on the path(s) of
 276 # the target(s).
 277 #
 278 ###################################################
 279
 280 # Find default configuration & binary.
 281 Default(environ.get('M5_DEFAULT_BINARY', 'build/ALPHA/gem5.debug'))
 282
 283 # helper function: find last occurrence of element in list
 284 def rfind(l, elt, offs = -1):
 285     for i in range(len(l)+offs, 0, -1):
 286         if l[i] == elt:
 287             return i
 288     raise ValueError, "element not found"
 289
 290 # Take a list of paths (or SCons Nodes) and return a list with all
 291 # paths made absolute and ~-expanded.  Paths will be interpreted
 292 # relative to the launch directory unless a different root is provided
 293 def makePathListAbsolute(path_list, root=GetLaunchDir()):
 294     return [abspath(joinpath(root, expanduser(str(p))))
 295             for p in path_list]
 296
 297 # Each target must have 'build' in the interior of the path; the
 298 # directory below this will determine the build parameters.  For
 299 # example, for target 'foo/bar/build/ALPHA_SE/arch/alpha/blah.do' we
 300 # recognize that ALPHA_SE specifies the configuration because it
 301 # follow 'build' in the build path.
 302
 303 # The funky assignment to "[:]" is needed to replace the list contents
 304 # in place rather than reassign the symbol to a new list, which
 305 # doesn't work (obviously!).
 306 BUILD_TARGETS[:] = makePathListAbsolute(BUILD_TARGETS)
 307
 308 # Generate a list of the unique build roots and configs that the
 309 # collected targets reference.
 310 variant_paths = []
 311 build_root = None
 312 for t in BUILD_TARGETS:
 313     path_dirs = t.split('/')
 314     try:
 315         build_top = rfind(path_dirs, 'build', -2)
 316     except:
 317         print "Error: no non-leaf 'build' dir found on target path", t
 318         Exit(1)
 319     this_build_root = joinpath('/',*path_dirs[:build_top+1])
 320     if not build_root:
 321         build_root = this_build_root
 322     else:
 323         if this_build_root != build_root:
 324             print "Error: build targets not under same build root\n"\
 325                   "  %s\n  %s" % (build_root, this_build_root)
 326             Exit(1)
 327     variant_path = joinpath('/',*path_dirs[:build_top+2])
 328     if variant_path not in variant_paths:
 329         variant_paths.append(variant_path)
 330
 331 # Make sure build_root exists (might not if this is the first build there)
 332 if not isdir(build_root):
 333     mkdir(build_root)
 334 main['BUILDROOT'] = build_root
 335
 336 Export('main')
 337
 338 main.SConsignFile(joinpath(build_root, "sconsign"))
 339
 340 # Default duplicate option is to use hard links, but this messes up
 341 # when you use emacs to edit a file in the target dir, as emacs moves
 342 # file to file~ then copies to file, breaking the link.  Symbolic
 343 # (soft) links work better.
 344 main.SetOption('duplicate', 'soft-copy')
 345
 346 #
 347 # Set up global sticky variables... these are common to an entire build
 348 # tree (not specific to a particular build like ALPHA_SE)
 349 #
 350
 351 global_vars_file = joinpath(build_root, 'variables.global')
 352
 353 global_vars = Variables(global_vars_file, args=ARGUMENTS)
 354
 355 global_vars.AddVariables(
 356     ('CC', 'C compiler', environ.get('CC', main['CC'])),
 357     ('CXX', 'C++ compiler', environ.get('CXX', main['CXX'])),
 358     ('BATCH', 'Use batch pool for build and tests', False),
 359     ('BATCH_CMD', 'Batch pool submission command name', 'qdo'),
 360     ('M5_BUILD_CACHE', 'Cache built objects in this directory', False),
 361     ('EXTRAS', 'Add extra directories to the compilation', '')
 362     )
 363
 364 # Update main environment with values from ARGUMENTS & global_vars_file
 365 global_vars.Update(main)
 366 help_texts["global_vars"] += global_vars.GenerateHelpText(main)
 367
 368 # Save sticky variable settings back to current variables file
 369 global_vars.Save(global_vars_file, main)
 370
 371 # Parse EXTRAS variable to build list of all directories where we're
 372 # look for sources etc.  This list is exported as extras_dir_list.
 373 base_dir = main.srcdir.abspath
 374 if main['EXTRAS']:
 375     extras_dir_list = makePathListAbsolute(main['EXTRAS'].split(':'))
 376 else:
 377     extras_dir_list = []
 378
 379 Export('base_dir')
 380 Export('extras_dir_list')
 381
 382 # the ext directory should be on the #includes path
 383 main.Append(CPPPATH=[Dir('ext')])
 384
 385 def strip_build_path(path, env):
 386     path = str(path)
 387     variant_base = env['BUILDROOT'] + os.path.sep
 388     if path.startswith(variant_base):
 389         path = path[len(variant_base):]
 390     elif path.startswith('build/'):
 391         path = path[6:]
 392     return path
 393
 394 # Generate a string of the form:
 395 #   common/path/prefix/src1, src2 -> tgt1, tgt2
 396 # to print while building.
 397 class Transform(object):
 398     # all specific color settings should be here and nowhere else
 399     tool_color = termcap.Normal
 400     pfx_color = termcap.Yellow
 401     srcs_color = termcap.Yellow + termcap.Bold
 402     arrow_color = termcap.Blue + termcap.Bold
 403     tgts_color = termcap.Yellow + termcap.Bold
 404
 405     def __init__(self, tool, max_sources=99):
 406         self.format = self.tool_color + (" [%8s] " % tool) \
 407                       + self.pfx_color + "%s" \
 408                       + self.srcs_color + "%s" \
 409                       + self.arrow_color + " -> " \
 410                       + self.tgts_color + "%s" \
 411                       + termcap.Normal
 412         self.max_sources = max_sources
 413
 414     def __call__(self, target, source, env, for_signature=None):
 415         # truncate source list according to max_sources param
 416         source = source[0:self.max_sources]
 417         def strip(f):
 418             return strip_build_path(str(f), env)
 419         if len(source) > 0:
 420             srcs = map(strip, source)
 421         else:
 422             srcs = ['']
 423         tgts = map(strip, target)
 424         # surprisingly, os.path.commonprefix is a dumb char-by-char string
 425         # operation that has nothing to do with paths.
 426         com_pfx = os.path.commonprefix(srcs + tgts)
 427         com_pfx_len = len(com_pfx)
 428         if com_pfx:
 429             # do some cleanup and sanity checking on common prefix
 430             if com_pfx[-1] == ".":
 431                 # prefix matches all but file extension: ok
 432                 # back up one to change 'foo.cc -> o' to 'foo.cc -> .o'
 433                 com_pfx = com_pfx[0:-1]
 434             elif com_pfx[-1] == "/":
 435                 # common prefix is directory path: OK
 436                 pass
 437             else:
 438                 src0_len = len(srcs[0])
 439                 tgt0_len = len(tgts[0])
 440                 if src0_len == com_pfx_len:
 441                     # source is a substring of target, OK
 442                     pass
 443                 elif tgt0_len == com_pfx_len:
 444                     # target is a substring of source, need to back up to
 445                     # avoid empty string on RHS of arrow
 446                     sep_idx = com_pfx.rfind(".")
 447                     if sep_idx != -1:
 448                         com_pfx = com_pfx[0:sep_idx]
 449                     else:
 450                         com_pfx = ''
 451                 elif src0_len > com_pfx_len and srcs[0][com_pfx_len] == ".":
 452                     # still splitting at file extension: ok
 453                     pass
 454                 else:
 455                     # probably a fluke; ignore it
 456                     com_pfx = ''
 457         # recalculate length in case com_pfx was modified
 458         com_pfx_len = len(com_pfx)
 459         def fmt(files):
 460             f = map(lambda s: s[com_pfx_len:], files)
 461             return ', '.join(f)
 462         return self.format % (com_pfx, fmt(srcs), fmt(tgts))
 463
 464 Export('Transform')
 465
 466
 467 if GetOption('verbose'):
 468     def MakeAction(action, string, *args, **kwargs):
 469         return Action(action, *args, **kwargs)
 470 else:
 471     MakeAction = Action
 472     main['CCCOMSTR']        = Transform("CC")
 473     main['CXXCOMSTR']       = Transform("CXX")
 474     main['ASCOMSTR']        = Transform("AS")
 475     main['SWIGCOMSTR']      = Transform("SWIG")
 476     main['ARCOMSTR']        = Transform("AR", 0)
 477     main['LINKCOMSTR']      = Transform("LINK", 0)
 478     main['RANLIBCOMSTR']    = Transform("RANLIB", 0)
 479     main['M4COMSTR']        = Transform("M4")
 480     main['SHCCCOMSTR']      = Transform("SHCC")
 481     main['SHCXXCOMSTR']     = Transform("SHCXX")
 482 Export('MakeAction')
 483
 484 CXX_version = readCommand([main['CXX'],'--version'], exception=False)
 485 CXX_V = readCommand([main['CXX'],'-V'], exception=False)
 486
 487 main['GCC'] = CXX_version and CXX_version.find('g++') >= 0
 488 main['SUNCC'] = CXX_V and CXX_V.find('Sun C++') >= 0
 489 main['ICC'] = CXX_V and CXX_V.find('Intel') >= 0
 490 main['CLANG'] = CXX_V and CXX_V.find('clang') >= 0
 491 if main['GCC'] + main['SUNCC'] + main['ICC'] + main['CLANG'] > 1:
 492     print 'Error: How can we have two at the same time?'
 493     Exit(1)
 494
 495 # Set up default C++ compiler flags
 496 if main['GCC']:
 497     main.Append(CCFLAGS=['-pipe'])
 498     main.Append(CCFLAGS=['-fno-strict-aliasing'])
 499     main.Append(CCFLAGS=['-Wall', '-Wno-sign-compare', '-Wundef'])
 500     main.Append(CXXFLAGS=['-Wno-deprecated'])
 501     # Read the GCC version to check for versions with bugs
 502     # Note CCVERSION doesn't work here because it is run with the CC
 503     # before we override it from the command line
 504     gcc_version = readCommand([main['CXX'], '-dumpversion'], exception=False)
 505     main['GCC_VERSION'] = gcc_version
 506     if not compareVersions(gcc_version, '4.4.1') or \
 507        not compareVersions(gcc_version, '4.4.2'):
 508         print 'Info: Tree vectorizer in GCC 4.4.1 & 4.4.2 is buggy, disabling.'
 509         main.Append(CCFLAGS=['-fno-tree-vectorize'])
 510 elif main['ICC']:
 511     pass #Fix me... add warning flags once we clean up icc warnings
 512 elif main['SUNCC']:
 513     main.Append(CCFLAGS=['-Qoption ccfe'])
 514     main.Append(CCFLAGS=['-features=gcc'])
 515     main.Append(CCFLAGS=['-features=extensions'])
 516     main.Append(CCFLAGS=['-library=stlport4'])
 517     main.Append(CCFLAGS=['-xar'])
 518     #main.Append(CCFLAGS=['-instances=semiexplicit'])
 519 elif main['CLANG']:
 520     clang_version_re = re.compile(".* version (\d+\.\d+)")
 521     clang_version_match = clang_version_re.match(CXX_version)
 522     if (clang_version_match):
 523         clang_version = clang_version_match.groups()[0]
 524         if compareVersions(clang_version, "2.9") < 0:
 525             print 'Error: clang version 2.9 or newer required.'
 526             print '       Installed version:', clang_version
 527             Exit(1)
 528     else:
 529         print 'Error: Unable to determine clang version.'
 530         Exit(1)
 531
 532     main.Append(CCFLAGS=['-pipe'])
 533     main.Append(CCFLAGS=['-fno-strict-aliasing'])
 534     main.Append(CCFLAGS=['-Wall', '-Wno-sign-compare', '-Wundef'])
 535     main.Append(CCFLAGS=['-Wno-tautological-compare'])
 536     main.Append(CCFLAGS=['-Wno-self-assign'])
 537 else:
 538     print 'Error: Don\'t know what compiler options to use for your compiler.'
 539     print '       Please fix SConstruct and src/SConscript and try again.'
 540     Exit(1)
 541
 542 # Set up common yacc/bison flags (needed for Ruby)
 543 main['YACCFLAGS'] = '-d'
 544 main['YACCHXXFILESUFFIX'] = '.hh'
 545
 546 # Do this after we save setting back, or else we'll tack on an
 547 # extra 'qdo' every time we run scons.
 548 if main['BATCH']:
 549     main['CC']     = main['BATCH_CMD'] + ' ' + main['CC']
 550     main['CXX']    = main['BATCH_CMD'] + ' ' + main['CXX']
 551     main['AS']     = main['BATCH_CMD'] + ' ' + main['AS']
 552     main['AR']     = main['BATCH_CMD'] + ' ' + main['AR']
 553     main['RANLIB'] = main['BATCH_CMD'] + ' ' + main['RANLIB']
 554
 555 if sys.platform == 'cygwin':
 556     # cygwin has some header file issues...
 557     main.Append(CCFLAGS=["-Wno-uninitialized"])
 558
 559 # Check for SWIG
 560 if not main.has_key('SWIG'):
 561     print 'Error: SWIG utility not found.'
 562     print '       Please install (see http://www.swig.org) and retry.'
 563     Exit(1)
 564
 565 # Check for appropriate SWIG version
 566 swig_version = readCommand(('swig', '-version'), exception='').split()
 567 # First 3 words should be "SWIG Version x.y.z"
 568 if len(swig_version) < 3 or \
 569         swig_version[0] != 'SWIG' or swig_version[1] != 'Version':
 570     print 'Error determining SWIG version.'
 571     Exit(1)
 572
 573 min_swig_version = '1.3.28'
 574 if compareVersions(swig_version[2], min_swig_version) < 0:
 575     print 'Error: SWIG version', min_swig_version, 'or newer required.'
 576     print '       Installed version:', swig_version[2]
 577     Exit(1)
 578
 579 # Set up SWIG flags & scanner
 580 swig_flags=Split('-c++ -python -modern -templatereduce $_CPPINCFLAGS')
 581 main.Append(SWIGFLAGS=swig_flags)
 582
 583 # filter out all existing swig scanners, they mess up the dependency
 584 # stuff for some reason
 585 scanners = []
 586 for scanner in main['SCANNERS']:
 587     skeys = scanner.skeys
 588     if skeys == '.i':
 589         continue
 590
 591     if isinstance(skeys, (list, tuple)) and '.i' in skeys:
 592         continue
 593
 594     scanners.append(scanner)
 595
 596 # add the new swig scanner that we like better
 597 from SCons.Scanner import ClassicCPP as CPPScanner
 598 swig_inc_re = '^[ \t]*[%,#][ \t]*(?:include|import)[ \t]*(<|")([^>"]+)(>|")'
 599 scanners.append(CPPScanner("SwigScan", [ ".i" ], "CPPPATH", swig_inc_re))
 600
 601 # replace the scanners list that has what we want
 602 main['SCANNERS'] = scanners
 603
 604 # Add a custom Check function to the Configure context so that we can
 605 # figure out if the compiler adds leading underscores to global
 606 # variables.  This is needed for the autogenerated asm files that we
 607 # use for embedding the python code.
 608 def CheckLeading(context):
 609     context.Message("Checking for leading underscore in global variables...")
 610     # 1) Define a global variable called x from asm so the C compiler
 611     #    won't change the symbol at all.
 612     # 2) Declare that variable.
 613     # 3) Use the variable
 614     #
 615     # If the compiler prepends an underscore, this will successfully
 616     # link because the external symbol 'x' will be called '_x' which
 617     # was defined by the asm statement.  If the compiler does not
 618     # prepend an underscore, this will not successfully link because
 619     # '_x' will have been defined by assembly, while the C portion of
 620     # the code will be trying to use 'x'
 621     ret = context.TryLink('''
 622         asm(".globl _x; _x: .byte 0");
 623         extern int x;
 624         int main() { return x; }
 625         ''', extension=".c")
 626     context.env.Append(LEADING_UNDERSCORE=ret)
 627     context.Result(ret)
 628     return ret
 629
 630 # Platform-specific configuration.  Note again that we assume that all
 631 # builds under a given build root run on the same host platform.
 632 conf = Configure(main,
 633                  conf_dir = joinpath(build_root, '.scons_config'),
 634                  log_file = joinpath(build_root, 'scons_config.log'),
 635                  custom_tests = { 'CheckLeading' : CheckLeading })
 636
 637 # Check for leading underscores.  Don't really need to worry either
 638 # way so don't need to check the return code.
 639 conf.CheckLeading()
 640
 641 # Check if we should compile a 64 bit binary on Mac OS X/Darwin
 642 try:
 643     import platform
 644     uname = platform.uname()
 645     if uname[0] == 'Darwin' and compareVersions(uname[2], '9.0.0') >= 0:
 646         if int(readCommand('sysctl -n hw.cpu64bit_capable')[0]):
 647             main.Append(CCFLAGS=['-arch', 'x86_64'])
 648             main.Append(CFLAGS=['-arch', 'x86_64'])
 649             main.Append(LINKFLAGS=['-arch', 'x86_64'])
 650             main.Append(ASFLAGS=['-arch', 'x86_64'])
 651 except:
 652     pass
 653
 654 # Recent versions of scons substitute a "Null" object for Configure()
 655 # when configuration isn't necessary, e.g., if the "--help" option is
 656 # present.  Unfortuantely this Null object always returns false,
 657 # breaking all our configuration checks.  We replace it with our own
 658 # more optimistic null object that returns True instead.
 659 if not conf:
 660     def NullCheck(*args, **kwargs):
 661         return True
 662
 663     class NullConf:
 664         def __init__(self, env):
 665             self.env = env
 666         def Finish(self):
 667             return self.env
 668         def __getattr__(self, mname):
 669             return NullCheck
 670
 671     conf = NullConf(main)
 672
 673 # Find Python include and library directories for embedding the
 674 # interpreter.  For consistency, we will use the same Python
 675 # installation used to run scons (and thus this script).  If you want
 676 # to link in an alternate version, see above for instructions on how
 677 # to invoke scons with a different copy of the Python interpreter.
 678 from distutils import sysconfig
 679
 680 py_getvar = sysconfig.get_config_var
 681
 682 py_debug = getattr(sys, 'pydebug', False)
 683 py_version = 'python' + py_getvar('VERSION') + (py_debug and "_d" or "")
 684
 685 py_general_include = sysconfig.get_python_inc()
 686 py_platform_include = sysconfig.get_python_inc(plat_specific=True)
 687 py_includes = [ py_general_include ]
 688 if py_platform_include != py_general_include:
 689     py_includes.append(py_platform_include)
 690
 691 py_lib_path = [ py_getvar('LIBDIR') ]
 692 # add the prefix/lib/pythonX.Y/config dir, but only if there is no
 693 # shared library in prefix/lib/.
 694 if not py_getvar('Py_ENABLE_SHARED'):
 695     py_lib_path.append(py_getvar('LIBPL'))
 696
 697 py_libs = []
 698 for lib in py_getvar('LIBS').split() + py_getvar('SYSLIBS').split():
 699     if not lib.startswith('-l'):
 700         # Python requires some special flags to link (e.g. -framework
 701         # common on OS X systems), assume appending preserves order
 702         main.Append(LINKFLAGS=[lib])
 703     else:
 704         lib = lib[2:]
 705         if lib not in py_libs:
 706             py_libs.append(lib)
 707 py_libs.append(py_version)
 708
 709 main.Append(CPPPATH=py_includes)
 710 main.Append(LIBPATH=py_lib_path)
 711
 712 # Cache build files in the supplied directory.
 713 if main['M5_BUILD_CACHE']:
 714     print 'Using build cache located at', main['M5_BUILD_CACHE']
 715     CacheDir(main['M5_BUILD_CACHE'])
 716
 717
 718 # verify that this stuff works
 719 if not conf.CheckHeader('Python.h', '<>'):
 720     print "Error: can't find Python.h header in", py_includes
 721     Exit(1)
 722
 723 for lib in py_libs:
 724     if not conf.CheckLib(lib):
 725         print "Error: can't find library %s required by python" % lib
 726         Exit(1)
 727
 728 # On Solaris you need to use libsocket for socket ops
 729 if not conf.CheckLibWithHeader(None, 'sys/socket.h', 'C++', 'accept(0,0,0);'):
 730    if not conf.CheckLibWithHeader('socket', 'sys/socket.h', 'C++', 'accept(0,0,0);'):
 731        print "Can't find library with socket calls (e.g. accept())"
 732        Exit(1)
 733
 734 # Check for zlib.  If the check passes, libz will be automatically
 735 # added to the LIBS environment variable.
 736 if not conf.CheckLibWithHeader('z', 'zlib.h', 'C++','zlibVersion();'):
 737     print 'Error: did not find needed zlib compression library '\
 738           'and/or zlib.h header file.'
 739     print '       Please install zlib and try again.'
 740     Exit(1)
 741
 742 # Check for librt.
 743 have_posix_clock = \
 744     conf.CheckLibWithHeader(None, 'time.h', 'C',
 745                             'clock_nanosleep(0,0,NULL,NULL);') or \
 746     conf.CheckLibWithHeader('rt', 'time.h', 'C',
 747                             'clock_nanosleep(0,0,NULL,NULL);')
 748
 749 if not have_posix_clock:
 750     print "Can't find library for POSIX clocks."
 751
 752 # Check for <fenv.h> (C99 FP environment control)
 753 have_fenv = conf.CheckHeader('fenv.h', '<>')
 754 if not have_fenv:
 755     print "Warning: Header file <fenv.h> not found."
 756     print "         This host has no IEEE FP rounding mode control."
 757
 758 ######################################################################
 759 #
 760 # Finish the configuration
 761 #
 762 main = conf.Finish()
 763
 764 ######################################################################
 765 #
 766 # Collect all non-global variables
 767 #
 768
 769 # Define the universe of supported ISAs
 770 all_isa_list = [ ]
 771 Export('all_isa_list')
 772
 773 class CpuModel(object):
 774     '''The CpuModel class encapsulates everything the ISA parser needs to
 775     know about a particular CPU model.'''
 776
 777     # Dict of available CPU model objects.  Accessible as CpuModel.dict.
 778     dict = {}
 779     list = []
 780     defaults = []
 781
 782     # Constructor.  Automatically adds models to CpuModel.dict.
 783     def __init__(self, name, filename, includes, strings, default=False):
 784         self.name = name           # name of model
 785         self.filename = filename   # filename for output exec code
 786         self.includes = includes   # include files needed in exec file
 787         # The 'strings' dict holds all the per-CPU symbols we can
 788         # substitute into templates etc.
 789         self.strings = strings
 790
 791         # This cpu is enabled by default
 792         self.default = default
 793
 794         # Add self to dict
 795         if name in CpuModel.dict:
 796             raise AttributeError, "CpuModel '%s' already registered" % name
 797         CpuModel.dict[name] = self
 798         CpuModel.list.append(name)
 799
 800 Export('CpuModel')
 801
 802 # Sticky variables get saved in the variables file so they persist from
 803 # one invocation to the next (unless overridden, in which case the new
 804 # value becomes sticky).
 805 sticky_vars = Variables(args=ARGUMENTS)
 806 Export('sticky_vars')
 807
 808 # Sticky variables that should be exported
 809 export_vars = []
 810 Export('export_vars')
 811
 812 # Walk the tree and execute all SConsopts scripts that wil add to the
 813 # above variables
 814 if not GetOption('verbose'):
 815     print "Reading SConsopts"
 816 for bdir in [ base_dir ] + extras_dir_list:
 817     if not isdir(bdir):
 818         print "Error: directory '%s' does not exist" % bdir
 819         Exit(1)
 820     for root, dirs, files in os.walk(bdir):
 821         if 'SConsopts' in files:
 822             if GetOption('verbose'):
 823                 print "Reading", joinpath(root, 'SConsopts')
 824             SConscript(joinpath(root, 'SConsopts'))
 825
 826 all_isa_list.sort()
 827
 828 sticky_vars.AddVariables(
 829     EnumVariable('TARGET_ISA', 'Target ISA', 'alpha', all_isa_list),
 830     ListVariable('CPU_MODELS', 'CPU models',
 831                  sorted(n for n,m in CpuModel.dict.iteritems() if m.default),
 832                  sorted(CpuModel.list)),
 833     BoolVariable('NO_FAST_ALLOC', 'Disable fast object allocator', False),
 834     BoolVariable('FORCE_FAST_ALLOC',
 835                  'Enable fast object allocator, even for gem5.debug', False),
 836     BoolVariable('FAST_ALLOC_STATS', 'Enable fast object allocator statistics',
 837                  False),
 838     BoolVariable('EFENCE', 'Link with Electric Fence malloc debugger',
 839                  False),
 840     BoolVariable('SS_COMPATIBLE_FP',
 841                  'Make floating-point results compatible with SimpleScalar',
 842                  False),
 843     BoolVariable('USE_SSE2',
 844                  'Compile for SSE2 (-msse2) to get IEEE FP on x86 hosts',
 845                  False),
 846     BoolVariable('USE_POSIX_CLOCK', 'Use POSIX Clocks', have_posix_clock),
 847     BoolVariable('USE_FENV', 'Use <fenv.h> IEEE mode control', have_fenv),
 848     BoolVariable('USE_CHECKER', 'Use checker for detailed CPU models', False),
 849     BoolVariable('CP_ANNOTATE', 'Enable critical path annotation capability', False),
 850     )
 851
 852 # These variables get exported to #defines in config/*.hh (see src/SConscript).
 853 export_vars += ['USE_FENV', 'NO_FAST_ALLOC', 'FORCE_FAST_ALLOC',
 854                 'FAST_ALLOC_STATS', 'SS_COMPATIBLE_FP', 'USE_CHECKER',
 855                 'TARGET_ISA', 'CP_ANNOTATE', 'USE_POSIX_CLOCK' ]
 856
 857 ###################################################
 858 #
 859 # Define a SCons builder for configuration flag headers.
 860 #
 861 ###################################################
 862
 863 # This function generates a config header file that #defines the
 864 # variable symbol to the current variable setting (0 or 1).  The source
 865 # operands are the name of the variable and a Value node containing the
 866 # value of the variable.
 867 def build_config_file(target, source, env):
 868     (variable, value) = [s.get_contents() for s in source]
 869     f = file(str(target[0]), 'w')
 870     print >> f, '#define', variable, value
 871     f.close()
 872     return None
 873
 874 # Combine the two functions into a scons Action object.
 875 config_action = MakeAction(build_config_file, Transform("CONFIG H", 2))
 876
 877 # The emitter munges the source & target node lists to reflect what
 878 # we're really doing.
 879 def config_emitter(target, source, env):
 880     # extract variable name from Builder arg
 881     variable = str(target[0])
 882     # True target is config header file
 883     target = joinpath('config', variable.lower() + '.hh')
 884     val = env[variable]
 885     if isinstance(val, bool):
 886         # Force value to 0/1
 887         val = int(val)
 888     elif isinstance(val, str):
 889         val = '"' + val + '"'
 890
 891     # Sources are variable name & value (packaged in SCons Value nodes)
 892     return ([target], [Value(variable), Value(val)])
 893
 894 config_builder = Builder(emitter = config_emitter, action = config_action)
 895
 896 main.Append(BUILDERS = { 'ConfigFile' : config_builder })
 897
 898 # libelf build is shared across all configs in the build root.
 899 main.SConscript('ext/libelf/SConscript',
 900                 variant_dir = joinpath(build_root, 'libelf'))
 901
 902 # gzstream build is shared across all configs in the build root.
 903 main.SConscript('ext/gzstream/SConscript',
 904                 variant_dir = joinpath(build_root, 'gzstream'))
 905
 906 ###################################################
 907 #
 908 # This function is used to set up a directory with switching headers
 909 #
 910 ###################################################
 911
 912 main['ALL_ISA_LIST'] = all_isa_list
 913 def make_switching_dir(dname, switch_headers, env):
 914     # Generate the header.  target[0] is the full path of the output
 915     # header to generate.  'source' is a dummy variable, since we get the
 916     # list of ISAs from env['ALL_ISA_LIST'].
 917     def gen_switch_hdr(target, source, env):
 918         fname = str(target[0])
 919         f = open(fname, 'w')
 920         isa = env['TARGET_ISA'].lower()
 921         print >>f, '#include "%s/%s/%s"' % (dname, isa, basename(fname))
 922         f.close()
 923
 924     # Build SCons Action object. 'varlist' specifies env vars that this
 925     # action depends on; when env['ALL_ISA_LIST'] changes these actions
 926     # should get re-executed.
 927     switch_hdr_action = MakeAction(gen_switch_hdr,
 928                           Transform("GENERATE"), varlist=['ALL_ISA_LIST'])
 929
 930     # Instantiate actions for each header
 931     for hdr in switch_headers:
 932         env.Command(hdr, [], switch_hdr_action)
 933 Export('make_switching_dir')
 934
 935 ###################################################
 936 #
 937 # Define build environments for selected configurations.
 938 #
 939 ###################################################
 940
 941 for variant_path in variant_paths:
 942     print "Building in", variant_path
 943
 944     # Make a copy of the build-root environment to use for this config.
 945     env = main.Clone()
 946     env['BUILDDIR'] = variant_path
 947
 948     # variant_dir is the tail component of build path, and is used to
 949     # determine the build parameters (e.g., 'ALPHA_SE')
 950     (build_root, variant_dir) = splitpath(variant_path)
 951
 952     # Set env variables according to the build directory config.
 953     sticky_vars.files = []
 954     # Variables for $BUILD_ROOT/$VARIANT_DIR are stored in
 955     # $BUILD_ROOT/variables/$VARIANT_DIR so you can nuke
 956     # $BUILD_ROOT/$VARIANT_DIR without losing your variables settings.
 957     current_vars_file = joinpath(build_root, 'variables', variant_dir)
 958     if isfile(current_vars_file):
 959         sticky_vars.files.append(current_vars_file)
 960         print "Using saved variables file %s" % current_vars_file
 961     else:
 962         # Build dir-specific variables file doesn't exist.
 963
 964         # Make sure the directory is there so we can create it later
 965         opt_dir = dirname(current_vars_file)
 966         if not isdir(opt_dir):
 967             mkdir(opt_dir)
 968
 969         # Get default build variables from source tree.  Variables are
 970         # normally determined by name of $VARIANT_DIR, but can be
 971         # overridden by '--default=' arg on command line.
 972         default = GetOption('default')
 973         opts_dir = joinpath(main.root.abspath, 'build_opts')
 974         if default:
 975             default_vars_files = [joinpath(build_root, 'variables', default),
 976                                   joinpath(opts_dir, default)]
 977         else:
 978             default_vars_files = [joinpath(opts_dir, variant_dir)]
 979         existing_files = filter(isfile, default_vars_files)
 980         if existing_files:
 981             default_vars_file = existing_files[0]
 982             sticky_vars.files.append(default_vars_file)
 983             print "Variables file %s not found,\n  using defaults in %s" \
 984                   % (current_vars_file, default_vars_file)
 985         else:
 986             print "Error: cannot find variables file %s or " \
 987                   "default file(s) %s" \
 988                   % (current_vars_file, ' or '.join(default_vars_files))
 989             Exit(1)
 990
 991     # Apply current variable settings to env
 992     sticky_vars.Update(env)
 993
 994     help_texts["local_vars"] += \
 995         "Build variables for %s:\n" % variant_dir \
 996                  + sticky_vars.GenerateHelpText(env)
 997
 998     # Process variable settings.
 999
1000     if not have_fenv and env['USE_FENV']:
1001         print "Warning: <fenv.h> not available; " \
1002               "forcing USE_FENV to False in", variant_dir + "."
1003         env['USE_FENV'] = False
1004
1005     if not env['USE_FENV']:
1006         print "Warning: No IEEE FP rounding mode control in", variant_dir + "."
1007         print "         FP results may deviate slightly from other platforms."
1008
1009     if env['EFENCE']:
1010         env.Append(LIBS=['efence'])
1011
1012     # Save sticky variable settings back to current variables file
1013     sticky_vars.Save(current_vars_file, env)
1014
1015     if env['USE_SSE2']:
1016         env.Append(CCFLAGS=['-msse2'])
1017
1018     # The src/SConscript file sets up the build rules in 'env' according
1019     # to the configured variables.  It returns a list of environments,
1020     # one for each variant build (debug, opt, etc.)
1021     envList = SConscript('src/SConscript', variant_dir = variant_path,
1022                          exports = 'env')
1023
1024     # Set up the regression tests for each build.
1025     for e in envList:
1026         SConscript('tests/SConscript',
1027                    variant_dir = joinpath(variant_path, 'tests', e.Label),
1028                    exports = { 'env' : e }, duplicate = False)
1029
1030 # base help text
1031 Help('''
1032 Usage: scons [scons options] [build variables] [target(s)]
1033
1034 Extra scons options:
1035 %(options)s
1036
1037 Global build variables:
1038 %(global_vars)s
1039
1040 %(local_vars)s
1041 ''' % help_texts)