#
###################################################
+from __future__ import print_function
+
# Global Python includes
import itertools
import os
import SCons.Node
from m5.util import compareVersions, readCommand
-from m5.util.terminal import get_termcap
help_texts = {
"options" : "",
help='Build with Address Sanitizer if available')
if GetOption('no_lto') and GetOption('force_lto'):
- print '--no-lto and --force-lto are mutually exclusive'
+ print('--no-lto and --force-lto are mutually exclusive')
Exit(1)
-termcap = get_termcap(GetOption('use_colors'))
-
########################################################################
#
# Set up the main build environment.
main = Environment()
+from gem5_scons import Transform
+from gem5_scons.util import get_termcap
+termcap = get_termcap()
+
main_dict_keys = main.Dictionary().keys()
# Check that we have a C/C++ compiler
if not ('CC' in main_dict_keys and 'CXX' in main_dict_keys):
- print "No C++ compiler installed (package g++ on Ubuntu and RedHat)"
+ print("No C++ compiler installed (package g++ on Ubuntu and RedHat)")
Exit(1)
###################################################
try:
build_top = rfind(path_dirs, 'build', -2)
except:
- print "Error: no non-leaf 'build' dir found on target path", t
+ print("Error: no non-leaf 'build' dir found on target path", t)
Exit(1)
this_build_root = joinpath('/',*path_dirs[:build_top+1])
if not build_root:
build_root = this_build_root
else:
if this_build_root != build_root:
- print "Error: build targets not under same build root\n"\
- " %s\n %s" % (build_root, this_build_root)
+ print("Error: build targets not under same build root\n"
+ " %s\n %s" % (build_root, this_build_root))
Exit(1)
variant_path = joinpath('/',*path_dirs[:build_top+2])
if variant_path not in variant_paths:
# Add shared top-level headers
main.Prepend(CPPPATH=Dir('include'))
-def strip_build_path(path, env):
- path = str(path)
- variant_base = env['BUILDROOT'] + os.path.sep
- if path.startswith(variant_base):
- path = path[len(variant_base):]
- elif path.startswith('build/'):
- path = path[6:]
- return path
-
-# Generate a string of the form:
-# common/path/prefix/src1, src2 -> tgt1, tgt2
-# to print while building.
-class Transform(object):
- # all specific color settings should be here and nowhere else
- tool_color = termcap.Normal
- pfx_color = termcap.Yellow
- srcs_color = termcap.Yellow + termcap.Bold
- arrow_color = termcap.Blue + termcap.Bold
- tgts_color = termcap.Yellow + termcap.Bold
-
- def __init__(self, tool, max_sources=99):
- self.format = self.tool_color + (" [%8s] " % tool) \
- + self.pfx_color + "%s" \
- + self.srcs_color + "%s" \
- + self.arrow_color + " -> " \
- + self.tgts_color + "%s" \
- + termcap.Normal
- self.max_sources = max_sources
-
- def __call__(self, target, source, env, for_signature=None):
- # truncate source list according to max_sources param
- source = source[0:self.max_sources]
- def strip(f):
- return strip_build_path(str(f), env)
- if len(source) > 0:
- srcs = map(strip, source)
- else:
- srcs = ['']
- tgts = map(strip, target)
- # surprisingly, os.path.commonprefix is a dumb char-by-char string
- # operation that has nothing to do with paths.
- com_pfx = os.path.commonprefix(srcs + tgts)
- com_pfx_len = len(com_pfx)
- if com_pfx:
- # do some cleanup and sanity checking on common prefix
- if com_pfx[-1] == ".":
- # prefix matches all but file extension: ok
- # back up one to change 'foo.cc -> o' to 'foo.cc -> .o'
- com_pfx = com_pfx[0:-1]
- elif com_pfx[-1] == "/":
- # common prefix is directory path: OK
- pass
- else:
- src0_len = len(srcs[0])
- tgt0_len = len(tgts[0])
- if src0_len == com_pfx_len:
- # source is a substring of target, OK
- pass
- elif tgt0_len == com_pfx_len:
- # target is a substring of source, need to back up to
- # avoid empty string on RHS of arrow
- sep_idx = com_pfx.rfind(".")
- if sep_idx != -1:
- com_pfx = com_pfx[0:sep_idx]
- else:
- com_pfx = ''
- elif src0_len > com_pfx_len and srcs[0][com_pfx_len] == ".":
- # still splitting at file extension: ok
- pass
- else:
- # probably a fluke; ignore it
- com_pfx = ''
- # recalculate length in case com_pfx was modified
- com_pfx_len = len(com_pfx)
- def fmt(files):
- f = map(lambda s: s[com_pfx_len:], files)
- return ', '.join(f)
- return self.format % (com_pfx, fmt(srcs), fmt(tgts))
-
-Export('Transform')
-
-# enable the regression script to use the termcap
-main['TERMCAP'] = termcap
-
if GetOption('verbose'):
def MakeAction(action, string, *args, **kwargs):
return Action(action, *args, **kwargs)
main['GCC'] = CXX_version and CXX_version.find('g++') >= 0
main['CLANG'] = CXX_version and CXX_version.find('clang') >= 0
if main['GCC'] + main['CLANG'] > 1:
- print 'Error: How can we have two at the same time?'
+ print('Error: How can we have two at the same time?')
Exit(1)
# Set up default C++ compiler flags
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.Append(CCFLAGS=['-Werror',
+ '-Wno-error=deprecated-declarations',
+ '-Wno-error=deprecated',
+ ])
else:
- print termcap.Yellow + termcap.Bold + 'Error' + termcap.Normal,
- print "Don't know what compiler options to use for your compiler."
- print termcap.Yellow + ' compiler:' + termcap.Normal, main['CXX']
- print termcap.Yellow + ' version:' + termcap.Normal,
+ print(termcap.Yellow + termcap.Bold + 'Error' + termcap.Normal, end=' ')
+ print("Don't know what compiler options to use for your compiler.")
+ print(termcap.Yellow + ' compiler:' + termcap.Normal, main['CXX'])
+ print(termcap.Yellow + ' version:' + termcap.Normal, end = ' ')
if not CXX_version:
- print termcap.Yellow + termcap.Bold + "COMMAND NOT FOUND!" +\
- termcap.Normal
+ print(termcap.Yellow + termcap.Bold + "COMMAND NOT FOUND!" +
+ termcap.Normal)
else:
- print CXX_version.replace('\n', '<nl>')
- print " If you're trying to use a compiler other than GCC"
- print " or clang, there appears to be something wrong with your"
- print " environment."
- print " "
- print " If you are trying to use a compiler other than those listed"
- print " above you will need to ease fix SConstruct and "
- print " src/SConscript to support that compiler."
+ print(CXX_version.replace('\n', '<nl>'))
+ print(" If you're trying to use a compiler other than GCC")
+ print(" or clang, there appears to be something wrong with your")
+ print(" environment.")
+ print(" ")
+ print(" If you are trying to use a compiler other than those listed")
+ print(" above you will need to ease fix SConstruct and ")
+ print(" src/SConscript to support that compiler.")
Exit(1)
if main['GCC']:
# http://gcc.gnu.org/projects/cxx0x.html for details.
gcc_version = readCommand([main['CXX'], '-dumpversion'], exception=False)
if compareVersions(gcc_version, "4.8") < 0:
- print 'Error: gcc version 4.8 or newer required.'
- print ' Installed version:', gcc_version
+ print('Error: gcc version 4.8 or newer required.')
+ print(' Installed version: ', gcc_version)
Exit(1)
main['GCC_VERSION'] = gcc_version
main.Append(PSHLINKFLAGS='-flinker-output=rel')
main.Append(PLINKFLAGS='-flinker-output=rel')
- # gcc from version 4.8 and above generates "rep; ret" instructions
- # to avoid performance penalties on certain AMD chips. Older
- # assemblers detect this as an error, "Error: expecting string
- # instruction after `rep'"
- as_version_raw = readCommand([main['AS'], '-v', '/dev/null',
- '-o', '/dev/null'],
- exception=False).split()
-
- # 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
# support it.
if GetOption('with_ubsan') and \
compareVersions(gcc_version, '4.9') < 0:
- print termcap.Yellow + termcap.Bold + \
- 'Warning: UBSan is only supported using gcc 4.9 and later.' + \
- termcap.Normal
+ print(termcap.Yellow + termcap.Bold +
+ 'Warning: UBSan is only supported using gcc 4.9 and later.' +
+ termcap.Normal)
disable_lto = GetOption('no_lto')
if not disable_lto and main.get('BROKEN_INCREMENTAL_LTO', False) and \
not GetOption('force_lto'):
- print termcap.Yellow + termcap.Bold + \
- '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.' + \
- termcap.Normal
+ print(termcap.Yellow + termcap.Bold +
+ '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.' +
+ termcap.Normal)
disable_lto = True
# Add the appropriate Link-Time Optimization (LTO) flags
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'])
+ # The address sanitizer is available for gcc >= 4.8
+ if GetOption('with_asan'):
+ if GetOption('with_ubsan') and \
+ compareVersions(main['GCC_VERSION'], '4.9') >= 0:
+ main.Append(CCFLAGS=['-fsanitize=address,undefined',
+ '-fno-omit-frame-pointer'],
+ LINKFLAGS='-fsanitize=address,undefined')
+ else:
+ main.Append(CCFLAGS=['-fsanitize=address',
+ '-fno-omit-frame-pointer'],
+ LINKFLAGS='-fsanitize=address')
+ # Only gcc >= 4.9 supports UBSan, so check both the version
+ # and the command-line option before adding the compiler and
+ # linker flags.
+ elif GetOption('with_ubsan') and \
+ compareVersions(main['GCC_VERSION'], '4.9') >= 0:
+ main.Append(CCFLAGS='-fsanitize=undefined')
+ main.Append(LINKFLAGS='-fsanitize=undefined')
elif main['CLANG']:
# Check for a supported version of clang, >= 3.1 is needed to
if (clang_version_match):
clang_version = clang_version_match.groups()[0]
if compareVersions(clang_version, "3.1") < 0:
- print 'Error: clang version 3.1 or newer required.'
- print ' Installed version:', clang_version
+ print('Error: clang version 3.1 or newer required.')
+ print(' Installed version:', clang_version)
Exit(1)
else:
- print 'Error: Unable to determine clang version.'
+ print('Error: Unable to determine clang version.')
Exit(1)
# clang has a few additional warnings that we disable, extraneous
if sys.platform.startswith('freebsd'):
main.Append(LIBS=['thr'])
+ # We require clang >= 3.1, so there is no need to check any
+ # versions here.
+ if GetOption('with_ubsan'):
+ if GetOption('with_asan'):
+ main.Append(CCFLAGS=['-fsanitize=address,undefined',
+ '-fno-omit-frame-pointer'],
+ LINKFLAGS='-fsanitize=address,undefined')
+ else:
+ main.Append(CCFLAGS='-fsanitize=undefined',
+ LINKFLAGS='-fsanitize=undefined')
+
+ elif GetOption('with_asan'):
+ main.Append(CCFLAGS=['-fsanitize=address',
+ '-fno-omit-frame-pointer'],
+ LINKFLAGS='-fsanitize=address')
+
else:
- print termcap.Yellow + termcap.Bold + 'Error' + termcap.Normal,
- print "Don't know what compiler options to use for your compiler."
- print termcap.Yellow + ' compiler:' + termcap.Normal, main['CXX']
- print termcap.Yellow + ' version:' + termcap.Normal,
+ print(termcap.Yellow + termcap.Bold + 'Error' + termcap.Normal, end=' ')
+ print("Don't know what compiler options to use for your compiler.")
+ print(termcap.Yellow + ' compiler:' + termcap.Normal, main['CXX'])
+ print(termcap.Yellow + ' version:' + termcap.Normal, end=' ')
if not CXX_version:
- print termcap.Yellow + termcap.Bold + "COMMAND NOT FOUND!" +\
- termcap.Normal
+ print(termcap.Yellow + termcap.Bold + "COMMAND NOT FOUND!" +
+ termcap.Normal)
else:
- print CXX_version.replace('\n', '<nl>')
- print " If you're trying to use a compiler other than GCC"
- print " or clang, there appears to be something wrong with your"
- print " environment."
- print " "
- print " If you are trying to use a compiler other than those listed"
- print " above you will need to ease fix SConstruct and "
- print " src/SConscript to support that compiler."
+ print(CXX_version.replace('\n', '<nl>'))
+ print(" If you're trying to use a compiler other than GCC")
+ print(" or clang, there appears to be something wrong with your")
+ print(" environment.")
+ print(" ")
+ print(" If you are trying to use a compiler other than those listed")
+ print(" above you will need to ease fix SConstruct and ")
+ print(" src/SConscript to support that compiler.")
Exit(1)
# Set up common yacc/bison flags (needed for Ruby)
# First two words should be "libprotoc x.y.z"
if len(protoc_version) < 2 or protoc_version[0] != 'libprotoc':
- print termcap.Yellow + termcap.Bold + \
- 'Warning: Protocol buffer compiler (protoc) not found.\n' + \
- ' Please install protobuf-compiler for tracing support.' + \
- termcap.Normal
+ print(termcap.Yellow + termcap.Bold +
+ 'Warning: Protocol buffer compiler (protoc) not found.\n' +
+ ' Please install protobuf-compiler for tracing support.' +
+ termcap.Normal)
main['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:
- print termcap.Yellow + termcap.Bold + \
- 'Warning: protoc version', min_protoc_version, \
- 'or newer required.\n' + \
- ' Installed version:', protoc_version[1], \
- termcap.Normal
+ print(termcap.Yellow + termcap.Bold +
+ 'Warning: protoc version', min_protoc_version,
+ 'or newer required.\n' +
+ ' Installed version:', protoc_version[1],
+ termcap.Normal)
main['PROTOC'] = False
else:
# Attempt to determine the appropriate include path and
# using pkg-config
main.ParseConfig('pkg-config --cflags --libs-only-L protobuf')
except:
- print termcap.Yellow + termcap.Bold + \
- 'Warning: pkg-config could not get protobuf flags.' + \
- termcap.Normal
+ print(termcap.Yellow + termcap.Bold +
+ 'Warning: pkg-config could not get protobuf flags.' +
+ termcap.Normal)
# Check for 'timeout' from GNU coreutils. If present, regressions will
# Cache build files in the supplied directory.
if main['M5_BUILD_CACHE']:
- print 'Using build cache located at', main['M5_BUILD_CACHE']
+ print('Using build cache located at', main['M5_BUILD_CACHE'])
CacheDir(main['M5_BUILD_CACHE'])
main['USE_PYTHON'] = not GetOption('without_python')
# verify that this stuff works
if not conf.CheckHeader('Python.h', '<>'):
- print "Error: can't find Python.h header in", py_includes
- print "Install Python headers (package python-dev on Ubuntu and RedHat)"
+ print("Error: Check failed for Python.h header in", py_includes)
+ print("Two possible reasons:")
+ print("1. Python headers are not installed (You can install the "
+ "package python-dev on Ubuntu and RedHat)")
+ print("2. SCons is using a wrong C compiler. This can happen if "
+ "CC has the wrong value.")
+ print("CC = %s" % main['CC'])
Exit(1)
for lib in py_libs:
if not conf.CheckLib(lib):
- print "Error: can't find library %s required by python" % 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);'):
if not conf.CheckLibWithHeader('socket', 'sys/socket.h', 'C++', 'accept(0,0,0);'):
- print "Can't find library with socket calls (e.g. accept())"
+ print("Can't find library with socket calls (e.g. accept())")
Exit(1)
# Check for zlib. If the check passes, libz will be automatically
# added to the LIBS environment variable.
if not conf.CheckLibWithHeader('z', 'zlib.h', 'C++','zlibVersion();'):
- print 'Error: did not find needed zlib compression library '\
- 'and/or zlib.h header file.'
- print ' Please install zlib and try again.'
+ print('Error: did not find needed zlib compression library '
+ 'and/or zlib.h header file.')
+ print(' Please install zlib and try again.')
Exit(1)
# If we have the protobuf compiler, also make sure we have the
conf.CheckLibWithHeader('protobuf', 'google/protobuf/message.h',
'C++', 'GOOGLE_PROTOBUF_VERIFY_VERSION;')
+# Valgrind gets much less confused if you tell it when you're using
+# alternative stacks.
+main['HAVE_VALGRIND'] = conf.CheckCHeader('valgrind/valgrind.h')
+
# If we have the compiler but not the library, print another warning.
if main['PROTOC'] and not main['HAVE_PROTOBUF']:
- print termcap.Yellow + termcap.Bold + \
- 'Warning: did not find protocol buffer library and/or headers.\n' + \
- ' Please install libprotobuf-dev for tracing support.' + \
- termcap.Normal
+ print(termcap.Yellow + termcap.Bold +
+ 'Warning: did not find protocol buffer library and/or headers.\n' +
+ ' Please install libprotobuf-dev for tracing support.' +
+ termcap.Normal)
# Check for librt.
have_posix_clock = \
elif conf.CheckLib('tcmalloc_minimal'):
main.Append(CCFLAGS=main['TCMALLOC_CCFLAGS'])
else:
- print termcap.Yellow + termcap.Bold + \
- "You can get a 12% performance improvement by "\
- "installing tcmalloc (libgoogle-perftools-dev package "\
- "on Ubuntu or RedHat)." + termcap.Normal
+ print(termcap.Yellow + termcap.Bold +
+ "You can get a 12% performance improvement by "
+ "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_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_symbols_fd((void*)0, 0, 0);'):
+ backtrace_checker):
# 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
+ 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."
+ print("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:
- print "Warning: Header file <fenv.h> not found."
- print " This host has no IEEE FP rounding mode control."
+ print("Warning: Header file <fenv.h> not found.")
+ print(" This host has no IEEE FP rounding mode control.")
# Check for <png.h> (libpng library needed if wanting to dump
# frame buffer image in png format)
have_png = conf.CheckHeader('png.h', '<>')
if not have_png:
- print "Warning: Header file <png.h> not found."
- print " This host has no libpng library."
- print " Disabling support for PNG framebuffers."
+ print("Warning: Header file <png.h> not found.")
+ print(" This host has no libpng library.")
+ print(" Disabling support for PNG framebuffers.")
# Check if we should enable KVM-based hardware virtualization. The API
# we rely on exists since version 2.6.36 of the kernel, but somehow
# the types as a fall back.
have_kvm = conf.CheckHeader('linux/kvm.h', '<>')
if not have_kvm:
- print "Info: Compatible header file <linux/kvm.h> not found, " \
- "disabling KVM support."
+ print("Info: Compatible header file <linux/kvm.h> not found, "
+ "disabling KVM support.")
# Check if the TUN/TAP driver is available.
have_tuntap = conf.CheckHeader('linux/if_tun.h', '<>')
if not have_tuntap:
- print "Info: Compatible header file <linux/if_tun.h> not found."
+ 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
import platform
host_isa = platform.machine()
except:
- print "Warning: Failed to determine host ISA."
+ print("Warning: Failed to determine host ISA.")
return False
if not have_posix_timers:
- print "Warning: Can not enable KVM, host seems to lack support " \
- "for POSIX timers"
+ print("Warning: Can not enable KVM, host seems to lack support "
+ "for POSIX timers")
return False
if isa == "arm":
return False
if not have_kvm_xsave:
- print "KVM on x86 requires xsave support in kernel headers."
+ print("KVM on x86 requires xsave support in kernel headers.")
return False
return True
# Walk the tree and execute all SConsopts scripts that wil add to the
# above variables
if GetOption('verbose'):
- print "Reading SConsopts"
+ print("Reading SConsopts")
for bdir in [ base_dir ] + extras_dir_list:
if not isdir(bdir):
- print "Error: directory '%s' does not exist" % bdir
+ print("Error: directory '%s' does not exist" % bdir)
Exit(1)
for root, dirs, files in os.walk(bdir):
if 'SConsopts' in files:
if GetOption('verbose'):
- print "Reading", joinpath(root, 'SConsopts')
+ print("Reading", joinpath(root, 'SConsopts'))
SConscript(joinpath(root, 'SConsopts'))
all_isa_list.sort()
# These variables get exported to #defines in config/*.hh (see src/SConscript).
export_vars += ['USE_FENV', 'SS_COMPATIBLE_FP', 'TARGET_ISA', 'TARGET_GPU_ISA',
'CP_ANNOTATE', 'USE_POSIX_CLOCK', 'USE_KVM', 'USE_TUNTAP',
- 'PROTOCOL', 'HAVE_PROTOBUF', 'HAVE_PERF_ATTR_EXCLUDE_HOST',
- 'USE_PNG']
+ 'PROTOCOL', 'HAVE_PROTOBUF', 'HAVE_VALGRIND',
+ 'HAVE_PERF_ATTR_EXCLUDE_HOST', 'USE_PNG']
###################################################
#
def build_config_file(target, source, env):
(variable, value) = [s.get_contents() for s in source]
f = file(str(target[0]), 'w')
- print >> f, '#define', variable, value
+ print('#define', variable, value, file=f)
f.close()
return None
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)
+ print('#include "%s/%s/%s"' % (dp, subdir, fp), file=hdr)
switching_header_action = MakeAction(build_switching_header,
Transform('GENERATE'))
for variant_path in variant_paths:
if not GetOption('silent'):
- print "Building in", variant_path
+ print("Building in", variant_path)
# Make a copy of the build-root environment to use for this config.
env = main.Clone()
if isfile(current_vars_file):
sticky_vars.files.append(current_vars_file)
if not GetOption('silent'):
- print "Using saved variables file %s" % current_vars_file
+ print("Using saved variables file %s" % current_vars_file)
elif variant_dir in ext_build_dirs:
# Things in ext are built without a variant directory.
continue
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)
+ 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 " \
- "default file(s) %s" \
- % (current_vars_file, ' or '.join(default_vars_files))
+ 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
# Process variable settings.
if not have_fenv and env['USE_FENV']:
- print "Warning: <fenv.h> not available; " \
- "forcing USE_FENV to False in", variant_dir + "."
+ print("Warning: <fenv.h> not available; "
+ "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", variant_dir + "."
- print " FP results may deviate slightly from other platforms."
+ print("Warning: No IEEE FP rounding mode control in",
+ variant_dir + ".")
+ print(" FP results may deviate slightly from other platforms.")
if not have_png and env['USE_PNG']:
- print "Warning: <png.h> not available; " \
- "forcing USE_PNG to False in", variant_dir + "."
+ print("Warning: <png.h> not available; "
+ "forcing USE_PNG to False in", variant_dir + ".")
env['USE_PNG'] = False
if env['USE_PNG']:
if env['USE_KVM']:
if not have_kvm:
- print "Warning: Can not enable KVM, host seems to lack KVM support"
+ print("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"
+ print("Info: KVM support disabled due to unsupported host and "
+ "target ISA combination")
env['USE_KVM'] = False
if env['USE_TUNTAP']:
if not have_tuntap:
- print "Warning: Can't connect EtherTap with a tap device."
+ print("Warning: Can't connect EtherTap with a tap device.")
env['USE_TUNTAP'] = False
if env['BUILD_GPU']:
# Warn about missing optional functionality
if env['USE_KVM']:
if not main['HAVE_PERF_ATTR_EXCLUDE_HOST']:
- print "Warning: perf_event headers lack support for the " \
- "exclude_host attribute. KVM instruction counts will " \
- "be inaccurate."
+ print("Warning: perf_event headers lack support for the "
+ "exclude_host attribute. KVM instruction counts will "
+ "be inaccurate.")
# Save sticky variable settings back to current variables file
sticky_vars.Save(current_vars_file, env)
projects / gem5.git / blobdiff