scons: Require SCons version 0.98.1
This allows me to clean things up so we are up to date with respect to deprecated features. There are many features scheduled for permanent failure in scons 2.0 and 0.98.1 provides the most compatability for that. It also paves the way for some nice new features that I will add soon
This commit is contained in:
Nathan Binkert
parent
9e268ae63f
commit
dd6ea8797f
501
SConstruct
501
SConstruct
|
|
@ -27,6 +27,7 @@
|
|||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
# Authors: Steve Reinhardt
|
||||
# Nathan Binkert
|
||||
|
||||
###################################################
|
||||
#
|
||||
|
|
@ -63,25 +64,55 @@
|
|||
#
|
||||
###################################################
|
||||
|
||||
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
|
||||
|
||||
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
|
||||
|
||||
import SCons
|
||||
|
||||
# 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)
|
||||
|
||||
# Import subprocess after we check the version since it doesn't exist in
|
||||
# Python < 2.4.
|
||||
import subprocess
|
||||
def read_command(cmd):
|
||||
"""run the command cmd, read the results and return them
|
||||
this is sorta like `cmd` in shell"""
|
||||
from subprocess import Popen, PIPE, STDOUT
|
||||
subp = Popen(cmd, shell=True, stdout=PIPE, stderr=STDOUT, close_fds=True)
|
||||
return subp.communicate()[0]
|
||||
|
||||
# helper function: compare arrays or strings of version numbers.
|
||||
# E.g., compare_version((1,3,25), (1,4,1)')
|
||||
|
|
@ -106,46 +137,6 @@ def compare_versions(v1, v2):
|
|||
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
|
||||
|
||||
|
|
@ -155,6 +146,25 @@ SRCDIR = joinpath(ROOT, 'src')
|
|||
# tell python where to find m5 python code
|
||||
sys.path.append(joinpath(ROOT, 'src/python'))
|
||||
|
||||
###################################################
|
||||
# Mercurial Stuff.
|
||||
# 1) Grab repository revision if we know it.
|
||||
# 2) Ensure that the style hook is in place.
|
||||
###################################################
|
||||
|
||||
hg_info = "Unknown"
|
||||
try:
|
||||
if not exists(ROOT) or not isdir(ROOT) or \
|
||||
not exists(joinpath(ROOT, ".hg")):
|
||||
raise ValueError(".hg directory not found")
|
||||
hg_info = read_command("cd %s; hg id -n -i -t -b" % ROOT).strip()
|
||||
except ImportError, e:
|
||||
print "Mercurial not found"
|
||||
except ValueError, e:
|
||||
print e
|
||||
except Exception, e:
|
||||
print "Other mercurial exception: %s" % e
|
||||
|
||||
def check_style_hook(ui):
|
||||
ui.readconfig(joinpath(ROOT, '.hg', 'hgrc'))
|
||||
style_hook = ui.config('hooks', 'pretxncommit.style', None)
|
||||
|
|
@ -183,6 +193,7 @@ if ARGUMENTS.get('IGNORE_STYLE') != 'True' and isdir(joinpath(ROOT, '.hg')):
|
|||
except ImportError:
|
||||
pass
|
||||
|
||||
|
||||
###################################################
|
||||
#
|
||||
# Figure out which configurations to set up based on the path(s) of
|
||||
|
|
@ -191,7 +202,7 @@ if ARGUMENTS.get('IGNORE_STYLE') != 'True' and isdir(joinpath(ROOT, '.hg')):
|
|||
###################################################
|
||||
|
||||
# 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):
|
||||
|
|
@ -211,17 +222,17 @@ 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)
|
||||
abs_targets = [ normpath(joinpath(launch_dir, str(x))) for x in \
|
||||
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)
|
||||
abs_targets = [ normpath(joinpath(ROOT, str(x))) for x in \
|
||||
DEFAULT_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:
|
||||
path_dirs = t.split('/')
|
||||
|
|
@ -238,13 +249,13 @@ for t in abs_targets:
|
|||
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)
|
||||
mkdir(build_root)
|
||||
|
||||
###################################################
|
||||
#
|
||||
|
|
@ -253,13 +264,14 @@ if not isdir(build_root):
|
|||
#
|
||||
###################################################
|
||||
|
||||
env = Environment(ENV = os.environ, # inherit user's environment vars
|
||||
env = Environment(ENV = environ, # inherit user's environment vars
|
||||
ROOT = ROOT,
|
||||
SRCDIR = SRCDIR)
|
||||
SRCDIR = SRCDIR,
|
||||
HG_INFO = hg_info)
|
||||
|
||||
Export('env')
|
||||
|
||||
env.SConsignFile(joinpath(build_root,"sconsign"))
|
||||
env.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
|
||||
|
|
@ -267,22 +279,16 @@ env.SConsignFile(joinpath(build_root,"sconsign"))
|
|||
# (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')
|
||||
|
||||
#
|
||||
# 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
|
||||
# Variable validators & converters for global sticky variables
|
||||
def PathListMakeAbsolute(val):
|
||||
if not val:
|
||||
return val
|
||||
f = lambda p: os.path.abspath(os.path.expanduser(p))
|
||||
f = lambda p: abspath(expanduser(p))
|
||||
return ':'.join(map(f, val.split(':')))
|
||||
|
||||
def PathListAllExist(key, val, env):
|
||||
|
|
@ -293,36 +299,35 @@ def PathListAllExist(key, val, env):
|
|||
if not isdir(path):
|
||||
raise SCons.Errors.UserError("Path does not exist: '%s'" % path)
|
||||
|
||||
global_sticky_opts_file = joinpath(build_root, 'options.global')
|
||||
global_sticky_vars_file = joinpath(build_root, 'variables.global')
|
||||
|
||||
global_sticky_opts = Options(global_sticky_opts_file, args=ARGUMENTS)
|
||||
global_sticky_vars = Variables(global_sticky_vars_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_sticky_vars.AddVariables(
|
||||
('CC', 'C compiler', environ.get('CC', env['CC'])),
|
||||
('CXX', 'C++ compiler', environ.get('CXX', env['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)
|
||||
)
|
||||
|
||||
|
||||
# base help text
|
||||
help_text = '''
|
||||
Usage: scons [scons options] [build options] [target(s)]
|
||||
|
||||
Global sticky options:
|
||||
'''
|
||||
|
||||
help_text += "Global sticky options:\n" \
|
||||
+ global_sticky_opts.GenerateHelpText(env)
|
||||
help_text += global_sticky_vars.GenerateHelpText(env)
|
||||
|
||||
# Update env with values from ARGUMENTS & file global_sticky_opts_file
|
||||
global_sticky_opts.Update(env)
|
||||
# Update env with values from ARGUMENTS & file global_sticky_vars_file
|
||||
global_sticky_vars.Update(env)
|
||||
|
||||
# Save sticky option settings back to current options file
|
||||
global_sticky_opts.Save(global_sticky_opts_file, env)
|
||||
# Save sticky variable settings back to current variables file
|
||||
global_sticky_vars.Save(global_sticky_vars_file, env)
|
||||
|
||||
# Parse EXTRAS option to build list of all directories where we're
|
||||
# Parse EXTRAS variable to build list of all directories where we're
|
||||
# look for sources etc. This list is exported as base_dir_list.
|
||||
base_dir = joinpath(ROOT, 'src')
|
||||
if env['EXTRAS']:
|
||||
|
|
@ -335,20 +340,13 @@ Export('extras_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
|
||||
env['GCC'] = read_command(env['CXX'] + ' --version').find('g++') >= 0
|
||||
env['SUNCC'] = read_command(env['CXX'] + ' -V').find('Sun C++') >= 0
|
||||
env['ICC'] = read_command(env['CXX'] + ' -V').find('Intel') >= 0
|
||||
if env['GCC'] + env['SUNCC'] + env['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')
|
||||
|
|
@ -390,7 +388,7 @@ if not env.has_key('SWIG'):
|
|||
Exit(1)
|
||||
|
||||
# Check for appropriate SWIG version
|
||||
swig_version = os.popen('swig -version').read().split()
|
||||
swig_version = read_command('swig -version').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':
|
||||
|
|
@ -470,9 +468,7 @@ 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]):
|
||||
if int(read_command('sysctl -n hw.cpu64bit_capable')[0]):
|
||||
env.Append(CCFLAGS='-arch x86_64')
|
||||
env.Append(CFLAGS='-arch x86_64')
|
||||
env.Append(LINKFLAGS='-arch x86_64')
|
||||
|
|
@ -504,32 +500,45 @@ if not conf:
|
|||
# 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
|
||||
|
||||
# Get brief Python version name (e.g., "python2.4") for locating
|
||||
# include & library files
|
||||
py_version_name = 'python' + sys.version[:3]
|
||||
py_getvar = sysconfig.get_config_var
|
||||
|
||||
# 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
|
||||
py_version = 'python' + py_getvar('VERSION')
|
||||
|
||||
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 = []
|
||||
# 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('-L' + py_getvar('LIBPL'))
|
||||
|
||||
py_libs = []
|
||||
for lib in py_getvar('LIBS').split() + py_getvar('SYSLIBS').split():
|
||||
if lib not in py_libs:
|
||||
py_libs.append(lib)
|
||||
py_libs.append('-l' + py_version)
|
||||
|
||||
env.Append(CPPPATH=py_includes)
|
||||
env.Append(LIBPATH=py_lib_path)
|
||||
#env.Append(LIBS=py_libs)
|
||||
|
||||
# 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:
|
||||
assert lib.startswith('-l')
|
||||
lib = lib[2:]
|
||||
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);'):
|
||||
|
|
@ -551,13 +560,16 @@ 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
|
||||
have_mysql = bool(mysql_config)
|
||||
|
||||
# Check MySQL version.
|
||||
if have_mysql:
|
||||
mysql_version = os.popen(mysql_config + ' --version').read()
|
||||
mysql_version = read_command(mysql_config + ' --version')
|
||||
min_mysql_version = '4.1'
|
||||
if compare_versions(mysql_version, min_mysql_version) < 0:
|
||||
print 'Warning: MySQL', min_mysql_version, 'or newer required.'
|
||||
|
|
@ -574,8 +586,17 @@ if have_mysql:
|
|||
# This seems to work in all versions
|
||||
mysql_config_libs = mysql_config + ' --libs'
|
||||
|
||||
######################################################################
|
||||
#
|
||||
# Finish the configuration
|
||||
#
|
||||
env = conf.Finish()
|
||||
|
||||
######################################################################
|
||||
#
|
||||
# Collect all non-global variables
|
||||
#
|
||||
|
||||
# Define the universe of supported ISAs
|
||||
all_isa_list = [ ]
|
||||
Export('all_isa_list')
|
||||
|
|
@ -585,18 +606,18 @@ all_cpu_list = [ ]
|
|||
default_cpus = [ ]
|
||||
Export('all_cpu_list', 'default_cpus')
|
||||
|
||||
# Sticky options get saved in the options file so they persist from
|
||||
# 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')
|
||||
# Non-sticky variables only apply to the current build.
|
||||
nonsticky_vars = Variables(args=ARGUMENTS)
|
||||
Export('nonsticky_vars')
|
||||
|
||||
# Walk the tree and execute all SConsopts scripts that wil add to the
|
||||
# above options
|
||||
# above variables
|
||||
for bdir in [ base_dir ] + extras_dir_list:
|
||||
for root, dirs, files in os.walk(bdir):
|
||||
if 'SConsopts' in files:
|
||||
|
|
@ -607,47 +628,37 @@ 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),
|
||||
sticky_vars.AddVariables(
|
||||
EnumVariable('TARGET_ISA', 'Target ISA', 'alpha', all_isa_list),
|
||||
BoolVariable('FULL_SYSTEM', 'Full-system support', False),
|
||||
ListVariable('CPU_MODELS', 'CPU models', default_cpus, all_cpu_list),
|
||||
BoolVariable('NO_FAST_ALLOC', 'Disable fast object allocator', False),
|
||||
BoolVariable('FAST_ALLOC_DEBUG', 'Enable fast object allocator debugging',
|
||||
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_MYSQL', 'Use MySQL for stats output', have_mysql),
|
||||
BoolVariable('USE_FENV', 'Use <fenv.h> IEEE mode control', have_fenv),
|
||||
BoolVariable('USE_CHECKER', 'Use checker for detailed CPU models', False),
|
||||
)
|
||||
|
||||
nonsticky_opts.AddOptions(
|
||||
BoolOption('update_ref', 'Update test reference outputs', False)
|
||||
nonsticky_vars.AddVariables(
|
||||
BoolVariable('update_ref', 'Update test reference outputs', 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).
|
||||
env.ExportVariables = ['FULL_SYSTEM', 'ALPHA_TLASER', 'USE_FENV', \
|
||||
'USE_MYSQL', 'NO_FAST_ALLOC', 'FAST_ALLOC_DEBUG', \
|
||||
'FAST_ALLOC_STATS', 'SS_COMPATIBLE_FP', \
|
||||
'USE_CHECKER', 'TARGET_ISA']
|
||||
|
||||
###################################################
|
||||
#
|
||||
|
|
@ -656,20 +667,20 @@ env.NoAction = Action(no_action, None)
|
|||
###################################################
|
||||
|
||||
# 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)
|
||||
|
|
@ -677,58 +688,32 @@ 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 })
|
||||
|
||||
|
||||
# libelf build is shared across all configs in the build root.
|
||||
env.SConscript('ext/libelf/SConscript',
|
||||
build_dir = joinpath(build_root, 'libelf'),
|
||||
variant_dir = joinpath(build_root, 'libelf'),
|
||||
exports = 'env')
|
||||
|
||||
# gzstream build is shared across all configs in the build root.
|
||||
env.SConscript('ext/gzstream/SConscript',
|
||||
build_dir = joinpath(build_root, 'gzstream'),
|
||||
variant_dir = joinpath(build_root, 'gzstream'),
|
||||
exports = 'env')
|
||||
|
||||
###################################################
|
||||
|
|
@ -738,19 +723,19 @@ env.SConscript('ext/gzstream/SConscript',
|
|||
###################################################
|
||||
|
||||
env['ALL_ISA_LIST'] = all_isa_list
|
||||
def make_switching_dir(dirname, switch_headers, env):
|
||||
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)
|
||||
bname = 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, isa.upper(), dname, isa, bname))
|
||||
cond = '#elif'
|
||||
f.write('#else\n#error "THE_ISA not set"\n#endif\n')
|
||||
f.close()
|
||||
|
|
@ -780,66 +765,66 @@ Export('make_switching_dir')
|
|||
# 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 = base_env.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)
|
||||
(build_root, variant_dir) = splitpath(variant_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
|
||||
# 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)
|
||||
mkdir(opt_dir)
|
||||
|
||||
# Get default build options from source tree. Options are
|
||||
# normally determined by name of $BUILD_DIR, but can be
|
||||
# Get default build variables from source tree. Variables are
|
||||
# normally determined by name of $VARIANT_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)
|
||||
default_vars_file = joinpath('build_opts',
|
||||
ARGUMENTS.get('default', variant_dir))
|
||||
if isfile(default_vars_file):
|
||||
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 %s" \
|
||||
% (current_vars_file, default_vars_file)
|
||||
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)
|
||||
nonsticky_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_text += "\nSticky variables for %s:\n" % variant_dir \
|
||||
+ sticky_vars.GenerateHelpText(env) \
|
||||
+ "\nNon-sticky variables for %s:\n" % variant_dir \
|
||||
+ nonsticky_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']:
|
||||
|
|
@ -848,29 +833,29 @@ for build_path in build_paths:
|
|||
if env['USE_MYSQL']:
|
||||
if not have_mysql:
|
||||
print "Warning: MySQL not available; " \
|
||||
"forcing USE_MYSQL to False in", build_dir + "."
|
||||
"forcing USE_MYSQL to False in", variant_dir + "."
|
||||
env['USE_MYSQL'] = False
|
||||
else:
|
||||
print "Compiling in", build_dir, "with MySQL support."
|
||||
print "Compiling in", variant_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')
|
||||
|
||||
# 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)
|
||||
|
|
|
|||
|
|
@ -87,7 +87,7 @@ ElfFile('libelf_convert.c')
|
|||
ElfFile('libelf_fsize.c')
|
||||
ElfFile('libelf_msize.c')
|
||||
|
||||
m4env = env.Copy()
|
||||
m4env = env.Clone()
|
||||
if env['GCC']:
|
||||
major,minor,dot = [ int(x) for x in env['CXXVERSION'].split('.')]
|
||||
if major >= 4:
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ Import('*')
|
|||
# Children need to see the environment
|
||||
Export('env')
|
||||
|
||||
build_env = dict([(opt, env[opt]) for opt in env.ExportOptions])
|
||||
build_env = dict([(opt, env[opt]) for opt in env.ExportVariables])
|
||||
|
||||
def sort_list(_list):
|
||||
"""return a sorted copy of '_list'"""
|
||||
|
|
@ -242,7 +242,7 @@ for extra_dir in extras_dir_list:
|
|||
build_dir = joinpath(env['BUILDDIR'], root[prefix_len:])
|
||||
SConscript(joinpath(root, 'SConscript'), build_dir=build_dir)
|
||||
|
||||
for opt in env.ExportOptions:
|
||||
for opt in env.ExportVariables:
|
||||
env.ConfigFile(opt)
|
||||
|
||||
########################################################################
|
||||
|
|
@ -353,25 +353,6 @@ depends = [ File(py_modules[dep]) for dep in module_depends ]
|
|||
# Commands for the basic automatically generated python files
|
||||
#
|
||||
|
||||
scons_dir = str(SCons.Node.FS.default_fs.SConstruct_dir)
|
||||
|
||||
hg_info = "Unknown"
|
||||
hg_demandimport = False
|
||||
try:
|
||||
if not exists(scons_dir) or not isdir(scons_dir) or \
|
||||
not exists(joinpath(scons_dir, ".hg")):
|
||||
raise ValueError(".hg directory not found")
|
||||
import subprocess
|
||||
output = subprocess.Popen("hg id -n -i -t -b".split(),
|
||||
stdout=subprocess.PIPE).communicate()[0]
|
||||
hg_info = output.strip()
|
||||
except ImportError, e:
|
||||
print "Mercurial not found"
|
||||
except ValueError, e:
|
||||
print e
|
||||
except Exception, e:
|
||||
print "Other mercurial exception: %s" % e
|
||||
|
||||
# Generate Python file containing a dict specifying the current
|
||||
# build_env flags.
|
||||
def makeDefinesPyFile(target, source, env):
|
||||
|
|
@ -381,7 +362,7 @@ def makeDefinesPyFile(target, source, env):
|
|||
print >>f, "hgRev = '%s'" % hg_info
|
||||
f.close()
|
||||
|
||||
defines_info = [ Value(build_env), Value(hg_info) ]
|
||||
defines_info = [ Value(build_env), Value(env['HG_INFO']) ]
|
||||
# Generate a file with all of the compile options in it
|
||||
env.Command('python/m5/defines.py', defines_info, makeDefinesPyFile)
|
||||
PySource('m5', 'python/m5/defines.py')
|
||||
|
|
@ -970,11 +951,11 @@ def makeEnv(label, objsfx, strip = False, **kwargs):
|
|||
libname = 'm5_' + label
|
||||
exename = 'm5.' + label
|
||||
|
||||
new_env = env.Copy(OBJSUFFIX=objsfx, SHOBJSUFFIX=objsfx + 's')
|
||||
new_env = env.Clone(OBJSUFFIX=objsfx, SHOBJSUFFIX=objsfx + 's')
|
||||
new_env.Label = label
|
||||
new_env.Append(**kwargs)
|
||||
|
||||
swig_env = new_env.Copy()
|
||||
swig_env = new_env.Clone()
|
||||
if env['GCC']:
|
||||
swig_env.Append(CCFLAGS='-Wno-uninitialized')
|
||||
swig_env.Append(CCFLAGS='-Wno-sign-compare')
|
||||
|
|
|
|||
|
|
@ -33,5 +33,5 @@ Import('*')
|
|||
all_isa_list.append('alpha')
|
||||
|
||||
# Alpha can be compiled with Turbolaser support instead of Tsunami
|
||||
sticky_opts.Add(BoolOption('ALPHA_TLASER',
|
||||
sticky_vars.Add(BoolVariable('ALPHA_TLASER',
|
||||
'Model Alpha TurboLaser platform (vs. Tsunami)', False))
|
||||
|
|
|
|||
Loading…
Reference in a new issue