X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=SConstruct;h=30f99c7b21703f148e6912d2d39fdd9641cb007a;hb=f44ddb94a6f72fe1ef04739817ee2102cee36c0f;hp=c51c7b28cdee19996c608102a5fb8269eafaa6f6;hpb=eed0795f3abf6da71ba62307ae29c975b4ad9246;p=gem5.git diff --git a/SConstruct b/SConstruct index c51c7b28c..30f99c7b2 100755 --- a/SConstruct +++ b/SConstruct @@ -1,6 +1,6 @@ # -*- mode:python -*- -# Copyright (c) 2013 ARM Limited +# Copyright (c) 2013, 2015, 2016 ARM Limited # All rights reserved. # # The license below extends only to copyright in the software and shall @@ -112,6 +112,7 @@ For more details, see: import itertools import os import re +import shutil import subprocess import sys @@ -194,6 +195,8 @@ AddLocalOption('--without-tcmalloc', dest='without_tcmalloc', help='Disable linking against tcmalloc') AddLocalOption('--with-ubsan', dest='with_ubsan', action='store_true', help='Build with Undefined Behavior Sanitizer if available') +AddLocalOption('--with-asan', dest='with_asan', action='store_true', + help='Build with Address Sanitizer if available') termcap = get_termcap(GetOption('use_colors')) @@ -206,13 +209,15 @@ termcap = get_termcap(GetOption('use_colors')) # export TERM so that clang reports errors in color use_vars = set([ 'AS', 'AR', 'CC', 'CXX', 'HOME', 'LD_LIBRARY_PATH', 'LIBRARY_PATH', 'PATH', 'PKG_CONFIG_PATH', 'PROTOC', - 'PYTHONPATH', 'RANLIB', 'SWIG', 'TERM' ]) + 'PYTHONPATH', 'RANLIB', 'TERM' ]) use_prefixes = [ - "M5", # M5 configuration (e.g., path to kernels) - "DISTCC_", # distcc (distributed compiler wrapper) configuration - "CCACHE_", # ccache (caching compiler wrapper) configuration - "CCC_", # clang static analyzer configuration + "ASAN_", # address sanitizer symbolizer path and settings + "CCACHE_", # ccache (caching compiler wrapper) configuration + "CCC_", # clang static analyzer configuration + "DISTCC_", # distcc (distributed compiler wrapper) configuration + "INCLUDE_SERVER_", # distcc pump server settings + "M5", # M5 configuration (e.g., path to kernels) ] use_env = {} @@ -236,11 +241,6 @@ if not ('CC' in main_dict_keys and 'CXX' in main_dict_keys): print "No C++ compiler installed (package g++ on Ubuntu and RedHat)" Exit(1) -# Check that swig is present -if not 'SWIG' in main_dict_keys: - print "swig is not installed (package swig on Ubuntu and RedHat)" - Exit(1) - # add useful python code PYTHONPATH so it can be used by subprocesses # as well main.AppendENVPath('PYTHONPATH', extra_python_paths) @@ -256,21 +256,40 @@ main.AppendENVPath('PYTHONPATH', extra_python_paths) hgdir = main.root.Dir(".hg") + +style_message = """ +You're missing the gem5 style hook, which automatically checks your code +against the gem5 style rules on %s. +This script will now install the hook in your %s. +Press enter to continue, or ctrl-c to abort: """ + 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. +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: """ + +git_style_message = """ +You're missing the gem5 style or commit message hook. These hooks help +to ensure that your code follows gem5's style rules on git commit. +This script will now install the hook in your .git/hooks/ directory. +Press enter to continue, or ctrl-c to abort: """ + +mercurial_style_upgrade_message = """ +Your Mercurial style hooks are not up-to-date. This script will now +try to automatically update them. A backup of your hgrc will be saved +in .hg/hgrc.old. 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 +hgstyle = %s/util/hgstyle.py [hooks] -pretxncommit.style = python:style.check_style -pre-qrefresh.style = python:style.check_style +pretxncommit.style = python:hgstyle.check_style +pre-qrefresh.style = python:hgstyle.check_style # End of SConstruct additions """ % (main.root.abspath) @@ -282,20 +301,58 @@ 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(): +# Skip this if --ignore-style was specified, there's no interactive +# terminal to prompt, or no recognized revision control system can be +# found. +ignore_style = GetOption('ignore_style') or not sys.stdin.isatty() + +# Try wire up Mercurial to the style hooks +if not ignore_style and hgdir.exists(): style_hook = True + style_hooks = tuple() + hgrc = hgdir.File('hgrc') + hgrc_old = hgdir.File('hgrc.old') try: 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) + ui.readconfig(hgrc.abspath) + style_hooks = (ui.config('hooks', 'pretxncommit.style', None), + ui.config('hooks', 'pre-qrefresh.style', None)) + style_hook = all(style_hooks) + style_extension = ui.config('extensions', 'style', None) except ImportError: print mercurial_lib_not_found - if not style_hook: + if "python:style.check_style" in style_hooks: + # Try to upgrade the style hooks + print mercurial_style_upgrade_message + # continue unless user does ctrl-c/ctrl-d etc. + try: + raw_input() + except: + print "Input exception, exiting scons.\n" + sys.exit(1) + shutil.copyfile(hgrc.abspath, hgrc_old.abspath) + re_style_hook = re.compile(r"^([^=#]+)\.style\s*=\s*([^#\s]+).*") + re_style_extension = re.compile("style\s*=\s*([^#\s]+).*") + old, new = open(hgrc_old.abspath, 'r'), open(hgrc.abspath, 'w') + for l in old: + m_hook = re_style_hook.match(l) + m_ext = re_style_extension.match(l) + if m_hook: + hook, check = m_hook.groups() + if check != "python:style.check_style": + print "Warning: %s.style is using a non-default " \ + "checker: %s" % (hook, check) + if hook not in ("pretxncommit", "pre-qrefresh"): + print "Warning: Updating unknown style hook: %s" % hook + + l = "%s.style = python:hgstyle.check_style\n" % hook + elif m_ext and m_ext.group(1) == style_extension: + l = "hgstyle = %s/util/hgstyle.py\n" % main.root.abspath + + new.write(l) + elif not style_hook: print mercurial_style_message, # continue unless user does ctrl-c/ctrl-d etc. try: @@ -306,13 +363,76 @@ if not GetOption('ignore_style') and hgdir.exists() and sys.stdin.isatty(): 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() + with open(hgrc_path, 'a') as f: + f.write(mercurial_style_hook) except: print "Error updating", hgrc_path sys.exit(1) +def install_git_style_hooks(): + try: + gitdir = Dir(readCommand( + ["git", "rev-parse", "--git-dir"]).strip("\n")) + except Exception, e: + print "Warning: Failed to find git repo directory: %s" % e + return + + git_hooks = gitdir.Dir("hooks") + def hook_exists(hook_name): + hook = git_hooks.File(hook_name) + return hook.exists() + + def hook_install(hook_name, script): + hook = git_hooks.File(hook_name) + if hook.exists(): + print "Warning: Can't install %s, hook already exists." % hook_name + return + + if hook.islink(): + print "Warning: Removing broken symlink for hook %s." % hook_name + os.unlink(hook.get_abspath()) + + if not git_hooks.exists(): + mkdir(git_hooks.get_abspath()) + git_hooks.clear() + + abs_symlink_hooks = git_hooks.islink() and \ + os.path.isabs(os.readlink(git_hooks.get_abspath())) + + # Use a relative symlink if the hooks live in the source directory, + # and the hooks directory is not a symlink to an absolute path. + if hook.is_under(main.root) and not abs_symlink_hooks: + script_path = os.path.relpath( + os.path.realpath(script.get_abspath()), + os.path.realpath(hook.Dir(".").get_abspath())) + else: + script_path = script.get_abspath() + + try: + os.symlink(script_path, hook.get_abspath()) + except: + print "Error updating git %s hook" % hook_name + raise + + if hook_exists("pre-commit") and hook_exists("commit-msg"): + return + + print git_style_message, + try: + raw_input() + except: + print "Input exception, exiting scons.\n" + sys.exit(1) + + git_style_script = File("util/git-pre-commit.py") + git_msg_script = File("ext/git-commit-msg") + + hook_install("pre-commit", git_style_script) + hook_install("commit-msg", git_msg_script) + +# Try to wire up git to the style hooks +if not ignore_style and main.root.Entry(".git").exists(): + install_git_style_hooks() ################################################### # @@ -399,7 +519,6 @@ global_vars = Variables(global_vars_file, args=ARGUMENTS) global_vars.AddVariables( ('CC', 'C compiler', environ.get('CC', main['CC'])), ('CXX', 'C++ compiler', environ.get('CXX', main['CXX'])), - ('SWIG', 'SWIG tool', environ.get('SWIG', main['SWIG'])), ('PROTOC', 'protoc tool', environ.get('PROTOC', 'protoc')), ('BATCH', 'Use batch pool for build and tests', False), ('BATCH_CMD', 'Batch pool submission command name', 'qdo'), @@ -520,9 +639,9 @@ else: 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['SHLINKCOMSTR'] = Transform("SHLINK", 0) main['RANLIBCOMSTR'] = Transform("RANLIB", 0) main['M4COMSTR'] = Transform("M4") main['SHCCCOMSTR'] = Transform("SHCC") @@ -553,15 +672,22 @@ if main['GCC'] or main['CLANG']: # As gcc and clang share many flags, do the common parts here main.Append(CCFLAGS=['-pipe']) main.Append(CCFLAGS=['-fno-strict-aliasing']) - # Enable -Wall and then disable the few warnings that we - # consistently violate - main.Append(CCFLAGS=['-Wall', '-Wno-sign-compare', '-Wundef']) - # We always compile using C++11, but only gcc >= 4.7 and clang 3.1 - # actually use that name, so we stick with c++0x - main.Append(CXXFLAGS=['-std=c++0x']) - # Add selected sanity checks from -Wextra - main.Append(CXXFLAGS=['-Wmissing-field-initializers', - '-Woverloaded-virtual']) + # Enable -Wall and -Wextra and then disable the few warnings that + # we consistently violate + main.Append(CCFLAGS=['-Wall', '-Wundef', '-Wextra', + '-Wno-sign-compare', '-Wno-unused-parameter']) + # We always compile using C++11 + main.Append(CXXFLAGS=['-std=c++11']) + if sys.platform.startswith('freebsd'): + main.Append(CCFLAGS=['-I/usr/local/include']) + main.Append(CXXFLAGS=['-I/usr/local/include']) + + main['FILTER_PSHLINKFLAGS'] = lambda x: str(x).replace(' -shared', '') + main['PSHLINKFLAGS'] = main.subst('${FILTER_PSHLINKFLAGS(SHLINKFLAGS)}') + main['PLINKFLAGS'] = main.subst('${LINKFLAGS}') + shared_partial_flags = ['-r', '-nostdlib'] + main.Append(PSHLINKFLAGS=shared_partial_flags) + main.Append(PLINKFLAGS=shared_partial_flags) else: print termcap.Yellow + termcap.Bold + 'Error' + termcap.Normal, print "Don't know what compiler options to use for your compiler." @@ -582,13 +708,12 @@ else: Exit(1) if main['GCC']: - # Check for a supported version of gcc. >= 4.6 is chosen for its + # Check for a supported version of gcc. >= 4.8 is chosen for its # level of c++11 support. See - # http://gcc.gnu.org/projects/cxx0x.html for details. 4.6 is also - # the first version with proper LTO support. + # http://gcc.gnu.org/projects/cxx0x.html for details. gcc_version = readCommand([main['CXX'], '-dumpversion'], exception=False) - if compareVersions(gcc_version, "4.6") < 0: - print 'Error: gcc version 4.6 or newer required.' + if compareVersions(gcc_version, "4.8") < 0: + print 'Error: gcc version 4.8 or newer required.' print ' Installed version:', gcc_version Exit(1) @@ -598,17 +723,22 @@ if main['GCC']: # to avoid performance penalties on certain AMD chips. Older # assemblers detect this as an error, "Error: expecting string # instruction after `rep'" - if compareVersions(gcc_version, "4.8") > 0: - as_version = readCommand([main['AS'], '-v', '/dev/null'], + as_version_raw = readCommand([main['AS'], '-v', '/dev/null', + '-o', '/dev/null'], exception=False).split() - if not as_version or compareVersions(as_version[-1], "2.23") < 0: - print termcap.Yellow + termcap.Bold + \ - 'Warning: This combination of gcc and binutils have' + \ - ' known incompatibilities.\n' + \ - ' If you encounter build problems, please update ' + \ - 'binutils to 2.23.' + \ - termcap.Normal + # version strings may contain extra distro-specific + # qualifiers, so play it safe and keep only what comes before + # the first hyphen + as_version = as_version_raw[-1].split('-')[0] if as_version_raw else None + + if not as_version or compareVersions(as_version, "2.23") < 0: + print termcap.Yellow + termcap.Bold + \ + 'Warning: This combination of gcc and binutils have' + \ + ' known incompatibilities.\n' + \ + ' If you encounter build problems, please update ' + \ + 'binutils to 2.23.' + \ + termcap.Normal # Make sure we warn if the user has requested to compile with the # Undefined Benahvior Sanitizer and this version of gcc does not @@ -635,30 +765,31 @@ if main['GCC']: main.Append(TCMALLOC_CCFLAGS=['-fno-builtin-malloc', '-fno-builtin-calloc', '-fno-builtin-realloc', '-fno-builtin-free']) + # add option to check for undeclared overrides + if compareVersions(gcc_version, "5.0") > 0: + main.Append(CCFLAGS=['-Wno-error=suggest-override']) + elif main['CLANG']: - # Check for a supported version of clang, >= 3.0 is needed to - # support similar features as gcc 4.6. See + # Check for a supported version of clang, >= 3.1 is needed to + # support similar features as gcc 4.8. See # http://clang.llvm.org/cxx_status.html for details clang_version_re = re.compile(".* version (\d+\.\d+)") clang_version_match = clang_version_re.search(CXX_version) if (clang_version_match): clang_version = clang_version_match.groups()[0] - if compareVersions(clang_version, "3.0") < 0: - print 'Error: clang version 3.0 or newer required.' + if compareVersions(clang_version, "3.1") < 0: + print 'Error: clang version 3.1 or newer required.' print ' Installed version:', clang_version Exit(1) else: print 'Error: Unable to determine clang version.' Exit(1) - # clang has a few additional warnings that we disable, - # tautological comparisons are allowed due to unsigned integers - # being compared to constants that happen to be 0, and extraneous + # clang has a few additional warnings that we disable, extraneous # parantheses are allowed due to Ruby's printing of the AST, # finally self assignments are allowed as the generated CPU code # is relying on this - main.Append(CCFLAGS=['-Wno-tautological-compare', - '-Wno-parentheses', + main.Append(CCFLAGS=['-Wno-parentheses', '-Wno-self-assign', # Some versions of libstdc++ (4.8?) seem to # use struct hash and class hash @@ -674,6 +805,10 @@ elif main['CLANG']: main.Append(CXXFLAGS=['-stdlib=libc++']) main.Append(LIBS=['c++']) + # On FreeBSD we need libthr. + if sys.platform.startswith('freebsd'): + main.Append(LIBS=['thr']) + else: print termcap.Yellow + termcap.Bold + 'Error' + termcap.Normal, print "Don't know what compiler options to use for your compiler." @@ -749,98 +884,21 @@ else: 'Warning: pkg-config could not get protobuf flags.' + \ termcap.Normal -# Check for 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 = readCommand([main['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': - print 'Error determining SWIG version.' - Exit(1) - -min_swig_version = '2.0.4' -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) - -# Check for known incompatibilities. The standard library shipped with -# gcc >= 4.9 does not play well with swig versions prior to 3.0 -if main['GCC'] and compareVersions(gcc_version, '4.9') >= 0 and \ - compareVersions(swig_version[2], '3.0') < 0: - print termcap.Yellow + termcap.Bold + \ - 'Warning: This combination of gcc and swig have' + \ - ' known incompatibilities.\n' + \ - ' If you encounter build problems, please update ' + \ - 'swig to 3.0 or later.' + \ - termcap.Normal - -# Set up SWIG flags & scanner -swig_flags=Split('-c++ -python -modern -templatereduce $_CPPINCFLAGS') -main.Append(SWIGFLAGS=swig_flags) # Check for 'timeout' from GNU coreutils. If present, regressions will # be run with a time limit. We require version 8.13 since we rely on # support for the '--foreground' option. -timeout_lines = readCommand(['timeout', '--version'], - exception='').splitlines() +if sys.platform.startswith('freebsd'): + timeout_lines = readCommand(['gtimeout', '--version'], + exception='').splitlines() +else: + timeout_lines = readCommand(['timeout', '--version'], + exception='').splitlines() # Get the first line and tokenize it timeout_version = timeout_lines[0].split() if timeout_lines else [] main['TIMEOUT'] = timeout_version and \ compareVersions(timeout_version[-1], '8.13') >= 0 -# filter out all existing swig scanners, they mess up the dependency -# stuff for some reason -scanners = [] -for scanner in main['SCANNERS']: - skeys = scanner.skeys - if skeys == '.i': - continue - - if isinstance(skeys, (list, tuple)) and '.i' in skeys: - continue - - scanners.append(scanner) - -# add the new swig scanner that we like better -from SCons.Scanner import ClassicCPP as CPPScanner -swig_inc_re = '^[ \t]*[%,#][ \t]*(?:include|import)[ \t]*(<|")([^>"]+)(>|")' -scanners.append(CPPScanner("SwigScan", [ ".i" ], "CPPPATH", swig_inc_re)) - -# replace the scanners list that has what we want -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 -# variables. This is needed for the autogenerated asm files that we -# use for embedding the python code. -def CheckLeading(context): - context.Message("Checking for leading underscore in global variables...") - # 1) Define a global variable called x from asm so the C compiler - # won't change the symbol at all. - # 2) Declare that variable. - # 3) Use the variable - # - # If the compiler prepends an underscore, this will successfully - # link because the external symbol 'x' will be called '_x' which - # was defined by the asm statement. If the compiler does not - # prepend an underscore, this will not successfully link because - # '_x' will have been defined by assembly, while the C portion of - # the code will be trying to use 'x' - ret = context.TryLink(''' - asm(".globl _x; _x: .byte 0"); - extern int x; - int main() { return x; } - ''', extension=".c") - context.env.Append(LEADING_UNDERSCORE=ret) - context.Result(ret) - return ret - # Add a custom Check function to test for structure members. def CheckMember(context, include, decl, member, include_quotes="<>"): context.Message("Checking for member %s in %s..." % @@ -867,14 +925,9 @@ conf = Configure(main, conf_dir = joinpath(build_root, '.scons_config'), log_file = joinpath(build_root, 'scons_config.log'), custom_tests = { - 'CheckLeading' : CheckLeading, 'CheckMember' : CheckMember, }) -# Check for leading underscores. Don't really need to worry either -# way so don't need to check the return code. -conf.CheckLeading() - # Check if we should compile a 64 bit binary on Mac OS X/Darwin try: import platform @@ -912,7 +965,8 @@ if main['M5_BUILD_CACHE']: print 'Using build cache located at', main['M5_BUILD_CACHE'] CacheDir(main['M5_BUILD_CACHE']) -if not GetOption('without_python'): +main['USE_PYTHON'] = not GetOption('without_python') +if main['USE_PYTHON']: # Find Python include and library directories for embedding the # interpreter. We rely on python-config to resolve the appropriate # includes and linker flags. ParseConfig does not seem to understand @@ -1009,6 +1063,26 @@ if not GetOption('without_tcmalloc'): "installing tcmalloc (libgoogle-perftools-dev package "\ "on Ubuntu or RedHat)." + termcap.Normal + +# Detect back trace implementations. The last implementation in the +# list will be used by default. +backtrace_impls = [ "none" ] + +if conf.CheckLibWithHeader(None, 'execinfo.h', 'C', + 'backtrace_symbols_fd((void*)0, 0, 0);'): + backtrace_impls.append("glibc") +elif conf.CheckLibWithHeader('execinfo', 'execinfo.h', 'C', + 'backtrace_symbols_fd((void*)0, 0, 0);'): + # NetBSD and FreeBSD need libexecinfo. + backtrace_impls.append("glibc") + main.Append(LIBS=['execinfo']) + +if backtrace_impls[-1] == "none": + default_backtrace_impl = "none" + print termcap.Yellow + termcap.Bold + \ + "No suitable back trace implementation found." + \ + termcap.Normal + if not have_posix_clock: print "Can't find library for POSIX clocks." @@ -1022,18 +1096,19 @@ if not have_fenv: # we rely on exists since version 2.6.36 of the kernel, but somehow # the KVM_API_VERSION does not reflect the change. We test for one of # the types as a fall back. -have_kvm = conf.CheckHeader('linux/kvm.h', '<>') and \ - conf.CheckTypeSize('struct kvm_xsave', '#include ') != 0 +have_kvm = conf.CheckHeader('linux/kvm.h', '<>') if not have_kvm: print "Info: Compatible header file not found, " \ "disabling KVM support." +# x86 needs support for xsave. We test for the structure here since we +# won't be able to run new tests by the time we know which ISA we're +# targeting. +have_kvm_xsave = conf.CheckTypeSize('struct kvm_xsave', + '#include ') != 0 + # Check if the requested target ISA is compatible with the host def is_isa_kvm_compatible(isa): - isa_comp_table = { - "arm" : ( "armv7l" ), - "x86" : ( "x86_64" ), - } try: import platform host_isa = platform.machine() @@ -1041,7 +1116,24 @@ def is_isa_kvm_compatible(isa): print "Warning: Failed to determine host ISA." return False - return host_isa in isa_comp_table.get(isa, []) + if not have_posix_timers: + print "Warning: Can not enable KVM, host seems to lack support " \ + "for POSIX timers" + return False + + if isa == "arm": + return host_isa in ( "armv7l", "aarch64" ) + elif isa == "x86": + if host_isa != "x86_64": + return False + + if not have_kvm_xsave: + print "KVM on x86 requires xsave support in kernel headers." + return False + + return True + else: + return False # Check if the exclude_host attribute is available. We want this to @@ -1063,7 +1155,9 @@ main = conf.Finish() # Define the universe of supported ISAs all_isa_list = [ ] +all_gpu_isa_list = [ ] Export('all_isa_list') +Export('all_gpu_isa_list') class CpuModel(object): '''The CpuModel class encapsulates everything the ISA parser needs to @@ -1119,9 +1213,11 @@ for bdir in [ base_dir ] + extras_dir_list: SConscript(joinpath(root, 'SConsopts')) all_isa_list.sort() +all_gpu_isa_list.sort() sticky_vars.AddVariables( EnumVariable('TARGET_ISA', 'Target ISA', 'alpha', all_isa_list), + EnumVariable('TARGET_GPU_ISA', 'Target GPU ISA', 'hsail', all_gpu_isa_list), ListVariable('CPU_MODELS', 'CPU models', sorted(n for n,m in CpuModel.dict.iteritems() if m.default), sorted(CpuModel.dict.keys())), @@ -1137,14 +1233,17 @@ sticky_vars.AddVariables( BoolVariable('USE_FENV', 'Use IEEE mode control', have_fenv), BoolVariable('CP_ANNOTATE', 'Enable critical path annotation capability', False), BoolVariable('USE_KVM', 'Enable hardware virtualized (KVM) CPU models', have_kvm), + BoolVariable('BUILD_GPU', 'Build the compute-GPU model', False), EnumVariable('PROTOCOL', 'Coherence protocol for Ruby', 'None', all_protocols), + EnumVariable('BACKTRACE_IMPL', 'Post-mortem dump implementation', + backtrace_impls[-1], backtrace_impls) ) # These variables get exported to #defines in config/*.hh (see src/SConscript). -export_vars += ['USE_FENV', 'SS_COMPATIBLE_FP', 'TARGET_ISA', 'CP_ANNOTATE', - 'USE_POSIX_CLOCK', 'USE_KVM', 'PROTOCOL', 'HAVE_PROTOBUF', - 'HAVE_PERF_ATTR_EXCLUDE_HOST'] +export_vars += ['USE_FENV', 'SS_COMPATIBLE_FP', 'TARGET_ISA', 'TARGET_GPU_ISA', + 'CP_ANNOTATE', 'USE_POSIX_CLOCK', 'USE_KVM', 'PROTOCOL', + 'HAVE_PROTOBUF', 'HAVE_PERF_ATTR_EXCLUDE_HOST'] ################################################### # @@ -1187,68 +1286,74 @@ config_builder = Builder(emitter = config_emitter, action = config_action) main.Append(BUILDERS = { 'ConfigFile' : config_builder }) -# libelf build is shared across all configs in the build root. -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')) - -# libfdt build is shared across all configs in the build root. -main.SConscript('ext/libfdt/SConscript', - variant_dir = joinpath(build_root, 'libfdt')) - -# fputils build is shared across all configs in the build root. -main.SConscript('ext/fputils/SConscript', - variant_dir = joinpath(build_root, 'fputils')) - -# DRAMSim2 build is shared across all configs in the build root. -main.SConscript('ext/dramsim2/SConscript', - variant_dir = joinpath(build_root, 'dramsim2')) +################################################### +# +# Builders for static and shared partially linked object files. +# +################################################### -# DRAMPower build is shared across all configs in the build root. -main.SConscript('ext/drampower/SConscript', - variant_dir = joinpath(build_root, 'drampower')) +partial_static_builder = Builder(action=SCons.Defaults.LinkAction, + src_suffix='$OBJSUFFIX', + src_builder=['StaticObject', 'Object'], + LINKFLAGS='$PLINKFLAGS', + LIBS='') + +def partial_shared_emitter(target, source, env): + for tgt in target: + tgt.attributes.shared = 1 + return (target, source) +partial_shared_builder = Builder(action=SCons.Defaults.ShLinkAction, + emitter=partial_shared_emitter, + src_suffix='$SHOBJSUFFIX', + src_builder='SharedObject', + SHLINKFLAGS='$PSHLINKFLAGS', + LIBS='') + +main.Append(BUILDERS = { 'PartialShared' : partial_shared_builder, + 'PartialStatic' : partial_static_builder }) + +# builds in ext are shared across all configs in the build root. +ext_dir = abspath(joinpath(str(main.root), 'ext')) +for root, dirs, files in os.walk(ext_dir): + if 'SConscript' in files: + build_dir = os.path.relpath(root, ext_dir) + main.SConscript(joinpath(root, 'SConscript'), + variant_dir=joinpath(build_root, build_dir)) + +main.Prepend(CPPPATH=Dir('ext/pybind11/include/')) ################################################### # -# This function is used to set up a directory with switching headers +# This builder and wrapper method are used to set up a directory with +# switching headers. Those are headers which are in a generic location and +# that include more specific headers from a directory chosen at build time +# based on the current build settings. # ################################################### -main['ALL_ISA_LIST'] = all_isa_list -all_isa_deps = {} -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]) - isa = env['TARGET_ISA'].lower() - try: - f = open(fname, 'w') - print >>f, '#include "%s/%s/%s"' % (dname, isa, basename(fname)) - f.close() - except IOError: - print "Failed to create %s" % fname - raise +def build_switching_header(target, source, env): + path = str(target[0]) + subdir = str(source[0]) + dp, fp = os.path.split(path) + dp = os.path.relpath(os.path.realpath(dp), + os.path.realpath(env['BUILDDIR'])) + with open(path, 'w') as hdr: + print >>hdr, '#include "%s/%s/%s"' % (dp, subdir, fp) - # 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 = MakeAction(gen_switch_hdr, - Transform("GENERATE"), varlist=['ALL_ISA_LIST']) +switching_header_action = MakeAction(build_switching_header, + Transform('GENERATE')) - # Instantiate actions for each header - for hdr in switch_headers: - env.Command(hdr, [], switch_hdr_action) +switching_header_builder = Builder(action=switching_header_action, + source_factory=Value, + single_source=True) - isa_target = Dir('.').up().name.lower().replace('_', '-') - env['PHONY_BASE'] = '#'+isa_target - all_isa_deps[isa_target] = None +main.Append(BUILDERS = { 'SwitchingHeader': switching_header_builder }) -Export('make_switching_dir') +def switching_headers(self, headers, source): + for header in headers: + self.SwitchingHeader(header, source) + +main.AddMethod(switching_headers, 'SwitchingHeaders') # all-isas -> all-deps -> all-environs -> all_targets main.Alias('#all-isas', []) @@ -1280,6 +1385,11 @@ BUILD_TARGETS[:] = ['#all-targets'] # ################################################### +def variant_name(path): + return os.path.basename(path).lower().replace('_', '-') +main['variant_name'] = variant_name +main['VARIANT_NAME'] = '${variant_name(BUILDDIR)}' + for variant_path in variant_paths: if not GetOption('silent'): print "Building in", variant_path @@ -1357,15 +1467,14 @@ for variant_path in variant_paths: if not have_kvm: print "Warning: Can not enable KVM, host seems to lack KVM support" env['USE_KVM'] = False - elif not have_posix_timers: - print "Warning: Can not enable KVM, host seems to lack support " \ - "for POSIX timers" - env['USE_KVM'] = False elif not is_isa_kvm_compatible(env['TARGET_ISA']): print "Info: KVM support disabled due to unsupported host and " \ "target ISA combination" env['USE_KVM'] = False + if env['BUILD_GPU']: + env.Append(CPPDEFINES=['BUILD_GPU']) + # Warn about missing optional functionality if env['USE_KVM']: if not main['HAVE_PERF_ATTR_EXCLUDE_HOST']: @@ -1390,6 +1499,8 @@ def pairwise(iterable): b.next() return itertools.izip(a, b) +variant_names = [variant_name(path) for path in variant_paths] + # Create false dependencies so SCons will parse ISAs, establish # dependencies, and setup the build Environments serially. Either # SCons (likely) and/or our SConscripts (possibly) cannot cope with -j @@ -1398,7 +1509,7 @@ def pairwise(iterable): # Every time I tried to remove this, builds would fail in some # creative new way. So, don't do that. You'll want to, though, because # tests/SConscript takes a long time to make its Environments. -for t1, t2 in pairwise(sorted(all_isa_deps.iterkeys())): +for t1, t2 in pairwise(sorted(variant_names)): main.Depends('#%s-deps' % t2, '#%s-deps' % t1) main.Depends('#%s-environs' % t2, '#%s-environs' % t1)