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