X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=SConstruct;h=62d90b3593e49c05d47a4c66597d96fe191df901;hb=0e597e944ae0cf368df06235e832bc441cb4e022;hp=9bfd1d1c8ce58314051099339aad42f8ec7e455e;hpb=0e64e1be0fc1ec7586dfb2171585608f713bfc4e;p=gem5.git diff --git a/SConstruct b/SConstruct index 9bfd1d1c8..62d90b359 100755 --- a/SConstruct +++ b/SConstruct @@ -121,10 +121,43 @@ sys.path[1:1] = extra_python_paths from m5.util import compareVersions, readCommand -AddOption('--colors', dest='use_colors', action='store_true') -AddOption('--no-colors', dest='use_colors', action='store_false') -use_colors = GetOption('use_colors') +help_texts = { + "options" : "", + "global_vars" : "", + "local_vars" : "" +} + +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: + 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: @@ -166,63 +199,62 @@ main.AppendENVPath('PYTHONPATH', extra_python_paths) hgdir = main.root.Dir(".hg") mercurial_style_message = """ -You're missing the M5 style hook. -Please install the hook so we can ensure that all code fits a common style. - -All you'd need to do is add the following lines to your repository .hg/hgrc -or your personal .hgrc ----------------- - +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_style pre-qrefresh.style = python:style.check_style -""" % (main.root) +# End of SConstruct additions -mercurial_bin_not_found = """ -Mercurial binary cannot be found, unfortunately this means that we -cannot easily determine the version of M5 that you are running and -this makes error messages more difficult to collect. Please consider -installing mercurial if you choose to post an error message -""" +""" % (main.root.abspath) mercurial_lib_not_found = """ -Mercurial libraries cannot be found, ignoring style hook -If you are actually a M5 developer, please fix this and -run the style hook. It is important. +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. """ -hg_info = "Unknown" -if hgdir.exists(): - # 1) Grab repository revision if we know it. - cmd = "hg id -n -i -t -b" +# 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: - hg_info = readCommand(cmd, cwd=main.root.abspath).strip() - except OSError: - print mercurial_bin_not_found - - # 2) Ensure that the style hook is in place. - try: - ui = None - if ARGUMENTS.get('IGNORE_STYLE') != 'True': - from mercurial import ui - ui = ui.ui() + from mercurial import 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: print mercurial_lib_not_found - if ui is not None: - ui.readconfig(hgdir.File('hgrc').abspath) - style_hook = ui.config('hooks', 'pretxncommit.style', None) - - if not style_hook: - print mercurial_style_message + 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) -else: - print ".hg directory not found" -main['HG_INFO'] = hg_info ################################################### # @@ -241,30 +273,29 @@ 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 = [ normpath(joinpath(launch_dir, str(x))) for x in \ - COMMAND_LINE_TARGETS] -else: - # Default targets are relative to root of tree - abs_targets = [ normpath(joinpath(main.root.abspath, str(x))) for x in \ - 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. 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) @@ -303,64 +334,31 @@ main.SetOption('duplicate', 'soft-copy') # tree (not specific to a particular build like ALPHA_SE) # -# Variable validators & converters for global sticky variables -def PathListMakeAbsolute(val): - if not val: - return val - f = lambda p: abspath(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_vars_file = joinpath(build_root, 'variables.global') - -global_sticky_vars = Variables(global_sticky_vars_file, args=ARGUMENTS) -global_nonsticky_vars = Variables(args=ARGUMENTS) - -global_sticky_vars.AddVariables( +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'), ('M5_BUILD_CACHE', 'Cache built objects in this directory', False), - ('EXTRAS', 'Add Extra directories to the compilation', '', - PathListAllExist, PathListMakeAbsolute), - ) - -global_nonsticky_vars.AddVariables( - ('VERBOSE', 'Print full tool command lines', False), - ('update_ref', 'Update test reference outputs', False) + ('EXTRAS', 'Add extra directories to the compilation', '') ) - -# base help text -help_text = ''' -Usage: scons [scons options] [build options] [target(s)] - -Global sticky options: -''' - -# Update main environment with values from ARGUMENTS & global_sticky_vars_file -global_sticky_vars.Update(main) -global_nonsticky_vars.Update(main) - -help_text += global_sticky_vars.GenerateHelpText(main) -help_text += global_nonsticky_vars.GenerateHelpText(main) +# Update main environment with values from ARGUMENTS & global_vars_file +global_vars.Update(main) +help_texts["global_vars"] += global_vars.GenerateHelpText(main) # Save sticky variable settings back to current variables file -global_sticky_vars.Save(global_sticky_vars_file, main) +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 base_dir_list. +# look for sources etc. This list is exported as extras_dir_list. base_dir = main.srcdir.abspath if main['EXTRAS']: - extras_dir_list = main['EXTRAS'].split(':') + extras_dir_list = makePathListAbsolute(main['EXTRAS'].split(':')) else: extras_dir_list = [] @@ -452,7 +450,7 @@ class Transform(object): Export('Transform') -if main['VERBOSE']: +if GetOption('verbose'): def MakeAction(action, string, *args, **kwargs): return Action(action, *args, **kwargs) else: @@ -475,7 +473,8 @@ 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: +main['CLANG'] = CXX_V and CXX_V.find('clang') >= 0 +if main['GCC'] + main['SUNCC'] + main['ICC'] + main['CLANG'] > 1: print 'Error: How can we have two at the same time?' Exit(1) @@ -489,6 +488,7 @@ if main['GCC']: # 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) + main['GCC_VERSION'] = gcc_version 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.' @@ -502,6 +502,24 @@ elif main['SUNCC']: main.Append(CCFLAGS=['-library=stlport4']) main.Append(CCFLAGS=['-xar']) #main.Append(CCFLAGS=['-instances=semiexplicit']) +elif main['CLANG']: + clang_version_re = re.compile(".* version (\d+\.\d+)") + clang_version_match = clang_version_re.match(CXX_version) + if (clang_version_match): + clang_version = clang_version_match.groups()[0] + if compareVersions(clang_version, "2.9") < 0: + print 'Error: clang version 2.9 or newer required.' + print ' Installed version:', clang_version + Exit(1) + else: + print 'Error: Unable to determine clang version.' + Exit(1) + + main.Append(CCFLAGS=['-pipe']) + main.Append(CCFLAGS=['-fno-strict-aliasing']) + main.Append(CCFLAGS=['-Wall', '-Wno-sign-compare', '-Wundef']) + main.Append(CCFLAGS=['-Wno-tautological-compare']) + main.Append(CCFLAGS=['-Wno-self-assign']) else: print 'Error: Don\'t know what compiler options to use for your compiler.' print ' Please fix SConstruct and src/SConscript and try again.' @@ -664,10 +682,14 @@ if not py_getvar('Py_ENABLE_SHARED'): 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) + if not lib.startswith('-l'): + # Python requires some special flags to link (e.g. -framework + # common on OS X systems), assume appending preserves order + main.Append(LINKFLAGS=[lib]) + else: + lib = lib[2:] + if lib not in py_libs: + py_libs.append(lib) py_libs.append(py_version) main.Append(CPPPATH=py_includes) @@ -719,32 +741,6 @@ if not have_fenv: print "Warning: Header file not found." print " This host has no IEEE FP rounding mode control." -###################################################################### -# -# Check for mysql. -# -mysql_config = WhereIs('mysql_config') -have_mysql = bool(mysql_config) - -# Check MySQL version. -if have_mysql: - mysql_version = readCommand(mysql_config + ' --version') - min_mysql_version = '4.1' - if compareVersions(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' - ###################################################################### # # Finish the configuration @@ -801,23 +797,28 @@ Export('export_vars') # Walk the tree and execute all SConsopts scripts that wil add to the # 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() 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('FAST_ALLOC_DEBUG', 'Enable fast object allocator debugging', - 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', @@ -828,19 +829,16 @@ sticky_vars.AddVariables( 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_POSIX_CLOCK', 'Use POSIX Clocks', have_posix_clock), BoolVariable('USE_FENV', 'Use IEEE mode control', have_fenv), BoolVariable('USE_CHECKER', 'Use checker for detailed CPU models', False), BoolVariable('CP_ANNOTATE', 'Enable critical path annotation capability', False), - BoolVariable('RUBY', 'Build with Ruby', False), ) # These variables get exported to #defines in config/*.hh (see src/SConscript). -export_vars += ['FULL_SYSTEM', 'USE_FENV', 'USE_MYSQL', - 'NO_FAST_ALLOC', 'FAST_ALLOC_DEBUG', 'FAST_ALLOC_STATS', - 'SS_COMPATIBLE_FP', 'USE_CHECKER', 'TARGET_ISA', 'CP_ANNOTATE', - 'USE_POSIX_CLOCK' ] +export_vars += ['USE_FENV', 'NO_FAST_ALLOC', 'FORCE_FAST_ALLOC', + 'FAST_ALLOC_STATS', 'SS_COMPATIBLE_FP', 'USE_CHECKER', + 'TARGET_ISA', 'CP_ANNOTATE', 'USE_POSIX_CLOCK' ] ################################################### # @@ -859,13 +857,8 @@ def build_config_file(target, source, env): f.close() return None -# Generate the message to be printed when building the config file. -def build_config_file_string(target, source, env): - (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) +config_action = MakeAction(build_config_file, Transform("CONFIG H", 2)) # The emitter munges the source & target node lists to reflect what # we're really doing. @@ -961,22 +954,31 @@ for variant_path in variant_paths: # 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_vars_file = joinpath('build_opts', - ARGUMENTS.get('default', variant_dir)) - if isfile(default_vars_file): + # 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 variables file %s or %s" \ - % (current_vars_file, default_vars_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 variable settings to env sticky_vars.Update(env) - help_text += "\nSticky variables for %s:\n" % variant_dir \ + help_texts["local_vars"] += \ + "Build variables for %s:\n" % variant_dir \ + sticky_vars.GenerateHelpText(env) # Process variable settings. @@ -993,16 +995,6 @@ for variant_path in variant_paths: 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", variant_dir + "." - env['USE_MYSQL'] = False - else: - print "Compiling in", variant_dir, "with MySQL support." - env.ParseConfig(mysql_config_libs) - env.ParseConfig(mysql_config_include) - # Save sticky variable settings back to current variables file sticky_vars.Save(current_vars_file, env) @@ -1021,4 +1013,15 @@ for variant_path in variant_paths: 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 + +Global build variables: +%(global_vars)s + +%(local_vars)s +''' % help_texts)