diff options
| -rw-r--r-- | SConstruct | 503 | ||||
| -rw-r--r-- | ext/libelf/SConscript | 2 | ||||
| -rw-r--r-- | src/SConscript | 29 | ||||
| -rw-r--r-- | src/arch/alpha/SConsopts | 2 |
4 files changed, 251 insertions, 285 deletions
diff --git a/SConstruct b/SConstruct index 6894ac05c..0b417ea88 100644 --- a/SConstruct +++ b/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 + +py_getvar = sysconfig.get_config_var -# Get brief Python version name (e.g., "python2.4") for locating -# include & library files -py_version_name = 'python' + sys.version[:3] +py_version = 'python' + py_getvar('VERSION') -# 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_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) - - # 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) + 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) diff --git a/ext/libelf/SConscript b/ext/libelf/SConscript index 18d1100a4..5e3038317 100644 --- a/ext/libelf/SConscript +++ b/ext/libelf/SConscript @@ -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: diff --git a/src/SConscript b/src/SConscript index 894a08df9..c02bf239d 100644 --- a/src/SConscript +++ b/src/SConscript @@ -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') diff --git a/src/arch/alpha/SConsopts b/src/arch/alpha/SConsopts index 633eeb06f..b418e27c8 100644 --- a/src/arch/alpha/SConsopts +++ b/src/arch/alpha/SConsopts @@ -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)) |