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