# -*- mode:python -*-
+# Copyright (c) 2011 Advanced Micro Devices, Inc.
+# Copyright (c) 2009 The Hewlett-Packard Development Company
# Copyright (c) 2004-2005 The Regents of The University of Michigan
# All rights reserved.
#
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Authors: Steve Reinhardt
+# Nathan Binkert
###################################################
#
#
###################################################
-import sys
+# Check for recent-enough Python and SCons versions.
+try:
+ # Really old versions of scons only take two options for the
+ # function, so check once without the revision and once with the
+ # revision, the first instance will fail for stuff other than
+ # 0.98, and the second will fail for 0.98.0
+ EnsureSConsVersion(0, 98)
+ EnsureSConsVersion(0, 98, 1)
+except SystemExit, e:
+ print """
+For more details, see:
+ http://m5sim.org/wiki/index.php/Compiling_M5
+"""
+ raise
+
+# We ensure the python version early because we have stuff that
+# requires python 2.4
+try:
+ EnsurePythonVersion(2, 4)
+except SystemExit, e:
+ print """
+You can use a non-default installation of the Python interpreter by
+either (1) rearranging your PATH so that scons finds the non-default
+'python' first or (2) explicitly invoking an alternative interpreter
+on the scons script.
+
+For more details, see:
+ http://m5sim.org/wiki/index.php/Using_a_non-default_Python_installation
+"""
+ raise
+
+# Global Python includes
import os
import re
+import subprocess
+import sys
-from os.path import isdir, isfile, join as joinpath
+from os import mkdir, environ
+from os.path import abspath, basename, dirname, expanduser, normpath
+from os.path import exists, isdir, isfile
+from os.path import join as joinpath, split as splitpath
+# SCons includes
import SCons
+import SCons.Node
-# Check for recent-enough Python and SCons versions. If your system's
-# default installation of Python is not recent enough, you can use a
-# non-default installation of the Python interpreter by either (1)
-# rearranging your PATH so that scons finds the non-default 'python'
-# first or (2) explicitly invoking an alternative interpreter on the
-# scons script, e.g., "/usr/local/bin/python2.4 `which scons` [args]".
-EnsurePythonVersion(2,4)
+extra_python_paths = [
+ Dir('src/python').srcnode().abspath, # M5 includes
+ Dir('ext/ply').srcnode().abspath, # ply is used by several files
+ ]
+
+sys.path[1:1] = extra_python_paths
-# Import subprocess after we check the version since it doesn't exist in
-# Python < 2.4.
-import subprocess
+from m5.util import compareVersions, readCommand
+
+help_texts = {
+ "options" : "",
+ "global_vars" : "",
+ "local_vars" : ""
+}
-# helper function: compare arrays or strings of version numbers.
-# E.g., compare_version((1,3,25), (1,4,1)')
-# returns -1, 0, 1 if v1 is <, ==, > v2
-def compare_versions(v1, v2):
- def make_version_list(v):
- if isinstance(v, (list,tuple)):
- return v
- elif isinstance(v, str):
- return map(lambda x: int(re.match('\d+', x).group()), v.split('.'))
+Export("help_texts")
+
+def AddM5Option(*args, **kwargs):
+ col_width = 30
+
+ help = " " + ", ".join(args)
+ if "help" in kwargs:
+ length = len(help)
+ if length >= col_width:
+ help += "\n" + " " * col_width
else:
- raise TypeError
-
- v1 = make_version_list(v1)
- v2 = make_version_list(v2)
- # Compare corresponding elements of lists
- for n1,n2 in zip(v1, v2):
- if n1 < n2: return -1
- if n1 > n2: return 1
- # all corresponding values are equal... see if one has extra values
- if len(v1) < len(v2): return -1
- if len(v1) > len(v2): return 1
- return 0
-
-# SCons version numbers need special processing because they can have
-# charecters and an release date embedded in them. This function does
-# the magic to extract them in a similar way to the SCons internal function
-# function does and then checks that the current version is not contained in
-# a list of version tuples (bad_ver_strs)
-def CheckSCons(bad_ver_strs):
- def scons_ver(v):
- num_parts = v.split(' ')[0].split('.')
- major = int(num_parts[0])
- minor = int(re.match('\d+', num_parts[1]).group())
- rev = 0
- rdate = 0
- if len(num_parts) > 2:
- try: rev = int(re.match('\d+', num_parts[2]).group())
- except: pass
- rev_parts = num_parts[2].split('d')
- if len(rev_parts) > 1:
- rdate = int(re.match('\d+', rev_parts[1]).group())
-
- return (major, minor, rev, rdate)
-
- sc_ver = scons_ver(SCons.__version__)
- for bad_ver in bad_ver_strs:
- bv = (scons_ver(bad_ver[0]), scons_ver(bad_ver[1]))
- if compare_versions(sc_ver, bv[0]) != -1 and\
- compare_versions(sc_ver, bv[1]) != 1:
- print "The version of SCons that you have installed: ", SCons.__version__
- print "has a bug that prevents it from working correctly with M5."
- print "Please install a version NOT contained within the following",
- print "ranges (inclusive):"
- for bad_ver in bad_ver_strs:
- print " %s - %s" % bad_ver
- Exit(2)
-
-CheckSCons((
- # We need a version that is 0.96.91 or newer
- ('0.0.0', '0.96.90'),
- ))
-
-
-# The absolute path to the current directory (where this file lives).
-ROOT = Dir('.').abspath
-
-# Path to the M5 source tree.
-SRCDIR = joinpath(ROOT, 'src')
-
-# tell python where to find m5 python code
-sys.path.append(joinpath(ROOT, 'src/python'))
-
-def check_style_hook(ui):
- ui.readconfig(joinpath(ROOT, '.hg', 'hgrc'))
- style_hook = ui.config('hooks', 'pretxncommit.style', None)
+ help += " " * (col_width - length)
+ help += kwargs["help"]
+ help_texts["options"] += help + "\n"
+
+ AddOption(*args, **kwargs)
+
+AddM5Option('--colors', dest='use_colors', action='store_true',
+ help="Add color to abbreviated scons output")
+AddM5Option('--no-colors', dest='use_colors', action='store_false',
+ help="Don't add color to abbreviated scons output")
+AddM5Option('--default', dest='default', type='string', action='store',
+ help='Override which build_opts file to use for defaults')
+AddM5Option('--ignore-style', dest='ignore_style', action='store_true',
+ help='Disable style checking hooks')
+AddM5Option('--update-ref', dest='update_ref', action='store_true',
+ help='Update test reference outputs')
+AddM5Option('--verbose', dest='verbose', action='store_true',
+ help='Print full tool command lines')
+
+use_colors = GetOption('use_colors')
+if use_colors:
+ from m5.util.terminal import termcap
+elif use_colors is None:
+ # option unspecified; default behavior is to use colors iff isatty
+ from m5.util.terminal import tty_termcap as termcap
+else:
+ from m5.util.terminal import no_termcap as termcap
- if not style_hook:
- print """\
-You're missing the M5 style hook.
-Please install the hook so we can ensure that all code fits a common style.
+########################################################################
+#
+# Set up the main build environment.
+#
+########################################################################
+use_vars = set([ 'AS', 'AR', 'CC', 'CXX', 'HOME', 'LD_LIBRARY_PATH', 'PATH',
+ 'PYTHONPATH', 'RANLIB' ])
-All you'd need to do is add the following lines to your repository .hg/hgrc
-or your personal .hgrc
-----------------
+use_env = {}
+for key,val in os.environ.iteritems():
+ if key in use_vars or key.startswith("M5"):
+ use_env[key] = val
+main = Environment(ENV=use_env)
+main.root = Dir(".") # The current directory (where this file lives).
+main.srcdir = Dir("src") # The source directory
+
+# add useful python code PYTHONPATH so it can be used by subprocesses
+# as well
+main.AppendENVPath('PYTHONPATH', extra_python_paths)
+
+########################################################################
+#
+# Mercurial Stuff.
+#
+# If the M5 directory is a mercurial repository, we should do some
+# extra things.
+#
+########################################################################
+
+hgdir = main.root.Dir(".hg")
+
+mercurial_style_message = """
+You're missing the gem5 style hook, which automatically checks your code
+against the gem5 style rules on hg commit and qrefresh commands. This
+script will now install the hook in your .hg/hgrc file.
+Press enter to continue, or ctrl-c to abort: """
+
+mercurial_style_hook = """
+# The following lines were automatically added by gem5/SConstruct
+# to provide the gem5 style-checking hooks
[extensions]
style = %s/util/style.py
[hooks]
-pretxncommit.style = python:style.check_whitespace
-""" % (ROOT)
- sys.exit(1)
-
-if ARGUMENTS.get('IGNORE_STYLE') != 'True' and isdir(joinpath(ROOT, '.hg')):
+pretxncommit.style = python:style.check_style
+pre-qrefresh.style = python:style.check_style
+# End of SConstruct additions
+
+""" % (main.root.abspath)
+
+mercurial_lib_not_found = """
+Mercurial libraries cannot be found, ignoring style hook. If
+you are a gem5 developer, please fix this and run the style
+hook. It is important.
+"""
+
+# Check for style hook and prompt for installation if it's not there.
+# Skip this if --ignore-style was specified, there's no .hg dir to
+# install a hook in, or there's no interactive terminal to prompt.
+if not GetOption('ignore_style') and hgdir.exists() and sys.stdin.isatty():
+ style_hook = True
try:
from mercurial import ui
- check_style_hook(ui.ui())
+ ui = ui.ui()
+ ui.readconfig(hgdir.File('hgrc').abspath)
+ style_hook = ui.config('hooks', 'pretxncommit.style', None) and \
+ ui.config('hooks', 'pre-qrefresh.style', None)
except ImportError:
- pass
+ print mercurial_lib_not_found
+
+ if not style_hook:
+ print mercurial_style_message,
+ # continue unless user does ctrl-c/ctrl-d etc.
+ try:
+ raw_input()
+ except:
+ print "Input exception, exiting scons.\n"
+ sys.exit(1)
+ hgrc_path = '%s/.hg/hgrc' % main.root.abspath
+ print "Adding style hook to", hgrc_path, "\n"
+ try:
+ hgrc = open(hgrc_path, 'a')
+ hgrc.write(mercurial_style_hook)
+ hgrc.close()
+ except:
+ print "Error updating", hgrc_path
+ sys.exit(1)
+
###################################################
#
###################################################
# Find default configuration & binary.
-Default(os.environ.get('M5_DEFAULT_BINARY', 'build/ALPHA_SE/m5.debug'))
+Default(environ.get('M5_DEFAULT_BINARY', 'build/ALPHA_SE/m5.debug'))
# helper function: find last occurrence of element in list
def rfind(l, elt, offs = -1):
return i
raise ValueError, "element not found"
+# Take a list of paths (or SCons Nodes) and return a list with all
+# paths made absolute and ~-expanded. Paths will be interpreted
+# relative to the launch directory unless a different root is provided
+def makePathListAbsolute(path_list, root=GetLaunchDir()):
+ return [abspath(joinpath(root, expanduser(str(p))))
+ for p in path_list]
+
# Each target must have 'build' in the interior of the path; the
# directory below this will determine the build parameters. For
# example, for target 'foo/bar/build/ALPHA_SE/arch/alpha/blah.do' we
# recognize that ALPHA_SE specifies the configuration because it
-# follow 'build' in the bulid path.
-
-# Generate absolute paths to targets so we can see where the build dir is
-if COMMAND_LINE_TARGETS:
- # Ask SCons which directory it was invoked from
- launch_dir = GetLaunchDir()
- # Make targets relative to invocation directory
- abs_targets = map(lambda x: os.path.normpath(joinpath(launch_dir, str(x))),
- COMMAND_LINE_TARGETS)
-else:
- # Default targets are relative to root of tree
- abs_targets = map(lambda x: os.path.normpath(joinpath(ROOT, str(x))),
- DEFAULT_TARGETS)
+# follow 'build' in the build path.
+# The funky assignment to "[:]" is needed to replace the list contents
+# in place rather than reassign the symbol to a new list, which
+# doesn't work (obviously!).
+BUILD_TARGETS[:] = makePathListAbsolute(BUILD_TARGETS)
# Generate a list of the unique build roots and configs that the
# collected targets reference.
-build_paths = []
+variant_paths = []
build_root = None
-for t in abs_targets:
+for t in BUILD_TARGETS:
path_dirs = t.split('/')
try:
build_top = rfind(path_dirs, 'build', -2)
print "Error: build targets not under same build root\n"\
" %s\n %s" % (build_root, this_build_root)
Exit(1)
- build_path = joinpath('/',*path_dirs[:build_top+2])
- if build_path not in build_paths:
- build_paths.append(build_path)
+ variant_path = joinpath('/',*path_dirs[:build_top+2])
+ if variant_path not in variant_paths:
+ variant_paths.append(variant_path)
# Make sure build_root exists (might not if this is the first build there)
if not isdir(build_root):
- os.mkdir(build_root)
-
-###################################################
-#
-# Set up the default build environment. This environment is copied
-# and modified according to each selected configuration.
-#
-###################################################
-
-env = Environment(ENV = os.environ, # inherit user's environment vars
- ROOT = ROOT,
- SRCDIR = SRCDIR)
+ mkdir(build_root)
+main['BUILDROOT'] = build_root
-Export('env')
+Export('main')
-env.SConsignFile(joinpath(build_root,"sconsign"))
+main.SConsignFile(joinpath(build_root, "sconsign"))
# Default duplicate option is to use hard links, but this messes up
# when you use emacs to edit a file in the target dir, as emacs moves
# file to file~ then copies to file, breaking the link. Symbolic
# (soft) links work better.
-env.SetOption('duplicate', 'soft-copy')
-
-# I waffle on this setting... it does avoid a few painful but
-# unnecessary builds, but it also seems to make trivial builds take
-# noticeably longer.
-if False:
- env.TargetSignatures('content')
+main.SetOption('duplicate', 'soft-copy')
#
-# Set up global sticky options... these are common to an entire build
+# Set up global sticky variables... these are common to an entire build
# tree (not specific to a particular build like ALPHA_SE)
#
-# Option validators & converters for global sticky options
-def PathListMakeAbsolute(val):
- if not val:
- return val
- f = lambda p: os.path.abspath(os.path.expanduser(p))
- return ':'.join(map(f, val.split(':')))
+global_vars_file = joinpath(build_root, 'variables.global')
-def PathListAllExist(key, val, env):
- if not val:
- return
- paths = val.split(':')
- for path in paths:
- if not isdir(path):
- raise SCons.Errors.UserError("Path does not exist: '%s'" % path)
+global_vars = Variables(global_vars_file, args=ARGUMENTS)
-global_sticky_opts_file = joinpath(build_root, 'options.global')
-
-global_sticky_opts = Options(global_sticky_opts_file, args=ARGUMENTS)
-
-global_sticky_opts.AddOptions(
- ('CC', 'C compiler', os.environ.get('CC', env['CC'])),
- ('CXX', 'C++ compiler', os.environ.get('CXX', env['CXX'])),
+global_vars.AddVariables(
+ ('CC', 'C compiler', environ.get('CC', main['CC'])),
+ ('CXX', 'C++ compiler', environ.get('CXX', main['CXX'])),
('BATCH', 'Use batch pool for build and tests', False),
('BATCH_CMD', 'Batch pool submission command name', 'qdo'),
- ('EXTRAS', 'Add Extra directories to the compilation', '',
- PathListAllExist, PathListMakeAbsolute)
- )
+ ('M5_BUILD_CACHE', 'Cache built objects in this directory', False),
+ ('EXTRAS', 'Add extra directories to the compilation', '')
+ )
+# Update main environment with values from ARGUMENTS & global_vars_file
+global_vars.Update(main)
+help_texts["global_vars"] += global_vars.GenerateHelpText(main)
-# base help text
-help_text = '''
-Usage: scons [scons options] [build options] [target(s)]
-
-'''
-
-help_text += "Global sticky options:\n" \
- + global_sticky_opts.GenerateHelpText(env)
-
-# Update env with values from ARGUMENTS & file global_sticky_opts_file
-global_sticky_opts.Update(env)
-
-# Save sticky option settings back to current options file
-global_sticky_opts.Save(global_sticky_opts_file, env)
-
-# Parse EXTRAS option to build list of all directories where we're
-# look for sources etc. This list is exported as base_dir_list.
-base_dir_list = [joinpath(ROOT, 'src')]
-if env['EXTRAS']:
- base_dir_list += env['EXTRAS'].split(':')
-
-Export('base_dir_list')
-
-# M5_PLY is used by isa_parser.py to find the PLY package.
-env.Append(ENV = { 'M5_PLY' : str(Dir('ext/ply')) })
-env['GCC'] = subprocess.Popen(env['CXX'] + ' --version', shell=True,
- stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
- close_fds=True).communicate()[0].find('g++') >= 0
-env['SUNCC'] = subprocess.Popen(env['CXX'] + ' -V', shell=True,
- stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
- close_fds=True).communicate()[0].find('Sun C++') >= 0
-env['ICC'] = subprocess.Popen(env['CXX'] + ' -V', shell=True,
- stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
- close_fds=True).communicate()[0].find('Intel') >= 0
-if env['GCC'] + env['SUNCC'] + env['ICC'] > 1:
+# Save sticky variable settings back to current variables file
+global_vars.Save(global_vars_file, main)
+
+# Parse EXTRAS variable to build list of all directories where we're
+# look for sources etc. This list is exported as extras_dir_list.
+base_dir = main.srcdir.abspath
+if main['EXTRAS']:
+ extras_dir_list = makePathListAbsolute(main['EXTRAS'].split(':'))
+else:
+ extras_dir_list = []
+
+Export('base_dir')
+Export('extras_dir_list')
+
+# the ext directory should be on the #includes path
+main.Append(CPPPATH=[Dir('ext')])
+
+def strip_build_path(path, env):
+ path = str(path)
+ variant_base = env['BUILDROOT'] + os.path.sep
+ if path.startswith(variant_base):
+ path = path[len(variant_base):]
+ elif path.startswith('build/'):
+ path = path[6:]
+ return path
+
+# Generate a string of the form:
+# common/path/prefix/src1, src2 -> tgt1, tgt2
+# to print while building.
+class Transform(object):
+ # all specific color settings should be here and nowhere else
+ tool_color = termcap.Normal
+ pfx_color = termcap.Yellow
+ srcs_color = termcap.Yellow + termcap.Bold
+ arrow_color = termcap.Blue + termcap.Bold
+ tgts_color = termcap.Yellow + termcap.Bold
+
+ def __init__(self, tool, max_sources=99):
+ self.format = self.tool_color + (" [%8s] " % tool) \
+ + self.pfx_color + "%s" \
+ + self.srcs_color + "%s" \
+ + self.arrow_color + " -> " \
+ + self.tgts_color + "%s" \
+ + termcap.Normal
+ self.max_sources = max_sources
+
+ def __call__(self, target, source, env, for_signature=None):
+ # truncate source list according to max_sources param
+ source = source[0:self.max_sources]
+ def strip(f):
+ return strip_build_path(str(f), env)
+ if len(source) > 0:
+ srcs = map(strip, source)
+ else:
+ srcs = ['']
+ tgts = map(strip, target)
+ # surprisingly, os.path.commonprefix is a dumb char-by-char string
+ # operation that has nothing to do with paths.
+ com_pfx = os.path.commonprefix(srcs + tgts)
+ com_pfx_len = len(com_pfx)
+ if com_pfx:
+ # do some cleanup and sanity checking on common prefix
+ if com_pfx[-1] == ".":
+ # prefix matches all but file extension: ok
+ # back up one to change 'foo.cc -> o' to 'foo.cc -> .o'
+ com_pfx = com_pfx[0:-1]
+ elif com_pfx[-1] == "/":
+ # common prefix is directory path: OK
+ pass
+ else:
+ src0_len = len(srcs[0])
+ tgt0_len = len(tgts[0])
+ if src0_len == com_pfx_len:
+ # source is a substring of target, OK
+ pass
+ elif tgt0_len == com_pfx_len:
+ # target is a substring of source, need to back up to
+ # avoid empty string on RHS of arrow
+ sep_idx = com_pfx.rfind(".")
+ if sep_idx != -1:
+ com_pfx = com_pfx[0:sep_idx]
+ else:
+ com_pfx = ''
+ elif src0_len > com_pfx_len and srcs[0][com_pfx_len] == ".":
+ # still splitting at file extension: ok
+ pass
+ else:
+ # probably a fluke; ignore it
+ com_pfx = ''
+ # recalculate length in case com_pfx was modified
+ com_pfx_len = len(com_pfx)
+ def fmt(files):
+ f = map(lambda s: s[com_pfx_len:], files)
+ return ', '.join(f)
+ return self.format % (com_pfx, fmt(srcs), fmt(tgts))
+
+Export('Transform')
+
+
+if GetOption('verbose'):
+ def MakeAction(action, string, *args, **kwargs):
+ return Action(action, *args, **kwargs)
+else:
+ MakeAction = Action
+ main['CCCOMSTR'] = Transform("CC")
+ main['CXXCOMSTR'] = Transform("CXX")
+ main['ASCOMSTR'] = Transform("AS")
+ main['SWIGCOMSTR'] = Transform("SWIG")
+ main['ARCOMSTR'] = Transform("AR", 0)
+ main['LINKCOMSTR'] = Transform("LINK", 0)
+ main['RANLIBCOMSTR'] = Transform("RANLIB", 0)
+ main['M4COMSTR'] = Transform("M4")
+ main['SHCCCOMSTR'] = Transform("SHCC")
+ main['SHCXXCOMSTR'] = Transform("SHCXX")
+Export('MakeAction')
+
+CXX_version = readCommand([main['CXX'],'--version'], exception=False)
+CXX_V = readCommand([main['CXX'],'-V'], exception=False)
+
+main['GCC'] = CXX_version and CXX_version.find('g++') >= 0
+main['SUNCC'] = CXX_V and CXX_V.find('Sun C++') >= 0
+main['ICC'] = CXX_V and CXX_V.find('Intel') >= 0
+if main['GCC'] + main['SUNCC'] + main['ICC'] > 1:
print 'Error: How can we have two at the same time?'
Exit(1)
-
# Set up default C++ compiler flags
-if env['GCC']:
- env.Append(CCFLAGS='-pipe')
- env.Append(CCFLAGS='-fno-strict-aliasing')
- env.Append(CCFLAGS=Split('-Wall -Wno-sign-compare -Werror -Wundef'))
- env.Append(CXXFLAGS='-Wno-deprecated')
-elif env['ICC']:
+if main['GCC']:
+ main.Append(CCFLAGS=['-pipe'])
+ main.Append(CCFLAGS=['-fno-strict-aliasing'])
+ main.Append(CCFLAGS=['-Wall', '-Wno-sign-compare', '-Wundef'])
+ main.Append(CXXFLAGS=['-Wno-deprecated'])
+ # Read the GCC version to check for versions with bugs
+ # Note CCVERSION doesn't work here because it is run with the CC
+ # before we override it from the command line
+ gcc_version = readCommand([main['CXX'], '-dumpversion'], exception=False)
+ if not compareVersions(gcc_version, '4.4.1') or \
+ not compareVersions(gcc_version, '4.4.2'):
+ print 'Info: Tree vectorizer in GCC 4.4.1 & 4.4.2 is buggy, disabling.'
+ main.Append(CCFLAGS=['-fno-tree-vectorize'])
+elif main['ICC']:
pass #Fix me... add warning flags once we clean up icc warnings
-elif env['SUNCC']:
- env.Append(CCFLAGS='-Qoption ccfe')
- env.Append(CCFLAGS='-features=gcc')
- env.Append(CCFLAGS='-features=extensions')
- env.Append(CCFLAGS='-library=stlport4')
- env.Append(CCFLAGS='-xar')
-# env.Append(CCFLAGS='-instances=semiexplicit')
+elif main['SUNCC']:
+ main.Append(CCFLAGS=['-Qoption ccfe'])
+ main.Append(CCFLAGS=['-features=gcc'])
+ main.Append(CCFLAGS=['-features=extensions'])
+ main.Append(CCFLAGS=['-library=stlport4'])
+ main.Append(CCFLAGS=['-xar'])
+ #main.Append(CCFLAGS=['-instances=semiexplicit'])
else:
print 'Error: Don\'t know what compiler options to use for your compiler.'
print ' Please fix SConstruct and src/SConscript and try again.'
Exit(1)
+# Set up common yacc/bison flags (needed for Ruby)
+main['YACCFLAGS'] = '-d'
+main['YACCHXXFILESUFFIX'] = '.hh'
+
# Do this after we save setting back, or else we'll tack on an
# extra 'qdo' every time we run scons.
-if env['BATCH']:
- env['CC'] = env['BATCH_CMD'] + ' ' + env['CC']
- env['CXX'] = env['BATCH_CMD'] + ' ' + env['CXX']
+if main['BATCH']:
+ main['CC'] = main['BATCH_CMD'] + ' ' + main['CC']
+ main['CXX'] = main['BATCH_CMD'] + ' ' + main['CXX']
+ main['AS'] = main['BATCH_CMD'] + ' ' + main['AS']
+ main['AR'] = main['BATCH_CMD'] + ' ' + main['AR']
+ main['RANLIB'] = main['BATCH_CMD'] + ' ' + main['RANLIB']
if sys.platform == 'cygwin':
# cygwin has some header file issues...
- env.Append(CCFLAGS=Split("-Wno-uninitialized"))
-env.Append(CPPPATH=[Dir('ext/dnet')])
+ main.Append(CCFLAGS=["-Wno-uninitialized"])
# Check for SWIG
-if not env.has_key('SWIG'):
+if not main.has_key('SWIG'):
print 'Error: SWIG utility not found.'
print ' Please install (see http://www.swig.org) and retry.'
Exit(1)
# Check for appropriate SWIG version
-swig_version = os.popen('swig -version').read().split()
+swig_version = readCommand(('swig', '-version'), exception='').split()
# First 3 words should be "SWIG Version x.y.z"
if len(swig_version) < 3 or \
swig_version[0] != 'SWIG' or swig_version[1] != 'Version':
Exit(1)
min_swig_version = '1.3.28'
-if compare_versions(swig_version[2], min_swig_version) < 0:
+if compareVersions(swig_version[2], min_swig_version) < 0:
print 'Error: SWIG version', min_swig_version, 'or newer required.'
print ' Installed version:', swig_version[2]
Exit(1)
# Set up SWIG flags & scanner
swig_flags=Split('-c++ -python -modern -templatereduce $_CPPINCFLAGS')
-env.Append(SWIGFLAGS=swig_flags)
+main.Append(SWIGFLAGS=swig_flags)
# filter out all existing swig scanners, they mess up the dependency
# stuff for some reason
scanners = []
-for scanner in env['SCANNERS']:
+for scanner in main['SCANNERS']:
skeys = scanner.skeys
if skeys == '.i':
continue
scanners.append(CPPScanner("SwigScan", [ ".i" ], "CPPPATH", swig_inc_re))
# replace the scanners list that has what we want
-env['SCANNERS'] = scanners
+main['SCANNERS'] = scanners
# Add a custom Check function to the Configure context so that we can
# figure out if the compiler adds leading underscores to global
# Platform-specific configuration. Note again that we assume that all
# builds under a given build root run on the same host platform.
-conf = Configure(env,
+conf = Configure(main,
conf_dir = joinpath(build_root, '.scons_config'),
log_file = joinpath(build_root, 'scons_config.log'),
custom_tests = { 'CheckLeading' : CheckLeading })
try:
import platform
uname = platform.uname()
- if uname[0] == 'Darwin' and compare_versions(uname[2], '9.0.0') >= 0:
- if int(subprocess.Popen('sysctl -n hw.cpu64bit_capable', shell=True,
- stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
- close_fds=True).communicate()[0][0]):
- env.Append(CCFLAGS='-arch x86_64')
- env.Append(CFLAGS='-arch x86_64')
- env.Append(LINKFLAGS='-arch x86_64')
- env.Append(ASFLAGS='-arch x86_64')
+ if uname[0] == 'Darwin' and compareVersions(uname[2], '9.0.0') >= 0:
+ if int(readCommand('sysctl -n hw.cpu64bit_capable')[0]):
+ main.Append(CCFLAGS=['-arch', 'x86_64'])
+ main.Append(CFLAGS=['-arch', 'x86_64'])
+ main.Append(LINKFLAGS=['-arch', 'x86_64'])
+ main.Append(ASFLAGS=['-arch', 'x86_64'])
except:
pass
def __getattr__(self, mname):
return NullCheck
- conf = NullConf(env)
+ conf = NullConf(main)
# Find Python include and library directories for embedding the
# interpreter. For consistency, we will use the same Python
# installation used to run scons (and thus this script). If you want
# to link in an alternate version, see above for instructions on how
# to invoke scons with a different copy of the Python interpreter.
+from distutils import sysconfig
+
+py_getvar = sysconfig.get_config_var
+
+py_debug = getattr(sys, 'pydebug', False)
+py_version = 'python' + py_getvar('VERSION') + (py_debug and "_d" or "")
+
+py_general_include = sysconfig.get_python_inc()
+py_platform_include = sysconfig.get_python_inc(plat_specific=True)
+py_includes = [ py_general_include ]
+if py_platform_include != py_general_include:
+ py_includes.append(py_platform_include)
+
+py_lib_path = [ py_getvar('LIBDIR') ]
+# add the prefix/lib/pythonX.Y/config dir, but only if there is no
+# shared library in prefix/lib/.
+if not py_getvar('Py_ENABLE_SHARED'):
+ py_lib_path.append(py_getvar('LIBPL'))
+
+py_libs = []
+for lib in py_getvar('LIBS').split() + py_getvar('SYSLIBS').split():
+ assert lib.startswith('-l')
+ lib = lib[2:]
+ if lib not in py_libs:
+ py_libs.append(lib)
+py_libs.append(py_version)
-# Get brief Python version name (e.g., "python2.4") for locating
-# include & library files
-py_version_name = 'python' + sys.version[:3]
+main.Append(CPPPATH=py_includes)
+main.Append(LIBPATH=py_lib_path)
-# include path, e.g. /usr/local/include/python2.4
-py_header_path = joinpath(sys.exec_prefix, 'include', py_version_name)
-env.Append(CPPPATH = py_header_path)
-# verify that it works
+# Cache build files in the supplied directory.
+if main['M5_BUILD_CACHE']:
+ print 'Using build cache located at', main['M5_BUILD_CACHE']
+ CacheDir(main['M5_BUILD_CACHE'])
+
+
+# verify that this stuff works
if not conf.CheckHeader('Python.h', '<>'):
- print "Error: can't find Python.h header in", py_header_path
+ print "Error: can't find Python.h header in", py_includes
Exit(1)
-# add library path too if it's not in the default place
-py_lib_path = None
-if sys.exec_prefix != '/usr':
- py_lib_path = joinpath(sys.exec_prefix, 'lib')
-elif sys.platform == 'cygwin':
- # cygwin puts the .dll in /bin for some reason
- py_lib_path = '/bin'
-if py_lib_path:
- env.Append(LIBPATH = py_lib_path)
- print 'Adding', py_lib_path, 'to LIBPATH for', py_version_name
-if not conf.CheckLib(py_version_name):
- print "Error: can't find Python library", py_version_name
- Exit(1)
+for lib in py_libs:
+ if not conf.CheckLib(lib):
+ print "Error: can't find library %s required by python" % lib
+ Exit(1)
# On Solaris you need to use libsocket for socket ops
if not conf.CheckLibWithHeader(None, 'sys/socket.h', 'C++', 'accept(0,0,0);'):
print ' Please install zlib and try again.'
Exit(1)
+# Check for librt.
+have_posix_clock = \
+ conf.CheckLibWithHeader(None, 'time.h', 'C',
+ 'clock_nanosleep(0,0,NULL,NULL);') or \
+ conf.CheckLibWithHeader('rt', 'time.h', 'C',
+ 'clock_nanosleep(0,0,NULL,NULL);')
+
+if not have_posix_clock:
+ print "Can't find library for POSIX clocks."
+
# Check for <fenv.h> (C99 FP environment control)
have_fenv = conf.CheckHeader('fenv.h', '<>')
if not have_fenv:
print "Warning: Header file <fenv.h> not found."
print " This host has no IEEE FP rounding mode control."
-# Check for mysql.
-mysql_config = WhereIs('mysql_config')
-have_mysql = mysql_config != None
-
-# Check MySQL version.
-if have_mysql:
- mysql_version = os.popen(mysql_config + ' --version').read()
- min_mysql_version = '4.1'
- if compare_versions(mysql_version, min_mysql_version) < 0:
- print 'Warning: MySQL', min_mysql_version, 'or newer required.'
- print ' Version', mysql_version, 'detected.'
- have_mysql = False
-
-# Set up mysql_config commands.
-if have_mysql:
- mysql_config_include = mysql_config + ' --include'
- if os.system(mysql_config_include + ' > /dev/null') != 0:
- # older mysql_config versions don't support --include, use
- # --cflags instead
- mysql_config_include = mysql_config + ' --cflags | sed s/\\\'//g'
- # This seems to work in all versions
- mysql_config_libs = mysql_config + ' --libs'
-
-env = conf.Finish()
+######################################################################
+#
+# Finish the configuration
+#
+main = conf.Finish()
+
+######################################################################
+#
+# Collect all non-global variables
+#
# Define the universe of supported ISAs
all_isa_list = [ ]
Export('all_isa_list')
-# Define the universe of supported CPU models
-all_cpu_list = [ ]
-default_cpus = [ ]
-Export('all_cpu_list', 'default_cpus')
+class CpuModel(object):
+ '''The CpuModel class encapsulates everything the ISA parser needs to
+ know about a particular CPU model.'''
+
+ # Dict of available CPU model objects. Accessible as CpuModel.dict.
+ dict = {}
+ list = []
+ defaults = []
+
+ # Constructor. Automatically adds models to CpuModel.dict.
+ def __init__(self, name, filename, includes, strings, default=False):
+ self.name = name # name of model
+ self.filename = filename # filename for output exec code
+ self.includes = includes # include files needed in exec file
+ # The 'strings' dict holds all the per-CPU symbols we can
+ # substitute into templates etc.
+ self.strings = strings
-# Sticky options get saved in the options file so they persist from
+ # This cpu is enabled by default
+ self.default = default
+
+ # Add self to dict
+ if name in CpuModel.dict:
+ raise AttributeError, "CpuModel '%s' already registered" % name
+ CpuModel.dict[name] = self
+ CpuModel.list.append(name)
+
+Export('CpuModel')
+
+# Sticky variables get saved in the variables file so they persist from
# one invocation to the next (unless overridden, in which case the new
# value becomes sticky).
-sticky_opts = Options(args=ARGUMENTS)
-Export('sticky_opts')
+sticky_vars = Variables(args=ARGUMENTS)
+Export('sticky_vars')
-# Non-sticky options only apply to the current build.
-nonsticky_opts = Options(args=ARGUMENTS)
-Export('nonsticky_opts')
+# Sticky variables that should be exported
+export_vars = []
+Export('export_vars')
# Walk the tree and execute all SConsopts scripts that wil add to the
-# above options
-for base_dir in base_dir_list:
- for root, dirs, files in os.walk(base_dir):
+# above variables
+if not GetOption('verbose'):
+ print "Reading SConsopts"
+for bdir in [ base_dir ] + extras_dir_list:
+ if not isdir(bdir):
+ print "Error: directory '%s' does not exist" % bdir
+ Exit(1)
+ for root, dirs, files in os.walk(bdir):
if 'SConsopts' in files:
- print "Reading", joinpath(root, 'SConsopts')
+ if GetOption('verbose'):
+ print "Reading", joinpath(root, 'SConsopts')
SConscript(joinpath(root, 'SConsopts'))
all_isa_list.sort()
-all_cpu_list.sort()
-default_cpus.sort()
-
-sticky_opts.AddOptions(
- EnumOption('TARGET_ISA', 'Target ISA', 'alpha', all_isa_list),
- BoolOption('FULL_SYSTEM', 'Full-system support', False),
- # There's a bug in scons 0.96.1 that causes ListOptions with list
- # values (more than one value) not to be able to be restored from
- # a saved option file. If this causes trouble then upgrade to
- # scons 0.96.90 or later.
- ListOption('CPU_MODELS', 'CPU models', default_cpus, all_cpu_list),
- BoolOption('NO_FAST_ALLOC', 'Disable fast object allocator', False),
- BoolOption('FAST_ALLOC_DEBUG', 'Enable fast object allocator debugging',
- False),
- BoolOption('FAST_ALLOC_STATS', 'Enable fast object allocator statistics',
- False),
- BoolOption('EFENCE', 'Link with Electric Fence malloc debugger',
- False),
- BoolOption('SS_COMPATIBLE_FP',
- 'Make floating-point results compatible with SimpleScalar',
- False),
- BoolOption('USE_SSE2',
- 'Compile for SSE2 (-msse2) to get IEEE FP on x86 hosts',
- False),
- BoolOption('USE_MYSQL', 'Use MySQL for stats output', have_mysql),
- BoolOption('USE_FENV', 'Use <fenv.h> IEEE mode control', have_fenv),
- BoolOption('USE_CHECKER', 'Use checker for detailed CPU models', False),
- )
-nonsticky_opts.AddOptions(
- BoolOption('update_ref', 'Update test reference outputs', False)
+sticky_vars.AddVariables(
+ EnumVariable('TARGET_ISA', 'Target ISA', 'alpha', all_isa_list),
+ BoolVariable('FULL_SYSTEM', 'Full-system support', False),
+ ListVariable('CPU_MODELS', 'CPU models',
+ sorted(n for n,m in CpuModel.dict.iteritems() if m.default),
+ sorted(CpuModel.list)),
+ BoolVariable('NO_FAST_ALLOC', 'Disable fast object allocator', False),
+ BoolVariable('FORCE_FAST_ALLOC',
+ 'Enable fast object allocator, even for m5.debug', False),
+ BoolVariable('FAST_ALLOC_STATS', 'Enable fast object allocator statistics',
+ False),
+ BoolVariable('EFENCE', 'Link with Electric Fence malloc debugger',
+ False),
+ BoolVariable('SS_COMPATIBLE_FP',
+ 'Make floating-point results compatible with SimpleScalar',
+ False),
+ BoolVariable('USE_SSE2',
+ 'Compile for SSE2 (-msse2) to get IEEE FP on x86 hosts',
+ False),
+ BoolVariable('USE_POSIX_CLOCK', 'Use POSIX Clocks', have_posix_clock),
+ BoolVariable('USE_FENV', 'Use <fenv.h> IEEE mode control', have_fenv),
+ BoolVariable('USE_CHECKER', 'Use checker for detailed CPU models', False),
+ BoolVariable('CP_ANNOTATE', 'Enable critical path annotation capability', False),
)
-# These options get exported to #defines in config/*.hh (see src/SConscript).
-env.ExportOptions = ['FULL_SYSTEM', 'ALPHA_TLASER', 'USE_FENV', \
- 'USE_MYSQL', 'NO_FAST_ALLOC', 'FAST_ALLOC_DEBUG', \
- 'FAST_ALLOC_STATS', 'SS_COMPATIBLE_FP', \
- 'USE_CHECKER', 'TARGET_ISA']
-
-# Define a handy 'no-op' action
-def no_action(target, source, env):
- return 0
-
-env.NoAction = Action(no_action, None)
+# These variables get exported to #defines in config/*.hh (see src/SConscript).
+export_vars += ['FULL_SYSTEM', 'USE_FENV',
+ 'NO_FAST_ALLOC', 'FORCE_FAST_ALLOC', 'FAST_ALLOC_STATS',
+ 'SS_COMPATIBLE_FP', 'USE_CHECKER', 'TARGET_ISA', 'CP_ANNOTATE',
+ 'USE_POSIX_CLOCK' ]
###################################################
#
###################################################
# This function generates a config header file that #defines the
-# option symbol to the current option setting (0 or 1). The source
-# operands are the name of the option and a Value node containing the
-# value of the option.
+# variable symbol to the current variable setting (0 or 1). The source
+# operands are the name of the variable and a Value node containing the
+# value of the variable.
def build_config_file(target, source, env):
- (option, value) = [s.get_contents() for s in source]
+ (variable, value) = [s.get_contents() for s in source]
f = file(str(target[0]), 'w')
- print >> f, '#define', option, value
+ print >> f, '#define', variable, value
f.close()
return None
# Generate the message to be printed when building the config file.
def build_config_file_string(target, source, env):
- (option, value) = [s.get_contents() for s in source]
- return "Defining %s as %s in %s." % (option, value, target[0])
+ (variable, value) = [s.get_contents() for s in source]
+ return "Defining %s as %s in %s." % (variable, value, target[0])
# Combine the two functions into a scons Action object.
config_action = Action(build_config_file, build_config_file_string)
# The emitter munges the source & target node lists to reflect what
# we're really doing.
def config_emitter(target, source, env):
- # extract option name from Builder arg
- option = str(target[0])
+ # extract variable name from Builder arg
+ variable = str(target[0])
# True target is config header file
- target = joinpath('config', option.lower() + '.hh')
- val = env[option]
+ target = joinpath('config', variable.lower() + '.hh')
+ val = env[variable]
if isinstance(val, bool):
# Force value to 0/1
val = int(val)
elif isinstance(val, str):
val = '"' + val + '"'
- # Sources are option name & value (packaged in SCons Value nodes)
- return ([target], [Value(option), Value(val)])
+ # Sources are variable name & value (packaged in SCons Value nodes)
+ return ([target], [Value(variable), Value(val)])
config_builder = Builder(emitter = config_emitter, action = config_action)
-env.Append(BUILDERS = { 'ConfigFile' : config_builder })
-
-###################################################
-#
-# Define a SCons builder for copying files. This is used by the
-# Python zipfile code in src/python/SConscript, but is placed up here
-# since it's potentially more generally applicable.
-#
-###################################################
-
-copy_builder = Builder(action = Copy("$TARGET", "$SOURCE"))
-
-env.Append(BUILDERS = { 'CopyFile' : copy_builder })
-
-###################################################
-#
-# Define a simple SCons builder to concatenate files.
-#
-# Used to append the Python zip archive to the executable.
-#
-###################################################
-
-concat_builder = Builder(action = Action(['cat $SOURCES > $TARGET',
- 'chmod +x $TARGET']))
-
-env.Append(BUILDERS = { 'Concat' : concat_builder })
-
+main.Append(BUILDERS = { 'ConfigFile' : config_builder })
# libelf build is shared across all configs in the build root.
-env.SConscript('ext/libelf/SConscript',
- build_dir = joinpath(build_root, 'libelf'),
- exports = 'env')
+main.SConscript('ext/libelf/SConscript',
+ variant_dir = joinpath(build_root, 'libelf'))
+
+# gzstream build is shared across all configs in the build root.
+main.SConscript('ext/gzstream/SConscript',
+ variant_dir = joinpath(build_root, 'gzstream'))
###################################################
#
#
###################################################
-env['ALL_ISA_LIST'] = all_isa_list
-def make_switching_dir(dirname, switch_headers, env):
+main['ALL_ISA_LIST'] = all_isa_list
+def make_switching_dir(dname, switch_headers, env):
# Generate the header. target[0] is the full path of the output
# header to generate. 'source' is a dummy variable, since we get the
# list of ISAs from env['ALL_ISA_LIST'].
def gen_switch_hdr(target, source, env):
fname = str(target[0])
- basename = os.path.basename(fname)
f = open(fname, 'w')
- f.write('#include "arch/isa_specific.hh"\n')
- cond = '#if'
- for isa in all_isa_list:
- f.write('%s THE_ISA == %s_ISA\n#include "%s/%s/%s"\n'
- % (cond, isa.upper(), dirname, isa, basename))
- cond = '#elif'
- f.write('#else\n#error "THE_ISA not set"\n#endif\n')
+ isa = env['TARGET_ISA'].lower()
+ print >>f, '#include "%s/%s/%s"' % (dname, isa, basename(fname))
f.close()
- return 0
-
- # String to print when generating header
- def gen_switch_hdr_string(target, source, env):
- return "Generating switch header " + str(target[0])
# Build SCons Action object. 'varlist' specifies env vars that this
# action depends on; when env['ALL_ISA_LIST'] changes these actions
# should get re-executed.
- switch_hdr_action = Action(gen_switch_hdr, gen_switch_hdr_string,
- varlist=['ALL_ISA_LIST'])
+ switch_hdr_action = MakeAction(gen_switch_hdr,
+ Transform("GENERATE"), varlist=['ALL_ISA_LIST'])
# Instantiate actions for each header
for hdr in switch_headers:
#
###################################################
-# rename base env
-base_env = env
-
-for build_path in build_paths:
- print "Building in", build_path
+for variant_path in variant_paths:
+ print "Building in", variant_path
# Make a copy of the build-root environment to use for this config.
- env = base_env.Copy()
- env['BUILDDIR'] = build_path
+ env = main.Clone()
+ env['BUILDDIR'] = variant_path
- # build_dir is the tail component of build path, and is used to
+ # variant_dir is the tail component of build path, and is used to
# determine the build parameters (e.g., 'ALPHA_SE')
- (build_root, build_dir) = os.path.split(build_path)
-
- # Set env options according to the build directory config.
- sticky_opts.files = []
- # Options for $BUILD_ROOT/$BUILD_DIR are stored in
- # $BUILD_ROOT/options/$BUILD_DIR so you can nuke
- # $BUILD_ROOT/$BUILD_DIR without losing your options settings.
- current_opts_file = joinpath(build_root, 'options', build_dir)
- if isfile(current_opts_file):
- sticky_opts.files.append(current_opts_file)
- print "Using saved options file %s" % current_opts_file
+ (build_root, variant_dir) = splitpath(variant_path)
+
+ # Set env variables according to the build directory config.
+ sticky_vars.files = []
+ # Variables for $BUILD_ROOT/$VARIANT_DIR are stored in
+ # $BUILD_ROOT/variables/$VARIANT_DIR so you can nuke
+ # $BUILD_ROOT/$VARIANT_DIR without losing your variables settings.
+ current_vars_file = joinpath(build_root, 'variables', variant_dir)
+ if isfile(current_vars_file):
+ sticky_vars.files.append(current_vars_file)
+ print "Using saved variables file %s" % current_vars_file
else:
- # Build dir-specific options file doesn't exist.
+ # Build dir-specific variables file doesn't exist.
# Make sure the directory is there so we can create it later
- opt_dir = os.path.dirname(current_opts_file)
+ opt_dir = dirname(current_vars_file)
if not isdir(opt_dir):
- os.mkdir(opt_dir)
-
- # Get default build options from source tree. Options are
- # normally determined by name of $BUILD_DIR, but can be
- # overriden by 'default=' arg on command line.
- default_opts_file = joinpath('build_opts',
- ARGUMENTS.get('default', build_dir))
- if isfile(default_opts_file):
- sticky_opts.files.append(default_opts_file)
- print "Options file %s not found,\n using defaults in %s" \
- % (current_opts_file, default_opts_file)
+ mkdir(opt_dir)
+
+ # Get default build variables from source tree. Variables are
+ # normally determined by name of $VARIANT_DIR, but can be
+ # overridden by '--default=' arg on command line.
+ default = GetOption('default')
+ opts_dir = joinpath(main.root.abspath, 'build_opts')
+ if default:
+ default_vars_files = [joinpath(build_root, 'variables', default),
+ joinpath(opts_dir, default)]
+ else:
+ default_vars_files = [joinpath(opts_dir, variant_dir)]
+ existing_files = filter(isfile, default_vars_files)
+ if existing_files:
+ default_vars_file = existing_files[0]
+ sticky_vars.files.append(default_vars_file)
+ print "Variables file %s not found,\n using defaults in %s" \
+ % (current_vars_file, default_vars_file)
else:
- print "Error: cannot find options file %s or %s" \
- % (current_opts_file, default_opts_file)
+ print "Error: cannot find variables file %s or " \
+ "default file(s) %s" \
+ % (current_vars_file, ' or '.join(default_vars_files))
Exit(1)
- # Apply current option settings to env
- sticky_opts.Update(env)
- nonsticky_opts.Update(env)
+ # Apply current variable settings to env
+ sticky_vars.Update(env)
- help_text += "\nSticky options for %s:\n" % build_dir \
- + sticky_opts.GenerateHelpText(env) \
- + "\nNon-sticky options for %s:\n" % build_dir \
- + nonsticky_opts.GenerateHelpText(env)
+ help_texts["local_vars"] += \
+ "Build variables for %s:\n" % variant_dir \
+ + sticky_vars.GenerateHelpText(env)
- # Process option settings.
+ # Process variable settings.
if not have_fenv and env['USE_FENV']:
print "Warning: <fenv.h> not available; " \
- "forcing USE_FENV to False in", build_dir + "."
+ "forcing USE_FENV to False in", variant_dir + "."
env['USE_FENV'] = False
if not env['USE_FENV']:
- print "Warning: No IEEE FP rounding mode control in", build_dir + "."
+ print "Warning: No IEEE FP rounding mode control in", variant_dir + "."
print " FP results may deviate slightly from other platforms."
if env['EFENCE']:
env.Append(LIBS=['efence'])
- if env['USE_MYSQL']:
- if not have_mysql:
- print "Warning: MySQL not available; " \
- "forcing USE_MYSQL to False in", build_dir + "."
- env['USE_MYSQL'] = False
- else:
- print "Compiling in", build_dir, "with MySQL support."
- env.ParseConfig(mysql_config_libs)
- env.ParseConfig(mysql_config_include)
-
- # Save sticky option settings back to current options file
- sticky_opts.Save(current_opts_file, env)
+ # Save sticky variable settings back to current variables file
+ sticky_vars.Save(current_vars_file, env)
if env['USE_SSE2']:
- env.Append(CCFLAGS='-msse2')
+ env.Append(CCFLAGS=['-msse2'])
+
+ if env['PROTOCOL'] != 'None':
+ env['RUBY'] = True
+ else:
+ env['RUBY'] = False
# The src/SConscript file sets up the build rules in 'env' according
- # to the configured options. It returns a list of environments,
+ # to the configured variables. It returns a list of environments,
# one for each variant build (debug, opt, etc.)
- envList = SConscript('src/SConscript', build_dir = build_path,
+ envList = SConscript('src/SConscript', variant_dir = variant_path,
exports = 'env')
# Set up the regression tests for each build.
for e in envList:
SConscript('tests/SConscript',
- build_dir = joinpath(build_path, 'tests', e.Label),
+ variant_dir = joinpath(variant_path, 'tests', e.Label),
exports = { 'env' : e }, duplicate = False)
-Help(help_text)
+# base help text
+Help('''
+Usage: scons [scons options] [build variables] [target(s)]
+Extra scons options:
+%(options)s
-###################################################
-#
-# Let SCons do its thing. At this point SCons will use the defined
-# build environments to build the requested targets.
-#
-###################################################
+Global build variables:
+%(global_vars)s
+%(local_vars)s
+''' % help_texts)
projects / gem5.git / blobdiff