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 main['BUILDROOT'] = build_root
 276
 277 Export('main')
 278
 279 main.SConsignFile(joinpath(build_root, "sconsign"))
 280
 281 # Default duplicate option is to use hard links, but this messes up
 282 # when you use emacs to edit a file in the target dir, as emacs moves
 283 # file to file~ then copies to file, breaking the link.  Symbolic
 284 # (soft) links work better.
 285 main.SetOption('duplicate', 'soft-copy')
 286
 287 #
 288 # Set up global sticky variables... these are common to an entire build
 289 # tree (not specific to a particular build like ALPHA_SE)
 290 #
 291
 292 # Variable validators & converters for global sticky variables
 293 def PathListMakeAbsolute(val):
 294     if not val:
 295         return val
 296     f = lambda p: abspath(expanduser(p))
 297     return ':'.join(map(f, val.split(':')))
 298
 299 def PathListAllExist(key, val, env):
 300     if not val:
 301         return
 302     paths = val.split(':')
 303     for path in paths:
 304         if not isdir(path):
 305             raise SCons.Errors.UserError("Path does not exist: '%s'" % path)
 306
 307 global_sticky_vars_file = joinpath(build_root, 'variables.global')
 308
 309 global_sticky_vars = Variables(global_sticky_vars_file, args=ARGUMENTS)
 310 global_nonsticky_vars = Variables(args=ARGUMENTS)
 311
 312 global_sticky_vars.AddVariables(
 313     ('CC', 'C compiler', environ.get('CC', main['CC'])),
 314     ('CXX', 'C++ compiler', environ.get('CXX', main['CXX'])),
 315     ('BATCH', 'Use batch pool for build and tests', False),
 316     ('BATCH_CMD', 'Batch pool submission command name', 'qdo'),
 317     ('M5_BUILD_CACHE', 'Cache built objects in this directory', False),
 318     ('EXTRAS', 'Add Extra directories to the compilation', '',
 319      PathListAllExist, PathListMakeAbsolute),
 320     )
 321
 322 global_nonsticky_vars.AddVariables(
 323     ('VERBOSE', 'Print full tool command lines', False),
 324     ('update_ref', 'Update test reference outputs', False)
 325     )
 326
 327
 328 # base help text
 329 help_text = '''
 330 Usage: scons [scons options] [build options] [target(s)]
 331
 332 Global sticky options:
 333 '''
 334
 335 # Update main environment with values from ARGUMENTS & global_sticky_vars_file
 336 global_sticky_vars.Update(main)
 337 global_nonsticky_vars.Update(main)
 338
 339 help_text += global_sticky_vars.GenerateHelpText(main)
 340 help_text += global_nonsticky_vars.GenerateHelpText(main)
 341
 342 # Save sticky variable settings back to current variables file
 343 global_sticky_vars.Save(global_sticky_vars_file, main)
 344
 345 # Parse EXTRAS variable to build list of all directories where we're
 346 # look for sources etc.  This list is exported as base_dir_list.
 347 base_dir = main.srcdir.abspath
 348 if main['EXTRAS']:
 349     extras_dir_list = main['EXTRAS'].split(':')
 350 else:
 351     extras_dir_list = []
 352
 353 Export('base_dir')
 354 Export('extras_dir_list')
 355
 356 # the ext directory should be on the #includes path
 357 main.Append(CPPPATH=[Dir('ext')])
 358
 359 def _STRIP(path, env):
 360     path = str(path)
 361     variant_base = env['BUILDROOT'] + os.path.sep
 362     if path.startswith(variant_base):
 363         path = path[len(variant_base):]
 364     elif path.startswith('build/'):
 365         path = path[6:]
 366     return path
 367
 368 def _STRIP_SOURCE(target, source, env, for_signature):
 369     return _STRIP(source[0], env)
 370 main['STRIP_SOURCE'] = _STRIP_SOURCE
 371
 372 def _STRIP_TARGET(target, source, env, for_signature):
 373     return _STRIP(target[0], env)
 374 main['STRIP_TARGET'] = _STRIP_TARGET
 375
 376 if main['VERBOSE']:
 377     def MakeAction(action, string, *args, **kwargs):
 378         return Action(action, *args, **kwargs)
 379 else:
 380     MakeAction = Action
 381     main['CCCOMSTR']        = ' [      CC] $STRIP_SOURCE'
 382     main['CXXCOMSTR']       = ' [     CXX] $STRIP_SOURCE'
 383     main['ASCOMSTR']        = ' [      AS] $STRIP_SOURCE'
 384     main['SWIGCOMSTR']      = ' [    SWIG] $STRIP_SOURCE'
 385     main['ARCOMSTR']        = ' [      AR] $STRIP_TARGET'
 386     main['LINKCOMSTR']      = ' [    LINK] $STRIP_TARGET'
 387     main['RANLIBCOMSTR']    = ' [  RANLIB] $STRIP_TARGET'
 388     main['M4COMSTR']        = ' [      M4] $STRIP_TARGET'
 389     main['SHCCCOMSTR']      = ' [    SHCC] $STRIP_TARGET'
 390     main['SHCXXCOMSTR']     = ' [   SHCXX] $STRIP_TARGET'
 391 Export('MakeAction')
 392
 393 CXX_version = readCommand([main['CXX'],'--version'], exception=False)
 394 CXX_V = readCommand([main['CXX'],'-V'], exception=False)
 395
 396 main['GCC'] = CXX_version and CXX_version.find('g++') >= 0
 397 main['SUNCC'] = CXX_V and CXX_V.find('Sun C++') >= 0
 398 main['ICC'] = CXX_V and CXX_V.find('Intel') >= 0
 399 if main['GCC'] + main['SUNCC'] + main['ICC'] > 1:
 400     print 'Error: How can we have two at the same time?'
 401     Exit(1)
 402
 403 # Set up default C++ compiler flags
 404 if main['GCC']:
 405     main.Append(CCFLAGS=['-pipe'])
 406     main.Append(CCFLAGS=['-fno-strict-aliasing'])
 407     main.Append(CCFLAGS=['-Wall', '-Wno-sign-compare', '-Wundef'])
 408     main.Append(CXXFLAGS=['-Wno-deprecated'])
 409     # Read the GCC version to check for versions with bugs
 410     # Note CCVERSION doesn't work here because it is run with the CC
 411     # before we override it from the command line
 412     gcc_version = readCommand([main['CXX'], '-dumpversion'], exception=False)
 413     if not compareVersions(gcc_version, '4.4.1') or \
 414        not compareVersions(gcc_version, '4.4.2'):
 415         print 'Info: Tree vectorizer in GCC 4.4.1 & 4.4.2 is buggy, disabling.'
 416         main.Append(CCFLAGS=['-fno-tree-vectorize'])
 417 elif main['ICC']:
 418     pass #Fix me... add warning flags once we clean up icc warnings
 419 elif main['SUNCC']:
 420     main.Append(CCFLAGS=['-Qoption ccfe'])
 421     main.Append(CCFLAGS=['-features=gcc'])
 422     main.Append(CCFLAGS=['-features=extensions'])
 423     main.Append(CCFLAGS=['-library=stlport4'])
 424     main.Append(CCFLAGS=['-xar'])
 425     #main.Append(CCFLAGS=['-instances=semiexplicit'])
 426 else:
 427     print 'Error: Don\'t know what compiler options to use for your compiler.'
 428     print '       Please fix SConstruct and src/SConscript and try again.'
 429     Exit(1)
 430
 431 # Set up common yacc/bison flags (needed for Ruby)
 432 main['YACCFLAGS'] = '-d'
 433 main['YACCHXXFILESUFFIX'] = '.hh'
 434
 435 # Do this after we save setting back, or else we'll tack on an
 436 # extra 'qdo' every time we run scons.
 437 if main['BATCH']:
 438     main['CC']     = main['BATCH_CMD'] + ' ' + main['CC']
 439     main['CXX']    = main['BATCH_CMD'] + ' ' + main['CXX']
 440     main['AS']     = main['BATCH_CMD'] + ' ' + main['AS']
 441     main['AR']     = main['BATCH_CMD'] + ' ' + main['AR']
 442     main['RANLIB'] = main['BATCH_CMD'] + ' ' + main['RANLIB']
 443
 444 if sys.platform == 'cygwin':
 445     # cygwin has some header file issues...
 446     main.Append(CCFLAGS=["-Wno-uninitialized"])
 447
 448 # Check for SWIG
 449 if not main.has_key('SWIG'):
 450     print 'Error: SWIG utility not found.'
 451     print '       Please install (see http://www.swig.org) and retry.'
 452     Exit(1)
 453
 454 # Check for appropriate SWIG version
 455 swig_version = readCommand(('swig', '-version'), exception='').split()
 456 # First 3 words should be "SWIG Version x.y.z"
 457 if len(swig_version) < 3 or \
 458         swig_version[0] != 'SWIG' or swig_version[1] != 'Version':
 459     print 'Error determining SWIG version.'
 460     Exit(1)
 461
 462 min_swig_version = '1.3.28'
 463 if compareVersions(swig_version[2], min_swig_version) < 0:
 464     print 'Error: SWIG version', min_swig_version, 'or newer required.'
 465     print '       Installed version:', swig_version[2]
 466     Exit(1)
 467
 468 # Set up SWIG flags & scanner
 469 swig_flags=Split('-c++ -python -modern -templatereduce $_CPPINCFLAGS')
 470 main.Append(SWIGFLAGS=swig_flags)
 471
 472 # filter out all existing swig scanners, they mess up the dependency
 473 # stuff for some reason
 474 scanners = []
 475 for scanner in main['SCANNERS']:
 476     skeys = scanner.skeys
 477     if skeys == '.i':
 478         continue
 479
 480     if isinstance(skeys, (list, tuple)) and '.i' in skeys:
 481         continue
 482
 483     scanners.append(scanner)
 484
 485 # add the new swig scanner that we like better
 486 from SCons.Scanner import ClassicCPP as CPPScanner
 487 swig_inc_re = '^[ \t]*[%,#][ \t]*(?:include|import)[ \t]*(<|")([^>"]+)(>|")'
 488 scanners.append(CPPScanner("SwigScan", [ ".i" ], "CPPPATH", swig_inc_re))
 489
 490 # replace the scanners list that has what we want
 491 main['SCANNERS'] = scanners
 492
 493 # Add a custom Check function to the Configure context so that we can
 494 # figure out if the compiler adds leading underscores to global
 495 # variables.  This is needed for the autogenerated asm files that we
 496 # use for embedding the python code.
 497 def CheckLeading(context):
 498     context.Message("Checking for leading underscore in global variables...")
 499     # 1) Define a global variable called x from asm so the C compiler
 500     #    won't change the symbol at all.
 501     # 2) Declare that variable.
 502     # 3) Use the variable
 503     #
 504     # If the compiler prepends an underscore, this will successfully
 505     # link because the external symbol 'x' will be called '_x' which
 506     # was defined by the asm statement.  If the compiler does not
 507     # prepend an underscore, this will not successfully link because
 508     # '_x' will have been defined by assembly, while the C portion of
 509     # the code will be trying to use 'x'
 510     ret = context.TryLink('''
 511         asm(".globl _x; _x: .byte 0");
 512         extern int x;
 513         int main() { return x; }
 514         ''', extension=".c")
 515     context.env.Append(LEADING_UNDERSCORE=ret)
 516     context.Result(ret)
 517     return ret
 518
 519 # Platform-specific configuration.  Note again that we assume that all
 520 # builds under a given build root run on the same host platform.
 521 conf = Configure(main,
 522                  conf_dir = joinpath(build_root, '.scons_config'),
 523                  log_file = joinpath(build_root, 'scons_config.log'),
 524                  custom_tests = { 'CheckLeading' : CheckLeading })
 525
 526 # Check for leading underscores.  Don't really need to worry either
 527 # way so don't need to check the return code.
 528 conf.CheckLeading()
 529
 530 # Check if we should compile a 64 bit binary on Mac OS X/Darwin
 531 try:
 532     import platform
 533     uname = platform.uname()
 534     if uname[0] == 'Darwin' and compareVersions(uname[2], '9.0.0') >= 0:
 535         if int(readCommand('sysctl -n hw.cpu64bit_capable')[0]):
 536             main.Append(CCFLAGS=['-arch', 'x86_64'])
 537             main.Append(CFLAGS=['-arch', 'x86_64'])
 538             main.Append(LINKFLAGS=['-arch', 'x86_64'])
 539             main.Append(ASFLAGS=['-arch', 'x86_64'])
 540 except:
 541     pass
 542
 543 # Recent versions of scons substitute a "Null" object for Configure()
 544 # when configuration isn't necessary, e.g., if the "--help" option is
 545 # present.  Unfortuantely this Null object always returns false,
 546 # breaking all our configuration checks.  We replace it with our own
 547 # more optimistic null object that returns True instead.
 548 if not conf:
 549     def NullCheck(*args, **kwargs):
 550         return True
 551
 552     class NullConf:
 553         def __init__(self, env):
 554             self.env = env
 555         def Finish(self):
 556             return self.env
 557         def __getattr__(self, mname):
 558             return NullCheck
 559
 560     conf = NullConf(main)
 561
 562 # Find Python include and library directories for embedding the
 563 # interpreter.  For consistency, we will use the same Python
 564 # installation used to run scons (and thus this script).  If you want
 565 # to link in an alternate version, see above for instructions on how
 566 # to invoke scons with a different copy of the Python interpreter.
 567 from distutils import sysconfig
 568
 569 py_getvar = sysconfig.get_config_var
 570
 571 py_debug = getattr(sys, 'pydebug', False)
 572 py_version = 'python' + py_getvar('VERSION') + (py_debug and "_d" or "")
 573
 574 py_general_include = sysconfig.get_python_inc()
 575 py_platform_include = sysconfig.get_python_inc(plat_specific=True)
 576 py_includes = [ py_general_include ]
 577 if py_platform_include != py_general_include:
 578     py_includes.append(py_platform_include)
 579
 580 py_lib_path = [ py_getvar('LIBDIR') ]
 581 # add the prefix/lib/pythonX.Y/config dir, but only if there is no
 582 # shared library in prefix/lib/.
 583 if not py_getvar('Py_ENABLE_SHARED'):
 584     py_lib_path.append(py_getvar('LIBPL'))
 585
 586 py_libs = []
 587 for lib in py_getvar('LIBS').split() + py_getvar('SYSLIBS').split():
 588     assert lib.startswith('-l')
 589     lib = lib[2:]
 590     if lib not in py_libs:
 591         py_libs.append(lib)
 592 py_libs.append(py_version)
 593
 594 main.Append(CPPPATH=py_includes)
 595 main.Append(LIBPATH=py_lib_path)
 596
 597 # Cache build files in the supplied directory.
 598 if main['M5_BUILD_CACHE']:
 599     print 'Using build cache located at', main['M5_BUILD_CACHE']
 600     CacheDir(main['M5_BUILD_CACHE'])
 601
 602
 603 # verify that this stuff works
 604 if not conf.CheckHeader('Python.h', '<>'):
 605     print "Error: can't find Python.h header in", py_includes
 606     Exit(1)
 607
 608 for lib in py_libs:
 609     if not conf.CheckLib(lib):
 610         print "Error: can't find library %s required by python" % lib
 611         Exit(1)
 612
 613 # On Solaris you need to use libsocket for socket ops
 614 if not conf.CheckLibWithHeader(None, 'sys/socket.h', 'C++', 'accept(0,0,0);'):
 615    if not conf.CheckLibWithHeader('socket', 'sys/socket.h', 'C++', 'accept(0,0,0);'):
 616        print "Can't find library with socket calls (e.g. accept())"
 617        Exit(1)
 618
 619 # Check for zlib.  If the check passes, libz will be automatically
 620 # added to the LIBS environment variable.
 621 if not conf.CheckLibWithHeader('z', 'zlib.h', 'C++','zlibVersion();'):
 622     print 'Error: did not find needed zlib compression library '\
 623           'and/or zlib.h header file.'
 624     print '       Please install zlib and try again.'
 625     Exit(1)
 626
 627 # Check for <fenv.h> (C99 FP environment control)
 628 have_fenv = conf.CheckHeader('fenv.h', '<>')
 629 if not have_fenv:
 630     print "Warning: Header file <fenv.h> not found."
 631     print "         This host has no IEEE FP rounding mode control."
 632
 633 ######################################################################
 634 #
 635 # Check for mysql.
 636 #
 637 mysql_config = WhereIs('mysql_config')
 638 have_mysql = bool(mysql_config)
 639
 640 # Check MySQL version.
 641 if have_mysql:
 642     mysql_version = readCommand(mysql_config + ' --version')
 643     min_mysql_version = '4.1'
 644     if compareVersions(mysql_version, min_mysql_version) < 0:
 645         print 'Warning: MySQL', min_mysql_version, 'or newer required.'
 646         print '         Version', mysql_version, 'detected.'
 647         have_mysql = False
 648
 649 # Set up mysql_config commands.
 650 if have_mysql:
 651     mysql_config_include = mysql_config + ' --include'
 652     if os.system(mysql_config_include + ' > /dev/null') != 0:
 653         # older mysql_config versions don't support --include, use
 654         # --cflags instead
 655         mysql_config_include = mysql_config + ' --cflags | sed s/\\\'//g'
 656     # This seems to work in all versions
 657     mysql_config_libs = mysql_config + ' --libs'
 658
 659 ######################################################################
 660 #
 661 # Finish the configuration
 662 #
 663 main = conf.Finish()
 664
 665 ######################################################################
 666 #
 667 # Collect all non-global variables
 668 #
 669
 670 # Define the universe of supported ISAs
 671 all_isa_list = [ ]
 672 Export('all_isa_list')
 673
 674 class CpuModel(object):
 675     '''The CpuModel class encapsulates everything the ISA parser needs to
 676     know about a particular CPU model.'''
 677
 678     # Dict of available CPU model objects.  Accessible as CpuModel.dict.
 679     dict = {}
 680     list = []
 681     defaults = []
 682
 683     # Constructor.  Automatically adds models to CpuModel.dict.
 684     def __init__(self, name, filename, includes, strings, default=False):
 685         self.name = name           # name of model
 686         self.filename = filename   # filename for output exec code
 687         self.includes = includes   # include files needed in exec file
 688         # The 'strings' dict holds all the per-CPU symbols we can
 689         # substitute into templates etc.
 690         self.strings = strings
 691
 692         # This cpu is enabled by default
 693         self.default = default
 694
 695         # Add self to dict
 696         if name in CpuModel.dict:
 697             raise AttributeError, "CpuModel '%s' already registered" % name
 698         CpuModel.dict[name] = self
 699         CpuModel.list.append(name)
 700
 701 Export('CpuModel')
 702
 703 # Sticky variables get saved in the variables file so they persist from
 704 # one invocation to the next (unless overridden, in which case the new
 705 # value becomes sticky).
 706 sticky_vars = Variables(args=ARGUMENTS)
 707 Export('sticky_vars')
 708
 709 # Sticky variables that should be exported
 710 export_vars = []
 711 Export('export_vars')
 712
 713 # Walk the tree and execute all SConsopts scripts that wil add to the
 714 # above variables
 715 for bdir in [ base_dir ] + extras_dir_list:
 716     for root, dirs, files in os.walk(bdir):
 717         if 'SConsopts' in files:
 718             print "Reading", joinpath(root, 'SConsopts')
 719             SConscript(joinpath(root, 'SConsopts'))
 720
 721 all_isa_list.sort()
 722
 723 sticky_vars.AddVariables(
 724     EnumVariable('TARGET_ISA', 'Target ISA', 'alpha', all_isa_list),
 725     BoolVariable('FULL_SYSTEM', 'Full-system support', False),
 726     ListVariable('CPU_MODELS', 'CPU models',
 727                  sorted(n for n,m in CpuModel.dict.iteritems() if m.default),
 728                  sorted(CpuModel.list)),
 729     BoolVariable('NO_FAST_ALLOC', 'Disable fast object allocator', False),
 730     BoolVariable('FAST_ALLOC_DEBUG', 'Enable fast object allocator debugging',
 731                  False),
 732     BoolVariable('FAST_ALLOC_STATS', 'Enable fast object allocator statistics',
 733                  False),
 734     BoolVariable('EFENCE', 'Link with Electric Fence malloc debugger',
 735                  False),
 736     BoolVariable('SS_COMPATIBLE_FP',
 737                  'Make floating-point results compatible with SimpleScalar',
 738                  False),
 739     BoolVariable('USE_SSE2',
 740                  'Compile for SSE2 (-msse2) to get IEEE FP on x86 hosts',
 741                  False),
 742     BoolVariable('USE_MYSQL', 'Use MySQL for stats output', have_mysql),
 743     BoolVariable('USE_FENV', 'Use <fenv.h> IEEE mode control', have_fenv),
 744     BoolVariable('USE_CHECKER', 'Use checker for detailed CPU models', False),
 745     BoolVariable('CP_ANNOTATE', 'Enable critical path annotation capability', False),
 746     BoolVariable('RUBY', 'Build with Ruby', False),
 747     )
 748
 749 # These variables get exported to #defines in config/*.hh (see src/SConscript).
 750 export_vars += ['FULL_SYSTEM', 'USE_FENV', 'USE_MYSQL',
 751                 'NO_FAST_ALLOC', 'FAST_ALLOC_DEBUG', 'FAST_ALLOC_STATS',
 752                 'SS_COMPATIBLE_FP', 'USE_CHECKER', 'TARGET_ISA', 'CP_ANNOTATE']
 753
 754 ###################################################
 755 #
 756 # Define a SCons builder for configuration flag headers.
 757 #
 758 ###################################################
 759
 760 # This function generates a config header file that #defines the
 761 # variable symbol to the current variable setting (0 or 1).  The source
 762 # operands are the name of the variable and a Value node containing the
 763 # value of the variable.
 764 def build_config_file(target, source, env):
 765     (variable, value) = [s.get_contents() for s in source]
 766     f = file(str(target[0]), 'w')
 767     print >> f, '#define', variable, value
 768     f.close()
 769     return None
 770
 771 # Generate the message to be printed when building the config file.
 772 def build_config_file_string(target, source, env):
 773     (variable, value) = [s.get_contents() for s in source]
 774     return "Defining %s as %s in %s." % (variable, value, target[0])
 775
 776 # Combine the two functions into a scons Action object.
 777 config_action = Action(build_config_file, build_config_file_string)
 778
 779 # The emitter munges the source & target node lists to reflect what
 780 # we're really doing.
 781 def config_emitter(target, source, env):
 782     # extract variable name from Builder arg
 783     variable = str(target[0])
 784     # True target is config header file
 785     target = joinpath('config', variable.lower() + '.hh')
 786     val = env[variable]
 787     if isinstance(val, bool):
 788         # Force value to 0/1
 789         val = int(val)
 790     elif isinstance(val, str):
 791         val = '"' + val + '"'
 792
 793     # Sources are variable name & value (packaged in SCons Value nodes)
 794     return ([target], [Value(variable), Value(val)])
 795
 796 config_builder = Builder(emitter = config_emitter, action = config_action)
 797
 798 main.Append(BUILDERS = { 'ConfigFile' : config_builder })
 799
 800 # libelf build is shared across all configs in the build root.
 801 main.SConscript('ext/libelf/SConscript',
 802                 variant_dir = joinpath(build_root, 'libelf'))
 803
 804 # gzstream build is shared across all configs in the build root.
 805 main.SConscript('ext/gzstream/SConscript',
 806                 variant_dir = joinpath(build_root, 'gzstream'))
 807
 808 ###################################################
 809 #
 810 # This function is used to set up a directory with switching headers
 811 #
 812 ###################################################
 813
 814 main['ALL_ISA_LIST'] = all_isa_list
 815 def make_switching_dir(dname, switch_headers, env):
 816     # Generate the header.  target[0] is the full path of the output
 817     # header to generate.  'source' is a dummy variable, since we get the
 818     # list of ISAs from env['ALL_ISA_LIST'].
 819     def gen_switch_hdr(target, source, env):
 820         fname = str(target[0])
 821         f = open(fname, 'w')
 822         isa = env['TARGET_ISA'].lower()
 823         print >>f, '#include "%s/%s/%s"' % (dname, isa, basename(fname))
 824         f.close()
 825
 826     # Build SCons Action object. 'varlist' specifies env vars that this
 827     # action depends on; when env['ALL_ISA_LIST'] changes these actions
 828     # should get re-executed.
 829     switch_hdr_action = MakeAction(gen_switch_hdr,
 830                      " [GENERATE] $STRIP_TARGET", varlist=['ALL_ISA_LIST'])
 831
 832     # Instantiate actions for each header
 833     for hdr in switch_headers:
 834         env.Command(hdr, [], switch_hdr_action)
 835 Export('make_switching_dir')
 836
 837 ###################################################
 838 #
 839 # Define build environments for selected configurations.
 840 #
 841 ###################################################
 842
 843 for variant_path in variant_paths:
 844     print "Building in", variant_path
 845
 846     # Make a copy of the build-root environment to use for this config.
 847     env = main.Clone()
 848     env['BUILDDIR'] = variant_path
 849
 850     # variant_dir is the tail component of build path, and is used to
 851     # determine the build parameters (e.g., 'ALPHA_SE')
 852     (build_root, variant_dir) = splitpath(variant_path)
 853
 854     # Set env variables according to the build directory config.
 855     sticky_vars.files = []
 856     # Variables for $BUILD_ROOT/$VARIANT_DIR are stored in
 857     # $BUILD_ROOT/variables/$VARIANT_DIR so you can nuke
 858     # $BUILD_ROOT/$VARIANT_DIR without losing your variables settings.
 859     current_vars_file = joinpath(build_root, 'variables', variant_dir)
 860     if isfile(current_vars_file):
 861         sticky_vars.files.append(current_vars_file)
 862         print "Using saved variables file %s" % current_vars_file
 863     else:
 864         # Build dir-specific variables file doesn't exist.
 865
 866         # Make sure the directory is there so we can create it later
 867         opt_dir = dirname(current_vars_file)
 868         if not isdir(opt_dir):
 869             mkdir(opt_dir)
 870
 871         # Get default build variables from source tree.  Variables are
 872         # normally determined by name of $VARIANT_DIR, but can be
 873         # overriden by 'default=' arg on command line.
 874         default_vars_file = joinpath('build_opts',
 875                                      ARGUMENTS.get('default', variant_dir))
 876         if isfile(default_vars_file):
 877             sticky_vars.files.append(default_vars_file)
 878             print "Variables file %s not found,\n  using defaults in %s" \
 879                   % (current_vars_file, default_vars_file)
 880         else:
 881             print "Error: cannot find variables file %s or %s" \
 882                   % (current_vars_file, default_vars_file)
 883             Exit(1)
 884
 885     # Apply current variable settings to env
 886     sticky_vars.Update(env)
 887
 888     help_text += "\nSticky variables for %s:\n" % variant_dir \
 889                  + sticky_vars.GenerateHelpText(env)
 890
 891     # Process variable settings.
 892
 893     if not have_fenv and env['USE_FENV']:
 894         print "Warning: <fenv.h> not available; " \
 895               "forcing USE_FENV to False in", variant_dir + "."
 896         env['USE_FENV'] = False
 897
 898     if not env['USE_FENV']:
 899         print "Warning: No IEEE FP rounding mode control in", variant_dir + "."
 900         print "         FP results may deviate slightly from other platforms."
 901
 902     if env['EFENCE']:
 903         env.Append(LIBS=['efence'])
 904
 905     if env['USE_MYSQL']:
 906         if not have_mysql:
 907             print "Warning: MySQL not available; " \
 908                   "forcing USE_MYSQL to False in", variant_dir + "."
 909             env['USE_MYSQL'] = False
 910         else:
 911             print "Compiling in", variant_dir, "with MySQL support."
 912             env.ParseConfig(mysql_config_libs)
 913             env.ParseConfig(mysql_config_include)
 914
 915     # Save sticky variable settings back to current variables file
 916     sticky_vars.Save(current_vars_file, env)
 917
 918     if env['USE_SSE2']:
 919         env.Append(CCFLAGS=['-msse2'])
 920
 921     # The src/SConscript file sets up the build rules in 'env' according
 922     # to the configured variables.  It returns a list of environments,
 923     # one for each variant build (debug, opt, etc.)
 924     envList = SConscript('src/SConscript', variant_dir = variant_path,
 925                          exports = 'env')
 926
 927     # Set up the regression tests for each build.
 928     for e in envList:
 929         SConscript('tests/SConscript',
 930                    variant_dir = joinpath(variant_path, 'tests', e.Label),
 931                    exports = { 'env' : e }, duplicate = False)
 932
 933 Help(help_text)