#
###################################################
-from __future__ import print_function
-
# Global Python includes
import atexit
import itertools
AddOption('--ignore-style', action='store_true',
help='Disable style checking hooks')
AddOption('--gold-linker', action='store_true', help='Use the gold linker')
+AddOption('--no-compress-debug', action='store_true',
+ help="Don't compress debug info in build files")
AddOption('--no-lto', action='store_true',
help='Disable Link-Time Optimization for fast')
-AddOption('--force-lto', action='store_true',
- help='Use Link-Time Optimization instead of partial linking' +
- ' when the compiler doesn\'t support using them together.')
AddOption('--verbose', action='store_true',
help='Print full tool command lines')
AddOption('--without-python', action='store_true',
help='Build systemc tests')
from gem5_scons import Transform, error, warning, summarize_warnings
-
-if GetOption('no_lto') and GetOption('force_lto'):
- error('--no-lto and --force-lto are mutually exclusive')
+import gem5_scons
########################################################################
#
#
########################################################################
-main = Environment()
+main = Environment(tools=['default', 'git'])
from gem5_scons.util import get_termcap
termcap = get_termcap()
('MARSHAL_CCFLAGS_EXTRA', 'Extra C and C++ marshal compiler flags', ''),
('MARSHAL_LDFLAGS_EXTRA', 'Extra marshal linker flags', ''),
('PYTHON_CONFIG', 'Python config binary to use',
- [ 'python2.7-config', 'python-config', 'python3-config' ]),
+ [ 'python3-config', 'python-config']
+ ),
('PROTOC', 'protoc tool', environ.get('PROTOC', 'protoc')),
('BATCH', 'Use batch pool for build and tests', False),
('BATCH_CMD', 'Batch pool submission command name', 'qdo'),
# Parse EXTRAS variable to build list of all directories where we're
# look for sources etc. This list is exported as extras_dir_list.
-base_dir = main.srcdir.abspath
+base_dir = Dir('#src').abspath
if main['EXTRAS']:
extras_dir_list = makePathListAbsolute(main['EXTRAS'].split(':'))
else:
# compiler we're using.
main['TCMALLOC_CCFLAGS'] = []
+# Platform-specific configuration. Note again that we assume that all
+# builds under a given build root run on the same host platform.
+conf = gem5_scons.Configure(main)
+
CXX_version = readCommand([main['CXX'],'--version'], exception=False)
CXX_V = readCommand([main['CXX'],'-V'], exception=False)
# 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'])
+ # We always compile using C++14
+ main.Append(CXXFLAGS=['-std=c++14'])
if sys.platform.startswith('freebsd'):
main.Append(CCFLAGS=['-I/usr/local/include'])
main.Append(CXXFLAGS=['-I/usr/local/include'])
- # On Mac OS X/Darwin the default linker doesn't support the
- # option --as-needed
- if sys.platform != "darwin":
- main.Append(LINKFLAGS='-Wl,--as-needed')
- main['FILTER_PSHLINKFLAGS'] = lambda x: str(x).replace(' -shared', '')
- main['PSHLINKFLAGS'] = main.subst('${FILTER_PSHLINKFLAGS(SHLINKFLAGS)}')
+ conf.CheckLinkFlag('-Wl,--as-needed')
if GetOption('gold_linker'):
main.Append(LINKFLAGS='-fuse-ld=gold')
- main['PLINKFLAGS'] = main.get('LINKFLAGS')
- shared_partial_flags = ['-r', '-nostdlib']
- main.Append(PSHLINKFLAGS=shared_partial_flags)
- main.Append(PLINKFLAGS=shared_partial_flags)
# Treat warnings as errors but white list some warnings that we
# want to allow (e.g., deprecation warnings).
main['GCC_VERSION'] = gcc_version
- # Incremental linking with LTO is currently broken in gcc versions
- # 4.9 and above. A version where everything works completely hasn't
- # yet been identified.
- #
- # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67548
- main['BROKEN_INCREMENTAL_LTO'] = True
-
- if compareVersions(gcc_version, '6.0') >= 0:
- # gcc versions 6.0 and greater accept an -flinker-output flag which
- # selects what type of output the linker should generate. This is
- # necessary for incremental lto to work, but is also broken in
- # current versions of gcc. It may not be necessary in future
- # versions. We add it here since it might be, and as a reminder that
- # it exists. It's excluded if lto is being forced.
- #
- # https://gcc.gnu.org/gcc-6/changes.html
- # https://gcc.gnu.org/ml/gcc-patches/2015-11/msg03161.html
- # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69866
- if not GetOption('force_lto'):
- main.Append(PSHLINKFLAGS='-flinker-output=rel')
- main.Append(PLINKFLAGS='-flinker-output=rel')
-
- disable_lto = GetOption('no_lto')
- if not disable_lto and main.get('BROKEN_INCREMENTAL_LTO', False) and \
- not GetOption('force_lto'):
- warning('Your compiler doesn\'t support incremental linking and lto '
- 'at the same time, so lto is being disabled. To force lto on '
- 'anyway, use the --force-lto option. That will disable '
- 'partial linking.')
- disable_lto = True
-
# Add the appropriate Link-Time Optimization (LTO) flags
# unless LTO is explicitly turned off. Note that these flags
# are only used by the fast target.
- if not disable_lto:
+ if not GetOption('no_lto'):
# Pass the LTO flag when compiling to produce GIMPLE
# output, we merely create the flags here and only append
# them later
# interchangeably.
'-Wno-mismatched-tags',
])
- if sys.platform != "darwin" and \
- compareVersions(clang_version, "10.0") >= 0:
- main.Append(CCFLAGS=['-Wno-c99-designator'])
-
- if compareVersions(clang_version, "8.0") >= 0:
- main.Append(CCFLAGS=['-Wno-defaulted-function-deleted'])
+ conf.CheckCxxFlag('-Wno-c99-designator')
+ conf.CheckCxxFlag('-Wno-defaulted-function-deleted')
main.Append(TCMALLOC_CCFLAGS=['-fno-builtin'])
main.Append(CCFLAGS=["-Wno-uninitialized"])
-have_pkg_config = readCommand(['pkg-config', '--version'], exception='')
+have_pkg_config = main.Detect('pkg-config')
# Check for the protobuf compiler
+main['HAVE_PROTOC'] = False
+protoc_version = []
try:
- main['HAVE_PROTOC'] = True
protoc_version = readCommand([main['PROTOC'], '--version']).split()
-
- # First two words should be "libprotoc x.y.z"
- if len(protoc_version) < 2 or protoc_version[0] != 'libprotoc':
- warning('Protocol buffer compiler (protoc) not found.\n'
- 'Please install protobuf-compiler for tracing support.')
- main['HAVE_PROTOC'] = False
- else:
- # Based on the availability of the compress stream wrappers,
- # require 2.1.0
- min_protoc_version = '2.1.0'
- if compareVersions(protoc_version[1], min_protoc_version) < 0:
- warning('protoc version', min_protoc_version,
- 'or newer required.\n'
- 'Installed version:', protoc_version[1])
- main['HAVE_PROTOC'] = False
- else:
- # Attempt to determine the appropriate include path and
- # library path using pkg-config, that means we also need to
- # check for pkg-config. Note that it is possible to use
- # protobuf without the involvement of pkg-config. Later on we
- # check go a library config check and at that point the test
- # will fail if libprotobuf cannot be found.
- if have_pkg_config:
- try:
- # Attempt to establish what linking flags to add for
- # protobuf
- # using pkg-config
- main.ParseConfig(
- 'pkg-config --cflags --libs-only-L protobuf')
- except:
- warning('pkg-config could not get protobuf flags.')
except Exception as e:
warning('While checking protoc version:', str(e))
- main['HAVE_PROTOC'] = False
-
-# 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.
-if sys.platform.startswith('freebsd'):
- timeout_lines = readCommand(['gtimeout', '--version'],
- exception='').splitlines()
+
+# Based on the availability of the compress stream wrappers, require 2.1.0.
+min_protoc_version = '2.1.0'
+
+# First two words should be "libprotoc x.y.z"
+if len(protoc_version) < 2 or protoc_version[0] != 'libprotoc':
+ warning('Protocol buffer compiler (protoc) not found.\n'
+ 'Please install protobuf-compiler for tracing support.')
+elif compareVersions(protoc_version[1], min_protoc_version) < 0:
+ warning('protoc version', min_protoc_version, 'or newer required.\n'
+ 'Installed version:', protoc_version[1])
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
-
-# 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..." %
- (member, decl))
- text = """
-#include %(header)s
-int main(){
- %(decl)s test;
- (void)test.%(member)s;
- return 0;
-};
-""" % { "header" : include_quotes[0] + include + include_quotes[1],
- "decl" : decl,
- "member" : member,
- }
-
- ret = context.TryCompile(text, extension=".cc")
- context.Result(ret)
- return ret
+ # Attempt to determine the appropriate include path and
+ # library path using pkg-config, that means we also need to
+ # check for pkg-config. Note that it is possible to use
+ # protobuf without the involvement of pkg-config. Later on we
+ # check go a library config check and at that point the test
+ # will fail if libprotobuf cannot be found.
+ if have_pkg_config:
+ conf.CheckPkgConfig('protobuf', '--cflags', '--libs-only-L')
+ main['HAVE_PROTOC'] = True
-# Platform-specific configuration. Note again that we assume that all
-# builds under a given build root run on the same host platform.
-conf = Configure(main,
- conf_dir = joinpath(build_root, '.scons_config'),
- log_file = joinpath(build_root, 'scons_config.log'),
- custom_tests = {
- 'CheckMember' : CheckMember,
- })
-
-# Check if we should compile a 64 bit binary on Mac OS X/Darwin
-try:
- import platform
- uname = platform.uname()
- if uname[0] == 'Darwin' and compareVersions(uname[2], '9.0.0') >= 0:
- if int(readCommand('sysctl -n hw.cpu64bit_capable')[0]):
- main.Append(CCFLAGS=['-arch', 'x86_64'])
- main.Append(CFLAGS=['-arch', 'x86_64'])
- main.Append(LINKFLAGS=['-arch', 'x86_64'])
- main.Append(ASFLAGS=['-arch', 'x86_64'])
-except:
- pass
-# Recent versions of scons substitute a "Null" object for Configure()
-# when configuration isn't necessary, e.g., if the "--help" option is
-# present. Unfortuantely this Null object always returns false,
-# breaking all our configuration checks. We replace it with our own
-# more optimistic null object that returns True instead.
-if not conf:
- def NullCheck(*args, **kwargs):
- return True
-
- class NullConf:
- def __init__(self, env):
- self.env = env
- def Finish(self):
- return self.env
- def __getattr__(self, mname):
- return NullCheck
-
- conf = NullConf(main)
# Cache build files in the supplied directory.
if main['M5_BUILD_CACHE']:
print('Using build cache located at', main['M5_BUILD_CACHE'])
CacheDir(main['M5_BUILD_CACHE'])
+if not GetOption('no_compress_debug'):
+ if not conf.CheckCxxFlag('-gz'):
+ warning("Can't enable object file debug section compression")
+ if not conf.CheckLinkFlag('-gz'):
+ warning("Can't enable executable debug section compression")
+
main['USE_PYTHON'] = not GetOption('without_python')
if main['USE_PYTHON']:
# Find Python include and library directories for embedding the
main['PYTHON_CONFIG'])
print("Info: Using Python config: %s" % (python_config, ))
+
py_includes = readCommand([python_config, '--includes'],
exception='').split()
py_includes = list(filter(
if not conf.CheckLib(lib):
error("Can't find library %s required by python." % lib)
-main.Prepend(CPPPATH=Dir('ext/pybind11/include/'))
-# Bare minimum environment that only includes python
-marshal_env = main.Clone()
-marshal_env.Append(CCFLAGS='$MARSHAL_CCFLAGS_EXTRA')
-marshal_env.Append(LINKFLAGS='$MARSHAL_LDFLAGS_EXTRA')
+ main.Prepend(CPPPATH=Dir('ext/pybind11/include/'))
+
+ marshal_env = main.Clone()
+
+ # Bare minimum environment that only includes python
+ marshal_env.Append(CCFLAGS='$MARSHAL_CCFLAGS_EXTRA')
+ marshal_env.Append(LINKFLAGS='$MARSHAL_LDFLAGS_EXTRA')
+
+ py_version = conf.CheckPythonLib()
+ if not py_version:
+ error("Can't find a working Python installation")
+
+ # Found a working Python installation. Check if it meets minimum
+ # requirements.
+ if py_version[0] < 3 or \
+ (py_version[0] == 3 and py_version[1] < 6):
+ error('Python version too old. Version 3.6 or newer is required.')
+ elif py_version[0] > 3:
+ warning('Python version too new. Python 3 expected.')
# On Solaris you need to use libsocket for socket ops
-if not conf.CheckLibWithHeader(None, 'sys/socket.h', 'C++', 'accept(0,0,0);'):
- if not conf.CheckLibWithHeader('socket', 'sys/socket.h',
- 'C++', 'accept(0,0,0);'):
- error("Can't find library with socket calls (e.g. accept()).")
+if not conf.CheckLibWithHeader(
+ [None, 'socket'], 'sys/socket.h', 'C++', 'accept(0,0,0);'):
+ error("Can't find library with socket calls (e.g. accept()).")
# Check for zlib. If the check passes, libz will be automatically
# added to the LIBS environment variable.
# Check for librt.
have_posix_clock = \
- conf.CheckLibWithHeader(None, 'time.h', 'C',
- 'clock_nanosleep(0,0,NULL,NULL);') or \
- conf.CheckLibWithHeader('rt', 'time.h', 'C',
+ conf.CheckLibWithHeader([None, 'rt'], 'time.h', 'C',
'clock_nanosleep(0,0,NULL,NULL);')
+if not have_posix_clock:
+ warning("Can't find library for POSIX clocks.")
have_posix_timers = \
conf.CheckLibWithHeader([None, 'rt'], [ 'time.h', 'signal.h' ], 'C',
"on Ubuntu or RedHat).")
-# Detect back trace implementations. The last implementation in the
-# list will be used by default.
-backtrace_impls = [ "none" ]
-
-backtrace_checker = 'char temp;' + \
- ' backtrace_symbols_fd((void*)&temp, 0, 0);'
-if conf.CheckLibWithHeader(None, 'execinfo.h', 'C', backtrace_checker):
- backtrace_impls.append("glibc")
-elif conf.CheckLibWithHeader('execinfo', 'execinfo.h', 'C',
- backtrace_checker):
- # NetBSD and FreeBSD need libexecinfo.
- backtrace_impls.append("glibc")
- main.Append(LIBS=['execinfo'])
-
-if backtrace_impls[-1] == "none":
- default_backtrace_impl = "none"
+if conf.CheckLibWithHeader([None, 'execinfo'], 'execinfo.h', 'C',
+ 'char temp; backtrace_symbols_fd((void *)&temp, 0, 0);'):
+ main['BACKTRACE_IMPL'] = 'glibc'
+else:
+ main['BACKTRACE_IMPL'] = 'none'
warning("No suitable back trace implementation found.")
-if not have_posix_clock:
- warning("Can't find library for POSIX clocks.")
-
# Check for <fenv.h> (C99 FP environment control)
have_fenv = conf.CheckHeader('fenv.h', '<>')
if not have_fenv:
if not have_tuntap:
print("Info: Compatible header file <linux/if_tun.h> not found.")
-# 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 <linux/kvm.h>') != 0
-
-# Check if the requested target ISA is compatible with the host
-def is_isa_kvm_compatible(isa):
- try:
- import platform
- host_isa = platform.machine()
- except:
- warning("Failed to determine host ISA.")
- return False
-
- if not have_posix_timers:
- 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:
- warning("KVM on x86 requires xsave support in kernel headers.")
- return False
+# Determine what ISA KVM can support on this host.
+kvm_isa = None
+host_isa = None
+try:
+ import platform
+ host_isa = platform.machine()
+except:
+ pass
- return True
+if not host_isa:
+ warning("Failed to determine host ISA.")
+elif not have_posix_timers:
+ warning("Cannot enable KVM, host seems to lack support for POSIX timers")
+elif host_isa in ('armv7l', 'aarch64'):
+ kvm_isa = 'arm'
+elif host_isa == 'x86_64':
+ if conf.CheckTypeSize('struct kvm_xsave', '#include <linux/kvm.h>') != 0:
+ kvm_isa = 'x86'
else:
- return False
+ warning("KVM on x86 requires xsave support in kernel headers.")
# Check if the exclude_host attribute is available. We want this to
main['HAVE_PERF_ATTR_EXCLUDE_HOST'] = conf.CheckMember(
'linux/perf_event.h', 'struct perf_event_attr', 'exclude_host')
-def check_hdf5():
- return \
- conf.CheckLibWithHeader('hdf5', 'hdf5.h', 'C',
- 'H5Fcreate("", 0, 0, 0);') and \
- conf.CheckLibWithHeader('hdf5_cpp', 'H5Cpp.h', 'C++',
- 'H5::H5File("", 0);')
-
-def check_hdf5_pkg(name):
- print("Checking for %s using pkg-config..." % name, end="")
- if not have_pkg_config:
- print(" pkg-config not found")
- return False
-
- try:
- main.ParseConfig('pkg-config --cflags-only-I --libs-only-L %s' % name)
- print(" yes")
- return True
- except:
- print(" no")
- return False
-
# Check if there is a pkg-config configuration for hdf5. If we find
# it, setup the environment to enable linking and header inclusion. We
# don't actually try to include any headers or link with hdf5 at this
# stage.
-if not check_hdf5_pkg('hdf5-serial'):
- check_hdf5_pkg('hdf5')
+if have_pkg_config:
+ conf.CheckPkgConfig(['hdf5-serial', 'hdf5'],
+ '--cflags-only-I', '--libs-only-L')
# Check if the HDF5 libraries can be found. This check respects the
# include path and library path provided by pkg-config. We perform
# this check even if there isn't a pkg-config configuration for hdf5
# since some installations don't use pkg-config.
-have_hdf5 = check_hdf5()
+have_hdf5 = \
+ conf.CheckLibWithHeader('hdf5', 'hdf5.h', 'C',
+ 'H5Fcreate("", 0, 0, 0);') and \
+ conf.CheckLibWithHeader('hdf5_cpp', 'H5Cpp.h', 'C++',
+ 'H5::H5File("", 0);')
if not have_hdf5:
- print("Warning: Couldn't find any HDF5 C++ libraries. Disabling")
- print(" HDF5 support.")
+ warning("Couldn't find any HDF5 C++ libraries. Disabling HDF5 support.")
######################################################################
#
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),
('NUMBER_BITS_PER_SET', 'Max elements in set (default 64)',
64),
BoolVariable('USE_HDF5', 'Enable the HDF5 support', have_hdf5),
# value of the variable.
def build_config_file(target, source, env):
(variable, value) = [s.get_contents().decode('utf-8') for s in source]
- with open(str(target[0]), 'w') as f:
+ with open(str(target[0].abspath), 'w') as f:
print('#define', variable, value, file=f)
return None
# extract variable name from Builder arg
variable = str(target[0])
# True target is config header file
- target = joinpath('config', variable.lower() + '.hh')
+ target = Dir('config').File(variable.lower() + '.hh')
val = env[variable]
if isinstance(val, bool):
# Force value to 0/1
val = '"' + val + '"'
# Sources are variable name & value (packaged in SCons Value nodes)
- return ([target], [Value(variable), Value(val)])
+ return [target], [Value(variable), Value(val)]
-config_builder = Builder(emitter = config_emitter, action = config_action)
+config_builder = Builder(emitter=config_emitter, action=config_action)
main.Append(BUILDERS = { 'ConfigFile' : config_builder })
-###################################################
-#
-# Builders for static and shared partially linked object files.
-#
-###################################################
-
-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 })
-
def add_local_rpath(env, *targets):
'''Set up an RPATH for a library which lives in the build directory.
main.AddMethod(add_local_rpath, 'AddLocalRPATH')
# builds in ext are shared across all configs in the build root.
-ext_dir = abspath(joinpath(str(main.root), 'ext'))
+ext_dir = Dir('#ext').abspath
ext_build_dirs = []
for root, dirs, files in os.walk(ext_dir):
if 'SConscript' in files:
# normally determined by name of $VARIANT_DIR, but can be
# overridden by '--default=' arg on command line.
default = GetOption('default')
- opts_dir = joinpath(main.root.abspath, 'build_opts')
+ opts_dir = Dir('#build_opts').abspath
if default:
default_vars_files = [joinpath(build_root, 'variables', default),
joinpath(opts_dir, default)]
if not have_kvm:
warning("Can not enable KVM, host seems to lack KVM support")
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")
+ elif kvm_isa != env['TARGET_ISA']:
+ print("Info: KVM for %s not supported on %s host." %
+ (env['TARGET_ISA'], kvm_isa))
env['USE_KVM'] = False
if env['USE_TUNTAP']:
env.Append(CCFLAGS='$CCFLAGS_EXTRA')
env.Append(LINKFLAGS='$LDFLAGS_EXTRA')
+ exports=['env']
+ if main['USE_PYTHON']:
+ exports.append('marshal_env')
+
# The src/SConscript file sets up the build rules in 'env' according
# to the configured variables. It returns a list of environments,
# one for each variant build (debug, opt, etc.)
- SConscript('src/SConscript', variant_dir=variant_path,
- exports=['env', 'marshal_env'])
+ SConscript('src/SConscript', variant_dir=variant_path, exports=exports)
atexit.register(summarize_warnings)
projects / gem5.git / blobdiff