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 ('m5'), 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_FS/m5.opt' for
  41 # the optimized full-system version).
  42 #
  43 # You can build M5 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>/m5 ; scons build/ALPHA_FS/m5.debug
  53 #   % cd <path-to-src>/m5/build/ALPHA_FS; scons -u m5.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>/m5 ; scons /local/foo/build/ALPHA_FS/m5.debug
  60 #   % cd /local/foo/build/ALPHA_FS; scons -C <path-to-src>/m5 m5.debug
  61 #
  62 # You can use 'scons -H' to print scons options.  If you're in this
  63 # 'm5' directory (or use -u or -C to tell scons where to find this
  64 # file), you can use 'scons -h' to print all the M5-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://m5sim.org/wiki/index.php/Compiling_M5
  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://m5sim.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, # M5 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 AddOption('--colors', dest='use_colors', action='store_true')
 125 AddOption('--no-colors', dest='use_colors', action='store_false')
 126 use_colors = GetOption('use_colors')
 127
 128 if use_colors:
 129     from m5.util.terminal import termcap
 130 elif use_colors is None:
 131     # option unspecified; default behavior is to use colors iff isatty
 132     from m5.util.terminal import tty_termcap as termcap
 133 else:
 134     from m5.util.terminal import no_termcap as termcap
 135
 136 ########################################################################
 137 #
 138 # Set up the main build environment.
 139 #
 140 ########################################################################
 141 use_vars = set([ 'AS', 'AR', 'CC', 'CXX', 'HOME', 'LD_LIBRARY_PATH', 'PATH',
 142                  'PYTHONPATH', 'RANLIB' ])
 143
 144 use_env = {}
 145 for key,val in os.environ.iteritems():
 146     if key in use_vars or key.startswith("M5"):
 147         use_env[key] = val
 148
 149 main = Environment(ENV=use_env)
 150 main.root = Dir(".")         # The current directory (where this file lives).
 151 main.srcdir = Dir("src")     # The source directory
 152
 153 # add useful python code PYTHONPATH so it can be used by subprocesses
 154 # as well
 155 main.AppendENVPath('PYTHONPATH', extra_python_paths)
 156
 157 ########################################################################
 158 #
 159 # Mercurial Stuff.
 160 #
 161 # If the M5 directory is a mercurial repository, we should do some
 162 # extra things.
 163 #
 164 ########################################################################
 165
 166 hgdir = main.root.Dir(".hg")
 167
 168 mercurial_style_message = """
 169 You're missing the M5 style hook.
 170 Please install the hook so we can ensure that all code fits a common style.
 171
 172 All you'd need to do is add the following lines to your repository .hg/hgrc
 173 or your personal .hgrc
 174 ----------------
 175
 176 [extensions]
 177 style = %s/util/style.py
 178
 179 [hooks]
 180 pretxncommit.style = python:style.check_style
 181 pre-qrefresh.style = python:style.check_style
 182 """ % (main.root)
 183
 184 mercurial_bin_not_found = """
 185 Mercurial binary cannot be found, unfortunately this means that we
 186 cannot easily determine the version of M5 that you are running and
 187 this makes error messages more difficult to collect.  Please consider
 188 installing mercurial if you choose to post an error message
 189 """
 190
 191 mercurial_lib_not_found = """
 192 Mercurial libraries cannot be found, ignoring style hook
 193 If you are actually a M5 developer, please fix this and
 194 run the style hook. It is important.
 195 """
 196
 197 hg_info = "Unknown"
 198 if hgdir.exists():
 199     # 1) Grab repository revision if we know it.
 200     cmd = "hg id -n -i -t -b"
 201     try:
 202         hg_info = readCommand(cmd, cwd=main.root.abspath).strip()
 203     except OSError:
 204         print mercurial_bin_not_found
 205
 206     # 2) Ensure that the style hook is in place.
 207     try:
 208         ui = None
 209         if ARGUMENTS.get('IGNORE_STYLE') != 'True':
 210             from mercurial import ui
 211             ui = ui.ui()
 212     except ImportError:
 213         print mercurial_lib_not_found
 214
 215     if ui is not None:
 216         ui.readconfig(hgdir.File('hgrc').abspath)
 217         style_hook = ui.config('hooks', 'pretxncommit.style', None)
 218
 219         if not style_hook:
 220             print mercurial_style_message
 221             sys.exit(1)
 222 else:
 223     print ".hg directory not found"
 224
 225 main['HG_INFO'] = hg_info
 226
 227 ###################################################
 228 #
 229 # Figure out which configurations to set up based on the path(s) of
 230 # the target(s).
 231 #
 232 ###################################################
 233
 234 # Find default configuration & binary.
 235 Default(environ.get('M5_DEFAULT_BINARY', 'build/ALPHA_SE/m5.debug'))
 236
 237 # helper function: find last occurrence of element in list
 238 def rfind(l, elt, offs = -1):
 239     for i in range(len(l)+offs, 0, -1):
 240         if l[i] == elt:
 241             return i
 242     raise ValueError, "element not found"
 243
 244 # Each target must have 'build' in the interior of the path; the
 245 # directory below this will determine the build parameters.  For
 246 # example, for target 'foo/bar/build/ALPHA_SE/arch/alpha/blah.do' we
 247 # recognize that ALPHA_SE specifies the configuration because it
 248 # follow 'build' in the bulid path.
 249
 250 # Generate absolute paths to targets so we can see where the build dir is
 251 if COMMAND_LINE_TARGETS:
 252     # Ask SCons which directory it was invoked from
 253     launch_dir = GetLaunchDir()
 254     # Make targets relative to invocation directory
 255     abs_targets = [ normpath(joinpath(launch_dir, str(x))) for x in \
 256                     COMMAND_LINE_TARGETS]
 257 else:
 258     # Default targets are relative to root of tree
 259     abs_targets = [ normpath(joinpath(main.root.abspath, str(x))) for x in \
 260                     DEFAULT_TARGETS]
 261
 262
 263 # Generate a list of the unique build roots and configs that the
 264 # collected targets reference.
 265 variant_paths = []
 266 build_root = None
 267 for t in abs_targets:
 268     path_dirs = t.split('/')
 269     try:
 270         build_top = rfind(path_dirs, 'build', -2)
 271     except:
 272         print "Error: no non-leaf 'build' dir found on target path", t
 273         Exit(1)
 274     this_build_root = joinpath('/',*path_dirs[:build_top+1])
 275     if not build_root:
 276         build_root = this_build_root
 277     else:
 278         if this_build_root != build_root:
 279             print "Error: build targets not under same build root\n"\
 280                   "  %s\n  %s" % (build_root, this_build_root)
 281             Exit(1)
 282     variant_path = joinpath('/',*path_dirs[:build_top+2])
 283     if variant_path not in variant_paths:
 284         variant_paths.append(variant_path)
 285
 286 # Make sure build_root exists (might not if this is the first build there)
 287 if not isdir(build_root):
 288     mkdir(build_root)
 289 main['BUILDROOT'] = build_root
 290
 291 Export('main')
 292
 293 main.SConsignFile(joinpath(build_root, "sconsign"))
 294
 295 # Default duplicate option is to use hard links, but this messes up
 296 # when you use emacs to edit a file in the target dir, as emacs moves
 297 # file to file~ then copies to file, breaking the link.  Symbolic
 298 # (soft) links work better.
 299 main.SetOption('duplicate', 'soft-copy')
 300
 301 #
 302 # Set up global sticky variables... these are common to an entire build
 303 # tree (not specific to a particular build like ALPHA_SE)
 304 #
 305
 306 # Variable validators & converters for global sticky variables
 307 def PathListMakeAbsolute(val):
 308     if not val:
 309         return val
 310     f = lambda p: abspath(expanduser(p))
 311     return ':'.join(map(f, val.split(':')))
 312
 313 def PathListAllExist(key, val, env):
 314     if not val:
 315         return
 316     paths = val.split(':')
 317     for path in paths:
 318         if not isdir(path):
 319             raise SCons.Errors.UserError("Path does not exist: '%s'" % path)
 320
 321 global_sticky_vars_file = joinpath(build_root, 'variables.global')
 322
 323 global_sticky_vars = Variables(global_sticky_vars_file, args=ARGUMENTS)
 324 global_nonsticky_vars = Variables(args=ARGUMENTS)
 325
 326 global_sticky_vars.AddVariables(
 327     ('CC', 'C compiler', environ.get('CC', main['CC'])),
 328     ('CXX', 'C++ compiler', environ.get('CXX', main['CXX'])),
 329     ('BATCH', 'Use batch pool for build and tests', False),
 330     ('BATCH_CMD', 'Batch pool submission command name', 'qdo'),
 331     ('M5_BUILD_CACHE', 'Cache built objects in this directory', False),
 332     ('EXTRAS', 'Add Extra directories to the compilation', '',
 333      PathListAllExist, PathListMakeAbsolute),
 334     )
 335
 336 global_nonsticky_vars.AddVariables(
 337     ('VERBOSE', 'Print full tool command lines', False),
 338     ('update_ref', 'Update test reference outputs', False)
 339     )
 340
 341
 342 # base help text
 343 help_text = '''
 344 Usage: scons [scons options] [build options] [target(s)]
 345
 346 Global sticky options:
 347 '''
 348
 349 # Update main environment with values from ARGUMENTS & global_sticky_vars_file
 350 global_sticky_vars.Update(main)
 351 global_nonsticky_vars.Update(main)
 352
 353 help_text += global_sticky_vars.GenerateHelpText(main)
 354 help_text += global_nonsticky_vars.GenerateHelpText(main)
 355
 356 # Save sticky variable settings back to current variables file
 357 global_sticky_vars.Save(global_sticky_vars_file, main)
 358
 359 # Parse EXTRAS variable to build list of all directories where we're
 360 # look for sources etc.  This list is exported as base_dir_list.
 361 base_dir = main.srcdir.abspath
 362 if main['EXTRAS']:
 363     extras_dir_list = main['EXTRAS'].split(':')
 364 else:
 365     extras_dir_list = []
 366
 367 Export('base_dir')
 368 Export('extras_dir_list')
 369
 370 # the ext directory should be on the #includes path
 371 main.Append(CPPPATH=[Dir('ext')])
 372
 373 def strip_build_path(path, env):
 374     path = str(path)
 375     variant_base = env['BUILDROOT'] + os.path.sep
 376     if path.startswith(variant_base):
 377         path = path[len(variant_base):]
 378     elif path.startswith('build/'):
 379         path = path[6:]
 380     return path
 381
 382 # Generate a string of the form:
 383 #   common/path/prefix/src1, src2 -> tgt1, tgt2
 384 # to print while building.
 385 class Transform(object):
 386     # all specific color settings should be here and nowhere else
 387     tool_color = termcap.Normal
 388     pfx_color = termcap.Yellow
 389     srcs_color = termcap.Yellow + termcap.Bold
 390     arrow_color = termcap.Blue + termcap.Bold
 391     tgts_color = termcap.Yellow + termcap.Bold
 392
 393     def __init__(self, tool, max_sources=99):
 394         self.format = self.tool_color + (" [%8s] " % tool) \
 395                       + self.pfx_color + "%s" \
 396                       + self.srcs_color + "%s" \
 397                       + self.arrow_color + " -> " \
 398                       + self.tgts_color + "%s" \
 399                       + termcap.Normal
 400         self.max_sources = max_sources
 401
 402     def __call__(self, target, source, env, for_signature=None):
 403         # truncate source list according to max_sources param
 404         source = source[0:self.max_sources]
 405         def strip(f):
 406             return strip_build_path(str(f), env)
 407         if len(source) > 0:
 408             srcs = map(strip, source)
 409         else:
 410             srcs = ['']
 411         tgts = map(strip, target)
 412         # surprisingly, os.path.commonprefix is a dumb char-by-char string
 413         # operation that has nothing to do with paths.
 414         com_pfx = os.path.commonprefix(srcs + tgts)
 415         com_pfx_len = len(com_pfx)
 416         if com_pfx:
 417             # do some cleanup and sanity checking on common prefix
 418             if com_pfx[-1] == ".":
 419                 # prefix matches all but file extension: ok
 420                 # back up one to change 'foo.cc -> o' to 'foo.cc -> .o'
 421                 com_pfx = com_pfx[0:-1]
 422             elif com_pfx[-1] == "/":
 423                 # common prefix is directory path: OK
 424                 pass
 425             else:
 426                 src0_len = len(srcs[0])
 427                 tgt0_len = len(tgts[0])
 428                 if src0_len == com_pfx_len:
 429                     # source is a substring of target, OK
 430                     pass
 431                 elif tgt0_len == com_pfx_len:
 432                     # target is a substring of source, need to back up to
 433                     # avoid empty string on RHS of arrow
 434                     sep_idx = com_pfx.rfind(".")
 435                     if sep_idx != -1:
 436                         com_pfx = com_pfx[0:sep_idx]
 437                     else:
 438                         com_pfx = ''
 439                 elif src0_len > com_pfx_len and srcs[0][com_pfx_len] == ".":
 440                     # still splitting at file extension: ok
 441                     pass
 442                 else:
 443                     # probably a fluke; ignore it
 444                     com_pfx = ''
 445         # recalculate length in case com_pfx was modified
 446         com_pfx_len = len(com_pfx)
 447         def fmt(files):
 448             f = map(lambda s: s[com_pfx_len:], files)
 449             return ', '.join(f)
 450         return self.format % (com_pfx, fmt(srcs), fmt(tgts))
 451
 452 Export('Transform')
 453
 454
 455 if main['VERBOSE']:
 456     def MakeAction(action, string, *args, **kwargs):
 457         return Action(action, *args, **kwargs)
 458 else:
 459     MakeAction = Action
 460     main['CCCOMSTR']        = Transform("CC")
 461     main['CXXCOMSTR']       = Transform("CXX")
 462     main['ASCOMSTR']        = Transform("AS")
 463     main['SWIGCOMSTR']      = Transform("SWIG")
 464     main['ARCOMSTR']        = Transform("AR", 0)
 465     main['LINKCOMSTR']      = Transform("LINK", 0)
 466     main['RANLIBCOMSTR']    = Transform("RANLIB", 0)
 467     main['M4COMSTR']        = Transform("M4")
 468     main['SHCCCOMSTR']      = Transform("SHCC")
 469     main['SHCXXCOMSTR']     = Transform("SHCXX")
 470 Export('MakeAction')
 471
 472 CXX_version = readCommand([main['CXX'],'--version'], exception=False)
 473 CXX_V = readCommand([main['CXX'],'-V'], exception=False)
 474
 475 main['GCC'] = CXX_version and CXX_version.find('g++') >= 0
 476 main['SUNCC'] = CXX_V and CXX_V.find('Sun C++') >= 0
 477 main['ICC'] = CXX_V and CXX_V.find('Intel') >= 0
 478 if main['GCC'] + main['SUNCC'] + main['ICC'] > 1:
 479     print 'Error: How can we have two at the same time?'
 480     Exit(1)
 481
 482 # Set up default C++ compiler flags
 483 if main['GCC']:
 484     main.Append(CCFLAGS=['-pipe'])
 485     main.Append(CCFLAGS=['-fno-strict-aliasing'])
 486     main.Append(CCFLAGS=['-Wall', '-Wno-sign-compare', '-Wundef'])
 487     main.Append(CXXFLAGS=['-Wno-deprecated'])
 488     # Read the GCC version to check for versions with bugs
 489     # Note CCVERSION doesn't work here because it is run with the CC
 490     # before we override it from the command line
 491     gcc_version = readCommand([main['CXX'], '-dumpversion'], exception=False)
 492     if not compareVersions(gcc_version, '4.4.1') or \
 493        not compareVersions(gcc_version, '4.4.2'):
 494         print 'Info: Tree vectorizer in GCC 4.4.1 & 4.4.2 is buggy, disabling.'
 495         main.Append(CCFLAGS=['-fno-tree-vectorize'])
 496 elif main['ICC']:
 497     pass #Fix me... add warning flags once we clean up icc warnings
 498 elif main['SUNCC']:
 499     main.Append(CCFLAGS=['-Qoption ccfe'])
 500     main.Append(CCFLAGS=['-features=gcc'])
 501     main.Append(CCFLAGS=['-features=extensions'])
 502     main.Append(CCFLAGS=['-library=stlport4'])
 503     main.Append(CCFLAGS=['-xar'])
 504     #main.Append(CCFLAGS=['-instances=semiexplicit'])
 505 else:
 506     print 'Error: Don\'t know what compiler options to use for your compiler.'
 507     print '       Please fix SConstruct and src/SConscript and try again.'
 508     Exit(1)
 509
 510 # Set up common yacc/bison flags (needed for Ruby)
 511 main['YACCFLAGS'] = '-d'
 512 main['YACCHXXFILESUFFIX'] = '.hh'
 513
 514 # Do this after we save setting back, or else we'll tack on an
 515 # extra 'qdo' every time we run scons.
 516 if main['BATCH']:
 517     main['CC']     = main['BATCH_CMD'] + ' ' + main['CC']
 518     main['CXX']    = main['BATCH_CMD'] + ' ' + main['CXX']
 519     main['AS']     = main['BATCH_CMD'] + ' ' + main['AS']
 520     main['AR']     = main['BATCH_CMD'] + ' ' + main['AR']
 521     main['RANLIB'] = main['BATCH_CMD'] + ' ' + main['RANLIB']
 522
 523 if sys.platform == 'cygwin':
 524     # cygwin has some header file issues...
 525     main.Append(CCFLAGS=["-Wno-uninitialized"])
 526
 527 # Check for SWIG
 528 if not main.has_key('SWIG'):
 529     print 'Error: SWIG utility not found.'
 530     print '       Please install (see http://www.swig.org) and retry.'
 531     Exit(1)
 532
 533 # Check for appropriate SWIG version
 534 swig_version = readCommand(('swig', '-version'), exception='').split()
 535 # First 3 words should be "SWIG Version x.y.z"
 536 if len(swig_version) < 3 or \
 537         swig_version[0] != 'SWIG' or swig_version[1] != 'Version':
 538     print 'Error determining SWIG version.'
 539     Exit(1)
 540
 541 min_swig_version = '1.3.28'
 542 if compareVersions(swig_version[2], min_swig_version) < 0:
 543     print 'Error: SWIG version', min_swig_version, 'or newer required.'
 544     print '       Installed version:', swig_version[2]
 545     Exit(1)
 546
 547 # Set up SWIG flags & scanner
 548 swig_flags=Split('-c++ -python -modern -templatereduce $_CPPINCFLAGS')
 549 main.Append(SWIGFLAGS=swig_flags)
 550
 551 # filter out all existing swig scanners, they mess up the dependency
 552 # stuff for some reason
 553 scanners = []
 554 for scanner in main['SCANNERS']:
 555     skeys = scanner.skeys
 556     if skeys == '.i':
 557         continue
 558
 559     if isinstance(skeys, (list, tuple)) and '.i' in skeys:
 560         continue
 561
 562     scanners.append(scanner)
 563
 564 # add the new swig scanner that we like better
 565 from SCons.Scanner import ClassicCPP as CPPScanner
 566 swig_inc_re = '^[ \t]*[%,#][ \t]*(?:include|import)[ \t]*(<|")([^>"]+)(>|")'
 567 scanners.append(CPPScanner("SwigScan", [ ".i" ], "CPPPATH", swig_inc_re))
 568
 569 # replace the scanners list that has what we want
 570 main['SCANNERS'] = scanners
 571
 572 # Add a custom Check function to the Configure context so that we can
 573 # figure out if the compiler adds leading underscores to global
 574 # variables.  This is needed for the autogenerated asm files that we
 575 # use for embedding the python code.
 576 def CheckLeading(context):
 577     context.Message("Checking for leading underscore in global variables...")
 578     # 1) Define a global variable called x from asm so the C compiler
 579     #    won't change the symbol at all.
 580     # 2) Declare that variable.
 581     # 3) Use the variable
 582     #
 583     # If the compiler prepends an underscore, this will successfully
 584     # link because the external symbol 'x' will be called '_x' which
 585     # was defined by the asm statement.  If the compiler does not
 586     # prepend an underscore, this will not successfully link because
 587     # '_x' will have been defined by assembly, while the C portion of
 588     # the code will be trying to use 'x'
 589     ret = context.TryLink('''
 590         asm(".globl _x; _x: .byte 0");
 591         extern int x;
 592         int main() { return x; }
 593         ''', extension=".c")
 594     context.env.Append(LEADING_UNDERSCORE=ret)
 595     context.Result(ret)
 596     return ret
 597
 598 # Platform-specific configuration.  Note again that we assume that all
 599 # builds under a given build root run on the same host platform.
 600 conf = Configure(main,
 601                  conf_dir = joinpath(build_root, '.scons_config'),
 602                  log_file = joinpath(build_root, 'scons_config.log'),
 603                  custom_tests = { 'CheckLeading' : CheckLeading })
 604
 605 # Check for leading underscores.  Don't really need to worry either
 606 # way so don't need to check the return code.
 607 conf.CheckLeading()
 608
 609 # Check if we should compile a 64 bit binary on Mac OS X/Darwin
 610 try:
 611     import platform
 612     uname = platform.uname()
 613     if uname[0] == 'Darwin' and compareVersions(uname[2], '9.0.0') >= 0:
 614         if int(readCommand('sysctl -n hw.cpu64bit_capable')[0]):
 615             main.Append(CCFLAGS=['-arch', 'x86_64'])
 616             main.Append(CFLAGS=['-arch', 'x86_64'])
 617             main.Append(LINKFLAGS=['-arch', 'x86_64'])
 618             main.Append(ASFLAGS=['-arch', 'x86_64'])
 619 except:
 620     pass
 621
 622 # Recent versions of scons substitute a "Null" object for Configure()
 623 # when configuration isn't necessary, e.g., if the "--help" option is
 624 # present.  Unfortuantely this Null object always returns false,
 625 # breaking all our configuration checks.  We replace it with our own
 626 # more optimistic null object that returns True instead.
 627 if not conf:
 628     def NullCheck(*args, **kwargs):
 629         return True
 630
 631     class NullConf:
 632         def __init__(self, env):
 633             self.env = env
 634         def Finish(self):
 635             return self.env
 636         def __getattr__(self, mname):
 637             return NullCheck
 638
 639     conf = NullConf(main)
 640
 641 # Find Python include and library directories for embedding the
 642 # interpreter.  For consistency, we will use the same Python
 643 # installation used to run scons (and thus this script).  If you want
 644 # to link in an alternate version, see above for instructions on how
 645 # to invoke scons with a different copy of the Python interpreter.
 646 from distutils import sysconfig
 647
 648 py_getvar = sysconfig.get_config_var
 649
 650 py_debug = getattr(sys, 'pydebug', False)
 651 py_version = 'python' + py_getvar('VERSION') + (py_debug and "_d" or "")
 652
 653 py_general_include = sysconfig.get_python_inc()
 654 py_platform_include = sysconfig.get_python_inc(plat_specific=True)
 655 py_includes = [ py_general_include ]
 656 if py_platform_include != py_general_include:
 657     py_includes.append(py_platform_include)
 658
 659 py_lib_path = [ py_getvar('LIBDIR') ]
 660 # add the prefix/lib/pythonX.Y/config dir, but only if there is no
 661 # shared library in prefix/lib/.
 662 if not py_getvar('Py_ENABLE_SHARED'):
 663     py_lib_path.append(py_getvar('LIBPL'))
 664
 665 py_libs = []
 666 for lib in py_getvar('LIBS').split() + py_getvar('SYSLIBS').split():
 667     assert lib.startswith('-l')
 668     lib = lib[2:]
 669     if lib not in py_libs:
 670         py_libs.append(lib)
 671 py_libs.append(py_version)
 672
 673 main.Append(CPPPATH=py_includes)
 674 main.Append(LIBPATH=py_lib_path)
 675
 676 # Cache build files in the supplied directory.
 677 if main['M5_BUILD_CACHE']:
 678     print 'Using build cache located at', main['M5_BUILD_CACHE']
 679     CacheDir(main['M5_BUILD_CACHE'])
 680
 681
 682 # verify that this stuff works
 683 if not conf.CheckHeader('Python.h', '<>'):
 684     print "Error: can't find Python.h header in", py_includes
 685     Exit(1)
 686
 687 for lib in py_libs:
 688     if not conf.CheckLib(lib):
 689         print "Error: can't find library %s required by python" % lib
 690         Exit(1)
 691
 692 # On Solaris you need to use libsocket for socket ops
 693 if not conf.CheckLibWithHeader(None, 'sys/socket.h', 'C++', 'accept(0,0,0);'):
 694    if not conf.CheckLibWithHeader('socket', 'sys/socket.h', 'C++', 'accept(0,0,0);'):
 695        print "Can't find library with socket calls (e.g. accept())"
 696        Exit(1)
 697
 698 # Check for zlib.  If the check passes, libz will be automatically
 699 # added to the LIBS environment variable.
 700 if not conf.CheckLibWithHeader('z', 'zlib.h', 'C++','zlibVersion();'):
 701     print 'Error: did not find needed zlib compression library '\
 702           'and/or zlib.h header file.'
 703     print '       Please install zlib and try again.'
 704     Exit(1)
 705
 706 # Check for librt.
 707 have_posix_clock = \
 708     conf.CheckLibWithHeader(None, 'time.h', 'C',
 709                             'clock_nanosleep(0,0,NULL,NULL);') or \
 710     conf.CheckLibWithHeader('rt', 'time.h', 'C',
 711                             'clock_nanosleep(0,0,NULL,NULL);')
 712
 713 if not have_posix_clock:
 714     print "Can't find library for POSIX clocks."
 715
 716 # Check for <fenv.h> (C99 FP environment control)
 717 have_fenv = conf.CheckHeader('fenv.h', '<>')
 718 if not have_fenv:
 719     print "Warning: Header file <fenv.h> not found."
 720     print "         This host has no IEEE FP rounding mode control."
 721
 722 ######################################################################
 723 #
 724 # Check for mysql.
 725 #
 726 mysql_config = WhereIs('mysql_config')
 727 have_mysql = bool(mysql_config)
 728
 729 # Check MySQL version.
 730 if have_mysql:
 731     mysql_version = readCommand(mysql_config + ' --version')
 732     min_mysql_version = '4.1'
 733     if compareVersions(mysql_version, min_mysql_version) < 0:
 734         print 'Warning: MySQL', min_mysql_version, 'or newer required.'
 735         print '         Version', mysql_version, 'detected.'
 736         have_mysql = False
 737
 738 # Set up mysql_config commands.
 739 if have_mysql:
 740     mysql_config_include = mysql_config + ' --include'
 741     if os.system(mysql_config_include + ' > /dev/null') != 0:
 742         # older mysql_config versions don't support --include, use
 743         # --cflags instead
 744         mysql_config_include = mysql_config + ' --cflags | sed s/\\\'//g'
 745     # This seems to work in all versions
 746     mysql_config_libs = mysql_config + ' --libs'
 747
 748 ######################################################################
 749 #
 750 # Finish the configuration
 751 #
 752 main = conf.Finish()
 753
 754 ######################################################################
 755 #
 756 # Collect all non-global variables
 757 #
 758
 759 # Define the universe of supported ISAs
 760 all_isa_list = [ ]
 761 Export('all_isa_list')
 762
 763 class CpuModel(object):
 764     '''The CpuModel class encapsulates everything the ISA parser needs to
 765     know about a particular CPU model.'''
 766
 767     # Dict of available CPU model objects.  Accessible as CpuModel.dict.
 768     dict = {}
 769     list = []
 770     defaults = []
 771
 772     # Constructor.  Automatically adds models to CpuModel.dict.
 773     def __init__(self, name, filename, includes, strings, default=False):
 774         self.name = name           # name of model
 775         self.filename = filename   # filename for output exec code
 776         self.includes = includes   # include files needed in exec file
 777         # The 'strings' dict holds all the per-CPU symbols we can
 778         # substitute into templates etc.
 779         self.strings = strings
 780
 781         # This cpu is enabled by default
 782         self.default = default
 783
 784         # Add self to dict
 785         if name in CpuModel.dict:
 786             raise AttributeError, "CpuModel '%s' already registered" % name
 787         CpuModel.dict[name] = self
 788         CpuModel.list.append(name)
 789
 790 Export('CpuModel')
 791
 792 # Sticky variables get saved in the variables file so they persist from
 793 # one invocation to the next (unless overridden, in which case the new
 794 # value becomes sticky).
 795 sticky_vars = Variables(args=ARGUMENTS)
 796 Export('sticky_vars')
 797
 798 # Sticky variables that should be exported
 799 export_vars = []
 800 Export('export_vars')
 801
 802 # Walk the tree and execute all SConsopts scripts that wil add to the
 803 # above variables
 804 for bdir in [ base_dir ] + extras_dir_list:
 805     for root, dirs, files in os.walk(bdir):
 806         if 'SConsopts' in files:
 807             print "Reading", joinpath(root, 'SConsopts')
 808             SConscript(joinpath(root, 'SConsopts'))
 809
 810 all_isa_list.sort()
 811
 812 sticky_vars.AddVariables(
 813     EnumVariable('TARGET_ISA', 'Target ISA', 'alpha', all_isa_list),
 814     BoolVariable('FULL_SYSTEM', 'Full-system support', False),
 815     ListVariable('CPU_MODELS', 'CPU models',
 816                  sorted(n for n,m in CpuModel.dict.iteritems() if m.default),
 817                  sorted(CpuModel.list)),
 818     BoolVariable('NO_FAST_ALLOC', 'Disable fast object allocator', False),
 819     BoolVariable('FAST_ALLOC_DEBUG', 'Enable fast object allocator debugging',
 820                  False),
 821     BoolVariable('FAST_ALLOC_STATS', 'Enable fast object allocator statistics',
 822                  False),
 823     BoolVariable('EFENCE', 'Link with Electric Fence malloc debugger',
 824                  False),
 825     BoolVariable('SS_COMPATIBLE_FP',
 826                  'Make floating-point results compatible with SimpleScalar',
 827                  False),
 828     BoolVariable('USE_SSE2',
 829                  'Compile for SSE2 (-msse2) to get IEEE FP on x86 hosts',
 830                  False),
 831     BoolVariable('USE_MYSQL', 'Use MySQL for stats output', have_mysql),
 832     BoolVariable('USE_POSIX_CLOCK', 'Use POSIX Clocks', have_posix_clock),
 833     BoolVariable('USE_FENV', 'Use <fenv.h> IEEE mode control', have_fenv),
 834     BoolVariable('USE_CHECKER', 'Use checker for detailed CPU models', False),
 835     BoolVariable('CP_ANNOTATE', 'Enable critical path annotation capability', False),
 836     BoolVariable('RUBY', 'Build with Ruby', False),
 837     )
 838
 839 # These variables get exported to #defines in config/*.hh (see src/SConscript).
 840 export_vars += ['FULL_SYSTEM', 'USE_FENV', 'USE_MYSQL',
 841                 'NO_FAST_ALLOC', 'FAST_ALLOC_DEBUG', 'FAST_ALLOC_STATS',
 842                 'SS_COMPATIBLE_FP', 'USE_CHECKER', 'TARGET_ISA', 'CP_ANNOTATE',
 843                 'USE_POSIX_CLOCK' ]
 844
 845 ###################################################
 846 #
 847 # Define a SCons builder for configuration flag headers.
 848 #
 849 ###################################################
 850
 851 # This function generates a config header file that #defines the
 852 # variable symbol to the current variable setting (0 or 1).  The source
 853 # operands are the name of the variable and a Value node containing the
 854 # value of the variable.
 855 def build_config_file(target, source, env):
 856     (variable, value) = [s.get_contents() for s in source]
 857     f = file(str(target[0]), 'w')
 858     print >> f, '#define', variable, value
 859     f.close()
 860     return None
 861
 862 # Generate the message to be printed when building the config file.
 863 def build_config_file_string(target, source, env):
 864     (variable, value) = [s.get_contents() for s in source]
 865     return "Defining %s as %s in %s." % (variable, value, target[0])
 866
 867 # Combine the two functions into a scons Action object.
 868 config_action = Action(build_config_file, build_config_file_string)
 869
 870 # The emitter munges the source & target node lists to reflect what
 871 # we're really doing.
 872 def config_emitter(target, source, env):
 873     # extract variable name from Builder arg
 874     variable = str(target[0])
 875     # True target is config header file
 876     target = joinpath('config', variable.lower() + '.hh')
 877     val = env[variable]
 878     if isinstance(val, bool):
 879         # Force value to 0/1
 880         val = int(val)
 881     elif isinstance(val, str):
 882         val = '"' + val + '"'
 883
 884     # Sources are variable name & value (packaged in SCons Value nodes)
 885     return ([target], [Value(variable), Value(val)])
 886
 887 config_builder = Builder(emitter = config_emitter, action = config_action)
 888
 889 main.Append(BUILDERS = { 'ConfigFile' : config_builder })
 890
 891 # libelf build is shared across all configs in the build root.
 892 main.SConscript('ext/libelf/SConscript',
 893                 variant_dir = joinpath(build_root, 'libelf'))
 894
 895 # gzstream build is shared across all configs in the build root.
 896 main.SConscript('ext/gzstream/SConscript',
 897                 variant_dir = joinpath(build_root, 'gzstream'))
 898
 899 ###################################################
 900 #
 901 # This function is used to set up a directory with switching headers
 902 #
 903 ###################################################
 904
 905 main['ALL_ISA_LIST'] = all_isa_list
 906 def make_switching_dir(dname, switch_headers, env):
 907     # Generate the header.  target[0] is the full path of the output
 908     # header to generate.  'source' is a dummy variable, since we get the
 909     # list of ISAs from env['ALL_ISA_LIST'].
 910     def gen_switch_hdr(target, source, env):
 911         fname = str(target[0])
 912         f = open(fname, 'w')
 913         isa = env['TARGET_ISA'].lower()
 914         print >>f, '#include "%s/%s/%s"' % (dname, isa, basename(fname))
 915         f.close()
 916
 917     # Build SCons Action object. 'varlist' specifies env vars that this
 918     # action depends on; when env['ALL_ISA_LIST'] changes these actions
 919     # should get re-executed.
 920     switch_hdr_action = MakeAction(gen_switch_hdr,
 921                           Transform("GENERATE"), varlist=['ALL_ISA_LIST'])
 922
 923     # Instantiate actions for each header
 924     for hdr in switch_headers:
 925         env.Command(hdr, [], switch_hdr_action)
 926 Export('make_switching_dir')
 927
 928 ###################################################
 929 #
 930 # Define build environments for selected configurations.
 931 #
 932 ###################################################
 933
 934 for variant_path in variant_paths:
 935     print "Building in", variant_path
 936
 937     # Make a copy of the build-root environment to use for this config.
 938     env = main.Clone()
 939     env['BUILDDIR'] = variant_path
 940
 941     # variant_dir is the tail component of build path, and is used to
 942     # determine the build parameters (e.g., 'ALPHA_SE')
 943     (build_root, variant_dir) = splitpath(variant_path)
 944
 945     # Set env variables according to the build directory config.
 946     sticky_vars.files = []
 947     # Variables for $BUILD_ROOT/$VARIANT_DIR are stored in
 948     # $BUILD_ROOT/variables/$VARIANT_DIR so you can nuke
 949     # $BUILD_ROOT/$VARIANT_DIR without losing your variables settings.
 950     current_vars_file = joinpath(build_root, 'variables', variant_dir)
 951     if isfile(current_vars_file):
 952         sticky_vars.files.append(current_vars_file)
 953         print "Using saved variables file %s" % current_vars_file
 954     else:
 955         # Build dir-specific variables file doesn't exist.
 956
 957         # Make sure the directory is there so we can create it later
 958         opt_dir = dirname(current_vars_file)
 959         if not isdir(opt_dir):
 960             mkdir(opt_dir)
 961
 962         # Get default build variables from source tree.  Variables are
 963         # normally determined by name of $VARIANT_DIR, but can be
 964         # overriden by 'default=' arg on command line.
 965         default_vars_file = joinpath('build_opts',
 966                                      ARGUMENTS.get('default', variant_dir))
 967         if isfile(default_vars_file):
 968             sticky_vars.files.append(default_vars_file)
 969             print "Variables file %s not found,\n  using defaults in %s" \
 970                   % (current_vars_file, default_vars_file)
 971         else:
 972             print "Error: cannot find variables file %s or %s" \
 973                   % (current_vars_file, default_vars_file)
 974             Exit(1)
 975
 976     # Apply current variable settings to env
 977     sticky_vars.Update(env)
 978
 979     help_text += "\nSticky variables for %s:\n" % variant_dir \
 980                  + sticky_vars.GenerateHelpText(env)
 981
 982     # Process variable settings.
 983
 984     if not have_fenv and env['USE_FENV']:
 985         print "Warning: <fenv.h> not available; " \
 986               "forcing USE_FENV to False in", variant_dir + "."
 987         env['USE_FENV'] = False
 988
 989     if not env['USE_FENV']:
 990         print "Warning: No IEEE FP rounding mode control in", variant_dir + "."
 991         print "         FP results may deviate slightly from other platforms."
 992
 993     if env['EFENCE']:
 994         env.Append(LIBS=['efence'])
 995
 996     if env['USE_MYSQL']:
 997         if not have_mysql:
 998             print "Warning: MySQL not available; " \
 999                   "forcing USE_MYSQL to False in", variant_dir + "."
1000             env['USE_MYSQL'] = False
1001         else:
1002             print "Compiling in", variant_dir, "with MySQL support."
1003             env.ParseConfig(mysql_config_libs)
1004             env.ParseConfig(mysql_config_include)
1005
1006     # Save sticky variable settings back to current variables file
1007     sticky_vars.Save(current_vars_file, env)
1008
1009     if env['USE_SSE2']:
1010         env.Append(CCFLAGS=['-msse2'])
1011
1012     # The src/SConscript file sets up the build rules in 'env' according
1013     # to the configured variables.  It returns a list of environments,
1014     # one for each variant build (debug, opt, etc.)
1015     envList = SConscript('src/SConscript', variant_dir = variant_path,
1016                          exports = 'env')
1017
1018     # Set up the regression tests for each build.
1019     for e in envList:
1020         SConscript('tests/SConscript',
1021                    variant_dir = joinpath(variant_path, 'tests', e.Label),
1022                    exports = { 'env' : e }, duplicate = False)
1023
1024 Help(help_text)