SConstruct

   1 # -*- mode:python -*-
   2
   3 # Copyright (c) 2009 The Hewlett-Packard Development Company
   4 # Copyright (c) 2004-2005 The Regents of The University of Michigan
   5 # All rights reserved.
   6 #
   7 # Redistribution and use in source and binary forms, with or without
   8 # modification, are permitted provided that the following conditions are
   9 # met: redistributions of source code must retain the above copyright
  10 # notice, this list of conditions and the following disclaimer;
  11 # redistributions in binary form must reproduce the above copyright
  12 # notice, this list of conditions and the following disclaimer in the
  13 # documentation and/or other materials provided with the distribution;
  14 # neither the name of the copyright holders nor the names of its
  15 # contributors may be used to endorse or promote products derived from
  16 # this software without specific prior written permission.
  17 #
  18 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 #
  30 # Authors: Steve Reinhardt
  31 #          Nathan Binkert
  32
  33 ###################################################
  34 #
  35 # SCons top-level build description (SConstruct) file.
  36 #
  37 # While in this directory ('m5'), just type 'scons' to build the default
  38 # configuration (see below), or type 'scons build/<CONFIG>/<binary>'
  39 # to build some other configuration (e.g., 'build/ALPHA_FS/m5.opt' for
  40 # the optimized full-system version).
  41 #
  42 # You can build M5 in a different directory as long as there is a
  43 # 'build/<CONFIG>' somewhere along the target path.  The build system
  44 # expects that all configs under the same build directory are being
  45 # built for the same host system.
  46 #
  47 # Examples:
  48 #
  49 #   The following two commands are equivalent.  The '-u' option tells
  50 #   scons to search up the directory tree for this SConstruct file.
  51 #   % cd <path-to-src>/m5 ; scons build/ALPHA_FS/m5.debug
  52 #   % cd <path-to-src>/m5/build/ALPHA_FS; scons -u m5.debug
  53 #
  54 #   The following two commands are equivalent and demonstrate building
  55 #   in a directory outside of the source tree.  The '-C' option tells
  56 #   scons to chdir to the specified directory to find this SConstruct
  57 #   file.
  58 #   % cd <path-to-src>/m5 ; scons /local/foo/build/ALPHA_FS/m5.debug
  59 #   % cd /local/foo/build/ALPHA_FS; scons -C <path-to-src>/m5 m5.debug
  60 #
  61 # You can use 'scons -H' to print scons options.  If you're in this
  62 # 'm5' directory (or use -u or -C to tell scons where to find this
  63 # file), you can use 'scons -h' to print all the M5-specific build
  64 # options as well.
  65 #
  66 ###################################################
  67
  68 # Check for recent-enough Python and SCons versions.
  69 try:
  70     # Really old versions of scons only take two options for the
  71     # function, so check once without the revision and once with the
  72     # revision, the first instance will fail for stuff other than
  73     # 0.98, and the second will fail for 0.98.0
  74     EnsureSConsVersion(0, 98)
  75     EnsureSConsVersion(0, 98, 1)
  76 except SystemExit, e:
  77     print """
  78 For more details, see:
  79     http://m5sim.org/wiki/index.php/Compiling_M5
  80 """
  81     raise
  82
  83 # We ensure the python version early because we have stuff that
  84 # requires python 2.4
  85 try:
  86     EnsurePythonVersion(2, 4)
  87 except SystemExit, e:
  88     print """
  89 You can use a non-default installation of the Python interpreter by
  90 either (1) rearranging your PATH so that scons finds the non-default
  91 'python' first or (2) explicitly invoking an alternative interpreter
  92 on the scons script.
  93
  94 For more details, see:
  95     http://m5sim.org/wiki/index.php/Using_a_non-default_Python_installation
  96 """
  97     raise
  98
  99 # Global Python includes
 100 import os
 101 import re
 102 import subprocess
 103 import sys
 104
 105 from os import mkdir, environ
 106 from os.path import abspath, basename, dirname, expanduser, normpath
 107 from os.path import exists,  isdir, isfile
 108 from os.path import join as joinpath, split as splitpath
 109
 110 # SCons includes
 111 import SCons
 112 import SCons.Node
 113
 114 extra_python_paths = [
 115     Dir('src/python').srcnode().abspath, # M5 includes
 116     Dir('ext/ply').srcnode().abspath, # ply is used by several files
 117     ]
 118
 119 sys.path[1:1] = extra_python_paths
 120
 121 from m5.util import compareVersions, readCommand
 122
 123 ########################################################################
 124 #
 125 # Set up the main build environment.
 126 #
 127 ########################################################################
 128 use_vars = set([ 'AS', 'AR', 'CC', 'CXX', 'HOME', 'LD_LIBRARY_PATH', 'PATH',
 129                  'PYTHONPATH', 'RANLIB' ])
 130
 131 use_env = {}
 132 for key,val in os.environ.iteritems():
 133     if key in use_vars or key.startswith("M5"):
 134         use_env[key] = val
 135
 136 main = Environment(ENV=use_env)
 137 main.root = Dir(".")         # The current directory (where this file lives).
 138 main.srcdir = Dir("src")     # The source directory
 139
 140 # add useful python code PYTHONPATH so it can be used by subprocesses
 141 # as well
 142 main.AppendENVPath('PYTHONPATH', extra_python_paths)
 143
 144 ########################################################################
 145 #
 146 # Mercurial Stuff.
 147 #
 148 # If the M5 directory is a mercurial repository, we should do some
 149 # extra things.
 150 #
 151 ########################################################################
 152
 153 hgdir = main.root.Dir(".hg")
 154
 155 mercurial_style_message = """
 156 You're missing the M5 style hook.
 157 Please install the hook so we can ensure that all code fits a common style.
 158
 159 All you'd need to do is add the following lines to your repository .hg/hgrc
 160 or your personal .hgrc
 161 ----------------
 162
 163 [extensions]
 164 style = %s/util/style.py
 165
 166 [hooks]
 167 pretxncommit.style = python:style.check_whitespace
 168 """ % (main.root)
 169
 170 mercurial_bin_not_found = """
 171 Mercurial binary cannot be found, unfortunately this means that we
 172 cannot easily determine the version of M5 that you are running and
 173 this makes error messages more difficult to collect.  Please consider
 174 installing mercurial if you choose to post an error message
 175 """
 176
 177 mercurial_lib_not_found = """
 178 Mercurial libraries cannot be found, ignoring style hook
 179 If you are actually a M5 developer, please fix this and
 180 run the style hook. It is important.
 181 """
 182
 183 hg_info = "Unknown"
 184 if hgdir.exists():
 185     # 1) Grab repository revision if we know it.
 186     cmd = "hg id -n -i -t -b"
 187     try:
 188         hg_info = readCommand(cmd, cwd=main.root.abspath).strip()
 189     except OSError:
 190         print mercurial_bin_not_found
 191
 192     # 2) Ensure that the style hook is in place.
 193     try:
 194         ui = None
 195         if ARGUMENTS.get('IGNORE_STYLE') != 'True':
 196             from mercurial import ui
 197             ui = ui.ui()
 198     except ImportError:
 199         print mercurial_lib_not_found
 200
 201     if ui is not None:
 202         ui.readconfig(hgdir.File('hgrc').abspath)
 203         style_hook = ui.config('hooks', 'pretxncommit.style', None)
 204
 205         if not style_hook:
 206             print mercurial_style_message
 207             sys.exit(1)
 208 else:
 209     print ".hg directory not found"
 210
 211 main['HG_INFO'] = hg_info
 212
 213 ###################################################
 214 #
 215 # Figure out which configurations to set up based on the path(s) of
 216 # the target(s).
 217 #
 218 ###################################################
 219
 220 # Find default configuration & binary.
 221 Default(environ.get('M5_DEFAULT_BINARY', 'build/ALPHA_SE/m5.debug'))
 222
 223 # helper function: find last occurrence of element in list
 224 def rfind(l, elt, offs = -1):
 225     for i in range(len(l)+offs, 0, -1):
 226         if l[i] == elt:
 227             return i
 228     raise ValueError, "element not found"
 229
 230 # Each target must have 'build' in the interior of the path; the
 231 # directory below this will determine the build parameters.  For
 232 # example, for target 'foo/bar/build/ALPHA_SE/arch/alpha/blah.do' we
 233 # recognize that ALPHA_SE specifies the configuration because it
 234 # follow 'build' in the bulid path.
 235
 236 # Generate absolute paths to targets so we can see where the build dir is
 237 if COMMAND_LINE_TARGETS:
 238     # Ask SCons which directory it was invoked from
 239     launch_dir = GetLaunchDir()
 240     # Make targets relative to invocation directory
 241     abs_targets = [ normpath(joinpath(launch_dir, str(x))) for x in \
 242                     COMMAND_LINE_TARGETS]
 243 else:
 244     # Default targets are relative to root of tree
 245     abs_targets = [ normpath(joinpath(main.root.abspath, str(x))) for x in \
 246                     DEFAULT_TARGETS]
 247
 248
 249 # Generate a list of the unique build roots and configs that the
 250 # collected targets reference.
 251 variant_paths = []
 252 build_root = None
 253 for t in abs_targets:
 254     path_dirs = t.split('/')
 255     try:
 256         build_top = rfind(path_dirs, 'build', -2)
 257     except:
 258         print "Error: no non-leaf 'build' dir found on target path", t
 259         Exit(1)
 260     this_build_root = joinpath('/',*path_dirs[:build_top+1])
 261     if not build_root:
 262         build_root = this_build_root
 263     else:
 264         if this_build_root != build_root:
 265             print "Error: build targets not under same build root\n"\
 266                   "  %s\n  %s" % (build_root, this_build_root)
 267             Exit(1)
 268     variant_path = joinpath('/',*path_dirs[:build_top+2])
 269     if variant_path not in variant_paths:
 270         variant_paths.append(variant_path)
 271
 272 # Make sure build_root exists (might not if this is the first build there)
 273 if not isdir(build_root):
 274     mkdir(build_root)
 275
 276 Export('main')
 277
 278 main.SConsignFile(joinpath(build_root, "sconsign"))
 279
 280 # Default duplicate option is to use hard links, but this messes up
 281 # when you use emacs to edit a file in the target dir, as emacs moves
 282 # file to file~ then copies to file, breaking the link.  Symbolic
 283 # (soft) links work better.
 284 main.SetOption('duplicate', 'soft-copy')
 285
 286 #
 287 # Set up global sticky variables... these are common to an entire build
 288 # tree (not specific to a particular build like ALPHA_SE)
 289 #
 290
 291 # Variable validators & converters for global sticky variables
 292 def PathListMakeAbsolute(val):
 293     if not val:
 294         return val
 295     f = lambda p: abspath(expanduser(p))
 296     return ':'.join(map(f, val.split(':')))
 297
 298 def PathListAllExist(key, val, env):
 299     if not val:
 300         return
 301     paths = val.split(':')
 302     for path in paths:
 303         if not isdir(path):
 304             raise SCons.Errors.UserError("Path does not exist: '%s'" % path)
 305
 306 global_sticky_vars_file = joinpath(build_root, 'variables.global')
 307
 308 global_sticky_vars = Variables(global_sticky_vars_file, args=ARGUMENTS)
 309
 310 global_sticky_vars.AddVariables(
 311     ('CC', 'C compiler', environ.get('CC', main['CC'])),
 312     ('CXX', 'C++ compiler', environ.get('CXX', main['CXX'])),
 313     ('BATCH', 'Use batch pool for build and tests', False),
 314     ('BATCH_CMD', 'Batch pool submission command name', 'qdo'),
 315     ('EXTRAS', 'Add Extra directories to the compilation', '',
 316      PathListAllExist, PathListMakeAbsolute),
 317     BoolVariable('RUBY', 'Build with Ruby', False),
 318     )
 319
 320 # base help text
 321 help_text = '''
 322 Usage: scons [scons options] [build options] [target(s)]
 323
 324 Global sticky options:
 325 '''
 326
 327 help_text += global_sticky_vars.GenerateHelpText(main)
 328
 329 # Update main environment with values from ARGUMENTS & global_sticky_vars_file
 330 global_sticky_vars.Update(main)
 331
 332 # Save sticky variable settings back to current variables file
 333 global_sticky_vars.Save(global_sticky_vars_file, main)
 334
 335 # Parse EXTRAS variable to build list of all directories where we're
 336 # look for sources etc.  This list is exported as base_dir_list.
 337 base_dir = main.srcdir.abspath
 338 if main['EXTRAS']:
 339     extras_dir_list = main['EXTRAS'].split(':')
 340 else:
 341     extras_dir_list = []
 342
 343 Export('base_dir')
 344 Export('extras_dir_list')
 345
 346 # the ext directory should be on the #includes path
 347 main.Append(CPPPATH=[Dir('ext')])
 348
 349 CXX_version = readCommand([main['CXX'],'--version'], exception=False)
 350 CXX_V = readCommand([main['CXX'],'-V'], exception=False)
 351
 352 main['GCC'] = CXX_version and CXX_version.find('g++') >= 0
 353 main['SUNCC'] = CXX_V and CXX_V.find('Sun C++') >= 0
 354 main['ICC'] = CXX_V and CXX_V.find('Intel') >= 0
 355 if main['GCC'] + main['SUNCC'] + main['ICC'] > 1:
 356     print 'Error: How can we have two at the same time?'
 357     Exit(1)
 358
 359 # Set up default C++ compiler flags
 360 if main['GCC']:
 361     main.Append(CCFLAGS='-pipe')
 362     main.Append(CCFLAGS='-fno-strict-aliasing')
 363     main.Append(CCFLAGS=['-Wall', '-Wno-sign-compare', '-Wundef'])
 364     main.Append(CXXFLAGS='-Wno-deprecated')
 365 elif main['ICC']:
 366     pass #Fix me... add warning flags once we clean up icc warnings
 367 elif main['SUNCC']:
 368     main.Append(CCFLAGS='-Qoption ccfe')
 369     main.Append(CCFLAGS='-features=gcc')
 370     main.Append(CCFLAGS='-features=extensions')
 371     main.Append(CCFLAGS='-library=stlport4')
 372     main.Append(CCFLAGS='-xar')
 373     #main.Append(CCFLAGS='-instances=semiexplicit')
 374 else:
 375     print 'Error: Don\'t know what compiler options to use for your compiler.'
 376     print '       Please fix SConstruct and src/SConscript and try again.'
 377     Exit(1)
 378
 379 # Set up common yacc/bison flags (needed for Ruby)
 380 main['YACCFLAGS'] = '-d'
 381 main['YACCHXXFILESUFFIX'] = '.hh'
 382
 383 # Do this after we save setting back, or else we'll tack on an
 384 # extra 'qdo' every time we run scons.
 385 if main['BATCH']:
 386     main['CC']     = main['BATCH_CMD'] + ' ' + main['CC']
 387     main['CXX']    = main['BATCH_CMD'] + ' ' + main['CXX']
 388     main['AS']     = main['BATCH_CMD'] + ' ' + main['AS']
 389     main['AR']     = main['BATCH_CMD'] + ' ' + main['AR']
 390     main['RANLIB'] = main['BATCH_CMD'] + ' ' + main['RANLIB']
 391
 392 if sys.platform == 'cygwin':
 393     # cygwin has some header file issues...
 394     main.Append(CCFLAGS="-Wno-uninitialized")
 395
 396 # Check for SWIG
 397 if not main.has_key('SWIG'):
 398     print 'Error: SWIG utility not found.'
 399     print '       Please install (see http://www.swig.org) and retry.'
 400     Exit(1)
 401
 402 # Check for appropriate SWIG version
 403 swig_version = readCommand(('swig', '-version'), exception='').split()
 404 # First 3 words should be "SWIG Version x.y.z"
 405 if len(swig_version) < 3 or \
 406         swig_version[0] != 'SWIG' or swig_version[1] != 'Version':
 407     print 'Error determining SWIG version.'
 408     Exit(1)
 409
 410 min_swig_version = '1.3.28'
 411 if compareVersions(swig_version[2], min_swig_version) < 0:
 412     print 'Error: SWIG version', min_swig_version, 'or newer required.'
 413     print '       Installed version:', swig_version[2]
 414     Exit(1)
 415
 416 # Set up SWIG flags & scanner
 417 swig_flags=Split('-c++ -python -modern -templatereduce $_CPPINCFLAGS')
 418 main.Append(SWIGFLAGS=swig_flags)
 419
 420 # filter out all existing swig scanners, they mess up the dependency
 421 # stuff for some reason
 422 scanners = []
 423 for scanner in main['SCANNERS']:
 424     skeys = scanner.skeys
 425     if skeys == '.i':
 426         continue
 427
 428     if isinstance(skeys, (list, tuple)) and '.i' in skeys:
 429         continue
 430
 431     scanners.append(scanner)
 432
 433 # add the new swig scanner that we like better
 434 from SCons.Scanner import ClassicCPP as CPPScanner
 435 swig_inc_re = '^[ \t]*[%,#][ \t]*(?:include|import)[ \t]*(<|")([^>"]+)(>|")'
 436 scanners.append(CPPScanner("SwigScan", [ ".i" ], "CPPPATH", swig_inc_re))
 437
 438 # replace the scanners list that has what we want
 439 main['SCANNERS'] = scanners
 440
 441 # Add a custom Check function to the Configure context so that we can
 442 # figure out if the compiler adds leading underscores to global
 443 # variables.  This is needed for the autogenerated asm files that we
 444 # use for embedding the python code.
 445 def CheckLeading(context):
 446     context.Message("Checking for leading underscore in global variables...")
 447     # 1) Define a global variable called x from asm so the C compiler
 448     #    won't change the symbol at all.
 449     # 2) Declare that variable.
 450     # 3) Use the variable
 451     #
 452     # If the compiler prepends an underscore, this will successfully
 453     # link because the external symbol 'x' will be called '_x' which
 454     # was defined by the asm statement.  If the compiler does not
 455     # prepend an underscore, this will not successfully link because
 456     # '_x' will have been defined by assembly, while the C portion of
 457     # the code will be trying to use 'x'
 458     ret = context.TryLink('''
 459         asm(".globl _x; _x: .byte 0");
 460         extern int x;
 461         int main() { return x; }
 462         ''', extension=".c")
 463     context.env.Append(LEADING_UNDERSCORE=ret)
 464     context.Result(ret)
 465     return ret
 466
 467 # Platform-specific configuration.  Note again that we assume that all
 468 # builds under a given build root run on the same host platform.
 469 conf = Configure(main,
 470                  conf_dir = joinpath(build_root, '.scons_config'),
 471                  log_file = joinpath(build_root, 'scons_config.log'),
 472                  custom_tests = { 'CheckLeading' : CheckLeading })
 473
 474 # Check for leading underscores.  Don't really need to worry either
 475 # way so don't need to check the return code.
 476 conf.CheckLeading()
 477
 478 # Check if we should compile a 64 bit binary on Mac OS X/Darwin
 479 try:
 480     import platform
 481     uname = platform.uname()
 482     if uname[0] == 'Darwin' and compareVersions(uname[2], '9.0.0') >= 0:
 483         if int(readCommand('sysctl -n hw.cpu64bit_capable')[0]):
 484             main.Append(CCFLAGS='-arch x86_64')
 485             main.Append(CFLAGS='-arch x86_64')
 486             main.Append(LINKFLAGS='-arch x86_64')
 487             main.Append(ASFLAGS='-arch x86_64')
 488 except:
 489     pass
 490
 491 # Recent versions of scons substitute a "Null" object for Configure()
 492 # when configuration isn't necessary, e.g., if the "--help" option is
 493 # present.  Unfortuantely this Null object always returns false,
 494 # breaking all our configuration checks.  We replace it with our own
 495 # more optimistic null object that returns True instead.
 496 if not conf:
 497     def NullCheck(*args, **kwargs):
 498         return True
 499
 500     class NullConf:
 501         def __init__(self, env):
 502             self.env = env
 503         def Finish(self):
 504             return self.env
 505         def __getattr__(self, mname):
 506             return NullCheck
 507
 508     conf = NullConf(main)
 509
 510 # Find Python include and library directories for embedding the
 511 # interpreter.  For consistency, we will use the same Python
 512 # installation used to run scons (and thus this script).  If you want
 513 # to link in an alternate version, see above for instructions on how
 514 # to invoke scons with a different copy of the Python interpreter.
 515 from distutils import sysconfig
 516
 517 py_getvar = sysconfig.get_config_var
 518
 519 py_version = 'python' + py_getvar('VERSION')
 520
 521 py_general_include = sysconfig.get_python_inc()
 522 py_platform_include = sysconfig.get_python_inc(plat_specific=True)
 523 py_includes = [ py_general_include ]
 524 if py_platform_include != py_general_include:
 525     py_includes.append(py_platform_include)
 526
 527 py_lib_path = [ py_getvar('LIBDIR') ]
 528 # add the prefix/lib/pythonX.Y/config dir, but only if there is no
 529 # shared library in prefix/lib/.
 530 if not py_getvar('Py_ENABLE_SHARED'):
 531     py_lib_path.append(py_getvar('LIBPL'))
 532
 533 py_libs = []
 534 for lib in py_getvar('LIBS').split() + py_getvar('SYSLIBS').split():
 535     assert lib.startswith('-l')
 536     lib = lib[2:]
 537     if lib not in py_libs:
 538         py_libs.append(lib)
 539 py_libs.append(py_version)
 540
 541 main.Append(CPPPATH=py_includes)
 542 main.Append(LIBPATH=py_lib_path)
 543
 544 # verify that this stuff works
 545 if not conf.CheckHeader('Python.h', '<>'):
 546     print "Error: can't find Python.h header in", py_includes
 547     Exit(1)
 548
 549 for lib in py_libs:
 550     if not conf.CheckLib(lib):
 551         print "Error: can't find library %s required by python" % lib
 552         Exit(1)
 553
 554 # On Solaris you need to use libsocket for socket ops
 555 if not conf.CheckLibWithHeader(None, 'sys/socket.h', 'C++', 'accept(0,0,0);'):
 556    if not conf.CheckLibWithHeader('socket', 'sys/socket.h', 'C++', 'accept(0,0,0);'):
 557        print "Can't find library with socket calls (e.g. accept())"
 558        Exit(1)
 559
 560 # Check for zlib.  If the check passes, libz will be automatically
 561 # added to the LIBS environment variable.
 562 if not conf.CheckLibWithHeader('z', 'zlib.h', 'C++','zlibVersion();'):
 563     print 'Error: did not find needed zlib compression library '\
 564           'and/or zlib.h header file.'
 565     print '       Please install zlib and try again.'
 566     Exit(1)
 567
 568 # Check for <fenv.h> (C99 FP environment control)
 569 have_fenv = conf.CheckHeader('fenv.h', '<>')
 570 if not have_fenv:
 571     print "Warning: Header file <fenv.h> not found."
 572     print "         This host has no IEEE FP rounding mode control."
 573
 574 ######################################################################
 575 #
 576 # Check for mysql.
 577 #
 578 mysql_config = WhereIs('mysql_config')
 579 have_mysql = bool(mysql_config)
 580
 581 # Check MySQL version.
 582 if have_mysql:
 583     mysql_version = readCommand(mysql_config + ' --version')
 584     min_mysql_version = '4.1'
 585     if compareVersions(mysql_version, min_mysql_version) < 0:
 586         print 'Warning: MySQL', min_mysql_version, 'or newer required.'
 587         print '         Version', mysql_version, 'detected.'
 588         have_mysql = False
 589
 590 # Set up mysql_config commands.
 591 if have_mysql:
 592     mysql_config_include = mysql_config + ' --include'
 593     if os.system(mysql_config_include + ' > /dev/null') != 0:
 594         # older mysql_config versions don't support --include, use
 595         # --cflags instead
 596         mysql_config_include = mysql_config + ' --cflags | sed s/\\\'//g'
 597     # This seems to work in all versions
 598     mysql_config_libs = mysql_config + ' --libs'
 599
 600 ######################################################################
 601 #
 602 # Finish the configuration
 603 #
 604 main = conf.Finish()
 605
 606 ######################################################################
 607 #
 608 # Collect all non-global variables
 609 #
 610
 611 # Define the universe of supported ISAs
 612 all_isa_list = [ ]
 613 Export('all_isa_list')
 614
 615 # Define the universe of supported CPU models
 616 all_cpu_list = [ ]
 617 default_cpus = [ ]
 618 Export('all_cpu_list', 'default_cpus')
 619
 620 # Sticky variables get saved in the variables file so they persist from
 621 # one invocation to the next (unless overridden, in which case the new
 622 # value becomes sticky).
 623 sticky_vars = Variables(args=ARGUMENTS)
 624 Export('sticky_vars')
 625
 626 # Sticky variables that should be exported
 627 export_vars = []
 628 Export('export_vars')
 629
 630 # Non-sticky variables only apply to the current build.
 631 nonsticky_vars = Variables(args=ARGUMENTS)
 632 Export('nonsticky_vars')
 633
 634 # Walk the tree and execute all SConsopts scripts that wil add to the
 635 # above variables
 636 for bdir in [ base_dir ] + extras_dir_list:
 637     for root, dirs, files in os.walk(bdir):
 638         if 'SConsopts' in files:
 639             print "Reading", joinpath(root, 'SConsopts')
 640             SConscript(joinpath(root, 'SConsopts'))
 641
 642 all_isa_list.sort()
 643 all_cpu_list.sort()
 644 default_cpus.sort()
 645
 646 sticky_vars.AddVariables(
 647     EnumVariable('TARGET_ISA', 'Target ISA', 'alpha', all_isa_list),
 648     BoolVariable('FULL_SYSTEM', 'Full-system support', False),
 649     ListVariable('CPU_MODELS', 'CPU models', default_cpus, all_cpu_list),
 650     BoolVariable('NO_FAST_ALLOC', 'Disable fast object allocator', False),
 651     BoolVariable('FAST_ALLOC_DEBUG', 'Enable fast object allocator debugging',
 652                  False),
 653     BoolVariable('FAST_ALLOC_STATS', 'Enable fast object allocator statistics',
 654                  False),
 655     BoolVariable('EFENCE', 'Link with Electric Fence malloc debugger',
 656                  False),
 657     BoolVariable('SS_COMPATIBLE_FP',
 658                  'Make floating-point results compatible with SimpleScalar',
 659                  False),
 660     BoolVariable('USE_SSE2',
 661                  'Compile for SSE2 (-msse2) to get IEEE FP on x86 hosts',
 662                  False),
 663     BoolVariable('USE_MYSQL', 'Use MySQL for stats output', have_mysql),
 664     BoolVariable('USE_FENV', 'Use <fenv.h> IEEE mode control', have_fenv),
 665     BoolVariable('USE_CHECKER', 'Use checker for detailed CPU models', False),
 666     BoolVariable('CP_ANNOTATE', 'Enable critical path annotation capability', False),
 667     )
 668
 669 nonsticky_vars.AddVariables(
 670     BoolVariable('update_ref', 'Update test reference outputs', False)
 671     )
 672
 673 # These variables get exported to #defines in config/*.hh (see src/SConscript).
 674 export_vars += ['FULL_SYSTEM', 'USE_FENV', 'USE_MYSQL',
 675                 'NO_FAST_ALLOC', 'FAST_ALLOC_DEBUG', 'FAST_ALLOC_STATS',
 676                 'SS_COMPATIBLE_FP', 'USE_CHECKER', 'TARGET_ISA', 'CP_ANNOTATE']
 677
 678 ###################################################
 679 #
 680 # Define a SCons builder for configuration flag headers.
 681 #
 682 ###################################################
 683
 684 # This function generates a config header file that #defines the
 685 # variable symbol to the current variable setting (0 or 1).  The source
 686 # operands are the name of the variable and a Value node containing the
 687 # value of the variable.
 688 def build_config_file(target, source, env):
 689     (variable, value) = [s.get_contents() for s in source]
 690     f = file(str(target[0]), 'w')
 691     print >> f, '#define', variable, value
 692     f.close()
 693     return None
 694
 695 # Generate the message to be printed when building the config file.
 696 def build_config_file_string(target, source, env):
 697     (variable, value) = [s.get_contents() for s in source]
 698     return "Defining %s as %s in %s." % (variable, value, target[0])
 699
 700 # Combine the two functions into a scons Action object.
 701 config_action = Action(build_config_file, build_config_file_string)
 702
 703 # The emitter munges the source & target node lists to reflect what
 704 # we're really doing.
 705 def config_emitter(target, source, env):
 706     # extract variable name from Builder arg
 707     variable = str(target[0])
 708     # True target is config header file
 709     target = joinpath('config', variable.lower() + '.hh')
 710     val = env[variable]
 711     if isinstance(val, bool):
 712         # Force value to 0/1
 713         val = int(val)
 714     elif isinstance(val, str):
 715         val = '"' + val + '"'
 716
 717     # Sources are variable name & value (packaged in SCons Value nodes)
 718     return ([target], [Value(variable), Value(val)])
 719
 720 config_builder = Builder(emitter = config_emitter, action = config_action)
 721
 722 main.Append(BUILDERS = { 'ConfigFile' : config_builder })
 723
 724 # libelf build is shared across all configs in the build root.
 725 main.SConscript('ext/libelf/SConscript',
 726                 variant_dir = joinpath(build_root, 'libelf'))
 727
 728 # gzstream build is shared across all configs in the build root.
 729 main.SConscript('ext/gzstream/SConscript',
 730                 variant_dir = joinpath(build_root, 'gzstream'))
 731
 732 ###################################################
 733 #
 734 # This function is used to set up a directory with switching headers
 735 #
 736 ###################################################
 737
 738 main['ALL_ISA_LIST'] = all_isa_list
 739 def make_switching_dir(dname, switch_headers, env):
 740     # Generate the header.  target[0] is the full path of the output
 741     # header to generate.  'source' is a dummy variable, since we get the
 742     # list of ISAs from env['ALL_ISA_LIST'].
 743     def gen_switch_hdr(target, source, env):
 744         fname = str(target[0])
 745         f = open(fname, 'w')
 746         isa = env['TARGET_ISA'].lower()
 747         print >>f, '#include "%s/%s/%s"' % (dname, isa, basename(fname))
 748         f.close()
 749
 750     # String to print when generating header
 751     def gen_switch_hdr_string(target, source, env):
 752         return "Generating switch header " + str(target[0])
 753
 754     # Build SCons Action object. 'varlist' specifies env vars that this
 755     # action depends on; when env['ALL_ISA_LIST'] changes these actions
 756     # should get re-executed.
 757     switch_hdr_action = Action(gen_switch_hdr, gen_switch_hdr_string,
 758                                varlist=['ALL_ISA_LIST'])
 759
 760     # Instantiate actions for each header
 761     for hdr in switch_headers:
 762         env.Command(hdr, [], switch_hdr_action)
 763 Export('make_switching_dir')
 764
 765 ###################################################
 766 #
 767 # Define build environments for selected configurations.
 768 #
 769 ###################################################
 770
 771 for variant_path in variant_paths:
 772     print "Building in", variant_path
 773
 774     # Make a copy of the build-root environment to use for this config.
 775     env = main.Clone()
 776     env['BUILDDIR'] = variant_path
 777
 778     # variant_dir is the tail component of build path, and is used to
 779     # determine the build parameters (e.g., 'ALPHA_SE')
 780     (build_root, variant_dir) = splitpath(variant_path)
 781
 782     # Set env variables according to the build directory config.
 783     sticky_vars.files = []
 784     # Variables for $BUILD_ROOT/$VARIANT_DIR are stored in
 785     # $BUILD_ROOT/variables/$VARIANT_DIR so you can nuke
 786     # $BUILD_ROOT/$VARIANT_DIR without losing your variables settings.
 787     current_vars_file = joinpath(build_root, 'variables', variant_dir)
 788     if isfile(current_vars_file):
 789         sticky_vars.files.append(current_vars_file)
 790         print "Using saved variables file %s" % current_vars_file
 791     else:
 792         # Build dir-specific variables file doesn't exist.
 793
 794         # Make sure the directory is there so we can create it later
 795         opt_dir = dirname(current_vars_file)
 796         if not isdir(opt_dir):
 797             mkdir(opt_dir)
 798
 799         # Get default build variables from source tree.  Variables are
 800         # normally determined by name of $VARIANT_DIR, but can be
 801         # overriden by 'default=' arg on command line.
 802         default_vars_file = joinpath('build_opts',
 803                                      ARGUMENTS.get('default', variant_dir))
 804         if isfile(default_vars_file):
 805             sticky_vars.files.append(default_vars_file)
 806             print "Variables file %s not found,\n  using defaults in %s" \
 807                   % (current_vars_file, default_vars_file)
 808         else:
 809             print "Error: cannot find variables file %s or %s" \
 810                   % (current_vars_file, default_vars_file)
 811             Exit(1)
 812
 813     # Apply current variable settings to env
 814     sticky_vars.Update(env)
 815     nonsticky_vars.Update(env)
 816
 817     help_text += "\nSticky variables for %s:\n" % variant_dir \
 818                  + sticky_vars.GenerateHelpText(env) \
 819                  + "\nNon-sticky variables for %s:\n" % variant_dir \
 820                  + nonsticky_vars.GenerateHelpText(env)
 821
 822     # Process variable settings.
 823
 824     if not have_fenv and env['USE_FENV']:
 825         print "Warning: <fenv.h> not available; " \
 826               "forcing USE_FENV to False in", variant_dir + "."
 827         env['USE_FENV'] = False
 828
 829     if not env['USE_FENV']:
 830         print "Warning: No IEEE FP rounding mode control in", variant_dir + "."
 831         print "         FP results may deviate slightly from other platforms."
 832
 833     if env['EFENCE']:
 834         env.Append(LIBS=['efence'])
 835
 836     if env['USE_MYSQL']:
 837         if not have_mysql:
 838             print "Warning: MySQL not available; " \
 839                   "forcing USE_MYSQL to False in", variant_dir + "."
 840             env['USE_MYSQL'] = False
 841         else:
 842             print "Compiling in", variant_dir, "with MySQL support."
 843             env.ParseConfig(mysql_config_libs)
 844             env.ParseConfig(mysql_config_include)
 845
 846     # Save sticky variable settings back to current variables file
 847     sticky_vars.Save(current_vars_file, env)
 848
 849     if env['USE_SSE2']:
 850         env.Append(CCFLAGS='-msse2')
 851
 852     # The src/SConscript file sets up the build rules in 'env' according
 853     # to the configured variables.  It returns a list of environments,
 854     # one for each variant build (debug, opt, etc.)
 855     envList = SConscript('src/SConscript', variant_dir = variant_path,
 856                          exports = 'env')
 857
 858     # Set up the regression tests for each build.
 859     for e in envList:
 860         SConscript('tests/SConscript',
 861                    variant_dir = joinpath(variant_path, 'tests', e.Label),
 862                    exports = { 'env' : e }, duplicate = False)
 863
 864 Help(help_text)