SConstruct revision 12920
1# -*- mode:python -*- 2 3# Copyright (c) 2013, 2015-2017 ARM Limited 4# All rights reserved. 5# 6# The license below extends only to copyright in the software and shall 7# not be construed as granting a license to any other intellectual 8# property including but not limited to intellectual property relating 9# to a hardware implementation of the functionality of the software 10# licensed hereunder. You may use the software subject to the license 11# terms below provided that you ensure that this notice is replicated 12# unmodified and in its entirety in all distributions of the software, 13# modified or unmodified, in source code or in binary form. 14# 15# Copyright (c) 2011 Advanced Micro Devices, Inc. 16# Copyright (c) 2009 The Hewlett-Packard Development Company 17# Copyright (c) 2004-2005 The Regents of The University of Michigan 18# All rights reserved. 19# 20# Redistribution and use in source and binary forms, with or without 21# modification, are permitted provided that the following conditions are 22# met: redistributions of source code must retain the above copyright 23# notice, this list of conditions and the following disclaimer; 24# redistributions in binary form must reproduce the above copyright 25# notice, this list of conditions and the following disclaimer in the 26# documentation and/or other materials provided with the distribution; 27# neither the name of the copyright holders nor the names of its 28# contributors may be used to endorse or promote products derived from 29# this software without specific prior written permission. 30# 31# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 34# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 36# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 37# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 38# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 39# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 40# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 41# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 42# 43# Authors: Steve Reinhardt 44# Nathan Binkert 45 46################################################### 47# 48# SCons top-level build description (SConstruct) file. 49# 50# While in this directory ('gem5'), just type 'scons' to build the default 51# configuration (see below), or type 'scons build/<CONFIG>/<binary>' 52# to build some other configuration (e.g., 'build/ALPHA/gem5.opt' for 53# the optimized full-system version). 54# 55# You can build gem5 in a different directory as long as there is a 56# 'build/<CONFIG>' somewhere along the target path. The build system 57# expects that all configs under the same build directory are being 58# built for the same host system. 59# 60# Examples: 61# 62# The following two commands are equivalent. The '-u' option tells 63# scons to search up the directory tree for this SConstruct file. 64# % cd <path-to-src>/gem5 ; scons build/ALPHA/gem5.debug 65# % cd <path-to-src>/gem5/build/ALPHA; scons -u gem5.debug 66# 67# The following two commands are equivalent and demonstrate building 68# in a directory outside of the source tree. The '-C' option tells 69# scons to chdir to the specified directory to find this SConstruct 70# file. 71# % cd <path-to-src>/gem5 ; scons /local/foo/build/ALPHA/gem5.debug 72# % cd /local/foo/build/ALPHA; scons -C <path-to-src>/gem5 gem5.debug 73# 74# You can use 'scons -H' to print scons options. If you're in this 75# 'gem5' directory (or use -u or -C to tell scons where to find this 76# file), you can use 'scons -h' to print all the gem5-specific build 77# options as well. 78# 79################################################### 80 81from __future__ import print_function 82 83# Global Python includes 84import itertools 85import os 86import re 87import shutil 88import subprocess 89import sys 90 91from os import mkdir, environ 92from os.path import abspath, basename, dirname, expanduser, normpath 93from os.path import exists, isdir, isfile 94from os.path import join as joinpath, split as splitpath 95 96# SCons includes 97import SCons 98import SCons.Node 99 100from m5.util import compareVersions, readCommand 101 102help_texts = { 103 "options" : "", 104 "global_vars" : "", 105 "local_vars" : "" 106} 107 108Export("help_texts") 109 110 111# There's a bug in scons in that (1) by default, the help texts from 112# AddOption() are supposed to be displayed when you type 'scons -h' 113# and (2) you can override the help displayed by 'scons -h' using the 114# Help() function, but these two features are incompatible: once 115# you've overridden the help text using Help(), there's no way to get 116# at the help texts from AddOptions. See: 117# http://scons.tigris.org/issues/show_bug.cgi?id=2356 118# http://scons.tigris.org/issues/show_bug.cgi?id=2611 119# This hack lets us extract the help text from AddOptions and 120# re-inject it via Help(). Ideally someday this bug will be fixed and 121# we can just use AddOption directly. 122def AddLocalOption(*args, **kwargs): 123 col_width = 30 124 125 help = " " + ", ".join(args) 126 if "help" in kwargs: 127 length = len(help) 128 if length >= col_width: 129 help += "\n" + " " * col_width 130 else: 131 help += " " * (col_width - length) 132 help += kwargs["help"] 133 help_texts["options"] += help + "\n" 134 135 AddOption(*args, **kwargs) 136 137AddLocalOption('--colors', dest='use_colors', action='store_true', 138 help="Add color to abbreviated scons output") 139AddLocalOption('--no-colors', dest='use_colors', action='store_false', 140 help="Don't add color to abbreviated scons output") 141AddLocalOption('--with-cxx-config', dest='with_cxx_config', 142 action='store_true', 143 help="Build with support for C++-based configuration") 144AddLocalOption('--default', dest='default', type='string', action='store', 145 help='Override which build_opts file to use for defaults') 146AddLocalOption('--ignore-style', dest='ignore_style', action='store_true', 147 help='Disable style checking hooks') 148AddLocalOption('--no-lto', dest='no_lto', action='store_true', 149 help='Disable Link-Time Optimization for fast') 150AddLocalOption('--force-lto', dest='force_lto', action='store_true', 151 help='Use Link-Time Optimization instead of partial linking' + 152 ' when the compiler doesn\'t support using them together.') 153AddLocalOption('--update-ref', dest='update_ref', action='store_true', 154 help='Update test reference outputs') 155AddLocalOption('--verbose', dest='verbose', action='store_true', 156 help='Print full tool command lines') 157AddLocalOption('--without-python', dest='without_python', 158 action='store_true', 159 help='Build without Python configuration support') 160AddLocalOption('--without-tcmalloc', dest='without_tcmalloc', 161 action='store_true', 162 help='Disable linking against tcmalloc') 163AddLocalOption('--with-ubsan', dest='with_ubsan', action='store_true', 164 help='Build with Undefined Behavior Sanitizer if available') 165AddLocalOption('--with-asan', dest='with_asan', action='store_true', 166 help='Build with Address Sanitizer if available') 167 168if GetOption('no_lto') and GetOption('force_lto'): 169 print('--no-lto and --force-lto are mutually exclusive') 170 Exit(1) 171 172######################################################################## 173# 174# Set up the main build environment. 175# 176######################################################################## 177 178main = Environment() 179 180from gem5_scons import Transform 181from gem5_scons.util import get_termcap 182termcap = get_termcap() 183 184main_dict_keys = main.Dictionary().keys() 185 186# Check that we have a C/C++ compiler 187if not ('CC' in main_dict_keys and 'CXX' in main_dict_keys): 188 print("No C++ compiler installed (package g++ on Ubuntu and RedHat)") 189 Exit(1) 190 191################################################### 192# 193# Figure out which configurations to set up based on the path(s) of 194# the target(s). 195# 196################################################### 197 198# Find default configuration & binary. 199Default(environ.get('M5_DEFAULT_BINARY', 'build/ALPHA/gem5.debug')) 200 201# helper function: find last occurrence of element in list 202def rfind(l, elt, offs = -1): 203 for i in range(len(l)+offs, 0, -1): 204 if l[i] == elt: 205 return i 206 raise ValueError, "element not found" 207 208# Take a list of paths (or SCons Nodes) and return a list with all 209# paths made absolute and ~-expanded. Paths will be interpreted 210# relative to the launch directory unless a different root is provided 211def makePathListAbsolute(path_list, root=GetLaunchDir()): 212 return [abspath(joinpath(root, expanduser(str(p)))) 213 for p in path_list] 214 215# Each target must have 'build' in the interior of the path; the 216# directory below this will determine the build parameters. For 217# example, for target 'foo/bar/build/ALPHA_SE/arch/alpha/blah.do' we 218# recognize that ALPHA_SE specifies the configuration because it 219# follow 'build' in the build path. 220 221# The funky assignment to "[:]" is needed to replace the list contents 222# in place rather than reassign the symbol to a new list, which 223# doesn't work (obviously!). 224BUILD_TARGETS[:] = makePathListAbsolute(BUILD_TARGETS) 225 226# Generate a list of the unique build roots and configs that the 227# collected targets reference. 228variant_paths = [] 229build_root = None 230for t in BUILD_TARGETS: 231 path_dirs = t.split('/') 232 try: 233 build_top = rfind(path_dirs, 'build', -2) 234 except: 235 print("Error: no non-leaf 'build' dir found on target path", t) 236 Exit(1) 237 this_build_root = joinpath('/',*path_dirs[:build_top+1]) 238 if not build_root: 239 build_root = this_build_root 240 else: 241 if this_build_root != build_root: 242 print("Error: build targets not under same build root\n" 243 " %s\n %s" % (build_root, this_build_root)) 244 Exit(1) 245 variant_path = joinpath('/',*path_dirs[:build_top+2]) 246 if variant_path not in variant_paths: 247 variant_paths.append(variant_path) 248 249# Make sure build_root exists (might not if this is the first build there) 250if not isdir(build_root): 251 mkdir(build_root) 252main['BUILDROOT'] = build_root 253 254Export('main') 255 256main.SConsignFile(joinpath(build_root, "sconsign")) 257 258# Default duplicate option is to use hard links, but this messes up 259# when you use emacs to edit a file in the target dir, as emacs moves 260# file to file~ then copies to file, breaking the link. Symbolic 261# (soft) links work better. 262main.SetOption('duplicate', 'soft-copy') 263 264# 265# Set up global sticky variables... these are common to an entire build 266# tree (not specific to a particular build like ALPHA_SE) 267# 268 269global_vars_file = joinpath(build_root, 'variables.global') 270 271global_vars = Variables(global_vars_file, args=ARGUMENTS) 272 273global_vars.AddVariables( 274 ('CC', 'C compiler', environ.get('CC', main['CC'])), 275 ('CXX', 'C++ compiler', environ.get('CXX', main['CXX'])), 276 ('PROTOC', 'protoc tool', environ.get('PROTOC', 'protoc')), 277 ('BATCH', 'Use batch pool for build and tests', False), 278 ('BATCH_CMD', 'Batch pool submission command name', 'qdo'), 279 ('M5_BUILD_CACHE', 'Cache built objects in this directory', False), 280 ('EXTRAS', 'Add extra directories to the compilation', '') 281 ) 282 283# Update main environment with values from ARGUMENTS & global_vars_file 284global_vars.Update(main) 285help_texts["global_vars"] += global_vars.GenerateHelpText(main) 286 287# Save sticky variable settings back to current variables file 288global_vars.Save(global_vars_file, main) 289 290# Parse EXTRAS variable to build list of all directories where we're 291# look for sources etc. This list is exported as extras_dir_list. 292base_dir = main.srcdir.abspath 293if main['EXTRAS']: 294 extras_dir_list = makePathListAbsolute(main['EXTRAS'].split(':')) 295else: 296 extras_dir_list = [] 297 298Export('base_dir') 299Export('extras_dir_list') 300 301# the ext directory should be on the #includes path 302main.Append(CPPPATH=[Dir('ext')]) 303 304# Add shared top-level headers 305main.Prepend(CPPPATH=Dir('include')) 306 307if GetOption('verbose'): 308 def MakeAction(action, string, *args, **kwargs): 309 return Action(action, *args, **kwargs) 310else: 311 MakeAction = Action 312 main['CCCOMSTR'] = Transform("CC") 313 main['CXXCOMSTR'] = Transform("CXX") 314 main['ASCOMSTR'] = Transform("AS") 315 main['ARCOMSTR'] = Transform("AR", 0) 316 main['LINKCOMSTR'] = Transform("LINK", 0) 317 main['SHLINKCOMSTR'] = Transform("SHLINK", 0) 318 main['RANLIBCOMSTR'] = Transform("RANLIB", 0) 319 main['M4COMSTR'] = Transform("M4") 320 main['SHCCCOMSTR'] = Transform("SHCC") 321 main['SHCXXCOMSTR'] = Transform("SHCXX") 322Export('MakeAction') 323 324# Initialize the Link-Time Optimization (LTO) flags 325main['LTO_CCFLAGS'] = [] 326main['LTO_LDFLAGS'] = [] 327 328# According to the readme, tcmalloc works best if the compiler doesn't 329# assume that we're using the builtin malloc and friends. These flags 330# are compiler-specific, so we need to set them after we detect which 331# compiler we're using. 332main['TCMALLOC_CCFLAGS'] = [] 333 334CXX_version = readCommand([main['CXX'],'--version'], exception=False) 335CXX_V = readCommand([main['CXX'],'-V'], exception=False) 336 337main['GCC'] = CXX_version and CXX_version.find('g++') >= 0 338main['CLANG'] = CXX_version and CXX_version.find('clang') >= 0 339if main['GCC'] + main['CLANG'] > 1: 340 print('Error: How can we have two at the same time?') 341 Exit(1) 342 343# Set up default C++ compiler flags 344if main['GCC'] or main['CLANG']: 345 # As gcc and clang share many flags, do the common parts here 346 main.Append(CCFLAGS=['-pipe']) 347 main.Append(CCFLAGS=['-fno-strict-aliasing']) 348 # Enable -Wall and -Wextra and then disable the few warnings that 349 # we consistently violate 350 main.Append(CCFLAGS=['-Wall', '-Wundef', '-Wextra', 351 '-Wno-sign-compare', '-Wno-unused-parameter']) 352 # We always compile using C++11 353 main.Append(CXXFLAGS=['-std=c++11']) 354 if sys.platform.startswith('freebsd'): 355 main.Append(CCFLAGS=['-I/usr/local/include']) 356 main.Append(CXXFLAGS=['-I/usr/local/include']) 357 358 main['FILTER_PSHLINKFLAGS'] = lambda x: str(x).replace(' -shared', '') 359 main['PSHLINKFLAGS'] = main.subst('${FILTER_PSHLINKFLAGS(SHLINKFLAGS)}') 360 main['PLINKFLAGS'] = main.subst('${LINKFLAGS}') 361 shared_partial_flags = ['-r', '-nostdlib'] 362 main.Append(PSHLINKFLAGS=shared_partial_flags) 363 main.Append(PLINKFLAGS=shared_partial_flags) 364 365 # Treat warnings as errors but white list some warnings that we 366 # want to allow (e.g., deprecation warnings). 367 main.Append(CCFLAGS=['-Werror', 368 '-Wno-error=deprecated-declarations', 369 '-Wno-error=deprecated', 370 ]) 371else: 372 print(termcap.Yellow + termcap.Bold + 'Error' + termcap.Normal, end=' ') 373 print("Don't know what compiler options to use for your compiler.") 374 print(termcap.Yellow + ' compiler:' + termcap.Normal, main['CXX']) 375 print(termcap.Yellow + ' version:' + termcap.Normal, end = ' ') 376 if not CXX_version: 377 print(termcap.Yellow + termcap.Bold + "COMMAND NOT FOUND!" + 378 termcap.Normal) 379 else: 380 print(CXX_version.replace('\n', '<nl>')) 381 print(" If you're trying to use a compiler other than GCC") 382 print(" or clang, there appears to be something wrong with your") 383 print(" environment.") 384 print(" ") 385 print(" If you are trying to use a compiler other than those listed") 386 print(" above you will need to ease fix SConstruct and ") 387 print(" src/SConscript to support that compiler.") 388 Exit(1) 389 390if main['GCC']: 391 # Check for a supported version of gcc. >= 4.8 is chosen for its 392 # level of c++11 support. See 393 # http://gcc.gnu.org/projects/cxx0x.html for details. 394 gcc_version = readCommand([main['CXX'], '-dumpversion'], exception=False) 395 if compareVersions(gcc_version, "4.8") < 0: 396 print('Error: gcc version 4.8 or newer required.') 397 print(' Installed version: ', gcc_version) 398 Exit(1) 399 400 main['GCC_VERSION'] = gcc_version 401 402 if compareVersions(gcc_version, '4.9') >= 0: 403 # Incremental linking with LTO is currently broken in gcc versions 404 # 4.9 and above. A version where everything works completely hasn't 405 # yet been identified. 406 # 407 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67548 408 main['BROKEN_INCREMENTAL_LTO'] = True 409 if compareVersions(gcc_version, '6.0') >= 0: 410 # gcc versions 6.0 and greater accept an -flinker-output flag which 411 # selects what type of output the linker should generate. This is 412 # necessary for incremental lto to work, but is also broken in 413 # current versions of gcc. It may not be necessary in future 414 # versions. We add it here since it might be, and as a reminder that 415 # it exists. It's excluded if lto is being forced. 416 # 417 # https://gcc.gnu.org/gcc-6/changes.html 418 # https://gcc.gnu.org/ml/gcc-patches/2015-11/msg03161.html 419 # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69866 420 if not GetOption('force_lto'): 421 main.Append(PSHLINKFLAGS='-flinker-output=rel') 422 main.Append(PLINKFLAGS='-flinker-output=rel') 423 424 # gcc from version 4.8 and above generates "rep; ret" instructions 425 # to avoid performance penalties on certain AMD chips. Older 426 # assemblers detect this as an error, "Error: expecting string 427 # instruction after `rep'" 428 as_version_raw = readCommand([main['AS'], '-v', '/dev/null', 429 '-o', '/dev/null'], 430 exception=False).split() 431 432 # version strings may contain extra distro-specific 433 # qualifiers, so play it safe and keep only what comes before 434 # the first hyphen 435 as_version = as_version_raw[-1].split('-')[0] if as_version_raw else None 436 437 if not as_version or compareVersions(as_version, "2.23") < 0: 438 print(termcap.Yellow + termcap.Bold + 439 'Warning: This combination of gcc and binutils have' + 440 ' known incompatibilities.\n' + 441 ' If you encounter build problems, please update ' + 442 'binutils to 2.23.' + 443 termcap.Normal) 444 445 # Make sure we warn if the user has requested to compile with the 446 # Undefined Benahvior Sanitizer and this version of gcc does not 447 # support it. 448 if GetOption('with_ubsan') and \ 449 compareVersions(gcc_version, '4.9') < 0: 450 print(termcap.Yellow + termcap.Bold + 451 'Warning: UBSan is only supported using gcc 4.9 and later.' + 452 termcap.Normal) 453 454 disable_lto = GetOption('no_lto') 455 if not disable_lto and main.get('BROKEN_INCREMENTAL_LTO', False) and \ 456 not GetOption('force_lto'): 457 print(termcap.Yellow + termcap.Bold + 458 'Warning: Your compiler doesn\'t support incremental linking' + 459 ' and lto at the same time, so lto is being disabled. To force' + 460 ' lto on anyway, use the --force-lto option. That will disable' + 461 ' partial linking.' + 462 termcap.Normal) 463 disable_lto = True 464 465 # Add the appropriate Link-Time Optimization (LTO) flags 466 # unless LTO is explicitly turned off. Note that these flags 467 # are only used by the fast target. 468 if not disable_lto: 469 # Pass the LTO flag when compiling to produce GIMPLE 470 # output, we merely create the flags here and only append 471 # them later 472 main['LTO_CCFLAGS'] = ['-flto=%d' % GetOption('num_jobs')] 473 474 # Use the same amount of jobs for LTO as we are running 475 # scons with 476 main['LTO_LDFLAGS'] = ['-flto=%d' % GetOption('num_jobs')] 477 478 main.Append(TCMALLOC_CCFLAGS=['-fno-builtin-malloc', '-fno-builtin-calloc', 479 '-fno-builtin-realloc', '-fno-builtin-free']) 480 481 # The address sanitizer is available for gcc >= 4.8 482 if GetOption('with_asan'): 483 if GetOption('with_ubsan') and \ 484 compareVersions(main['GCC_VERSION'], '4.9') >= 0: 485 main.Append(CCFLAGS=['-fsanitize=address,undefined', 486 '-fno-omit-frame-pointer'], 487 LINKFLAGS='-fsanitize=address,undefined') 488 else: 489 main.Append(CCFLAGS=['-fsanitize=address', 490 '-fno-omit-frame-pointer'], 491 LINKFLAGS='-fsanitize=address') 492 # Only gcc >= 4.9 supports UBSan, so check both the version 493 # and the command-line option before adding the compiler and 494 # linker flags. 495 elif GetOption('with_ubsan') and \ 496 compareVersions(main['GCC_VERSION'], '4.9') >= 0: 497 main.Append(CCFLAGS='-fsanitize=undefined') 498 main.Append(LINKFLAGS='-fsanitize=undefined') 499 500elif main['CLANG']: 501 # Check for a supported version of clang, >= 3.1 is needed to 502 # support similar features as gcc 4.8. See 503 # http://clang.llvm.org/cxx_status.html for details 504 clang_version_re = re.compile(".* version (\d+\.\d+)") 505 clang_version_match = clang_version_re.search(CXX_version) 506 if (clang_version_match): 507 clang_version = clang_version_match.groups()[0] 508 if compareVersions(clang_version, "3.1") < 0: 509 print('Error: clang version 3.1 or newer required.') 510 print(' Installed version:', clang_version) 511 Exit(1) 512 else: 513 print('Error: Unable to determine clang version.') 514 Exit(1) 515 516 # clang has a few additional warnings that we disable, extraneous 517 # parantheses are allowed due to Ruby's printing of the AST, 518 # finally self assignments are allowed as the generated CPU code 519 # is relying on this 520 main.Append(CCFLAGS=['-Wno-parentheses', 521 '-Wno-self-assign', 522 # Some versions of libstdc++ (4.8?) seem to 523 # use struct hash and class hash 524 # interchangeably. 525 '-Wno-mismatched-tags', 526 ]) 527 528 main.Append(TCMALLOC_CCFLAGS=['-fno-builtin']) 529 530 # On Mac OS X/Darwin we need to also use libc++ (part of XCode) as 531 # opposed to libstdc++, as the later is dated. 532 if sys.platform == "darwin": 533 main.Append(CXXFLAGS=['-stdlib=libc++']) 534 main.Append(LIBS=['c++']) 535 536 # On FreeBSD we need libthr. 537 if sys.platform.startswith('freebsd'): 538 main.Append(LIBS=['thr']) 539 540 # We require clang >= 3.1, so there is no need to check any 541 # versions here. 542 if GetOption('with_ubsan'): 543 if GetOption('with_asan'): 544 env.Append(CCFLAGS=['-fsanitize=address,undefined', 545 '-fno-omit-frame-pointer'], 546 LINKFLAGS='-fsanitize=address,undefined') 547 else: 548 env.Append(CCFLAGS='-fsanitize=undefined', 549 LINKFLAGS='-fsanitize=undefined') 550 551 elif GetOption('with_asan'): 552 env.Append(CCFLAGS=['-fsanitize=address', 553 '-fno-omit-frame-pointer'], 554 LINKFLAGS='-fsanitize=address') 555 556else: 557 print(termcap.Yellow + termcap.Bold + 'Error' + termcap.Normal, end=' ') 558 print("Don't know what compiler options to use for your compiler.") 559 print(termcap.Yellow + ' compiler:' + termcap.Normal, main['CXX']) 560 print(termcap.Yellow + ' version:' + termcap.Normal, end=' ') 561 if not CXX_version: 562 print(termcap.Yellow + termcap.Bold + "COMMAND NOT FOUND!" + 563 termcap.Normal) 564 else: 565 print(CXX_version.replace('\n', '<nl>')) 566 print(" If you're trying to use a compiler other than GCC") 567 print(" or clang, there appears to be something wrong with your") 568 print(" environment.") 569 print(" ") 570 print(" If you are trying to use a compiler other than those listed") 571 print(" above you will need to ease fix SConstruct and ") 572 print(" src/SConscript to support that compiler.") 573 Exit(1) 574 575# Set up common yacc/bison flags (needed for Ruby) 576main['YACCFLAGS'] = '-d' 577main['YACCHXXFILESUFFIX'] = '.hh' 578 579# Do this after we save setting back, or else we'll tack on an 580# extra 'qdo' every time we run scons. 581if main['BATCH']: 582 main['CC'] = main['BATCH_CMD'] + ' ' + main['CC'] 583 main['CXX'] = main['BATCH_CMD'] + ' ' + main['CXX'] 584 main['AS'] = main['BATCH_CMD'] + ' ' + main['AS'] 585 main['AR'] = main['BATCH_CMD'] + ' ' + main['AR'] 586 main['RANLIB'] = main['BATCH_CMD'] + ' ' + main['RANLIB'] 587 588if sys.platform == 'cygwin': 589 # cygwin has some header file issues... 590 main.Append(CCFLAGS=["-Wno-uninitialized"]) 591 592# Check for the protobuf compiler 593protoc_version = readCommand([main['PROTOC'], '--version'], 594 exception='').split() 595 596# First two words should be "libprotoc x.y.z" 597if len(protoc_version) < 2 or protoc_version[0] != 'libprotoc': 598 print(termcap.Yellow + termcap.Bold + 599 'Warning: Protocol buffer compiler (protoc) not found.\n' + 600 ' Please install protobuf-compiler for tracing support.' + 601 termcap.Normal) 602 main['PROTOC'] = False 603else: 604 # Based on the availability of the compress stream wrappers, 605 # require 2.1.0 606 min_protoc_version = '2.1.0' 607 if compareVersions(protoc_version[1], min_protoc_version) < 0: 608 print(termcap.Yellow + termcap.Bold + 609 'Warning: protoc version', min_protoc_version, 610 'or newer required.\n' + 611 ' Installed version:', protoc_version[1], 612 termcap.Normal) 613 main['PROTOC'] = False 614 else: 615 # Attempt to determine the appropriate include path and 616 # library path using pkg-config, that means we also need to 617 # check for pkg-config. Note that it is possible to use 618 # protobuf without the involvement of pkg-config. Later on we 619 # check go a library config check and at that point the test 620 # will fail if libprotobuf cannot be found. 621 if readCommand(['pkg-config', '--version'], exception=''): 622 try: 623 # Attempt to establish what linking flags to add for protobuf 624 # using pkg-config 625 main.ParseConfig('pkg-config --cflags --libs-only-L protobuf') 626 except: 627 print(termcap.Yellow + termcap.Bold + 628 'Warning: pkg-config could not get protobuf flags.' + 629 termcap.Normal) 630 631 632# Check for 'timeout' from GNU coreutils. If present, regressions will 633# be run with a time limit. We require version 8.13 since we rely on 634# support for the '--foreground' option. 635if sys.platform.startswith('freebsd'): 636 timeout_lines = readCommand(['gtimeout', '--version'], 637 exception='').splitlines() 638else: 639 timeout_lines = readCommand(['timeout', '--version'], 640 exception='').splitlines() 641# Get the first line and tokenize it 642timeout_version = timeout_lines[0].split() if timeout_lines else [] 643main['TIMEOUT'] = timeout_version and \ 644 compareVersions(timeout_version[-1], '8.13') >= 0 645 646# Add a custom Check function to test for structure members. 647def CheckMember(context, include, decl, member, include_quotes="<>"): 648 context.Message("Checking for member %s in %s..." % 649 (member, decl)) 650 text = """ 651#include %(header)s 652int main(){ 653 %(decl)s test; 654 (void)test.%(member)s; 655 return 0; 656}; 657""" % { "header" : include_quotes[0] + include + include_quotes[1], 658 "decl" : decl, 659 "member" : member, 660 } 661 662 ret = context.TryCompile(text, extension=".cc") 663 context.Result(ret) 664 return ret 665 666# Platform-specific configuration. Note again that we assume that all 667# builds under a given build root run on the same host platform. 668conf = Configure(main, 669 conf_dir = joinpath(build_root, '.scons_config'), 670 log_file = joinpath(build_root, 'scons_config.log'), 671 custom_tests = { 672 'CheckMember' : CheckMember, 673 }) 674 675# Check if we should compile a 64 bit binary on Mac OS X/Darwin 676try: 677 import platform 678 uname = platform.uname() 679 if uname[0] == 'Darwin' and compareVersions(uname[2], '9.0.0') >= 0: 680 if int(readCommand('sysctl -n hw.cpu64bit_capable')[0]): 681 main.Append(CCFLAGS=['-arch', 'x86_64']) 682 main.Append(CFLAGS=['-arch', 'x86_64']) 683 main.Append(LINKFLAGS=['-arch', 'x86_64']) 684 main.Append(ASFLAGS=['-arch', 'x86_64']) 685except: 686 pass 687 688# Recent versions of scons substitute a "Null" object for Configure() 689# when configuration isn't necessary, e.g., if the "--help" option is 690# present. Unfortuantely this Null object always returns false, 691# breaking all our configuration checks. We replace it with our own 692# more optimistic null object that returns True instead. 693if not conf: 694 def NullCheck(*args, **kwargs): 695 return True 696 697 class NullConf: 698 def __init__(self, env): 699 self.env = env 700 def Finish(self): 701 return self.env 702 def __getattr__(self, mname): 703 return NullCheck 704 705 conf = NullConf(main) 706 707# Cache build files in the supplied directory. 708if main['M5_BUILD_CACHE']: 709 print('Using build cache located at', main['M5_BUILD_CACHE']) 710 CacheDir(main['M5_BUILD_CACHE']) 711 712main['USE_PYTHON'] = not GetOption('without_python') 713if main['USE_PYTHON']: 714 # Find Python include and library directories for embedding the 715 # interpreter. We rely on python-config to resolve the appropriate 716 # includes and linker flags. ParseConfig does not seem to understand 717 # the more exotic linker flags such as -Xlinker and -export-dynamic so 718 # we add them explicitly below. If you want to link in an alternate 719 # version of python, see above for instructions on how to invoke 720 # scons with the appropriate PATH set. 721 # 722 # First we check if python2-config exists, else we use python-config 723 python_config = readCommand(['which', 'python2-config'], 724 exception='').strip() 725 if not os.path.exists(python_config): 726 python_config = readCommand(['which', 'python-config'], 727 exception='').strip() 728 py_includes = readCommand([python_config, '--includes'], 729 exception='').split() 730 # Strip the -I from the include folders before adding them to the 731 # CPPPATH 732 main.Append(CPPPATH=map(lambda inc: inc[2:], py_includes)) 733 734 # Read the linker flags and split them into libraries and other link 735 # flags. The libraries are added later through the call the CheckLib. 736 py_ld_flags = readCommand([python_config, '--ldflags'], 737 exception='').split() 738 py_libs = [] 739 for lib in py_ld_flags: 740 if not lib.startswith('-l'): 741 main.Append(LINKFLAGS=[lib]) 742 else: 743 lib = lib[2:] 744 if lib not in py_libs: 745 py_libs.append(lib) 746 747 # verify that this stuff works 748 if not conf.CheckHeader('Python.h', '<>'): 749 print("Error: Check failed for Python.h header in", py_includes) 750 print("Two possible reasons:") 751 print("1. Python headers are not installed (You can install the " 752 "package python-dev on Ubuntu and RedHat)") 753 print("2. SCons is using a wrong C compiler. This can happen if " 754 "CC has the wrong value.") 755 print("CC = %s" % main['CC']) 756 Exit(1) 757 758 for lib in py_libs: 759 if not conf.CheckLib(lib): 760 print("Error: can't find library %s required by python" % lib) 761 Exit(1) 762 763# On Solaris you need to use libsocket for socket ops 764if not conf.CheckLibWithHeader(None, 'sys/socket.h', 'C++', 'accept(0,0,0);'): 765 if not conf.CheckLibWithHeader('socket', 'sys/socket.h', 'C++', 'accept(0,0,0);'): 766 print("Can't find library with socket calls (e.g. accept())") 767 Exit(1) 768 769# Check for zlib. If the check passes, libz will be automatically 770# added to the LIBS environment variable. 771if not conf.CheckLibWithHeader('z', 'zlib.h', 'C++','zlibVersion();'): 772 print('Error: did not find needed zlib compression library ' 773 'and/or zlib.h header file.') 774 print(' Please install zlib and try again.') 775 Exit(1) 776 777# If we have the protobuf compiler, also make sure we have the 778# development libraries. If the check passes, libprotobuf will be 779# automatically added to the LIBS environment variable. After 780# this, we can use the HAVE_PROTOBUF flag to determine if we have 781# got both protoc and libprotobuf available. 782main['HAVE_PROTOBUF'] = main['PROTOC'] and \ 783 conf.CheckLibWithHeader('protobuf', 'google/protobuf/message.h', 784 'C++', 'GOOGLE_PROTOBUF_VERIFY_VERSION;') 785 786# Valgrind gets much less confused if you tell it when you're using 787# alternative stacks. 788main['HAVE_VALGRIND'] = conf.CheckCHeader('valgrind/valgrind.h') 789 790# If we have the compiler but not the library, print another warning. 791if main['PROTOC'] and not main['HAVE_PROTOBUF']: 792 print(termcap.Yellow + termcap.Bold + 793 'Warning: did not find protocol buffer library and/or headers.\n' + 794 ' Please install libprotobuf-dev for tracing support.' + 795 termcap.Normal) 796 797# Check for librt. 798have_posix_clock = \ 799 conf.CheckLibWithHeader(None, 'time.h', 'C', 800 'clock_nanosleep(0,0,NULL,NULL);') or \ 801 conf.CheckLibWithHeader('rt', 'time.h', 'C', 802 'clock_nanosleep(0,0,NULL,NULL);') 803 804have_posix_timers = \ 805 conf.CheckLibWithHeader([None, 'rt'], [ 'time.h', 'signal.h' ], 'C', 806 'timer_create(CLOCK_MONOTONIC, NULL, NULL);') 807 808if not GetOption('without_tcmalloc'): 809 if conf.CheckLib('tcmalloc'): 810 main.Append(CCFLAGS=main['TCMALLOC_CCFLAGS']) 811 elif conf.CheckLib('tcmalloc_minimal'): 812 main.Append(CCFLAGS=main['TCMALLOC_CCFLAGS']) 813 else: 814 print(termcap.Yellow + termcap.Bold + 815 "You can get a 12% performance improvement by " 816 "installing tcmalloc (libgoogle-perftools-dev package " 817 "on Ubuntu or RedHat)." + termcap.Normal) 818 819 820# Detect back trace implementations. The last implementation in the 821# list will be used by default. 822backtrace_impls = [ "none" ] 823 824backtrace_checker = 'char temp;' + \ 825 ' backtrace_symbols_fd((void*)&temp, 0, 0);' 826if conf.CheckLibWithHeader(None, 'execinfo.h', 'C', backtrace_checker): 827 backtrace_impls.append("glibc") 828elif conf.CheckLibWithHeader('execinfo', 'execinfo.h', 'C', 829 backtrace_checker): 830 # NetBSD and FreeBSD need libexecinfo. 831 backtrace_impls.append("glibc") 832 main.Append(LIBS=['execinfo']) 833 834if backtrace_impls[-1] == "none": 835 default_backtrace_impl = "none" 836 print(termcap.Yellow + termcap.Bold + 837 "No suitable back trace implementation found." + 838 termcap.Normal) 839 840if not have_posix_clock: 841 print("Can't find library for POSIX clocks.") 842 843# Check for <fenv.h> (C99 FP environment control) 844have_fenv = conf.CheckHeader('fenv.h', '<>') 845if not have_fenv: 846 print("Warning: Header file <fenv.h> not found.") 847 print(" This host has no IEEE FP rounding mode control.") 848 849# Check for <png.h> (libpng library needed if wanting to dump 850# frame buffer image in png format) 851have_png = conf.CheckHeader('png.h', '<>') 852if not have_png: 853 print("Warning: Header file <png.h> not found.") 854 print(" This host has no libpng library.") 855 print(" Disabling support for PNG framebuffers.") 856 857# Check if we should enable KVM-based hardware virtualization. The API 858# we rely on exists since version 2.6.36 of the kernel, but somehow 859# the KVM_API_VERSION does not reflect the change. We test for one of 860# the types as a fall back. 861have_kvm = conf.CheckHeader('linux/kvm.h', '<>') 862if not have_kvm: 863 print("Info: Compatible header file <linux/kvm.h> not found, " 864 "disabling KVM support.") 865 866# Check if the TUN/TAP driver is available. 867have_tuntap = conf.CheckHeader('linux/if_tun.h', '<>') 868if not have_tuntap: 869 print("Info: Compatible header file <linux/if_tun.h> not found.") 870 871# x86 needs support for xsave. We test for the structure here since we 872# won't be able to run new tests by the time we know which ISA we're 873# targeting. 874have_kvm_xsave = conf.CheckTypeSize('struct kvm_xsave', 875 '#include <linux/kvm.h>') != 0 876 877# Check if the requested target ISA is compatible with the host 878def is_isa_kvm_compatible(isa): 879 try: 880 import platform 881 host_isa = platform.machine() 882 except: 883 print("Warning: Failed to determine host ISA.") 884 return False 885 886 if not have_posix_timers: 887 print("Warning: Can not enable KVM, host seems to lack support " 888 "for POSIX timers") 889 return False 890 891 if isa == "arm": 892 return host_isa in ( "armv7l", "aarch64" ) 893 elif isa == "x86": 894 if host_isa != "x86_64": 895 return False 896 897 if not have_kvm_xsave: 898 print("KVM on x86 requires xsave support in kernel headers.") 899 return False 900 901 return True 902 else: 903 return False 904 905 906# Check if the exclude_host attribute is available. We want this to 907# get accurate instruction counts in KVM. 908main['HAVE_PERF_ATTR_EXCLUDE_HOST'] = conf.CheckMember( 909 'linux/perf_event.h', 'struct perf_event_attr', 'exclude_host') 910 911 912###################################################################### 913# 914# Finish the configuration 915# 916main = conf.Finish() 917 918###################################################################### 919# 920# Collect all non-global variables 921# 922 923# Define the universe of supported ISAs 924all_isa_list = [ ] 925all_gpu_isa_list = [ ] 926Export('all_isa_list') 927Export('all_gpu_isa_list') 928 929class CpuModel(object): 930 '''The CpuModel class encapsulates everything the ISA parser needs to 931 know about a particular CPU model.''' 932 933 # Dict of available CPU model objects. Accessible as CpuModel.dict. 934 dict = {} 935 936 # Constructor. Automatically adds models to CpuModel.dict. 937 def __init__(self, name, default=False): 938 self.name = name # name of model 939 940 # This cpu is enabled by default 941 self.default = default 942 943 # Add self to dict 944 if name in CpuModel.dict: 945 raise AttributeError, "CpuModel '%s' already registered" % name 946 CpuModel.dict[name] = self 947 948Export('CpuModel') 949 950# Sticky variables get saved in the variables file so they persist from 951# one invocation to the next (unless overridden, in which case the new 952# value becomes sticky). 953sticky_vars = Variables(args=ARGUMENTS) 954Export('sticky_vars') 955 956# Sticky variables that should be exported 957export_vars = [] 958Export('export_vars') 959 960# For Ruby 961all_protocols = [] 962Export('all_protocols') 963protocol_dirs = [] 964Export('protocol_dirs') 965slicc_includes = [] 966Export('slicc_includes') 967 968# Walk the tree and execute all SConsopts scripts that wil add to the 969# above variables 970if GetOption('verbose'): 971 print("Reading SConsopts") 972for bdir in [ base_dir ] + extras_dir_list: 973 if not isdir(bdir): 974 print("Error: directory '%s' does not exist" % bdir) 975 Exit(1) 976 for root, dirs, files in os.walk(bdir): 977 if 'SConsopts' in files: 978 if GetOption('verbose'): 979 print("Reading", joinpath(root, 'SConsopts')) 980 SConscript(joinpath(root, 'SConsopts')) 981 982all_isa_list.sort() 983all_gpu_isa_list.sort() 984 985sticky_vars.AddVariables( 986 EnumVariable('TARGET_ISA', 'Target ISA', 'alpha', all_isa_list), 987 EnumVariable('TARGET_GPU_ISA', 'Target GPU ISA', 'hsail', all_gpu_isa_list), 988 ListVariable('CPU_MODELS', 'CPU models', 989 sorted(n for n,m in CpuModel.dict.iteritems() if m.default), 990 sorted(CpuModel.dict.keys())), 991 BoolVariable('EFENCE', 'Link with Electric Fence malloc debugger', 992 False), 993 BoolVariable('SS_COMPATIBLE_FP', 994 'Make floating-point results compatible with SimpleScalar', 995 False), 996 BoolVariable('USE_SSE2', 997 'Compile for SSE2 (-msse2) to get IEEE FP on x86 hosts', 998 False), 999 BoolVariable('USE_POSIX_CLOCK', 'Use POSIX Clocks', have_posix_clock), 1000 BoolVariable('USE_FENV', 'Use <fenv.h> IEEE mode control', have_fenv), 1001 BoolVariable('USE_PNG', 'Enable support for PNG images', have_png), 1002 BoolVariable('CP_ANNOTATE', 'Enable critical path annotation capability', 1003 False), 1004 BoolVariable('USE_KVM', 'Enable hardware virtualized (KVM) CPU models', 1005 have_kvm), 1006 BoolVariable('USE_TUNTAP', 1007 'Enable using a tap device to bridge to the host network', 1008 have_tuntap), 1009 BoolVariable('BUILD_GPU', 'Build the compute-GPU model', False), 1010 EnumVariable('PROTOCOL', 'Coherence protocol for Ruby', 'None', 1011 all_protocols), 1012 EnumVariable('BACKTRACE_IMPL', 'Post-mortem dump implementation', 1013 backtrace_impls[-1], backtrace_impls) 1014 ) 1015 1016# These variables get exported to #defines in config/*.hh (see src/SConscript). 1017export_vars += ['USE_FENV', 'SS_COMPATIBLE_FP', 'TARGET_ISA', 'TARGET_GPU_ISA', 1018 'CP_ANNOTATE', 'USE_POSIX_CLOCK', 'USE_KVM', 'USE_TUNTAP', 1019 'PROTOCOL', 'HAVE_PROTOBUF', 'HAVE_VALGRIND', 1020 'HAVE_PERF_ATTR_EXCLUDE_HOST', 'USE_PNG'] 1021 1022################################################### 1023# 1024# Define a SCons builder for configuration flag headers. 1025# 1026################################################### 1027 1028# This function generates a config header file that #defines the 1029# variable symbol to the current variable setting (0 or 1). The source 1030# operands are the name of the variable and a Value node containing the 1031# value of the variable. 1032def build_config_file(target, source, env): 1033 (variable, value) = [s.get_contents() for s in source] 1034 f = file(str(target[0]), 'w') 1035 print('#define', variable, value, file=f) 1036 f.close() 1037 return None 1038 1039# Combine the two functions into a scons Action object. 1040config_action = MakeAction(build_config_file, Transform("CONFIG H", 2)) 1041 1042# The emitter munges the source & target node lists to reflect what 1043# we're really doing. 1044def config_emitter(target, source, env): 1045 # extract variable name from Builder arg 1046 variable = str(target[0]) 1047 # True target is config header file 1048 target = joinpath('config', variable.lower() + '.hh') 1049 val = env[variable] 1050 if isinstance(val, bool): 1051 # Force value to 0/1 1052 val = int(val) 1053 elif isinstance(val, str): 1054 val = '"' + val + '"' 1055 1056 # Sources are variable name & value (packaged in SCons Value nodes) 1057 return ([target], [Value(variable), Value(val)]) 1058 1059config_builder = Builder(emitter = config_emitter, action = config_action) 1060 1061main.Append(BUILDERS = { 'ConfigFile' : config_builder }) 1062 1063################################################### 1064# 1065# Builders for static and shared partially linked object files. 1066# 1067################################################### 1068 1069partial_static_builder = Builder(action=SCons.Defaults.LinkAction, 1070 src_suffix='$OBJSUFFIX', 1071 src_builder=['StaticObject', 'Object'], 1072 LINKFLAGS='$PLINKFLAGS', 1073 LIBS='') 1074 1075def partial_shared_emitter(target, source, env): 1076 for tgt in target: 1077 tgt.attributes.shared = 1 1078 return (target, source) 1079partial_shared_builder = Builder(action=SCons.Defaults.ShLinkAction, 1080 emitter=partial_shared_emitter, 1081 src_suffix='$SHOBJSUFFIX', 1082 src_builder='SharedObject', 1083 SHLINKFLAGS='$PSHLINKFLAGS', 1084 LIBS='') 1085 1086main.Append(BUILDERS = { 'PartialShared' : partial_shared_builder, 1087 'PartialStatic' : partial_static_builder }) 1088 1089# builds in ext are shared across all configs in the build root. 1090ext_dir = abspath(joinpath(str(main.root), 'ext')) 1091ext_build_dirs = [] 1092for root, dirs, files in os.walk(ext_dir): 1093 if 'SConscript' in files: 1094 build_dir = os.path.relpath(root, ext_dir) 1095 ext_build_dirs.append(build_dir) 1096 main.SConscript(joinpath(root, 'SConscript'), 1097 variant_dir=joinpath(build_root, build_dir)) 1098 1099main.Prepend(CPPPATH=Dir('ext/pybind11/include/')) 1100 1101################################################### 1102# 1103# This builder and wrapper method are used to set up a directory with 1104# switching headers. Those are headers which are in a generic location and 1105# that include more specific headers from a directory chosen at build time 1106# based on the current build settings. 1107# 1108################################################### 1109 1110def build_switching_header(target, source, env): 1111 path = str(target[0]) 1112 subdir = str(source[0]) 1113 dp, fp = os.path.split(path) 1114 dp = os.path.relpath(os.path.realpath(dp), 1115 os.path.realpath(env['BUILDDIR'])) 1116 with open(path, 'w') as hdr: 1117 print('#include "%s/%s/%s"' % (dp, subdir, fp), file=hdr) 1118 1119switching_header_action = MakeAction(build_switching_header, 1120 Transform('GENERATE')) 1121 1122switching_header_builder = Builder(action=switching_header_action, 1123 source_factory=Value, 1124 single_source=True) 1125 1126main.Append(BUILDERS = { 'SwitchingHeader': switching_header_builder }) 1127 1128def switching_headers(self, headers, source): 1129 for header in headers: 1130 self.SwitchingHeader(header, source) 1131 1132main.AddMethod(switching_headers, 'SwitchingHeaders') 1133 1134################################################### 1135# 1136# Define build environments for selected configurations. 1137# 1138################################################### 1139 1140for variant_path in variant_paths: 1141 if not GetOption('silent'): 1142 print("Building in", variant_path) 1143 1144 # Make a copy of the build-root environment to use for this config. 1145 env = main.Clone() 1146 env['BUILDDIR'] = variant_path 1147 1148 # variant_dir is the tail component of build path, and is used to 1149 # determine the build parameters (e.g., 'ALPHA_SE') 1150 (build_root, variant_dir) = splitpath(variant_path) 1151 1152 # Set env variables according to the build directory config. 1153 sticky_vars.files = [] 1154 # Variables for $BUILD_ROOT/$VARIANT_DIR are stored in 1155 # $BUILD_ROOT/variables/$VARIANT_DIR so you can nuke 1156 # $BUILD_ROOT/$VARIANT_DIR without losing your variables settings. 1157 current_vars_file = joinpath(build_root, 'variables', variant_dir) 1158 if isfile(current_vars_file): 1159 sticky_vars.files.append(current_vars_file) 1160 if not GetOption('silent'): 1161 print("Using saved variables file %s" % current_vars_file) 1162 elif variant_dir in ext_build_dirs: 1163 # Things in ext are built without a variant directory. 1164 continue 1165 else: 1166 # Build dir-specific variables file doesn't exist. 1167 1168 # Make sure the directory is there so we can create it later 1169 opt_dir = dirname(current_vars_file) 1170 if not isdir(opt_dir): 1171 mkdir(opt_dir) 1172 1173 # Get default build variables from source tree. Variables are 1174 # normally determined by name of $VARIANT_DIR, but can be 1175 # overridden by '--default=' arg on command line. 1176 default = GetOption('default') 1177 opts_dir = joinpath(main.root.abspath, 'build_opts') 1178 if default: 1179 default_vars_files = [joinpath(build_root, 'variables', default), 1180 joinpath(opts_dir, default)] 1181 else: 1182 default_vars_files = [joinpath(opts_dir, variant_dir)] 1183 existing_files = filter(isfile, default_vars_files) 1184 if existing_files: 1185 default_vars_file = existing_files[0] 1186 sticky_vars.files.append(default_vars_file) 1187 print("Variables file %s not found,\n using defaults in %s" 1188 % (current_vars_file, default_vars_file)) 1189 else: 1190 print("Error: cannot find variables file %s or " 1191 "default file(s) %s" 1192 % (current_vars_file, ' or '.join(default_vars_files))) 1193 Exit(1) 1194 1195 # Apply current variable settings to env 1196 sticky_vars.Update(env) 1197 1198 help_texts["local_vars"] += \ 1199 "Build variables for %s:\n" % variant_dir \ 1200 + sticky_vars.GenerateHelpText(env) 1201 1202 # Process variable settings. 1203 1204 if not have_fenv and env['USE_FENV']: 1205 print("Warning: <fenv.h> not available; " 1206 "forcing USE_FENV to False in", variant_dir + ".") 1207 env['USE_FENV'] = False 1208 1209 if not env['USE_FENV']: 1210 print("Warning: No IEEE FP rounding mode control in", 1211 variant_dir + ".") 1212 print(" FP results may deviate slightly from other platforms.") 1213 1214 if not have_png and env['USE_PNG']: 1215 print("Warning: <png.h> not available; " 1216 "forcing USE_PNG to False in", variant_dir + ".") 1217 env['USE_PNG'] = False 1218 1219 if env['USE_PNG']: 1220 env.Append(LIBS=['png']) 1221 1222 if env['EFENCE']: 1223 env.Append(LIBS=['efence']) 1224 1225 if env['USE_KVM']: 1226 if not have_kvm: 1227 print("Warning: Can not enable KVM, host seems to " 1228 "lack KVM support") 1229 env['USE_KVM'] = False 1230 elif not is_isa_kvm_compatible(env['TARGET_ISA']): 1231 print("Info: KVM support disabled due to unsupported host and " 1232 "target ISA combination") 1233 env['USE_KVM'] = False 1234 1235 if env['USE_TUNTAP']: 1236 if not have_tuntap: 1237 print("Warning: Can't connect EtherTap with a tap device.") 1238 env['USE_TUNTAP'] = False 1239 1240 if env['BUILD_GPU']: 1241 env.Append(CPPDEFINES=['BUILD_GPU']) 1242 1243 # Warn about missing optional functionality 1244 if env['USE_KVM']: 1245 if not main['HAVE_PERF_ATTR_EXCLUDE_HOST']: 1246 print("Warning: perf_event headers lack support for the " 1247 "exclude_host attribute. KVM instruction counts will " 1248 "be inaccurate.") 1249 1250 # Save sticky variable settings back to current variables file 1251 sticky_vars.Save(current_vars_file, env) 1252 1253 if env['USE_SSE2']: 1254 env.Append(CCFLAGS=['-msse2']) 1255 1256 # The src/SConscript file sets up the build rules in 'env' according 1257 # to the configured variables. It returns a list of environments, 1258 # one for each variant build (debug, opt, etc.) 1259 SConscript('src/SConscript', variant_dir = variant_path, exports = 'env') 1260 1261# base help text 1262Help(''' 1263Usage: scons [scons options] [build variables] [target(s)] 1264 1265Extra scons options: 1266%(options)s 1267 1268Global build variables: 1269%(global_vars)s 1270 1271%(local_vars)s 1272''' % help_texts) 1273