SConstruct

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