SConstruct revision 14209:7efe1c187149
12623SN/A# -*- mode:python -*- 22623SN/A 32623SN/A# Copyright (c) 2013, 2015-2019 ARM Limited 42623SN/A# All rights reserved. 52623SN/A# 62623SN/A# The license below extends only to copyright in the software and shall 72623SN/A# not be construed as granting a license to any other intellectual 82623SN/A# property including but not limited to intellectual property relating 92623SN/A# to a hardware implementation of the functionality of the software 102623SN/A# licensed hereunder. You may use the software subject to the license 112623SN/A# terms below provided that you ensure that this notice is replicated 122623SN/A# unmodified and in its entirety in all distributions of the software, 132623SN/A# modified or unmodified, in source code or in binary form. 142623SN/A# 152623SN/A# Copyright (c) 2011 Advanced Micro Devices, Inc. 162623SN/A# Copyright (c) 2009 The Hewlett-Packard Development Company 172623SN/A# Copyright (c) 2004-2005 The Regents of The University of Michigan 182623SN/A# All rights reserved. 192623SN/A# 202623SN/A# Redistribution and use in source and binary forms, with or without 212623SN/A# modification, are permitted provided that the following conditions are 222623SN/A# met: redistributions of source code must retain the above copyright 232623SN/A# notice, this list of conditions and the following disclaimer; 242623SN/A# redistributions in binary form must reproduce the above copyright 252623SN/A# notice, this list of conditions and the following disclaimer in the 262623SN/A# documentation and/or other materials provided with the distribution; 272665Ssaidi@eecs.umich.edu# neither the name of the copyright holders nor the names of its 282665Ssaidi@eecs.umich.edu# contributors may be used to endorse or promote products derived from 292623SN/A# this software without specific prior written permission. 302623SN/A# 312623SN/A# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 322623SN/A# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 332623SN/A# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 342623SN/A# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 352623SN/A# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 362623SN/A# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 372623SN/A# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 382623SN/A# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 392623SN/A# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 402623SN/A# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 412623SN/A# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 422623SN/A# 432623SN/A# Authors: Steve Reinhardt 442623SN/A# Nathan Binkert 452623SN/A 462623SN/A################################################### 472623SN/A# 482623SN/A# SCons top-level build description (SConstruct) file. 492623SN/A# 502623SN/A# While in this directory ('gem5'), just type 'scons' to build the default 512623SN/A# configuration (see below), or type 'scons build/<CONFIG>/<binary>' 522623SN/A# to build some other configuration (e.g., 'build/ALPHA/gem5.opt' for 532623SN/A# the optimized full-system version). 542623SN/A# 552623SN/A# You can build gem5 in a different directory as long as there is a 562623SN/A# 'build/<CONFIG>' somewhere along the target path. The build system 572623SN/A# expects that all configs under the same build directory are being 582623SN/A# built for the same host system. 592623SN/A# 602623SN/A# Examples: 612623SN/A# 622623SN/A# The following two commands are equivalent. The '-u' option tells 632623SN/A# scons to search up the directory tree for this SConstruct file. 642623SN/A# % cd <path-to-src>/gem5 ; scons build/ALPHA/gem5.debug 652623SN/A# % cd <path-to-src>/gem5/build/ALPHA; scons -u gem5.debug 662623SN/A# 672623SN/A# The following two commands are equivalent and demonstrate building 682623SN/A# in a directory outside of the source tree. The '-C' option tells 692623SN/A# scons to chdir to the specified directory to find this SConstruct 702623SN/A# file. 712623SN/A# % cd <path-to-src>/gem5 ; scons /local/foo/build/ALPHA/gem5.debug 722623SN/A# % cd /local/foo/build/ALPHA; scons -C <path-to-src>/gem5 gem5.debug 732623SN/A# 742623SN/A# You can use 'scons -H' to print scons options. If you're in this 752623SN/A# 'gem5' directory (or use -u or -C to tell scons where to find this 762623SN/A# file), you can use 'scons -h' to print all the gem5-specific build 772623SN/A# options as well. 782623SN/A# 792623SN/A################################################### 802623SN/A 812623SN/Afrom __future__ import print_function 822623SN/A 832630SN/A# Global Python includes 842623SN/Aimport itertools 852623SN/Aimport os 862623SN/Aimport re 872623SN/Aimport shutil 882623SN/Aimport subprocess 892623SN/Aimport sys 902630SN/A 912623SN/Afrom os import mkdir, environ 922623SN/Afrom os.path import abspath, basename, dirname, expanduser, normpath 932623SN/Afrom os.path import exists, isdir, isfile 942623SN/Afrom os.path import join as joinpath, split as splitpath 952623SN/Afrom re import match 962623SN/A 972630SN/A# SCons includes 982623SN/Aimport SCons 992623SN/Aimport SCons.Node 1002623SN/Aimport SCons.Node.FS 1012623SN/A 1022623SN/Afrom m5.util import compareVersions, readCommand 1032623SN/A 1042623SN/Ahelp_texts = { 1052626SN/A "options" : "", 1062626SN/A "global_vars" : "", 1072626SN/A "local_vars" : "" 1082623SN/A} 1092623SN/A 1102623SN/AExport("help_texts") 1112657Ssaidi@eecs.umich.edu 1122623SN/A 1132623SN/A# There's a bug in scons in that (1) by default, the help texts from 1142623SN/A# AddOption() are supposed to be displayed when you type 'scons -h' 1152623SN/A# and (2) you can override the help displayed by 'scons -h' using the 1162623SN/A# Help() function, but these two features are incompatible: once 1172623SN/A# you've overridden the help text using Help(), there's no way to get 1182623SN/A# at the help texts from AddOptions. See: 1192623SN/A# http://scons.tigris.org/issues/show_bug.cgi?id=2356 1202623SN/A# http://scons.tigris.org/issues/show_bug.cgi?id=2611 1212640Sstever@eecs.umich.edu# This hack lets us extract the help text from AddOptions and 1222623SN/A# re-inject it via Help(). Ideally someday this bug will be fixed and 1232623SN/A# we can just use AddOption directly. 1242623SN/Adef AddLocalOption(*args, **kwargs): 1252663Sstever@eecs.umich.edu col_width = 30 1262663Sstever@eecs.umich.edu 1272641Sstever@eecs.umich.edu help = " " + ", ".join(args) 1282623SN/A if "help" in kwargs: 1292623SN/A length = len(help) 1302663Sstever@eecs.umich.edu if length >= col_width: 1312641Sstever@eecs.umich.edu help += "\n" + " " * col_width 1322641Sstever@eecs.umich.edu else: 1332623SN/A help += " " * (col_width - length) 1342623SN/A help += kwargs["help"] 1352663Sstever@eecs.umich.edu help_texts["options"] += help + "\n" 1362641Sstever@eecs.umich.edu 1372641Sstever@eecs.umich.edu AddOption(*args, **kwargs) 1382623SN/A 1392623SN/AAddLocalOption('--colors', dest='use_colors', action='store_true', 1402623SN/A help="Add color to abbreviated scons output") 1412623SN/AAddLocalOption('--no-colors', dest='use_colors', action='store_false', 1422623SN/A help="Don't add color to abbreviated scons output") 1432623SN/AAddLocalOption('--with-cxx-config', dest='with_cxx_config', 1442623SN/A action='store_true', 1452623SN/A help="Build with support for C++-based configuration") 1462623SN/AAddLocalOption('--default', dest='default', type='string', action='store', 1472623SN/A help='Override which build_opts file to use for defaults') 1482623SN/AAddLocalOption('--ignore-style', dest='ignore_style', action='store_true', 1492623SN/A help='Disable style checking hooks') 1502623SN/AAddLocalOption('--gold-linker', dest='gold_linker', action='store_true', 1512623SN/A help='Use the gold linker') 1522623SN/AAddLocalOption('--no-lto', dest='no_lto', action='store_true', 1532623SN/A help='Disable Link-Time Optimization for fast') 1542623SN/AAddLocalOption('--force-lto', dest='force_lto', action='store_true', 1552623SN/A help='Use Link-Time Optimization instead of partial linking' + 1562623SN/A ' when the compiler doesn\'t support using them together.') 1572623SN/AAddLocalOption('--update-ref', dest='update_ref', action='store_true', 1582623SN/A help='Update test reference outputs') 1592623SN/AAddLocalOption('--verbose', dest='verbose', action='store_true', 1602623SN/A help='Print full tool command lines') 1612623SN/AAddLocalOption('--without-python', dest='without_python', 1622623SN/A action='store_true', 1632623SN/A help='Build without Python configuration support') 1642623SN/AAddLocalOption('--without-tcmalloc', dest='without_tcmalloc', 1652623SN/A action='store_true', 1662623SN/A help='Disable linking against tcmalloc') 1672623SN/AAddLocalOption('--with-ubsan', dest='with_ubsan', action='store_true', 1682623SN/A help='Build with Undefined Behavior Sanitizer if available') 1692623SN/AAddLocalOption('--with-asan', dest='with_asan', action='store_true', 1702623SN/A help='Build with Address Sanitizer if available') 1712623SN/A 1722623SN/Aif GetOption('no_lto') and GetOption('force_lto'): 1732623SN/A print('--no-lto and --force-lto are mutually exclusive') 1742623SN/A Exit(1) 1752623SN/A 1762623SN/A######################################################################## 1772623SN/A# 1782623SN/A# Set up the main build environment. 1792623SN/A# 1802623SN/A######################################################################## 1812623SN/A 1822623SN/Amain = Environment() 1832623SN/A 1842623SN/Afrom gem5_scons import Transform 1852623SN/Afrom gem5_scons.util import get_termcap 1862623SN/Atermcap = get_termcap() 1872623SN/A 1882623SN/Amain_dict_keys = main.Dictionary().keys() 1892623SN/A 1902623SN/A# Check that we have a C/C++ compiler 1912623SN/Aif not ('CC' in main_dict_keys and 'CXX' in main_dict_keys): 1922623SN/A print("No C++ compiler installed (package g++ on Ubuntu and RedHat)") 1932623SN/A Exit(1) 1942623SN/A 1952623SN/A################################################### 1962623SN/A# 1972623SN/A# Figure out which configurations to set up based on the path(s) of 1982623SN/A# the target(s). 1992623SN/A# 2002623SN/A################################################### 2012623SN/A 2022623SN/A# Find default configuration & binary. 2032623SN/ADefault(environ.get('M5_DEFAULT_BINARY', 'build/ALPHA/gem5.debug')) 2042623SN/A 2052623SN/A# helper function: find last occurrence of element in list 2062623SN/Adef rfind(l, elt, offs = -1): 2072623SN/A for i in range(len(l)+offs, 0, -1): 2082623SN/A if l[i] == elt: 2092623SN/A return i 2102623SN/A raise ValueError, "element not found" 2112623SN/A 2122623SN/A# Take a list of paths (or SCons Nodes) and return a list with all 2132623SN/A# paths made absolute and ~-expanded. Paths will be interpreted 2142623SN/A# relative to the launch directory unless a different root is provided 2152623SN/Adef makePathListAbsolute(path_list, root=GetLaunchDir()): 2162623SN/A return [abspath(joinpath(root, expanduser(str(p)))) 2172626SN/A for p in path_list] 2182626SN/A 2192626SN/Adef find_first_prog(prog_names): 2202626SN/A """Find the absolute path to the first existing binary in prog_names""" 2212626SN/A 2222623SN/A if not isinstance(prog_names, (list, tuple)): 2232623SN/A prog_names = [ prog_names ] 2242623SN/A 2252623SN/A for p in prog_names: 2262623SN/A p = main.WhereIs(p) 2272623SN/A if p is not None: 2282623SN/A return p 2292623SN/A 2302623SN/A return None 2312623SN/A 2322663Sstever@eecs.umich.edu# Each target must have 'build' in the interior of the path; the 2332623SN/A# directory below this will determine the build parameters. For 2342623SN/A# example, for target 'foo/bar/build/ALPHA_SE/arch/alpha/blah.do' we 2352623SN/A# recognize that ALPHA_SE specifies the configuration because it 2362623SN/A# follow 'build' in the build path. 2372623SN/A 2382623SN/A# The funky assignment to "[:]" is needed to replace the list contents 2392623SN/A# in place rather than reassign the symbol to a new list, which 2402623SN/A# doesn't work (obviously!). 2412623SN/ABUILD_TARGETS[:] = makePathListAbsolute(BUILD_TARGETS) 2422623SN/A 2432641Sstever@eecs.umich.edu# Generate a list of the unique build roots and configs that the 2442623SN/A# collected targets reference. 2452662Sstever@eecs.umich.eduvariant_paths = [] 2462623SN/Abuild_root = None 2472623SN/Afor t in BUILD_TARGETS: 2482641Sstever@eecs.umich.edu path_dirs = t.split('/') 2492623SN/A try: 2502623SN/A build_top = rfind(path_dirs, 'build', -2) 2512623SN/A except: 2522623SN/A print("Error: no non-leaf 'build' dir found on target path", t) 2532623SN/A Exit(1) 2542623SN/A this_build_root = joinpath('/',*path_dirs[:build_top+1]) 2552623SN/A if not build_root: 2562623SN/A build_root = this_build_root 2572623SN/A else: 2582623SN/A if this_build_root != build_root: 2592623SN/A print("Error: build targets not under same build root\n" 2602623SN/A " %s\n %s" % (build_root, this_build_root)) 2612623SN/A Exit(1) 2622623SN/A variant_path = joinpath('/',*path_dirs[:build_top+2]) 2632623SN/A if variant_path not in variant_paths: 2642623SN/A variant_paths.append(variant_path) 2652623SN/A 2662623SN/A# Make sure build_root exists (might not if this is the first build there) 2672623SN/Aif not isdir(build_root): 2682623SN/A mkdir(build_root) 2692623SN/Amain['BUILDROOT'] = build_root 2702623SN/A 2712623SN/AExport('main') 2722623SN/A 2732623SN/Amain.SConsignFile(joinpath(build_root, "sconsign")) 2742623SN/A 2752623SN/A# Default duplicate option is to use hard links, but this messes up 2762623SN/A# when you use emacs to edit a file in the target dir, as emacs moves 2772623SN/A# file to file~ then copies to file, breaking the link. Symbolic 2782623SN/A# (soft) links work better. 2792623SN/Amain.SetOption('duplicate', 'soft-copy') 2802623SN/A 2812623SN/A# 2822623SN/A# Set up global sticky variables... these are common to an entire build 2832623SN/A# tree (not specific to a particular build like ALPHA_SE) 2842623SN/A# 2852623SN/A 2862623SN/Aglobal_vars_file = joinpath(build_root, 'variables.global') 2872623SN/A 2882623SN/Aglobal_vars = Variables(global_vars_file, args=ARGUMENTS) 2892623SN/A 2902623SN/Aglobal_vars.AddVariables( 2912623SN/A ('CC', 'C compiler', environ.get('CC', main['CC'])), 2922623SN/A ('CXX', 'C++ compiler', environ.get('CXX', main['CXX'])), 2932623SN/A ('CCFLAGS_EXTRA', 'Extra C and C++ compiler flags', ''), 2942623SN/A ('LDFLAGS_EXTRA', 'Extra linker flags', ''), 2952623SN/A ('PYTHON_CONFIG', 'Python config binary to use', 2962623SN/A [ 'python2.7-config', 'python-config' ]), 2972623SN/A ('PROTOC', 'protoc tool', environ.get('PROTOC', 'protoc')), 2982623SN/A ('BATCH', 'Use batch pool for build and tests', False), 2992623SN/A ('BATCH_CMD', 'Batch pool submission command name', 'qdo'), 3002623SN/A ('M5_BUILD_CACHE', 'Cache built objects in this directory', False), 3012623SN/A ('EXTRAS', 'Add extra directories to the compilation', '') 3022623SN/A ) 3032623SN/A 3042623SN/A# Update main environment with values from ARGUMENTS & global_vars_file 3052623SN/Aglobal_vars.Update(main) 3062623SN/Ahelp_texts["global_vars"] += global_vars.GenerateHelpText(main) 3072663Sstever@eecs.umich.edu 3082623SN/A# Save sticky variable settings back to current variables file 3092623SN/Aglobal_vars.Save(global_vars_file, main) 3102623SN/A 3112623SN/A# Parse EXTRAS variable to build list of all directories where we're 3122623SN/A# look for sources etc. This list is exported as extras_dir_list. 3132623SN/Abase_dir = main.srcdir.abspath 3142623SN/Aif main['EXTRAS']: 3152623SN/A extras_dir_list = makePathListAbsolute(main['EXTRAS'].split(':')) 3162623SN/Aelse: 3172623SN/A extras_dir_list = [] 3182623SN/A 3192662Sstever@eecs.umich.eduExport('base_dir') 3202623SN/AExport('extras_dir_list') 3212623SN/A 3222662Sstever@eecs.umich.edu# the ext directory should be on the #includes path 3232623SN/Amain.Append(CPPPATH=[Dir('ext')]) 3242623SN/A 3252641Sstever@eecs.umich.edu# Add shared top-level headers 3262631SN/Amain.Prepend(CPPPATH=Dir('include')) 3272631SN/A 3282631SN/Aif GetOption('verbose'): 3292631SN/A def MakeAction(action, string, *args, **kwargs): 3302623SN/A return Action(action, *args, **kwargs) 3312623SN/Aelse: 3322623SN/A MakeAction = Action 3332623SN/A main['CCCOMSTR'] = Transform("CC") 3342623SN/A main['CXXCOMSTR'] = Transform("CXX") 3352623SN/A main['ASCOMSTR'] = Transform("AS") 3362623SN/A main['ARCOMSTR'] = Transform("AR", 0) 3372623SN/A main['LINKCOMSTR'] = Transform("LINK", 0) 3382623SN/A main['SHLINKCOMSTR'] = Transform("SHLINK", 0) 3392623SN/A main['RANLIBCOMSTR'] = Transform("RANLIB", 0) 3402623SN/A main['M4COMSTR'] = Transform("M4") 3412623SN/A main['SHCCCOMSTR'] = Transform("SHCC") 3422623SN/A main['SHCXXCOMSTR'] = Transform("SHCXX") 3432623SN/AExport('MakeAction') 3442623SN/A 3452623SN/A# Initialize the Link-Time Optimization (LTO) flags 3462623SN/Amain['LTO_CCFLAGS'] = [] 3472623SN/Amain['LTO_LDFLAGS'] = [] 3482623SN/A 3492623SN/A# According to the readme, tcmalloc works best if the compiler doesn't 3502623SN/A# assume that we're using the builtin malloc and friends. These flags 3512623SN/A# are compiler-specific, so we need to set them after we detect which 3522623SN/A# compiler we're using. 3532623SN/Amain['TCMALLOC_CCFLAGS'] = [] 3542623SN/A 3552623SN/ACXX_version = readCommand([main['CXX'],'--version'], exception=False) 3562623SN/ACXX_V = readCommand([main['CXX'],'-V'], exception=False) 3572623SN/A 3582623SN/Amain['GCC'] = CXX_version and CXX_version.find('g++') >= 0 3592623SN/Amain['CLANG'] = CXX_version and CXX_version.find('clang') >= 0 3602623SN/Aif main['GCC'] + main['CLANG'] > 1: 3612623SN/A print('Error: How can we have two at the same time?') 3622623SN/A Exit(1) 3632623SN/A 3642623SN/A# Set up default C++ compiler flags 3652623SN/Aif main['GCC'] or main['CLANG']: 3662623SN/A # As gcc and clang share many flags, do the common parts here 3672623SN/A main.Append(CCFLAGS=['-pipe']) 3682623SN/A main.Append(CCFLAGS=['-fno-strict-aliasing']) 3692623SN/A # Enable -Wall and -Wextra and then disable the few warnings that 3702623SN/A # we consistently violate 3712623SN/A main.Append(CCFLAGS=['-Wall', '-Wundef', '-Wextra', 3722623SN/A '-Wno-sign-compare', '-Wno-unused-parameter']) 3732623SN/A # We always compile using C++11 3742623SN/A main.Append(CXXFLAGS=['-std=c++11']) 3752623SN/A if sys.platform.startswith('freebsd'): 3762623SN/A main.Append(CCFLAGS=['-I/usr/local/include']) 3772623SN/A main.Append(CXXFLAGS=['-I/usr/local/include']) 3782623SN/A 3792623SN/A main['FILTER_PSHLINKFLAGS'] = lambda x: str(x).replace(' -shared', '') 3802623SN/A main['PSHLINKFLAGS'] = main.subst('${FILTER_PSHLINKFLAGS(SHLINKFLAGS)}') 3812623SN/A if GetOption('gold_linker'): 3822623SN/A main.Append(LINKFLAGS='-fuse-ld=gold') 3832623SN/A main['PLINKFLAGS'] = main.subst('${LINKFLAGS}') 3842623SN/A shared_partial_flags = ['-r', '-nostdlib'] 3852623SN/A main.Append(PSHLINKFLAGS=shared_partial_flags) 3862623SN/A main.Append(PLINKFLAGS=shared_partial_flags) 3872623SN/A 3882623SN/A # Treat warnings as errors but white list some warnings that we 3892623SN/A # want to allow (e.g., deprecation warnings). 3902623SN/A main.Append(CCFLAGS=['-Werror', 3912623SN/A '-Wno-error=deprecated-declarations', 3922623SN/A '-Wno-error=deprecated', 3932623SN/A ]) 3942623SN/Aelse: 3952623SN/A print(termcap.Yellow + termcap.Bold + 'Error' + termcap.Normal, end=' ') 3962626SN/A print("Don't know what compiler options to use for your compiler.") 3972626SN/A print(termcap.Yellow + ' compiler:' + termcap.Normal, main['CXX']) 3982662Sstever@eecs.umich.edu print(termcap.Yellow + ' version:' + termcap.Normal, end = ' ') 3992623SN/A if not CXX_version: 4002623SN/A print(termcap.Yellow + termcap.Bold + "COMMAND NOT FOUND!" + 4012662Sstever@eecs.umich.edu termcap.Normal) 4022662Sstever@eecs.umich.edu else: 4032662Sstever@eecs.umich.edu print(CXX_version.replace('\n', '<nl>')) 4042623SN/A print(" If you're trying to use a compiler other than GCC") 4052623SN/A print(" or clang, there appears to be something wrong with your") 4062623SN/A print(" environment.") 4072623SN/A print(" ") 4082623SN/A print(" If you are trying to use a compiler other than those listed") 4092623SN/A print(" above you will need to ease fix SConstruct and ") 4102623SN/A print(" src/SConscript to support that compiler.") 4112623SN/A Exit(1) 4122623SN/A 4132623SN/Aif main['GCC']: 4142623SN/A # Check for a supported version of gcc. >= 4.8 is chosen for its 4152623SN/A # level of c++11 support. See 4162623SN/A # http://gcc.gnu.org/projects/cxx0x.html for details. 4172623SN/A gcc_version = readCommand([main['CXX'], '-dumpversion'], exception=False) 4182662Sstever@eecs.umich.edu if compareVersions(gcc_version, "4.8") < 0: 4192623SN/A print('Error: gcc version 4.8 or newer required.') 4202662Sstever@eecs.umich.edu print(' Installed version: ', gcc_version) 4212623SN/A Exit(1) 4222623SN/A 4232623SN/A main['GCC_VERSION'] = gcc_version 4242623SN/A 4252623SN/A if compareVersions(gcc_version, '4.9') >= 0: 4262623SN/A # Incremental linking with LTO is currently broken in gcc versions 4272623SN/A # 4.9 and above. A version where everything works completely hasn't 4282623SN/A # yet been identified. 4292626SN/A # 4302626SN/A # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67548 4312623SN/A main['BROKEN_INCREMENTAL_LTO'] = True 4322623SN/A if compareVersions(gcc_version, '6.0') >= 0: 4332623SN/A # gcc versions 6.0 and greater accept an -flinker-output flag which 4342623SN/A # selects what type of output the linker should generate. This is 4352623SN/A # necessary for incremental lto to work, but is also broken in 4362623SN/A # current versions of gcc. It may not be necessary in future 4372623SN/A # versions. We add it here since it might be, and as a reminder that 4382623SN/A # it exists. It's excluded if lto is being forced. 4392623SN/A # 4402623SN/A # https://gcc.gnu.org/gcc-6/changes.html 4412623SN/A # https://gcc.gnu.org/ml/gcc-patches/2015-11/msg03161.html 4422623SN/A # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69866 4432623SN/A if not GetOption('force_lto'): 4442623SN/A main.Append(PSHLINKFLAGS='-flinker-output=rel') 4452623SN/A main.Append(PLINKFLAGS='-flinker-output=rel') 4462623SN/A 4472623SN/A # Make sure we warn if the user has requested to compile with the 4482623SN/A # Undefined Benahvior Sanitizer and this version of gcc does not 4492623SN/A # support it. 4502623SN/A if GetOption('with_ubsan') and \ 4512623SN/A compareVersions(gcc_version, '4.9') < 0: 4522623SN/A print(termcap.Yellow + termcap.Bold + 4532623SN/A 'Warning: UBSan is only supported using gcc 4.9 and later.' + 4542623SN/A termcap.Normal) 4552623SN/A 4562623SN/A disable_lto = GetOption('no_lto') 4572623SN/A if not disable_lto and main.get('BROKEN_INCREMENTAL_LTO', False) and \ 4582623SN/A not GetOption('force_lto'): 4592623SN/A print(termcap.Yellow + termcap.Bold + 4602623SN/A 'Warning: Your compiler doesn\'t support incremental linking' + 4612623SN/A ' and lto at the same time, so lto is being disabled. To force' + 4622623SN/A ' lto on anyway, use the --force-lto option. That will disable' + 4632623SN/A ' partial linking.' + 4642623SN/A termcap.Normal) 4652623SN/A disable_lto = True 4662623SN/A 4672623SN/A # Add the appropriate Link-Time Optimization (LTO) flags 4682623SN/A # unless LTO is explicitly turned off. Note that these flags 4692623SN/A # are only used by the fast target. 4702623SN/A if not disable_lto: 4712623SN/A # Pass the LTO flag when compiling to produce GIMPLE 4722623SN/A # output, we merely create the flags here and only append 4732623SN/A # them later 4742623SN/A main['LTO_CCFLAGS'] = ['-flto=%d' % GetOption('num_jobs')] 4752623SN/A 4762623SN/A # Use the same amount of jobs for LTO as we are running 4772623SN/A # scons with 4782623SN/A main['LTO_LDFLAGS'] = ['-flto=%d' % GetOption('num_jobs')] 4792623SN/A 4802623SN/A main.Append(TCMALLOC_CCFLAGS=['-fno-builtin-malloc', '-fno-builtin-calloc', 4812623SN/A '-fno-builtin-realloc', '-fno-builtin-free']) 4822623SN/A 4832623SN/A # The address sanitizer is available for gcc >= 4.8 4842623SN/A if GetOption('with_asan'): 4852623SN/A if GetOption('with_ubsan') and \ 4862623SN/A compareVersions(main['GCC_VERSION'], '4.9') >= 0: 4872623SN/A main.Append(CCFLAGS=['-fsanitize=address,undefined', 4882623SN/A '-fno-omit-frame-pointer'], 4892623SN/A LINKFLAGS='-fsanitize=address,undefined') 4902623SN/A else: 4912623SN/A main.Append(CCFLAGS=['-fsanitize=address', 4922623SN/A '-fno-omit-frame-pointer'], 4932623SN/A LINKFLAGS='-fsanitize=address') 4942623SN/A # Only gcc >= 4.9 supports UBSan, so check both the version 4952623SN/A # and the command-line option before adding the compiler and 4962623SN/A # linker flags. 4972623SN/A elif GetOption('with_ubsan') and \ 4982623SN/A compareVersions(main['GCC_VERSION'], '4.9') >= 0: 4992623SN/A main.Append(CCFLAGS='-fsanitize=undefined') 5002623SN/A main.Append(LINKFLAGS='-fsanitize=undefined') 5012623SN/A 5022623SN/Aelif main['CLANG']: 5032623SN/A # Check for a supported version of clang, >= 3.1 is needed to 5042623SN/A # support similar features as gcc 4.8. See 5052623SN/A # http://clang.llvm.org/cxx_status.html for details 5062623SN/A clang_version_re = re.compile(".* version (\d+\.\d+)") 5072623SN/A clang_version_match = clang_version_re.search(CXX_version) 5082623SN/A if (clang_version_match): 5092623SN/A clang_version = clang_version_match.groups()[0] 5102623SN/A if compareVersions(clang_version, "3.1") < 0: 5112623SN/A print('Error: clang version 3.1 or newer required.') 5122623SN/A print(' Installed version:', clang_version) 5132623SN/A Exit(1) 5142623SN/A else: 5152623SN/A print('Error: Unable to determine clang version.') 5162623SN/A Exit(1) 5172623SN/A 5182623SN/A # clang has a few additional warnings that we disable, extraneous 5192623SN/A # parantheses are allowed due to Ruby's printing of the AST, 5202623SN/A # finally self assignments are allowed as the generated CPU code 5212623SN/A # is relying on this 5222623SN/A main.Append(CCFLAGS=['-Wno-parentheses', 5232623SN/A '-Wno-self-assign', 5242623SN/A # Some versions of libstdc++ (4.8?) seem to 5252623SN/A # use struct hash and class hash 5262623SN/A # interchangeably. 5272623SN/A '-Wno-mismatched-tags', 5282623SN/A ]) 5292623SN/A 5302623SN/A main.Append(TCMALLOC_CCFLAGS=['-fno-builtin']) 531 532 # On Mac OS X/Darwin we need to also use libc++ (part of XCode) as 533 # opposed to libstdc++, as the later is dated. 534 if sys.platform == "darwin": 535 main.Append(CXXFLAGS=['-stdlib=libc++']) 536 main.Append(LIBS=['c++']) 537 538 # On FreeBSD we need libthr. 539 if sys.platform.startswith('freebsd'): 540 main.Append(LIBS=['thr']) 541 542 # We require clang >= 3.1, so there is no need to check any 543 # versions here. 544 if GetOption('with_ubsan'): 545 if GetOption('with_asan'): 546 main.Append(CCFLAGS=['-fsanitize=address,undefined', 547 '-fno-omit-frame-pointer'], 548 LINKFLAGS='-fsanitize=address,undefined') 549 else: 550 main.Append(CCFLAGS='-fsanitize=undefined', 551 LINKFLAGS='-fsanitize=undefined') 552 553 elif GetOption('with_asan'): 554 main.Append(CCFLAGS=['-fsanitize=address', 555 '-fno-omit-frame-pointer'], 556 LINKFLAGS='-fsanitize=address') 557 558else: 559 print(termcap.Yellow + termcap.Bold + 'Error' + termcap.Normal, end=' ') 560 print("Don't know what compiler options to use for your compiler.") 561 print(termcap.Yellow + ' compiler:' + termcap.Normal, main['CXX']) 562 print(termcap.Yellow + ' version:' + termcap.Normal, end=' ') 563 if not CXX_version: 564 print(termcap.Yellow + termcap.Bold + "COMMAND NOT FOUND!" + 565 termcap.Normal) 566 else: 567 print(CXX_version.replace('\n', '<nl>')) 568 print(" If you're trying to use a compiler other than GCC") 569 print(" or clang, there appears to be something wrong with your") 570 print(" environment.") 571 print(" ") 572 print(" If you are trying to use a compiler other than those listed") 573 print(" above you will need to ease fix SConstruct and ") 574 print(" src/SConscript to support that compiler.") 575 Exit(1) 576 577# Set up common yacc/bison flags (needed for Ruby) 578main['YACCFLAGS'] = '-d' 579main['YACCHXXFILESUFFIX'] = '.hh' 580 581# Do this after we save setting back, or else we'll tack on an 582# extra 'qdo' every time we run scons. 583if main['BATCH']: 584 main['CC'] = main['BATCH_CMD'] + ' ' + main['CC'] 585 main['CXX'] = main['BATCH_CMD'] + ' ' + main['CXX'] 586 main['AS'] = main['BATCH_CMD'] + ' ' + main['AS'] 587 main['AR'] = main['BATCH_CMD'] + ' ' + main['AR'] 588 main['RANLIB'] = main['BATCH_CMD'] + ' ' + main['RANLIB'] 589 590if sys.platform == 'cygwin': 591 # cygwin has some header file issues... 592 main.Append(CCFLAGS=["-Wno-uninitialized"]) 593 594 595have_pkg_config = readCommand(['pkg-config', '--version'], exception='') 596 597# Check for the protobuf compiler 598protoc_version = readCommand([main['PROTOC'], '--version'], 599 exception='').split() 600 601# First two words should be "libprotoc x.y.z" 602if len(protoc_version) < 2 or protoc_version[0] != 'libprotoc': 603 print(termcap.Yellow + termcap.Bold + 604 'Warning: Protocol buffer compiler (protoc) not found.\n' + 605 ' Please install protobuf-compiler for tracing support.' + 606 termcap.Normal) 607 main['PROTOC'] = False 608else: 609 # Based on the availability of the compress stream wrappers, 610 # require 2.1.0 611 min_protoc_version = '2.1.0' 612 if compareVersions(protoc_version[1], min_protoc_version) < 0: 613 print(termcap.Yellow + termcap.Bold + 614 'Warning: protoc version', min_protoc_version, 615 'or newer required.\n' + 616 ' Installed version:', protoc_version[1], 617 termcap.Normal) 618 main['PROTOC'] = False 619 else: 620 # Attempt to determine the appropriate include path and 621 # library path using pkg-config, that means we also need to 622 # check for pkg-config. Note that it is possible to use 623 # protobuf without the involvement of pkg-config. Later on we 624 # check go a library config check and at that point the test 625 # will fail if libprotobuf cannot be found. 626 if have_pkg_config: 627 try: 628 # Attempt to establish what linking flags to add for protobuf 629 # using pkg-config 630 main.ParseConfig('pkg-config --cflags --libs-only-L protobuf') 631 except: 632 print(termcap.Yellow + termcap.Bold + 633 'Warning: pkg-config could not get protobuf flags.' + 634 termcap.Normal) 635 636 637# Check for 'timeout' from GNU coreutils. If present, regressions will 638# be run with a time limit. We require version 8.13 since we rely on 639# support for the '--foreground' option. 640if sys.platform.startswith('freebsd'): 641 timeout_lines = readCommand(['gtimeout', '--version'], 642 exception='').splitlines() 643else: 644 timeout_lines = readCommand(['timeout', '--version'], 645 exception='').splitlines() 646# Get the first line and tokenize it 647timeout_version = timeout_lines[0].split() if timeout_lines else [] 648main['TIMEOUT'] = timeout_version and \ 649 compareVersions(timeout_version[-1], '8.13') >= 0 650 651# Add a custom Check function to test for structure members. 652def CheckMember(context, include, decl, member, include_quotes="<>"): 653 context.Message("Checking for member %s in %s..." % 654 (member, decl)) 655 text = """ 656#include %(header)s 657int main(){ 658 %(decl)s test; 659 (void)test.%(member)s; 660 return 0; 661}; 662""" % { "header" : include_quotes[0] + include + include_quotes[1], 663 "decl" : decl, 664 "member" : member, 665 } 666 667 ret = context.TryCompile(text, extension=".cc") 668 context.Result(ret) 669 return ret 670 671# Platform-specific configuration. Note again that we assume that all 672# builds under a given build root run on the same host platform. 673conf = Configure(main, 674 conf_dir = joinpath(build_root, '.scons_config'), 675 log_file = joinpath(build_root, 'scons_config.log'), 676 custom_tests = { 677 'CheckMember' : CheckMember, 678 }) 679 680# Check if we should compile a 64 bit binary on Mac OS X/Darwin 681try: 682 import platform 683 uname = platform.uname() 684 if uname[0] == 'Darwin' and compareVersions(uname[2], '9.0.0') >= 0: 685 if int(readCommand('sysctl -n hw.cpu64bit_capable')[0]): 686 main.Append(CCFLAGS=['-arch', 'x86_64']) 687 main.Append(CFLAGS=['-arch', 'x86_64']) 688 main.Append(LINKFLAGS=['-arch', 'x86_64']) 689 main.Append(ASFLAGS=['-arch', 'x86_64']) 690except: 691 pass 692 693# Recent versions of scons substitute a "Null" object for Configure() 694# when configuration isn't necessary, e.g., if the "--help" option is 695# present. Unfortuantely this Null object always returns false, 696# breaking all our configuration checks. We replace it with our own 697# more optimistic null object that returns True instead. 698if not conf: 699 def NullCheck(*args, **kwargs): 700 return True 701 702 class NullConf: 703 def __init__(self, env): 704 self.env = env 705 def Finish(self): 706 return self.env 707 def __getattr__(self, mname): 708 return NullCheck 709 710 conf = NullConf(main) 711 712# Cache build files in the supplied directory. 713if main['M5_BUILD_CACHE']: 714 print('Using build cache located at', main['M5_BUILD_CACHE']) 715 CacheDir(main['M5_BUILD_CACHE']) 716 717main['USE_PYTHON'] = not GetOption('without_python') 718if main['USE_PYTHON']: 719 # Find Python include and library directories for embedding the 720 # interpreter. We rely on python-config to resolve the appropriate 721 # includes and linker flags. ParseConfig does not seem to understand 722 # the more exotic linker flags such as -Xlinker and -export-dynamic so 723 # we add them explicitly below. If you want to link in an alternate 724 # version of python, see above for instructions on how to invoke 725 # scons with the appropriate PATH set. 726 727 python_config = find_first_prog(main['PYTHON_CONFIG']) 728 if python_config is None: 729 print("Error: can't find a suitable python-config, tried %s" % \ 730 main['PYTHON_CONFIG']) 731 Exit(1) 732 733 print("Info: Using Python config: %s" % (python_config, )) 734 py_includes = readCommand([python_config, '--includes'], 735 exception='').split() 736 py_includes = filter(lambda s: match(r'.*\/include\/.*',s), py_includes) 737 # Strip the -I from the include folders before adding them to the 738 # CPPPATH 739 py_includes = map(lambda s: s[2:] if s.startswith('-I') else s, py_includes) 740 main.Append(CPPPATH=py_includes) 741 742 # Read the linker flags and split them into libraries and other link 743 # flags. The libraries are added later through the call the CheckLib. 744 py_ld_flags = readCommand([python_config, '--ldflags'], 745 exception='').split() 746 py_libs = [] 747 for lib in py_ld_flags: 748 if not lib.startswith('-l'): 749 main.Append(LINKFLAGS=[lib]) 750 else: 751 lib = lib[2:] 752 if lib not in py_libs: 753 py_libs.append(lib) 754 755 # verify that this stuff works 756 if not conf.CheckHeader('Python.h', '<>'): 757 print("Error: Check failed for Python.h header in", py_includes) 758 print("Two possible reasons:") 759 print("1. Python headers are not installed (You can install the " 760 "package python-dev on Ubuntu and RedHat)") 761 print("2. SCons is using a wrong C compiler. This can happen if " 762 "CC has the wrong value.") 763 print("CC = %s" % main['CC']) 764 Exit(1) 765 766 for lib in py_libs: 767 if not conf.CheckLib(lib): 768 print("Error: can't find library %s required by python" % lib) 769 Exit(1) 770 771# On Solaris you need to use libsocket for socket ops 772if not conf.CheckLibWithHeader(None, 'sys/socket.h', 'C++', 'accept(0,0,0);'): 773 if not conf.CheckLibWithHeader('socket', 'sys/socket.h', 'C++', 'accept(0,0,0);'): 774 print("Can't find library with socket calls (e.g. accept())") 775 Exit(1) 776 777# Check for zlib. If the check passes, libz will be automatically 778# added to the LIBS environment variable. 779if not conf.CheckLibWithHeader('z', 'zlib.h', 'C++','zlibVersion();'): 780 print('Error: did not find needed zlib compression library ' 781 'and/or zlib.h header file.') 782 print(' Please install zlib and try again.') 783 Exit(1) 784 785# If we have the protobuf compiler, also make sure we have the 786# development libraries. If the check passes, libprotobuf will be 787# automatically added to the LIBS environment variable. After 788# this, we can use the HAVE_PROTOBUF flag to determine if we have 789# got both protoc and libprotobuf available. 790main['HAVE_PROTOBUF'] = main['PROTOC'] and \ 791 conf.CheckLibWithHeader('protobuf', 'google/protobuf/message.h', 792 'C++', 'GOOGLE_PROTOBUF_VERIFY_VERSION;') 793 794# Valgrind gets much less confused if you tell it when you're using 795# alternative stacks. 796main['HAVE_VALGRIND'] = conf.CheckCHeader('valgrind/valgrind.h') 797 798# If we have the compiler but not the library, print another warning. 799if main['PROTOC'] and not main['HAVE_PROTOBUF']: 800 print(termcap.Yellow + termcap.Bold + 801 'Warning: did not find protocol buffer library and/or headers.\n' + 802 ' Please install libprotobuf-dev for tracing support.' + 803 termcap.Normal) 804 805# Check for librt. 806have_posix_clock = \ 807 conf.CheckLibWithHeader(None, 'time.h', 'C', 808 'clock_nanosleep(0,0,NULL,NULL);') or \ 809 conf.CheckLibWithHeader('rt', 'time.h', 'C', 810 'clock_nanosleep(0,0,NULL,NULL);') 811 812have_posix_timers = \ 813 conf.CheckLibWithHeader([None, 'rt'], [ 'time.h', 'signal.h' ], 'C', 814 'timer_create(CLOCK_MONOTONIC, NULL, NULL);') 815 816if not GetOption('without_tcmalloc'): 817 if conf.CheckLib('tcmalloc'): 818 main.Append(CCFLAGS=main['TCMALLOC_CCFLAGS']) 819 elif conf.CheckLib('tcmalloc_minimal'): 820 main.Append(CCFLAGS=main['TCMALLOC_CCFLAGS']) 821 else: 822 print(termcap.Yellow + termcap.Bold + 823 "You can get a 12% performance improvement by " 824 "installing tcmalloc (libgoogle-perftools-dev package " 825 "on Ubuntu or RedHat)." + termcap.Normal) 826 827 828# Detect back trace implementations. The last implementation in the 829# list will be used by default. 830backtrace_impls = [ "none" ] 831 832backtrace_checker = 'char temp;' + \ 833 ' backtrace_symbols_fd((void*)&temp, 0, 0);' 834if conf.CheckLibWithHeader(None, 'execinfo.h', 'C', backtrace_checker): 835 backtrace_impls.append("glibc") 836elif conf.CheckLibWithHeader('execinfo', 'execinfo.h', 'C', 837 backtrace_checker): 838 # NetBSD and FreeBSD need libexecinfo. 839 backtrace_impls.append("glibc") 840 main.Append(LIBS=['execinfo']) 841 842if backtrace_impls[-1] == "none": 843 default_backtrace_impl = "none" 844 print(termcap.Yellow + termcap.Bold + 845 "No suitable back trace implementation found." + 846 termcap.Normal) 847 848if not have_posix_clock: 849 print("Can't find library for POSIX clocks.") 850 851# Check for <fenv.h> (C99 FP environment control) 852have_fenv = conf.CheckHeader('fenv.h', '<>') 853if not have_fenv: 854 print("Warning: Header file <fenv.h> not found.") 855 print(" This host has no IEEE FP rounding mode control.") 856 857# Check for <png.h> (libpng library needed if wanting to dump 858# frame buffer image in png format) 859have_png = conf.CheckHeader('png.h', '<>') 860if not have_png: 861 print("Warning: Header file <png.h> not found.") 862 print(" This host has no libpng library.") 863 print(" Disabling support for PNG framebuffers.") 864 865# Check if we should enable KVM-based hardware virtualization. The API 866# we rely on exists since version 2.6.36 of the kernel, but somehow 867# the KVM_API_VERSION does not reflect the change. We test for one of 868# the types as a fall back. 869have_kvm = conf.CheckHeader('linux/kvm.h', '<>') 870if not have_kvm: 871 print("Info: Compatible header file <linux/kvm.h> not found, " 872 "disabling KVM support.") 873 874# Check if the TUN/TAP driver is available. 875have_tuntap = conf.CheckHeader('linux/if_tun.h', '<>') 876if not have_tuntap: 877 print("Info: Compatible header file <linux/if_tun.h> not found.") 878 879# x86 needs support for xsave. We test for the structure here since we 880# won't be able to run new tests by the time we know which ISA we're 881# targeting. 882have_kvm_xsave = conf.CheckTypeSize('struct kvm_xsave', 883 '#include <linux/kvm.h>') != 0 884 885# Check if the requested target ISA is compatible with the host 886def is_isa_kvm_compatible(isa): 887 try: 888 import platform 889 host_isa = platform.machine() 890 except: 891 print("Warning: Failed to determine host ISA.") 892 return False 893 894 if not have_posix_timers: 895 print("Warning: Can not enable KVM, host seems to lack support " 896 "for POSIX timers") 897 return False 898 899 if isa == "arm": 900 return host_isa in ( "armv7l", "aarch64" ) 901 elif isa == "x86": 902 if host_isa != "x86_64": 903 return False 904 905 if not have_kvm_xsave: 906 print("KVM on x86 requires xsave support in kernel headers.") 907 return False 908 909 return True 910 else: 911 return False 912 913 914# Check if the exclude_host attribute is available. We want this to 915# get accurate instruction counts in KVM. 916main['HAVE_PERF_ATTR_EXCLUDE_HOST'] = conf.CheckMember( 917 'linux/perf_event.h', 'struct perf_event_attr', 'exclude_host') 918 919def check_hdf5(): 920 return \ 921 conf.CheckLibWithHeader('hdf5', 'hdf5.h', 'C', 922 'H5Fcreate("", 0, 0, 0);') and \ 923 conf.CheckLibWithHeader('hdf5_cpp', 'H5Cpp.h', 'C++', 924 'H5::H5File("", 0);') 925 926def check_hdf5_pkg(name): 927 print("Checking for %s using pkg-config..." % name, end="") 928 if not have_pkg_config: 929 print(" pkg-config not found") 930 return False 931 932 try: 933 main.ParseConfig('pkg-config --cflags-only-I --libs-only-L %s' % name) 934 print(" yes") 935 return True 936 except: 937 print(" no") 938 return False 939 940# Check if there is a pkg-config configuration for hdf5. If we find 941# it, setup the environment to enable linking and header inclusion. We 942# don't actually try to include any headers or link with hdf5 at this 943# stage. 944if not check_hdf5_pkg('hdf5-serial'): 945 check_hdf5_pkg('hdf5') 946 947# Check if the HDF5 libraries can be found. This check respects the 948# include path and library path provided by pkg-config. We perform 949# this check even if there isn't a pkg-config configuration for hdf5 950# since some installations don't use pkg-config. 951have_hdf5 = check_hdf5() 952if not have_hdf5: 953 print("Warning: Couldn't find any HDF5 C++ libraries. Disabling") 954 print(" HDF5 support.") 955 956###################################################################### 957# 958# Finish the configuration 959# 960main = conf.Finish() 961 962###################################################################### 963# 964# Collect all non-global variables 965# 966 967# Define the universe of supported ISAs 968all_isa_list = [ ] 969all_gpu_isa_list = [ ] 970Export('all_isa_list') 971Export('all_gpu_isa_list') 972 973class CpuModel(object): 974 '''The CpuModel class encapsulates everything the ISA parser needs to 975 know about a particular CPU model.''' 976 977 # Dict of available CPU model objects. Accessible as CpuModel.dict. 978 dict = {} 979 980 # Constructor. Automatically adds models to CpuModel.dict. 981 def __init__(self, name, default=False): 982 self.name = name # name of model 983 984 # This cpu is enabled by default 985 self.default = default 986 987 # Add self to dict 988 if name in CpuModel.dict: 989 raise AttributeError, "CpuModel '%s' already registered" % name 990 CpuModel.dict[name] = self 991 992Export('CpuModel') 993 994# Sticky variables get saved in the variables file so they persist from 995# one invocation to the next (unless overridden, in which case the new 996# value becomes sticky). 997sticky_vars = Variables(args=ARGUMENTS) 998Export('sticky_vars') 999 1000# Sticky variables that should be exported 1001export_vars = [] 1002Export('export_vars') 1003 1004# For Ruby 1005all_protocols = [] 1006Export('all_protocols') 1007protocol_dirs = [] 1008Export('protocol_dirs') 1009slicc_includes = [] 1010Export('slicc_includes') 1011 1012# Walk the tree and execute all SConsopts scripts that wil add to the 1013# above variables 1014if GetOption('verbose'): 1015 print("Reading SConsopts") 1016for bdir in [ base_dir ] + extras_dir_list: 1017 if not isdir(bdir): 1018 print("Error: directory '%s' does not exist" % bdir) 1019 Exit(1) 1020 for root, dirs, files in os.walk(bdir): 1021 if 'SConsopts' in files: 1022 if GetOption('verbose'): 1023 print("Reading", joinpath(root, 'SConsopts')) 1024 SConscript(joinpath(root, 'SConsopts')) 1025 1026all_isa_list.sort() 1027all_gpu_isa_list.sort() 1028 1029sticky_vars.AddVariables( 1030 EnumVariable('TARGET_ISA', 'Target ISA', 'alpha', all_isa_list), 1031 EnumVariable('TARGET_GPU_ISA', 'Target GPU ISA', 'hsail', all_gpu_isa_list), 1032 ListVariable('CPU_MODELS', 'CPU models', 1033 sorted(n for n,m in CpuModel.dict.iteritems() if m.default), 1034 sorted(CpuModel.dict.keys())), 1035 BoolVariable('EFENCE', 'Link with Electric Fence malloc debugger', 1036 False), 1037 BoolVariable('SS_COMPATIBLE_FP', 1038 'Make floating-point results compatible with SimpleScalar', 1039 False), 1040 BoolVariable('USE_SSE2', 1041 'Compile for SSE2 (-msse2) to get IEEE FP on x86 hosts', 1042 False), 1043 BoolVariable('USE_POSIX_CLOCK', 'Use POSIX Clocks', have_posix_clock), 1044 BoolVariable('USE_FENV', 'Use <fenv.h> IEEE mode control', have_fenv), 1045 BoolVariable('USE_PNG', 'Enable support for PNG images', have_png), 1046 BoolVariable('CP_ANNOTATE', 'Enable critical path annotation capability', 1047 False), 1048 BoolVariable('USE_KVM', 'Enable hardware virtualized (KVM) CPU models', 1049 have_kvm), 1050 BoolVariable('USE_TUNTAP', 1051 'Enable using a tap device to bridge to the host network', 1052 have_tuntap), 1053 BoolVariable('BUILD_GPU', 'Build the compute-GPU model', False), 1054 EnumVariable('PROTOCOL', 'Coherence protocol for Ruby', 'None', 1055 all_protocols), 1056 EnumVariable('BACKTRACE_IMPL', 'Post-mortem dump implementation', 1057 backtrace_impls[-1], backtrace_impls), 1058 ('NUMBER_BITS_PER_SET', 'Max elements in set (default 64)', 1059 64), 1060 BoolVariable('USE_HDF5', 'Enable the HDF5 support', have_hdf5), 1061 ) 1062 1063# These variables get exported to #defines in config/*.hh (see src/SConscript). 1064export_vars += ['USE_FENV', 'SS_COMPATIBLE_FP', 'TARGET_ISA', 'TARGET_GPU_ISA', 1065 'CP_ANNOTATE', 'USE_POSIX_CLOCK', 'USE_KVM', 'USE_TUNTAP', 1066 'PROTOCOL', 'HAVE_PROTOBUF', 'HAVE_VALGRIND', 1067 'HAVE_PERF_ATTR_EXCLUDE_HOST', 'USE_PNG', 1068 'NUMBER_BITS_PER_SET', 'USE_HDF5'] 1069 1070################################################### 1071# 1072# Define a SCons builder for configuration flag headers. 1073# 1074################################################### 1075 1076# This function generates a config header file that #defines the 1077# variable symbol to the current variable setting (0 or 1). The source 1078# operands are the name of the variable and a Value node containing the 1079# value of the variable. 1080def build_config_file(target, source, env): 1081 (variable, value) = [s.get_contents() for s in source] 1082 f = file(str(target[0]), 'w') 1083 print('#define', variable, value, file=f) 1084 f.close() 1085 return None 1086 1087# Combine the two functions into a scons Action object. 1088config_action = MakeAction(build_config_file, Transform("CONFIG H", 2)) 1089 1090# The emitter munges the source & target node lists to reflect what 1091# we're really doing. 1092def config_emitter(target, source, env): 1093 # extract variable name from Builder arg 1094 variable = str(target[0]) 1095 # True target is config header file 1096 target = joinpath('config', variable.lower() + '.hh') 1097 val = env[variable] 1098 if isinstance(val, bool): 1099 # Force value to 0/1 1100 val = int(val) 1101 elif isinstance(val, str): 1102 val = '"' + val + '"' 1103 1104 # Sources are variable name & value (packaged in SCons Value nodes) 1105 return ([target], [Value(variable), Value(val)]) 1106 1107config_builder = Builder(emitter = config_emitter, action = config_action) 1108 1109main.Append(BUILDERS = { 'ConfigFile' : config_builder }) 1110 1111################################################### 1112# 1113# Builders for static and shared partially linked object files. 1114# 1115################################################### 1116 1117partial_static_builder = Builder(action=SCons.Defaults.LinkAction, 1118 src_suffix='$OBJSUFFIX', 1119 src_builder=['StaticObject', 'Object'], 1120 LINKFLAGS='$PLINKFLAGS', 1121 LIBS='') 1122 1123def partial_shared_emitter(target, source, env): 1124 for tgt in target: 1125 tgt.attributes.shared = 1 1126 return (target, source) 1127partial_shared_builder = Builder(action=SCons.Defaults.ShLinkAction, 1128 emitter=partial_shared_emitter, 1129 src_suffix='$SHOBJSUFFIX', 1130 src_builder='SharedObject', 1131 SHLINKFLAGS='$PSHLINKFLAGS', 1132 LIBS='') 1133 1134main.Append(BUILDERS = { 'PartialShared' : partial_shared_builder, 1135 'PartialStatic' : partial_static_builder }) 1136 1137def add_local_rpath(env, *targets): 1138 '''Set up an RPATH for a library which lives in the build directory. 1139 1140 The construction environment variable BIN_RPATH_PREFIX should be set to 1141 the relative path of the build directory starting from the location of the 1142 binary.''' 1143 for target in targets: 1144 target = env.Entry(target) 1145 if not isinstance(target, SCons.Node.FS.Dir): 1146 target = target.dir 1147 relpath = os.path.relpath(target.abspath, env['BUILDDIR']) 1148 components = [ 1149 '\\$$ORIGIN', 1150 '${BIN_RPATH_PREFIX}', 1151 relpath 1152 ] 1153 env.Append(RPATH=[env.Literal(os.path.join(*components))]) 1154 1155if sys.platform != "darwin": 1156 main.Append(LINKFLAGS=Split('-z origin')) 1157 1158main.AddMethod(add_local_rpath, 'AddLocalRPATH') 1159 1160# builds in ext are shared across all configs in the build root. 1161ext_dir = abspath(joinpath(str(main.root), 'ext')) 1162ext_build_dirs = [] 1163for root, dirs, files in os.walk(ext_dir): 1164 if 'SConscript' in files: 1165 build_dir = os.path.relpath(root, ext_dir) 1166 ext_build_dirs.append(build_dir) 1167 main.SConscript(joinpath(root, 'SConscript'), 1168 variant_dir=joinpath(build_root, build_dir)) 1169 1170gdb_xml_dir = joinpath(ext_dir, 'gdb-xml') 1171Export('gdb_xml_dir') 1172 1173main.Prepend(CPPPATH=Dir('ext/pybind11/include/')) 1174 1175################################################### 1176# 1177# This builder and wrapper method are used to set up a directory with 1178# switching headers. Those are headers which are in a generic location and 1179# that include more specific headers from a directory chosen at build time 1180# based on the current build settings. 1181# 1182################################################### 1183 1184def build_switching_header(target, source, env): 1185 path = str(target[0]) 1186 subdir = str(source[0]) 1187 dp, fp = os.path.split(path) 1188 dp = os.path.relpath(os.path.realpath(dp), 1189 os.path.realpath(env['BUILDDIR'])) 1190 with open(path, 'w') as hdr: 1191 print('#include "%s/%s/%s"' % (dp, subdir, fp), file=hdr) 1192 1193switching_header_action = MakeAction(build_switching_header, 1194 Transform('GENERATE')) 1195 1196switching_header_builder = Builder(action=switching_header_action, 1197 source_factory=Value, 1198 single_source=True) 1199 1200main.Append(BUILDERS = { 'SwitchingHeader': switching_header_builder }) 1201 1202def switching_headers(self, headers, source): 1203 for header in headers: 1204 self.SwitchingHeader(header, source) 1205 1206main.AddMethod(switching_headers, 'SwitchingHeaders') 1207 1208################################################### 1209# 1210# Define build environments for selected configurations. 1211# 1212################################################### 1213 1214for variant_path in variant_paths: 1215 if not GetOption('silent'): 1216 print("Building in", variant_path) 1217 1218 # Make a copy of the build-root environment to use for this config. 1219 env = main.Clone() 1220 env['BUILDDIR'] = variant_path 1221 1222 # variant_dir is the tail component of build path, and is used to 1223 # determine the build parameters (e.g., 'ALPHA_SE') 1224 (build_root, variant_dir) = splitpath(variant_path) 1225 1226 # Set env variables according to the build directory config. 1227 sticky_vars.files = [] 1228 # Variables for $BUILD_ROOT/$VARIANT_DIR are stored in 1229 # $BUILD_ROOT/variables/$VARIANT_DIR so you can nuke 1230 # $BUILD_ROOT/$VARIANT_DIR without losing your variables settings. 1231 current_vars_file = joinpath(build_root, 'variables', variant_dir) 1232 if isfile(current_vars_file): 1233 sticky_vars.files.append(current_vars_file) 1234 if not GetOption('silent'): 1235 print("Using saved variables file %s" % current_vars_file) 1236 elif variant_dir in ext_build_dirs: 1237 # Things in ext are built without a variant directory. 1238 continue 1239 else: 1240 # Build dir-specific variables file doesn't exist. 1241 1242 # Make sure the directory is there so we can create it later 1243 opt_dir = dirname(current_vars_file) 1244 if not isdir(opt_dir): 1245 mkdir(opt_dir) 1246 1247 # Get default build variables from source tree. Variables are 1248 # normally determined by name of $VARIANT_DIR, but can be 1249 # overridden by '--default=' arg on command line. 1250 default = GetOption('default') 1251 opts_dir = joinpath(main.root.abspath, 'build_opts') 1252 if default: 1253 default_vars_files = [joinpath(build_root, 'variables', default), 1254 joinpath(opts_dir, default)] 1255 else: 1256 default_vars_files = [joinpath(opts_dir, variant_dir)] 1257 existing_files = filter(isfile, default_vars_files) 1258 if existing_files: 1259 default_vars_file = existing_files[0] 1260 sticky_vars.files.append(default_vars_file) 1261 print("Variables file %s not found,\n using defaults in %s" 1262 % (current_vars_file, default_vars_file)) 1263 else: 1264 print("Error: cannot find variables file %s or " 1265 "default file(s) %s" 1266 % (current_vars_file, ' or '.join(default_vars_files))) 1267 Exit(1) 1268 1269 # Apply current variable settings to env 1270 sticky_vars.Update(env) 1271 1272 help_texts["local_vars"] += \ 1273 "Build variables for %s:\n" % variant_dir \ 1274 + sticky_vars.GenerateHelpText(env) 1275 1276 # Process variable settings. 1277 1278 if not have_fenv and env['USE_FENV']: 1279 print("Warning: <fenv.h> not available; " 1280 "forcing USE_FENV to False in", variant_dir + ".") 1281 env['USE_FENV'] = False 1282 1283 if not env['USE_FENV']: 1284 print("Warning: No IEEE FP rounding mode control in", 1285 variant_dir + ".") 1286 print(" FP results may deviate slightly from other platforms.") 1287 1288 if not have_png and env['USE_PNG']: 1289 print("Warning: <png.h> not available; " 1290 "forcing USE_PNG to False in", variant_dir + ".") 1291 env['USE_PNG'] = False 1292 1293 if env['USE_PNG']: 1294 env.Append(LIBS=['png']) 1295 1296 if env['EFENCE']: 1297 env.Append(LIBS=['efence']) 1298 1299 if env['USE_KVM']: 1300 if not have_kvm: 1301 print("Warning: Can not enable KVM, host seems to " 1302 "lack KVM support") 1303 env['USE_KVM'] = False 1304 elif not is_isa_kvm_compatible(env['TARGET_ISA']): 1305 print("Info: KVM support disabled due to unsupported host and " 1306 "target ISA combination") 1307 env['USE_KVM'] = False 1308 1309 if env['USE_TUNTAP']: 1310 if not have_tuntap: 1311 print("Warning: Can't connect EtherTap with a tap device.") 1312 env['USE_TUNTAP'] = False 1313 1314 if env['BUILD_GPU']: 1315 env.Append(CPPDEFINES=['BUILD_GPU']) 1316 1317 # Warn about missing optional functionality 1318 if env['USE_KVM']: 1319 if not main['HAVE_PERF_ATTR_EXCLUDE_HOST']: 1320 print("Warning: perf_event headers lack support for the " 1321 "exclude_host attribute. KVM instruction counts will " 1322 "be inaccurate.") 1323 1324 # Save sticky variable settings back to current variables file 1325 sticky_vars.Save(current_vars_file, env) 1326 1327 if env['USE_SSE2']: 1328 env.Append(CCFLAGS=['-msse2']) 1329 1330 env.Append(CCFLAGS='$CCFLAGS_EXTRA') 1331 env.Append(LINKFLAGS='$LDFLAGS_EXTRA') 1332 1333 # The src/SConscript file sets up the build rules in 'env' according 1334 # to the configured variables. It returns a list of environments, 1335 # one for each variant build (debug, opt, etc.) 1336 SConscript('src/SConscript', variant_dir = variant_path, exports = 'env') 1337 1338# base help text 1339Help(''' 1340Usage: scons [scons options] [build variables] [target(s)] 1341 1342Extra scons options: 1343%(options)s 1344 1345Global build variables: 1346%(global_vars)s 1347 1348%(local_vars)s 1349''' % help_texts) 1350