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 ('gem5'), 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/gem5.opt' for
  41 # the optimized full-system version).
  42 #
  43 # You can build gem5 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>/gem5 ; scons build/ALPHA/gem5.debug
  53 #   % cd <path-to-src>/gem5/build/ALPHA; scons -u gem5.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>/gem5 ; scons /local/foo/build/ALPHA/gem5.debug
  60 #   % cd /local/foo/build/ALPHA; scons -C <path-to-src>/gem5 gem5.debug
  61 #
  62 # You can use 'scons -H' to print scons options.  If you're in this
  63 # 'gem5' directory (or use -u or -C to tell scons where to find this
  64 # file), you can use 'scons -h' to print all the gem5-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://gem5.org/Dependencies
  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://gem5.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, # gem5 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 from m5.util.terminal import get_termcap
 124
 125 help_texts = {
 126     "options" : "",
 127     "global_vars" : "",
 128     "local_vars" : ""
 129 }
 130
 131 Export("help_texts")
 132
 133
 134 # There's a bug in scons in that (1) by default, the help texts from
 135 # AddOption() are supposed to be displayed when you type 'scons -h'
 136 # and (2) you can override the help displayed by 'scons -h' using the
 137 # Help() function, but these two features are incompatible: once
 138 # you've overridden the help text using Help(), there's no way to get
 139 # at the help texts from AddOptions.  See:
 140 #     http://scons.tigris.org/issues/show_bug.cgi?id=2356
 141 #     http://scons.tigris.org/issues/show_bug.cgi?id=2611
 142 # This hack lets us extract the help text from AddOptions and
 143 # re-inject it via Help().  Ideally someday this bug will be fixed and
 144 # we can just use AddOption directly.
 145 def AddLocalOption(*args, **kwargs):
 146     col_width = 30
 147
 148     help = "  " + ", ".join(args)
 149     if "help" in kwargs:
 150         length = len(help)
 151         if length >= col_width:
 152             help += "\n" + " " * col_width
 153         else:
 154             help += " " * (col_width - length)
 155         help += kwargs["help"]
 156     help_texts["options"] += help + "\n"
 157
 158     AddOption(*args, **kwargs)
 159
 160 AddLocalOption('--colors', dest='use_colors', action='store_true',
 161                help="Add color to abbreviated scons output")
 162 AddLocalOption('--no-colors', dest='use_colors', action='store_false',
 163                help="Don't add color to abbreviated scons output")
 164 AddLocalOption('--default', dest='default', type='string', action='store',
 165                help='Override which build_opts file to use for defaults')
 166 AddLocalOption('--ignore-style', dest='ignore_style', action='store_true',
 167                help='Disable style checking hooks')
 168 AddLocalOption('--no-lto', dest='no_lto', action='store_true',
 169                help='Disable Link-Time Optimization for fast')
 170 AddLocalOption('--update-ref', dest='update_ref', action='store_true',
 171                help='Update test reference outputs')
 172 AddLocalOption('--verbose', dest='verbose', action='store_true',
 173                help='Print full tool command lines')
 174
 175 termcap = get_termcap(GetOption('use_colors'))
 176
 177 ########################################################################
 178 #
 179 # Set up the main build environment.
 180 #
 181 ########################################################################
 182 use_vars = set([ 'AS', 'AR', 'CC', 'CXX', 'HOME', 'LD_LIBRARY_PATH',
 183                  'LIBRARY_PATH', 'PATH', 'PYTHONPATH', 'RANLIB', 'SWIG' ])
 184
 185 use_env = {}
 186 for key,val in os.environ.iteritems():
 187     if key in use_vars or key.startswith("M5"):
 188         use_env[key] = val
 189
 190 main = Environment(ENV=use_env)
 191 main.Decider('MD5-timestamp')
 192 main.root = Dir(".")         # The current directory (where this file lives).
 193 main.srcdir = Dir("src")     # The source directory
 194
 195 main_dict_keys = main.Dictionary().keys()
 196
 197 # Check that we have a C/C++ compiler
 198 if not ('CC' in main_dict_keys and 'CXX' in main_dict_keys):
 199     print "No C++ compiler installed (package g++ on Ubuntu and RedHat)"
 200     Exit(1)
 201
 202 # Check that swig is present
 203 if not 'SWIG' in main_dict_keys:
 204     print "swig is not installed (package swig on Ubuntu and RedHat)"
 205     Exit(1)
 206
 207 # add useful python code PYTHONPATH so it can be used by subprocesses
 208 # as well
 209 main.AppendENVPath('PYTHONPATH', extra_python_paths)
 210
 211 ########################################################################
 212 #
 213 # Mercurial Stuff.
 214 #
 215 # If the gem5 directory is a mercurial repository, we should do some
 216 # extra things.
 217 #
 218 ########################################################################
 219
 220 hgdir = main.root.Dir(".hg")
 221
 222 mercurial_style_message = """
 223 You're missing the gem5 style hook, which automatically checks your code
 224 against the gem5 style rules on hg commit and qrefresh commands.  This
 225 script will now install the hook in your .hg/hgrc file.
 226 Press enter to continue, or ctrl-c to abort: """
 227
 228 mercurial_style_hook = """
 229 # The following lines were automatically added by gem5/SConstruct
 230 # to provide the gem5 style-checking hooks
 231 [extensions]
 232 style = %s/util/style.py
 233
 234 [hooks]
 235 pretxncommit.style = python:style.check_style
 236 pre-qrefresh.style = python:style.check_style
 237 # End of SConstruct additions
 238
 239 """ % (main.root.abspath)
 240
 241 mercurial_lib_not_found = """
 242 Mercurial libraries cannot be found, ignoring style hook.  If
 243 you are a gem5 developer, please fix this and run the style
 244 hook. It is important.
 245 """
 246
 247 # Check for style hook and prompt for installation if it's not there.
 248 # Skip this if --ignore-style was specified, there's no .hg dir to
 249 # install a hook in, or there's no interactive terminal to prompt.
 250 if not GetOption('ignore_style') and hgdir.exists() and sys.stdin.isatty():
 251     style_hook = True
 252     try:
 253         from mercurial import ui
 254         ui = ui.ui()
 255         ui.readconfig(hgdir.File('hgrc').abspath)
 256         style_hook = ui.config('hooks', 'pretxncommit.style', None) and \
 257                      ui.config('hooks', 'pre-qrefresh.style', None)
 258     except ImportError:
 259         print mercurial_lib_not_found
 260
 261     if not style_hook:
 262         print mercurial_style_message,
 263         # continue unless user does ctrl-c/ctrl-d etc.
 264         try:
 265             raw_input()
 266         except:
 267             print "Input exception, exiting scons.\n"
 268             sys.exit(1)
 269         hgrc_path = '%s/.hg/hgrc' % main.root.abspath
 270         print "Adding style hook to", hgrc_path, "\n"
 271         try:
 272             hgrc = open(hgrc_path, 'a')
 273             hgrc.write(mercurial_style_hook)
 274             hgrc.close()
 275         except:
 276             print "Error updating", hgrc_path
 277             sys.exit(1)
 278
 279
 280 ###################################################
 281 #
 282 # Figure out which configurations to set up based on the path(s) of
 283 # the target(s).
 284 #
 285 ###################################################
 286
 287 # Find default configuration & binary.
 288 Default(environ.get('M5_DEFAULT_BINARY', 'build/ALPHA/gem5.debug'))
 289
 290 # helper function: find last occurrence of element in list
 291 def rfind(l, elt, offs = -1):
 292     for i in range(len(l)+offs, 0, -1):
 293         if l[i] == elt:
 294             return i
 295     raise ValueError, "element not found"
 296
 297 # Take a list of paths (or SCons Nodes) and return a list with all
 298 # paths made absolute and ~-expanded.  Paths will be interpreted
 299 # relative to the launch directory unless a different root is provided
 300 def makePathListAbsolute(path_list, root=GetLaunchDir()):
 301     return [abspath(joinpath(root, expanduser(str(p))))
 302             for p in path_list]
 303
 304 # Each target must have 'build' in the interior of the path; the
 305 # directory below this will determine the build parameters.  For
 306 # example, for target 'foo/bar/build/ALPHA_SE/arch/alpha/blah.do' we
 307 # recognize that ALPHA_SE specifies the configuration because it
 308 # follow 'build' in the build path.
 309
 310 # The funky assignment to "[:]" is needed to replace the list contents
 311 # in place rather than reassign the symbol to a new list, which
 312 # doesn't work (obviously!).
 313 BUILD_TARGETS[:] = makePathListAbsolute(BUILD_TARGETS)
 314
 315 # Generate a list of the unique build roots and configs that the
 316 # collected targets reference.
 317 variant_paths = []
 318 build_root = None
 319 for t in BUILD_TARGETS:
 320     path_dirs = t.split('/')
 321     try:
 322         build_top = rfind(path_dirs, 'build', -2)
 323     except:
 324         print "Error: no non-leaf 'build' dir found on target path", t
 325         Exit(1)
 326     this_build_root = joinpath('/',*path_dirs[:build_top+1])
 327     if not build_root:
 328         build_root = this_build_root
 329     else:
 330         if this_build_root != build_root:
 331             print "Error: build targets not under same build root\n"\
 332                   "  %s\n  %s" % (build_root, this_build_root)
 333             Exit(1)
 334     variant_path = joinpath('/',*path_dirs[:build_top+2])
 335     if variant_path not in variant_paths:
 336         variant_paths.append(variant_path)
 337
 338 # Make sure build_root exists (might not if this is the first build there)
 339 if not isdir(build_root):
 340     mkdir(build_root)
 341 main['BUILDROOT'] = build_root
 342
 343 Export('main')
 344
 345 main.SConsignFile(joinpath(build_root, "sconsign"))
 346
 347 # Default duplicate option is to use hard links, but this messes up
 348 # when you use emacs to edit a file in the target dir, as emacs moves
 349 # file to file~ then copies to file, breaking the link.  Symbolic
 350 # (soft) links work better.
 351 main.SetOption('duplicate', 'soft-copy')
 352
 353 #
 354 # Set up global sticky variables... these are common to an entire build
 355 # tree (not specific to a particular build like ALPHA_SE)
 356 #
 357
 358 global_vars_file = joinpath(build_root, 'variables.global')
 359
 360 global_vars = Variables(global_vars_file, args=ARGUMENTS)
 361
 362 global_vars.AddVariables(
 363     ('CC', 'C compiler', environ.get('CC', main['CC'])),
 364     ('CXX', 'C++ compiler', environ.get('CXX', main['CXX'])),
 365     ('SWIG', 'SWIG tool', environ.get('SWIG', main['SWIG'])),
 366     ('BATCH', 'Use batch pool for build and tests', False),
 367     ('BATCH_CMD', 'Batch pool submission command name', 'qdo'),
 368     ('M5_BUILD_CACHE', 'Cache built objects in this directory', False),
 369     ('EXTRAS', 'Add extra directories to the compilation', '')
 370     )
 371
 372 # Update main environment with values from ARGUMENTS & global_vars_file
 373 global_vars.Update(main)
 374 help_texts["global_vars"] += global_vars.GenerateHelpText(main)
 375
 376 # Save sticky variable settings back to current variables file
 377 global_vars.Save(global_vars_file, main)
 378
 379 # Parse EXTRAS variable to build list of all directories where we're
 380 # look for sources etc.  This list is exported as extras_dir_list.
 381 base_dir = main.srcdir.abspath
 382 if main['EXTRAS']:
 383     extras_dir_list = makePathListAbsolute(main['EXTRAS'].split(':'))
 384 else:
 385     extras_dir_list = []
 386
 387 Export('base_dir')
 388 Export('extras_dir_list')
 389
 390 # the ext directory should be on the #includes path
 391 main.Append(CPPPATH=[Dir('ext')])
 392
 393 def strip_build_path(path, env):
 394     path = str(path)
 395     variant_base = env['BUILDROOT'] + os.path.sep
 396     if path.startswith(variant_base):
 397         path = path[len(variant_base):]
 398     elif path.startswith('build/'):
 399         path = path[6:]
 400     return path
 401
 402 # Generate a string of the form:
 403 #   common/path/prefix/src1, src2 -> tgt1, tgt2
 404 # to print while building.
 405 class Transform(object):
 406     # all specific color settings should be here and nowhere else
 407     tool_color = termcap.Normal
 408     pfx_color = termcap.Yellow
 409     srcs_color = termcap.Yellow + termcap.Bold
 410     arrow_color = termcap.Blue + termcap.Bold
 411     tgts_color = termcap.Yellow + termcap.Bold
 412
 413     def __init__(self, tool, max_sources=99):
 414         self.format = self.tool_color + (" [%8s] " % tool) \
 415                       + self.pfx_color + "%s" \
 416                       + self.srcs_color + "%s" \
 417                       + self.arrow_color + " -> " \
 418                       + self.tgts_color + "%s" \
 419                       + termcap.Normal
 420         self.max_sources = max_sources
 421
 422     def __call__(self, target, source, env, for_signature=None):
 423         # truncate source list according to max_sources param
 424         source = source[0:self.max_sources]
 425         def strip(f):
 426             return strip_build_path(str(f), env)
 427         if len(source) > 0:
 428             srcs = map(strip, source)
 429         else:
 430             srcs = ['']
 431         tgts = map(strip, target)
 432         # surprisingly, os.path.commonprefix is a dumb char-by-char string
 433         # operation that has nothing to do with paths.
 434         com_pfx = os.path.commonprefix(srcs + tgts)
 435         com_pfx_len = len(com_pfx)
 436         if com_pfx:
 437             # do some cleanup and sanity checking on common prefix
 438             if com_pfx[-1] == ".":
 439                 # prefix matches all but file extension: ok
 440                 # back up one to change 'foo.cc -> o' to 'foo.cc -> .o'
 441                 com_pfx = com_pfx[0:-1]
 442             elif com_pfx[-1] == "/":
 443                 # common prefix is directory path: OK
 444                 pass
 445             else:
 446                 src0_len = len(srcs[0])
 447                 tgt0_len = len(tgts[0])
 448                 if src0_len == com_pfx_len:
 449                     # source is a substring of target, OK
 450                     pass
 451                 elif tgt0_len == com_pfx_len:
 452                     # target is a substring of source, need to back up to
 453                     # avoid empty string on RHS of arrow
 454                     sep_idx = com_pfx.rfind(".")
 455                     if sep_idx != -1:
 456                         com_pfx = com_pfx[0:sep_idx]
 457                     else:
 458                         com_pfx = ''
 459                 elif src0_len > com_pfx_len and srcs[0][com_pfx_len] == ".":
 460                     # still splitting at file extension: ok
 461                     pass
 462                 else:
 463                     # probably a fluke; ignore it
 464                     com_pfx = ''
 465         # recalculate length in case com_pfx was modified
 466         com_pfx_len = len(com_pfx)
 467         def fmt(files):
 468             f = map(lambda s: s[com_pfx_len:], files)
 469             return ', '.join(f)
 470         return self.format % (com_pfx, fmt(srcs), fmt(tgts))
 471
 472 Export('Transform')
 473
 474 # enable the regression script to use the termcap
 475 main['TERMCAP'] = termcap
 476
 477 if GetOption('verbose'):
 478     def MakeAction(action, string, *args, **kwargs):
 479         return Action(action, *args, **kwargs)
 480 else:
 481     MakeAction = Action
 482     main['CCCOMSTR']        = Transform("CC")
 483     main['CXXCOMSTR']       = Transform("CXX")
 484     main['ASCOMSTR']        = Transform("AS")
 485     main['SWIGCOMSTR']      = Transform("SWIG")
 486     main['ARCOMSTR']        = Transform("AR", 0)
 487     main['LINKCOMSTR']      = Transform("LINK", 0)
 488     main['RANLIBCOMSTR']    = Transform("RANLIB", 0)
 489     main['M4COMSTR']        = Transform("M4")
 490     main['SHCCCOMSTR']      = Transform("SHCC")
 491     main['SHCXXCOMSTR']     = Transform("SHCXX")
 492 Export('MakeAction')
 493
 494 # Initialize the Link-Time Optimization (LTO) flags
 495 main['LTO_CCFLAGS'] = []
 496 main['LTO_LDFLAGS'] = []
 497
 498 CXX_version = readCommand([main['CXX'],'--version'], exception=False)
 499 CXX_V = readCommand([main['CXX'],'-V'], exception=False)
 500
 501 main['GCC'] = CXX_version and CXX_version.find('g++') >= 0
 502 main['SUNCC'] = CXX_V and CXX_V.find('Sun C++') >= 0
 503 main['ICC'] = CXX_V and CXX_V.find('Intel') >= 0
 504 main['CLANG'] = CXX_version and CXX_version.find('clang') >= 0
 505 if main['GCC'] + main['SUNCC'] + main['ICC'] + main['CLANG'] > 1:
 506     print 'Error: How can we have two at the same time?'
 507     Exit(1)
 508
 509 # Set up default C++ compiler flags
 510 if main['GCC']:
 511     main.Append(CCFLAGS=['-pipe'])
 512     main.Append(CCFLAGS=['-fno-strict-aliasing'])
 513     main.Append(CCFLAGS=['-Wall', '-Wno-sign-compare', '-Wundef'])
 514     # Read the GCC version to check for versions with bugs
 515     # Note CCVERSION doesn't work here because it is run with the CC
 516     # before we override it from the command line
 517     gcc_version = readCommand([main['CXX'], '-dumpversion'], exception=False)
 518     main['GCC_VERSION'] = gcc_version
 519     if not compareVersions(gcc_version, '4.4.1') or \
 520        not compareVersions(gcc_version, '4.4.2'):
 521         print 'Info: Tree vectorizer in GCC 4.4.1 & 4.4.2 is buggy, disabling.'
 522         main.Append(CCFLAGS=['-fno-tree-vectorize'])
 523     # c++0x support in gcc is useful already from 4.4, see
 524     # http://gcc.gnu.org/projects/cxx0x.html for details
 525     if compareVersions(gcc_version, '4.4') >= 0:
 526         main.Append(CXXFLAGS=['-std=c++0x'])
 527
 528     # LTO support is only really working properly from 4.6 and beyond
 529     if compareVersions(gcc_version, '4.6') >= 0:
 530         # Add the appropriate Link-Time Optimization (LTO) flags
 531         # unless LTO is explicitly turned off. Note that these flags
 532         # are only used by the fast target.
 533         if not GetOption('no_lto'):
 534             # Pass the LTO flag when compiling to produce GIMPLE
 535             # output, we merely create the flags here and only append
 536             # them later/
 537             main['LTO_CCFLAGS'] = ['-flto=%d' % GetOption('num_jobs')]
 538
 539             # Use the same amount of jobs for LTO as we are running
 540             # scons with, we hardcode the use of the linker plugin
 541             # which requires either gold or GNU ld >= 2.21
 542             main['LTO_LDFLAGS'] = ['-flto=%d' % GetOption('num_jobs'),
 543                                    '-fuse-linker-plugin']
 544
 545 elif main['ICC']:
 546     pass #Fix me... add warning flags once we clean up icc warnings
 547 elif main['SUNCC']:
 548     main.Append(CCFLAGS=['-Qoption ccfe'])
 549     main.Append(CCFLAGS=['-features=gcc'])
 550     main.Append(CCFLAGS=['-features=extensions'])
 551     main.Append(CCFLAGS=['-library=stlport4'])
 552     main.Append(CCFLAGS=['-xar'])
 553     #main.Append(CCFLAGS=['-instances=semiexplicit'])
 554 elif main['CLANG']:
 555     clang_version_re = re.compile(".* version (\d+\.\d+)")
 556     clang_version_match = clang_version_re.match(CXX_version)
 557     if (clang_version_match):
 558         clang_version = clang_version_match.groups()[0]
 559         if compareVersions(clang_version, "2.9") < 0:
 560             print 'Error: clang version 2.9 or newer required.'
 561             print '       Installed version:', clang_version
 562             Exit(1)
 563     else:
 564         print 'Error: Unable to determine clang version.'
 565         Exit(1)
 566
 567     main.Append(CCFLAGS=['-pipe'])
 568     main.Append(CCFLAGS=['-fno-strict-aliasing'])
 569     main.Append(CCFLAGS=['-Wall', '-Wno-sign-compare', '-Wundef'])
 570     main.Append(CCFLAGS=['-Wno-tautological-compare'])
 571     main.Append(CCFLAGS=['-Wno-self-assign'])
 572     # Ruby makes frequent use of extraneous parantheses in the printing
 573     # of if-statements
 574     main.Append(CCFLAGS=['-Wno-parentheses'])
 575
 576     # clang 2.9 does not play well with c++0x as it ships with C++
 577     # headers that produce errors, this was fixed in 3.0
 578     if compareVersions(clang_version, "3") >= 0:
 579         main.Append(CXXFLAGS=['-std=c++0x'])
 580 else:
 581     print termcap.Yellow + termcap.Bold + 'Error' + termcap.Normal,
 582     print "Don't know what compiler options to use for your compiler."
 583     print termcap.Yellow + '       compiler:' + termcap.Normal, main['CXX']
 584     print termcap.Yellow + '       version:' + termcap.Normal,
 585     if not CXX_version:
 586         print termcap.Yellow + termcap.Bold + "COMMAND NOT FOUND!" +\
 587                termcap.Normal
 588     else:
 589         print CXX_version.replace('\n', '<nl>')
 590     print "       If you're trying to use a compiler other than GCC, ICC, SunCC,"
 591     print "       or clang, there appears to be something wrong with your"
 592     print "       environment."
 593     print "       "
 594     print "       If you are trying to use a compiler other than those listed"
 595     print "       above you will need to ease fix SConstruct and "
 596     print "       src/SConscript to support that compiler."
 597     Exit(1)
 598
 599 # Set up common yacc/bison flags (needed for Ruby)
 600 main['YACCFLAGS'] = '-d'
 601 main['YACCHXXFILESUFFIX'] = '.hh'
 602
 603 # Do this after we save setting back, or else we'll tack on an
 604 # extra 'qdo' every time we run scons.
 605 if main['BATCH']:
 606     main['CC']     = main['BATCH_CMD'] + ' ' + main['CC']
 607     main['CXX']    = main['BATCH_CMD'] + ' ' + main['CXX']
 608     main['AS']     = main['BATCH_CMD'] + ' ' + main['AS']
 609     main['AR']     = main['BATCH_CMD'] + ' ' + main['AR']
 610     main['RANLIB'] = main['BATCH_CMD'] + ' ' + main['RANLIB']
 611
 612 if sys.platform == 'cygwin':
 613     # cygwin has some header file issues...
 614     main.Append(CCFLAGS=["-Wno-uninitialized"])
 615
 616 # Check for SWIG
 617 if not main.has_key('SWIG'):
 618     print 'Error: SWIG utility not found.'
 619     print '       Please install (see http://www.swig.org) and retry.'
 620     Exit(1)
 621
 622 # Check for appropriate SWIG version
 623 swig_version = readCommand([main['SWIG'], '-version'], exception='').split()
 624 # First 3 words should be "SWIG Version x.y.z"
 625 if len(swig_version) < 3 or \
 626         swig_version[0] != 'SWIG' or swig_version[1] != 'Version':
 627     print 'Error determining SWIG version.'
 628     Exit(1)
 629
 630 min_swig_version = '1.3.34'
 631 if compareVersions(swig_version[2], min_swig_version) < 0:
 632     print 'Error: SWIG version', min_swig_version, 'or newer required.'
 633     print '       Installed version:', swig_version[2]
 634     Exit(1)
 635
 636 # Set up SWIG flags & scanner
 637 swig_flags=Split('-c++ -python -modern -templatereduce $_CPPINCFLAGS')
 638 main.Append(SWIGFLAGS=swig_flags)
 639
 640 # filter out all existing swig scanners, they mess up the dependency
 641 # stuff for some reason
 642 scanners = []
 643 for scanner in main['SCANNERS']:
 644     skeys = scanner.skeys
 645     if skeys == '.i':
 646         continue
 647
 648     if isinstance(skeys, (list, tuple)) and '.i' in skeys:
 649         continue
 650
 651     scanners.append(scanner)
 652
 653 # add the new swig scanner that we like better
 654 from SCons.Scanner import ClassicCPP as CPPScanner
 655 swig_inc_re = '^[ \t]*[%,#][ \t]*(?:include|import)[ \t]*(<|")([^>"]+)(>|")'
 656 scanners.append(CPPScanner("SwigScan", [ ".i" ], "CPPPATH", swig_inc_re))
 657
 658 # replace the scanners list that has what we want
 659 main['SCANNERS'] = scanners
 660
 661 # Add a custom Check function to the Configure context so that we can
 662 # figure out if the compiler adds leading underscores to global
 663 # variables.  This is needed for the autogenerated asm files that we
 664 # use for embedding the python code.
 665 def CheckLeading(context):
 666     context.Message("Checking for leading underscore in global variables...")
 667     # 1) Define a global variable called x from asm so the C compiler
 668     #    won't change the symbol at all.
 669     # 2) Declare that variable.
 670     # 3) Use the variable
 671     #
 672     # If the compiler prepends an underscore, this will successfully
 673     # link because the external symbol 'x' will be called '_x' which
 674     # was defined by the asm statement.  If the compiler does not
 675     # prepend an underscore, this will not successfully link because
 676     # '_x' will have been defined by assembly, while the C portion of
 677     # the code will be trying to use 'x'
 678     ret = context.TryLink('''
 679         asm(".globl _x; _x: .byte 0");
 680         extern int x;
 681         int main() { return x; }
 682         ''', extension=".c")
 683     context.env.Append(LEADING_UNDERSCORE=ret)
 684     context.Result(ret)
 685     return ret
 686
 687 # Test for the presence of C++11 static asserts. If the compiler lacks
 688 # support for static asserts, base/compiler.hh enables a macro that
 689 # removes any static asserts in the code.
 690 def CheckStaticAssert(context):
 691     context.Message("Checking for C++11 static_assert support...")
 692     ret = context.TryCompile('''
 693         static_assert(1, "This assert is always true");
 694         ''', extension=".cc")
 695     context.env.Append(HAVE_STATIC_ASSERT=ret)
 696     context.Result(ret)
 697     return ret
 698
 699 # Platform-specific configuration.  Note again that we assume that all
 700 # builds under a given build root run on the same host platform.
 701 conf = Configure(main,
 702                  conf_dir = joinpath(build_root, '.scons_config'),
 703                  log_file = joinpath(build_root, 'scons_config.log'),
 704                  custom_tests = { 'CheckLeading' : CheckLeading,
 705                                   'CheckStaticAssert' : CheckStaticAssert,
 706                                 })
 707
 708 # Check for leading underscores.  Don't really need to worry either
 709 # way so don't need to check the return code.
 710 conf.CheckLeading()
 711
 712 # Check for C++11 features we want to use if they exist
 713 conf.CheckStaticAssert()
 714
 715 # Check if we should compile a 64 bit binary on Mac OS X/Darwin
 716 try:
 717     import platform
 718     uname = platform.uname()
 719     if uname[0] == 'Darwin' and compareVersions(uname[2], '9.0.0') >= 0:
 720         if int(readCommand('sysctl -n hw.cpu64bit_capable')[0]):
 721             main.Append(CCFLAGS=['-arch', 'x86_64'])
 722             main.Append(CFLAGS=['-arch', 'x86_64'])
 723             main.Append(LINKFLAGS=['-arch', 'x86_64'])
 724             main.Append(ASFLAGS=['-arch', 'x86_64'])
 725 except:
 726     pass
 727
 728 # Recent versions of scons substitute a "Null" object for Configure()
 729 # when configuration isn't necessary, e.g., if the "--help" option is
 730 # present.  Unfortuantely this Null object always returns false,
 731 # breaking all our configuration checks.  We replace it with our own
 732 # more optimistic null object that returns True instead.
 733 if not conf:
 734     def NullCheck(*args, **kwargs):
 735         return True
 736
 737     class NullConf:
 738         def __init__(self, env):
 739             self.env = env
 740         def Finish(self):
 741             return self.env
 742         def __getattr__(self, mname):
 743             return NullCheck
 744
 745     conf = NullConf(main)
 746
 747 # Find Python include and library directories for embedding the
 748 # interpreter.  For consistency, we will use the same Python
 749 # installation used to run scons (and thus this script).  If you want
 750 # to link in an alternate version, see above for instructions on how
 751 # to invoke scons with a different copy of the Python interpreter.
 752 from distutils import sysconfig
 753
 754 py_getvar = sysconfig.get_config_var
 755
 756 py_debug = getattr(sys, 'pydebug', False)
 757 py_version = 'python' + py_getvar('VERSION') + (py_debug and "_d" or "")
 758
 759 py_general_include = sysconfig.get_python_inc()
 760 py_platform_include = sysconfig.get_python_inc(plat_specific=True)
 761 py_includes = [ py_general_include ]
 762 if py_platform_include != py_general_include:
 763     py_includes.append(py_platform_include)
 764
 765 py_lib_path = [ py_getvar('LIBDIR') ]
 766 # add the prefix/lib/pythonX.Y/config dir, but only if there is no
 767 # shared library in prefix/lib/.
 768 if not py_getvar('Py_ENABLE_SHARED'):
 769     py_lib_path.append(py_getvar('LIBPL'))
 770
 771 py_libs = []
 772 for lib in py_getvar('LIBS').split() + py_getvar('SYSLIBS').split():
 773     if not lib.startswith('-l'):
 774         # Python requires some special flags to link (e.g. -framework
 775         # common on OS X systems), assume appending preserves order
 776         main.Append(LINKFLAGS=[lib])
 777     else:
 778         lib = lib[2:]
 779         if lib not in py_libs:
 780             py_libs.append(lib)
 781 py_libs.append(py_version)
 782
 783 main.Append(CPPPATH=py_includes)
 784 main.Append(LIBPATH=py_lib_path)
 785
 786 # Cache build files in the supplied directory.
 787 if main['M5_BUILD_CACHE']:
 788     print 'Using build cache located at', main['M5_BUILD_CACHE']
 789     CacheDir(main['M5_BUILD_CACHE'])
 790
 791
 792 # verify that this stuff works
 793 if not conf.CheckHeader('Python.h', '<>'):
 794     print "Error: can't find Python.h header in", py_includes
 795     print "Install Python headers (package python-dev on Ubuntu and RedHat)"
 796     Exit(1)
 797
 798 for lib in py_libs:
 799     if not conf.CheckLib(lib):
 800         print "Error: can't find library %s required by python" % lib
 801         Exit(1)
 802
 803 # On Solaris you need to use libsocket for socket ops
 804 if not conf.CheckLibWithHeader(None, 'sys/socket.h', 'C++', 'accept(0,0,0);'):
 805    if not conf.CheckLibWithHeader('socket', 'sys/socket.h', 'C++', 'accept(0,0,0);'):
 806        print "Can't find library with socket calls (e.g. accept())"
 807        Exit(1)
 808
 809 # Check for zlib.  If the check passes, libz will be automatically
 810 # added to the LIBS environment variable.
 811 if not conf.CheckLibWithHeader('z', 'zlib.h', 'C++','zlibVersion();'):
 812     print 'Error: did not find needed zlib compression library '\
 813           'and/or zlib.h header file.'
 814     print '       Please install zlib and try again.'
 815     Exit(1)
 816
 817 # Check for librt.
 818 have_posix_clock = \
 819     conf.CheckLibWithHeader(None, 'time.h', 'C',
 820                             'clock_nanosleep(0,0,NULL,NULL);') or \
 821     conf.CheckLibWithHeader('rt', 'time.h', 'C',
 822                             'clock_nanosleep(0,0,NULL,NULL);')
 823
 824 if conf.CheckLib('tcmalloc_minimal'):
 825     have_tcmalloc = True
 826 else:
 827     have_tcmalloc = False
 828     print termcap.Yellow + termcap.Bold + \
 829           "You can get a 12% performance improvement by installing tcmalloc "\
 830           "(libgoogle-perftools-dev package on Ubuntu or RedHat)." + \
 831           termcap.Normal
 832
 833 if not have_posix_clock:
 834     print "Can't find library for POSIX clocks."
 835
 836 # Check for <fenv.h> (C99 FP environment control)
 837 have_fenv = conf.CheckHeader('fenv.h', '<>')
 838 if not have_fenv:
 839     print "Warning: Header file <fenv.h> not found."
 840     print "         This host has no IEEE FP rounding mode control."
 841
 842 ######################################################################
 843 #
 844 # Finish the configuration
 845 #
 846 main = conf.Finish()
 847
 848 ######################################################################
 849 #
 850 # Collect all non-global variables
 851 #
 852
 853 # Define the universe of supported ISAs
 854 all_isa_list = [ ]
 855 Export('all_isa_list')
 856
 857 class CpuModel(object):
 858     '''The CpuModel class encapsulates everything the ISA parser needs to
 859     know about a particular CPU model.'''
 860
 861     # Dict of available CPU model objects.  Accessible as CpuModel.dict.
 862     dict = {}
 863     list = []
 864     defaults = []
 865
 866     # Constructor.  Automatically adds models to CpuModel.dict.
 867     def __init__(self, name, filename, includes, strings, default=False):
 868         self.name = name           # name of model
 869         self.filename = filename   # filename for output exec code
 870         self.includes = includes   # include files needed in exec file
 871         # The 'strings' dict holds all the per-CPU symbols we can
 872         # substitute into templates etc.
 873         self.strings = strings
 874
 875         # This cpu is enabled by default
 876         self.default = default
 877
 878         # Add self to dict
 879         if name in CpuModel.dict:
 880             raise AttributeError, "CpuModel '%s' already registered" % name
 881         CpuModel.dict[name] = self
 882         CpuModel.list.append(name)
 883
 884 Export('CpuModel')
 885
 886 # Sticky variables get saved in the variables file so they persist from
 887 # one invocation to the next (unless overridden, in which case the new
 888 # value becomes sticky).
 889 sticky_vars = Variables(args=ARGUMENTS)
 890 Export('sticky_vars')
 891
 892 # Sticky variables that should be exported
 893 export_vars = []
 894 Export('export_vars')
 895
 896 # For Ruby
 897 all_protocols = []
 898 Export('all_protocols')
 899 protocol_dirs = []
 900 Export('protocol_dirs')
 901 slicc_includes = []
 902 Export('slicc_includes')
 903
 904 # Walk the tree and execute all SConsopts scripts that wil add to the
 905 # above variables
 906 if not GetOption('verbose'):
 907     print "Reading SConsopts"
 908 for bdir in [ base_dir ] + extras_dir_list:
 909     if not isdir(bdir):
 910         print "Error: directory '%s' does not exist" % bdir
 911         Exit(1)
 912     for root, dirs, files in os.walk(bdir):
 913         if 'SConsopts' in files:
 914             if GetOption('verbose'):
 915                 print "Reading", joinpath(root, 'SConsopts')
 916             SConscript(joinpath(root, 'SConsopts'))
 917
 918 all_isa_list.sort()
 919
 920 sticky_vars.AddVariables(
 921     EnumVariable('TARGET_ISA', 'Target ISA', 'alpha', all_isa_list),
 922     ListVariable('CPU_MODELS', 'CPU models',
 923                  sorted(n for n,m in CpuModel.dict.iteritems() if m.default),
 924                  sorted(CpuModel.list)),
 925     BoolVariable('EFENCE', 'Link with Electric Fence malloc debugger',
 926                  False),
 927     BoolVariable('SS_COMPATIBLE_FP',
 928                  'Make floating-point results compatible with SimpleScalar',
 929                  False),
 930     BoolVariable('USE_SSE2',
 931                  'Compile for SSE2 (-msse2) to get IEEE FP on x86 hosts',
 932                  False),
 933     BoolVariable('USE_POSIX_CLOCK', 'Use POSIX Clocks', have_posix_clock),
 934     BoolVariable('USE_FENV', 'Use <fenv.h> IEEE mode control', have_fenv),
 935     BoolVariable('CP_ANNOTATE', 'Enable critical path annotation capability', False),
 936     EnumVariable('PROTOCOL', 'Coherence protocol for Ruby', 'None',
 937                   all_protocols),
 938     )
 939
 940 # These variables get exported to #defines in config/*.hh (see src/SConscript).
 941 export_vars += ['USE_FENV', 'SS_COMPATIBLE_FP',
 942                 'TARGET_ISA', 'CP_ANNOTATE', 'USE_POSIX_CLOCK', 'PROTOCOL',
 943                 'HAVE_STATIC_ASSERT']
 944
 945 ###################################################
 946 #
 947 # Define a SCons builder for configuration flag headers.
 948 #
 949 ###################################################
 950
 951 # This function generates a config header file that #defines the
 952 # variable symbol to the current variable setting (0 or 1).  The source
 953 # operands are the name of the variable and a Value node containing the
 954 # value of the variable.
 955 def build_config_file(target, source, env):
 956     (variable, value) = [s.get_contents() for s in source]
 957     f = file(str(target[0]), 'w')
 958     print >> f, '#define', variable, value
 959     f.close()
 960     return None
 961
 962 # Combine the two functions into a scons Action object.
 963 config_action = MakeAction(build_config_file, Transform("CONFIG H", 2))
 964
 965 # The emitter munges the source & target node lists to reflect what
 966 # we're really doing.
 967 def config_emitter(target, source, env):
 968     # extract variable name from Builder arg
 969     variable = str(target[0])
 970     # True target is config header file
 971     target = joinpath('config', variable.lower() + '.hh')
 972     val = env[variable]
 973     if isinstance(val, bool):
 974         # Force value to 0/1
 975         val = int(val)
 976     elif isinstance(val, str):
 977         val = '"' + val + '"'
 978
 979     # Sources are variable name & value (packaged in SCons Value nodes)
 980     return ([target], [Value(variable), Value(val)])
 981
 982 config_builder = Builder(emitter = config_emitter, action = config_action)
 983
 984 main.Append(BUILDERS = { 'ConfigFile' : config_builder })
 985
 986 # libelf build is shared across all configs in the build root.
 987 main.SConscript('ext/libelf/SConscript',
 988                 variant_dir = joinpath(build_root, 'libelf'))
 989
 990 # gzstream build is shared across all configs in the build root.
 991 main.SConscript('ext/gzstream/SConscript',
 992                 variant_dir = joinpath(build_root, 'gzstream'))
 993
 994 ###################################################
 995 #
 996 # This function is used to set up a directory with switching headers
 997 #
 998 ###################################################
 999
1000 main['ALL_ISA_LIST'] = all_isa_list
1001 def make_switching_dir(dname, switch_headers, env):
1002     # Generate the header.  target[0] is the full path of the output
1003     # header to generate.  'source' is a dummy variable, since we get the
1004     # list of ISAs from env['ALL_ISA_LIST'].
1005     def gen_switch_hdr(target, source, env):
1006         fname = str(target[0])
1007         f = open(fname, 'w')
1008         isa = env['TARGET_ISA'].lower()
1009         print >>f, '#include "%s/%s/%s"' % (dname, isa, basename(fname))
1010         f.close()
1011
1012     # Build SCons Action object. 'varlist' specifies env vars that this
1013     # action depends on; when env['ALL_ISA_LIST'] changes these actions
1014     # should get re-executed.
1015     switch_hdr_action = MakeAction(gen_switch_hdr,
1016                           Transform("GENERATE"), varlist=['ALL_ISA_LIST'])
1017
1018     # Instantiate actions for each header
1019     for hdr in switch_headers:
1020         env.Command(hdr, [], switch_hdr_action)
1021 Export('make_switching_dir')
1022
1023 ###################################################
1024 #
1025 # Define build environments for selected configurations.
1026 #
1027 ###################################################
1028
1029 for variant_path in variant_paths:
1030     print "Building in", variant_path
1031
1032     # Make a copy of the build-root environment to use for this config.
1033     env = main.Clone()
1034     env['BUILDDIR'] = variant_path
1035
1036     # variant_dir is the tail component of build path, and is used to
1037     # determine the build parameters (e.g., 'ALPHA_SE')
1038     (build_root, variant_dir) = splitpath(variant_path)
1039
1040     # Set env variables according to the build directory config.
1041     sticky_vars.files = []
1042     # Variables for $BUILD_ROOT/$VARIANT_DIR are stored in
1043     # $BUILD_ROOT/variables/$VARIANT_DIR so you can nuke
1044     # $BUILD_ROOT/$VARIANT_DIR without losing your variables settings.
1045     current_vars_file = joinpath(build_root, 'variables', variant_dir)
1046     if isfile(current_vars_file):
1047         sticky_vars.files.append(current_vars_file)
1048         print "Using saved variables file %s" % current_vars_file
1049     else:
1050         # Build dir-specific variables file doesn't exist.
1051
1052         # Make sure the directory is there so we can create it later
1053         opt_dir = dirname(current_vars_file)
1054         if not isdir(opt_dir):
1055             mkdir(opt_dir)
1056
1057         # Get default build variables from source tree.  Variables are
1058         # normally determined by name of $VARIANT_DIR, but can be
1059         # overridden by '--default=' arg on command line.
1060         default = GetOption('default')
1061         opts_dir = joinpath(main.root.abspath, 'build_opts')
1062         if default:
1063             default_vars_files = [joinpath(build_root, 'variables', default),
1064                                   joinpath(opts_dir, default)]
1065         else:
1066             default_vars_files = [joinpath(opts_dir, variant_dir)]
1067         existing_files = filter(isfile, default_vars_files)
1068         if existing_files:
1069             default_vars_file = existing_files[0]
1070             sticky_vars.files.append(default_vars_file)
1071             print "Variables file %s not found,\n  using defaults in %s" \
1072                   % (current_vars_file, default_vars_file)
1073         else:
1074             print "Error: cannot find variables file %s or " \
1075                   "default file(s) %s" \
1076                   % (current_vars_file, ' or '.join(default_vars_files))
1077             Exit(1)
1078
1079     # Apply current variable settings to env
1080     sticky_vars.Update(env)
1081
1082     help_texts["local_vars"] += \
1083         "Build variables for %s:\n" % variant_dir \
1084                  + sticky_vars.GenerateHelpText(env)
1085
1086     # Process variable settings.
1087
1088     if not have_fenv and env['USE_FENV']:
1089         print "Warning: <fenv.h> not available; " \
1090               "forcing USE_FENV to False in", variant_dir + "."
1091         env['USE_FENV'] = False
1092
1093     if not env['USE_FENV']:
1094         print "Warning: No IEEE FP rounding mode control in", variant_dir + "."
1095         print "         FP results may deviate slightly from other platforms."
1096
1097     if env['EFENCE']:
1098         env.Append(LIBS=['efence'])
1099
1100     # Save sticky variable settings back to current variables file
1101     sticky_vars.Save(current_vars_file, env)
1102
1103     if env['USE_SSE2']:
1104         env.Append(CCFLAGS=['-msse2'])
1105
1106     if have_tcmalloc:
1107         env.Append(LIBS=['tcmalloc_minimal'])
1108
1109     # The src/SConscript file sets up the build rules in 'env' according
1110     # to the configured variables.  It returns a list of environments,
1111     # one for each variant build (debug, opt, etc.)
1112     envList = SConscript('src/SConscript', variant_dir = variant_path,
1113                          exports = 'env')
1114
1115     # Set up the regression tests for each build.
1116     for e in envList:
1117         SConscript('tests/SConscript',
1118                    variant_dir = joinpath(variant_path, 'tests', e.Label),
1119                    exports = { 'env' : e }, duplicate = False)
1120
1121 # base help text
1122 Help('''
1123 Usage: scons [scons options] [build variables] [target(s)]
1124
1125 Extra scons options:
1126 %(options)s
1127
1128 Global build variables:
1129 %(global_vars)s
1130
1131 %(local_vars)s
1132 ''' % help_texts)