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     )
 318
 319 # base help text
 320 help_text = '''
 321 Usage: scons [scons options] [build options] [target(s)]
 322
 323 Global sticky options:
 324 '''
 325
 326 # Update main environment with values from ARGUMENTS & global_sticky_vars_file
 327 global_sticky_vars.Update(main)
 328
 329 help_text += global_sticky_vars.GenerateHelpText(main)
 330
 331 # Save sticky variable settings back to current variables file
 332 global_sticky_vars.Save(global_sticky_vars_file, main)
 333
 334 # Parse EXTRAS variable to build list of all directories where we're
 335 # look for sources etc.  This list is exported as base_dir_list.
 336 base_dir = main.srcdir.abspath
 337 if main['EXTRAS']:
 338     extras_dir_list = main['EXTRAS'].split(':')
 339 else:
 340     extras_dir_list = []
 341
 342 Export('base_dir')
 343 Export('extras_dir_list')
 344
 345 # the ext directory should be on the #includes path
 346 main.Append(CPPPATH=[Dir('ext')])
 347
 348 CXX_version = readCommand([main['CXX'],'--version'], exception=False)
 349 CXX_V = readCommand([main['CXX'],'-V'], exception=False)
 350
 351 main['GCC'] = CXX_version and CXX_version.find('g++') >= 0
 352 main['SUNCC'] = CXX_V and CXX_V.find('Sun C++') >= 0
 353 main['ICC'] = CXX_V and CXX_V.find('Intel') >= 0
 354 if main['GCC'] + main['SUNCC'] + main['ICC'] > 1:
 355     print 'Error: How can we have two at the same time?'
 356     Exit(1)
 357
 358 # Set up default C++ compiler flags
 359 if main['GCC']:
 360     main.Append(CCFLAGS='-pipe')
 361     main.Append(CCFLAGS='-fno-strict-aliasing')
 362     main.Append(CCFLAGS=['-Wall', '-Wno-sign-compare', '-Wundef'])
 363     main.Append(CXXFLAGS='-Wno-deprecated')
 364 elif main['ICC']:
 365     pass #Fix me... add warning flags once we clean up icc warnings
 366 elif main['SUNCC']:
 367     main.Append(CCFLAGS='-Qoption ccfe')
 368     main.Append(CCFLAGS='-features=gcc')
 369     main.Append(CCFLAGS='-features=extensions')
 370     main.Append(CCFLAGS='-library=stlport4')
 371     main.Append(CCFLAGS='-xar')
 372     #main.Append(CCFLAGS='-instances=semiexplicit')
 373 else:
 374     print 'Error: Don\'t know what compiler options to use for your compiler.'
 375     print '       Please fix SConstruct and src/SConscript and try again.'
 376     Exit(1)
 377
 378 # Set up common yacc/bison flags (needed for Ruby)
 379 main['YACCFLAGS'] = '-d'
 380 main['YACCHXXFILESUFFIX'] = '.hh'
 381
 382 # Do this after we save setting back, or else we'll tack on an
 383 # extra 'qdo' every time we run scons.
 384 if main['BATCH']:
 385     main['CC']     = main['BATCH_CMD'] + ' ' + main['CC']
 386     main['CXX']    = main['BATCH_CMD'] + ' ' + main['CXX']
 387     main['AS']     = main['BATCH_CMD'] + ' ' + main['AS']
 388     main['AR']     = main['BATCH_CMD'] + ' ' + main['AR']
 389     main['RANLIB'] = main['BATCH_CMD'] + ' ' + main['RANLIB']
 390
 391 if sys.platform == 'cygwin':
 392     # cygwin has some header file issues...
 393     main.Append(CCFLAGS="-Wno-uninitialized")
 394
 395 # Check for SWIG
 396 if not main.has_key('SWIG'):
 397     print 'Error: SWIG utility not found.'
 398     print '       Please install (see http://www.swig.org) and retry.'
 399     Exit(1)
 400
 401 # Check for appropriate SWIG version
 402 swig_version = readCommand(('swig', '-version'), exception='').split()
 403 # First 3 words should be "SWIG Version x.y.z"
 404 if len(swig_version) < 3 or \
 405         swig_version[0] != 'SWIG' or swig_version[1] != 'Version':
 406     print 'Error determining SWIG version.'
 407     Exit(1)
 408
 409 min_swig_version = '1.3.28'
 410 if compareVersions(swig_version[2], min_swig_version) < 0:
 411     print 'Error: SWIG version', min_swig_version, 'or newer required.'
 412     print '       Installed version:', swig_version[2]
 413     Exit(1)
 414
 415 # Set up SWIG flags & scanner
 416 swig_flags=Split('-c++ -python -modern -templatereduce $_CPPINCFLAGS')
 417 main.Append(SWIGFLAGS=swig_flags)
 418
 419 # filter out all existing swig scanners, they mess up the dependency
 420 # stuff for some reason
 421 scanners = []
 422 for scanner in main['SCANNERS']:
 423     skeys = scanner.skeys
 424     if skeys == '.i':
 425         continue
 426
 427     if isinstance(skeys, (list, tuple)) and '.i' in skeys:
 428         continue
 429
 430     scanners.append(scanner)
 431
 432 # add the new swig scanner that we like better
 433 from SCons.Scanner import ClassicCPP as CPPScanner
 434 swig_inc_re = '^[ \t]*[%,#][ \t]*(?:include|import)[ \t]*(<|")([^>"]+)(>|")'
 435 scanners.append(CPPScanner("SwigScan", [ ".i" ], "CPPPATH", swig_inc_re))
 436
 437 # replace the scanners list that has what we want
 438 main['SCANNERS'] = scanners
 439
 440 # Add a custom Check function to the Configure context so that we can
 441 # figure out if the compiler adds leading underscores to global
 442 # variables.  This is needed for the autogenerated asm files that we
 443 # use for embedding the python code.
 444 def CheckLeading(context):
 445     context.Message("Checking for leading underscore in global variables...")
 446     # 1) Define a global variable called x from asm so the C compiler
 447     #    won't change the symbol at all.
 448     # 2) Declare that variable.
 449     # 3) Use the variable
 450     #
 451     # If the compiler prepends an underscore, this will successfully
 452     # link because the external symbol 'x' will be called '_x' which
 453     # was defined by the asm statement.  If the compiler does not
 454     # prepend an underscore, this will not successfully link because
 455     # '_x' will have been defined by assembly, while the C portion of
 456     # the code will be trying to use 'x'
 457     ret = context.TryLink('''
 458         asm(".globl _x; _x: .byte 0");
 459         extern int x;
 460         int main() { return x; }
 461         ''', extension=".c")
 462     context.env.Append(LEADING_UNDERSCORE=ret)
 463     context.Result(ret)
 464     return ret
 465
 466 # Platform-specific configuration.  Note again that we assume that all
 467 # builds under a given build root run on the same host platform.
 468 conf = Configure(main,
 469                  conf_dir = joinpath(build_root, '.scons_config'),
 470                  log_file = joinpath(build_root, 'scons_config.log'),
 471                  custom_tests = { 'CheckLeading' : CheckLeading })
 472
 473 # Check for leading underscores.  Don't really need to worry either
 474 # way so don't need to check the return code.
 475 conf.CheckLeading()
 476
 477 # Check if we should compile a 64 bit binary on Mac OS X/Darwin
 478 try:
 479     import platform
 480     uname = platform.uname()
 481     if uname[0] == 'Darwin' and compareVersions(uname[2], '9.0.0') >= 0:
 482         if int(readCommand('sysctl -n hw.cpu64bit_capable')[0]):
 483             main.Append(CCFLAGS='-arch x86_64')
 484             main.Append(CFLAGS='-arch x86_64')
 485             main.Append(LINKFLAGS='-arch x86_64')
 486             main.Append(ASFLAGS='-arch x86_64')
 487 except:
 488     pass
 489
 490 # Recent versions of scons substitute a "Null" object for Configure()
 491 # when configuration isn't necessary, e.g., if the "--help" option is
 492 # present.  Unfortuantely this Null object always returns false,
 493 # breaking all our configuration checks.  We replace it with our own
 494 # more optimistic null object that returns True instead.
 495 if not conf:
 496     def NullCheck(*args, **kwargs):
 497         return True
 498
 499     class NullConf:
 500         def __init__(self, env):
 501             self.env = env
 502         def Finish(self):
 503             return self.env
 504         def __getattr__(self, mname):
 505             return NullCheck
 506
 507     conf = NullConf(main)
 508
 509 # Find Python include and library directories for embedding the
 510 # interpreter.  For consistency, we will use the same Python
 511 # installation used to run scons (and thus this script).  If you want
 512 # to link in an alternate version, see above for instructions on how
 513 # to invoke scons with a different copy of the Python interpreter.
 514 from distutils import sysconfig
 515
 516 py_getvar = sysconfig.get_config_var
 517
 518 py_debug = getattr(sys, 'pydebug', False)
 519 py_version = 'python' + py_getvar('VERSION') + (py_debug and "_d" or "")
 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 class CpuModel(object):
 616     '''The CpuModel class encapsulates everything the ISA parser needs to
 617     know about a particular CPU model.'''
 618
 619     # Dict of available CPU model objects.  Accessible as CpuModel.dict.
 620     dict = {}
 621     list = []
 622     defaults = []
 623
 624     # Constructor.  Automatically adds models to CpuModel.dict.
 625     def __init__(self, name, filename, includes, strings, default=False):
 626         self.name = name           # name of model
 627         self.filename = filename   # filename for output exec code
 628         self.includes = includes   # include files needed in exec file
 629         # The 'strings' dict holds all the per-CPU symbols we can
 630         # substitute into templates etc.
 631         self.strings = strings
 632
 633         # This cpu is enabled by default
 634         self.default = default
 635
 636         # Add self to dict
 637         if name in CpuModel.dict:
 638             raise AttributeError, "CpuModel '%s' already registered" % name
 639         CpuModel.dict[name] = self
 640         CpuModel.list.append(name)
 641
 642 Export('CpuModel')
 643
 644 # Sticky variables get saved in the variables file so they persist from
 645 # one invocation to the next (unless overridden, in which case the new
 646 # value becomes sticky).
 647 sticky_vars = Variables(args=ARGUMENTS)
 648 Export('sticky_vars')
 649
 650 # Sticky variables that should be exported
 651 export_vars = []
 652 Export('export_vars')
 653
 654 # Non-sticky variables only apply to the current build.
 655 nonsticky_vars = Variables(args=ARGUMENTS)
 656 Export('nonsticky_vars')
 657
 658 # Walk the tree and execute all SConsopts scripts that wil add to the
 659 # above variables
 660 for bdir in [ base_dir ] + extras_dir_list:
 661     for root, dirs, files in os.walk(bdir):
 662         if 'SConsopts' in files:
 663             print "Reading", joinpath(root, 'SConsopts')
 664             SConscript(joinpath(root, 'SConsopts'))
 665
 666 all_isa_list.sort()
 667
 668 sticky_vars.AddVariables(
 669     EnumVariable('TARGET_ISA', 'Target ISA', 'alpha', all_isa_list),
 670     BoolVariable('FULL_SYSTEM', 'Full-system support', False),
 671     ListVariable('CPU_MODELS', 'CPU models',
 672                  sorted(n for n,m in CpuModel.dict.iteritems() if m.default),
 673                  sorted(CpuModel.list)),
 674     BoolVariable('NO_FAST_ALLOC', 'Disable fast object allocator', False),
 675     BoolVariable('FAST_ALLOC_DEBUG', 'Enable fast object allocator debugging',
 676                  False),
 677     BoolVariable('FAST_ALLOC_STATS', 'Enable fast object allocator statistics',
 678                  False),
 679     BoolVariable('EFENCE', 'Link with Electric Fence malloc debugger',
 680                  False),
 681     BoolVariable('SS_COMPATIBLE_FP',
 682                  'Make floating-point results compatible with SimpleScalar',
 683                  False),
 684     BoolVariable('USE_SSE2',
 685                  'Compile for SSE2 (-msse2) to get IEEE FP on x86 hosts',
 686                  False),
 687     BoolVariable('USE_MYSQL', 'Use MySQL for stats output', have_mysql),
 688     BoolVariable('USE_FENV', 'Use <fenv.h> IEEE mode control', have_fenv),
 689     BoolVariable('USE_CHECKER', 'Use checker for detailed CPU models', False),
 690     BoolVariable('CP_ANNOTATE', 'Enable critical path annotation capability', False),
 691     BoolVariable('RUBY', 'Build with Ruby', False),
 692     )
 693
 694 nonsticky_vars.AddVariables(
 695     BoolVariable('update_ref', 'Update test reference outputs', False)
 696     )
 697
 698 # These variables get exported to #defines in config/*.hh (see src/SConscript).
 699 export_vars += ['FULL_SYSTEM', 'USE_FENV', 'USE_MYSQL',
 700                 'NO_FAST_ALLOC', 'FAST_ALLOC_DEBUG', 'FAST_ALLOC_STATS',
 701                 'SS_COMPATIBLE_FP', 'USE_CHECKER', 'TARGET_ISA', 'CP_ANNOTATE']
 702
 703 ###################################################
 704 #
 705 # Define a SCons builder for configuration flag headers.
 706 #
 707 ###################################################
 708
 709 # This function generates a config header file that #defines the
 710 # variable symbol to the current variable setting (0 or 1).  The source
 711 # operands are the name of the variable and a Value node containing the
 712 # value of the variable.
 713 def build_config_file(target, source, env):
 714     (variable, value) = [s.get_contents() for s in source]
 715     f = file(str(target[0]), 'w')
 716     print >> f, '#define', variable, value
 717     f.close()
 718     return None
 719
 720 # Generate the message to be printed when building the config file.
 721 def build_config_file_string(target, source, env):
 722     (variable, value) = [s.get_contents() for s in source]
 723     return "Defining %s as %s in %s." % (variable, value, target[0])
 724
 725 # Combine the two functions into a scons Action object.
 726 config_action = Action(build_config_file, build_config_file_string)
 727
 728 # The emitter munges the source & target node lists to reflect what
 729 # we're really doing.
 730 def config_emitter(target, source, env):
 731     # extract variable name from Builder arg
 732     variable = str(target[0])
 733     # True target is config header file
 734     target = joinpath('config', variable.lower() + '.hh')
 735     val = env[variable]
 736     if isinstance(val, bool):
 737         # Force value to 0/1
 738         val = int(val)
 739     elif isinstance(val, str):
 740         val = '"' + val + '"'
 741
 742     # Sources are variable name & value (packaged in SCons Value nodes)
 743     return ([target], [Value(variable), Value(val)])
 744
 745 config_builder = Builder(emitter = config_emitter, action = config_action)
 746
 747 main.Append(BUILDERS = { 'ConfigFile' : config_builder })
 748
 749 # libelf build is shared across all configs in the build root.
 750 main.SConscript('ext/libelf/SConscript',
 751                 variant_dir = joinpath(build_root, 'libelf'))
 752
 753 # gzstream build is shared across all configs in the build root.
 754 main.SConscript('ext/gzstream/SConscript',
 755                 variant_dir = joinpath(build_root, 'gzstream'))
 756
 757 ###################################################
 758 #
 759 # This function is used to set up a directory with switching headers
 760 #
 761 ###################################################
 762
 763 main['ALL_ISA_LIST'] = all_isa_list
 764 def make_switching_dir(dname, switch_headers, env):
 765     # Generate the header.  target[0] is the full path of the output
 766     # header to generate.  'source' is a dummy variable, since we get the
 767     # list of ISAs from env['ALL_ISA_LIST'].
 768     def gen_switch_hdr(target, source, env):
 769         fname = str(target[0])
 770         f = open(fname, 'w')
 771         isa = env['TARGET_ISA'].lower()
 772         print >>f, '#include "%s/%s/%s"' % (dname, isa, basename(fname))
 773         f.close()
 774
 775     # String to print when generating header
 776     def gen_switch_hdr_string(target, source, env):
 777         return "Generating switch header " + str(target[0])
 778
 779     # Build SCons Action object. 'varlist' specifies env vars that this
 780     # action depends on; when env['ALL_ISA_LIST'] changes these actions
 781     # should get re-executed.
 782     switch_hdr_action = Action(gen_switch_hdr, gen_switch_hdr_string,
 783                                varlist=['ALL_ISA_LIST'])
 784
 785     # Instantiate actions for each header
 786     for hdr in switch_headers:
 787         env.Command(hdr, [], switch_hdr_action)
 788 Export('make_switching_dir')
 789
 790 ###################################################
 791 #
 792 # Define build environments for selected configurations.
 793 #
 794 ###################################################
 795
 796 for variant_path in variant_paths:
 797     print "Building in", variant_path
 798
 799     # Make a copy of the build-root environment to use for this config.
 800     env = main.Clone()
 801     env['BUILDDIR'] = variant_path
 802
 803     # variant_dir is the tail component of build path, and is used to
 804     # determine the build parameters (e.g., 'ALPHA_SE')
 805     (build_root, variant_dir) = splitpath(variant_path)
 806
 807     # Set env variables according to the build directory config.
 808     sticky_vars.files = []
 809     # Variables for $BUILD_ROOT/$VARIANT_DIR are stored in
 810     # $BUILD_ROOT/variables/$VARIANT_DIR so you can nuke
 811     # $BUILD_ROOT/$VARIANT_DIR without losing your variables settings.
 812     current_vars_file = joinpath(build_root, 'variables', variant_dir)
 813     if isfile(current_vars_file):
 814         sticky_vars.files.append(current_vars_file)
 815         print "Using saved variables file %s" % current_vars_file
 816     else:
 817         # Build dir-specific variables file doesn't exist.
 818
 819         # Make sure the directory is there so we can create it later
 820         opt_dir = dirname(current_vars_file)
 821         if not isdir(opt_dir):
 822             mkdir(opt_dir)
 823
 824         # Get default build variables from source tree.  Variables are
 825         # normally determined by name of $VARIANT_DIR, but can be
 826         # overriden by 'default=' arg on command line.
 827         default_vars_file = joinpath('build_opts',
 828                                      ARGUMENTS.get('default', variant_dir))
 829         if isfile(default_vars_file):
 830             sticky_vars.files.append(default_vars_file)
 831             print "Variables file %s not found,\n  using defaults in %s" \
 832                   % (current_vars_file, default_vars_file)
 833         else:
 834             print "Error: cannot find variables file %s or %s" \
 835                   % (current_vars_file, default_vars_file)
 836             Exit(1)
 837
 838     # Apply current variable settings to env
 839     sticky_vars.Update(env)
 840     nonsticky_vars.Update(env)
 841
 842     help_text += "\nSticky variables for %s:\n" % variant_dir \
 843                  + sticky_vars.GenerateHelpText(env) \
 844                  + "\nNon-sticky variables for %s:\n" % variant_dir \
 845                  + nonsticky_vars.GenerateHelpText(env)
 846
 847     # Process variable settings.
 848
 849     if not have_fenv and env['USE_FENV']:
 850         print "Warning: <fenv.h> not available; " \
 851               "forcing USE_FENV to False in", variant_dir + "."
 852         env['USE_FENV'] = False
 853
 854     if not env['USE_FENV']:
 855         print "Warning: No IEEE FP rounding mode control in", variant_dir + "."
 856         print "         FP results may deviate slightly from other platforms."
 857
 858     if env['EFENCE']:
 859         env.Append(LIBS=['efence'])
 860
 861     if env['USE_MYSQL']:
 862         if not have_mysql:
 863             print "Warning: MySQL not available; " \
 864                   "forcing USE_MYSQL to False in", variant_dir + "."
 865             env['USE_MYSQL'] = False
 866         else:
 867             print "Compiling in", variant_dir, "with MySQL support."
 868             env.ParseConfig(mysql_config_libs)
 869             env.ParseConfig(mysql_config_include)
 870
 871     # Save sticky variable settings back to current variables file
 872     sticky_vars.Save(current_vars_file, env)
 873
 874     if env['USE_SSE2']:
 875         env.Append(CCFLAGS='-msse2')
 876
 877     # The src/SConscript file sets up the build rules in 'env' according
 878     # to the configured variables.  It returns a list of environments,
 879     # one for each variant build (debug, opt, etc.)
 880     envList = SConscript('src/SConscript', variant_dir = variant_path,
 881                          exports = 'env')
 882
 883     # Set up the regression tests for each build.
 884     for e in envList:
 885         SConscript('tests/SConscript',
 886                    variant_dir = joinpath(variant_path, 'tests', e.Label),
 887                    exports = { 'env' : e }, duplicate = False)
 888
 889 Help(help_text)