SConscript revision 13576:88594d85f9a9
1# -*- mode:python -*- 2 3# Copyright (c) 2018 ARM Limited 4# 5# The license below extends only to copyright in the software and shall 6# not be construed as granting a license to any other intellectual 7# property including but not limited to intellectual property relating 8# to a hardware implementation of the functionality of the software 9# licensed hereunder. You may use the software subject to the license 10# terms below provided that you ensure that this notice is replicated 11# unmodified and in its entirety in all distributions of the software, 12# modified or unmodified, in source code or in binary form. 13# 14# Copyright (c) 2004-2005 The Regents of The University of Michigan 15# All rights reserved. 16# 17# Redistribution and use in source and binary forms, with or without 18# modification, are permitted provided that the following conditions are 19# met: redistributions of source code must retain the above copyright 20# notice, this list of conditions and the following disclaimer; 21# redistributions in binary form must reproduce the above copyright 22# notice, this list of conditions and the following disclaimer in the 23# documentation and/or other materials provided with the distribution; 24# neither the name of the copyright holders nor the names of its 25# contributors may be used to endorse or promote products derived from 26# this software without specific prior written permission. 27# 28# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 29# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 30# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 31# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 32# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 33# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 34# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 35# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 36# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 37# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 38# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 39# 40# Authors: Nathan Binkert 41 42from __future__ import print_function 43 44import array 45import bisect 46import functools 47import imp 48import marshal 49import os 50import re 51import subprocess 52import sys 53import zlib 54 55from os.path import basename, dirname, exists, isdir, isfile, join as joinpath 56 57import SCons 58 59from gem5_scons import Transform 60 61# This file defines how to build a particular configuration of gem5 62# based on variable settings in the 'env' build environment. 63 64Import('*') 65 66# Children need to see the environment 67Export('env') 68 69build_env = [(opt, env[opt]) for opt in export_vars] 70 71from m5.util import code_formatter, compareVersions 72 73######################################################################## 74# Code for adding source files of various types 75# 76# When specifying a source file of some type, a set of tags can be 77# specified for that file. 78 79class SourceFilter(object): 80 def __init__(self, predicate): 81 self.predicate = predicate 82 83 def __or__(self, other): 84 return SourceFilter(lambda tags: self.predicate(tags) or 85 other.predicate(tags)) 86 87 def __and__(self, other): 88 return SourceFilter(lambda tags: self.predicate(tags) and 89 other.predicate(tags)) 90 91def with_tags_that(predicate): 92 '''Return a list of sources with tags that satisfy a predicate.''' 93 return SourceFilter(predicate) 94 95def with_any_tags(*tags): 96 '''Return a list of sources with any of the supplied tags.''' 97 return SourceFilter(lambda stags: len(set(tags) & stags) > 0) 98 99def with_all_tags(*tags): 100 '''Return a list of sources with all of the supplied tags.''' 101 return SourceFilter(lambda stags: set(tags) <= stags) 102 103def with_tag(tag): 104 '''Return a list of sources with the supplied tag.''' 105 return SourceFilter(lambda stags: tag in stags) 106 107def without_tags(*tags): 108 '''Return a list of sources without any of the supplied tags.''' 109 return SourceFilter(lambda stags: len(set(tags) & stags) == 0) 110 111def without_tag(tag): 112 '''Return a list of sources with the supplied tag.''' 113 return SourceFilter(lambda stags: tag not in stags) 114 115source_filter_factories = { 116 'with_tags_that': with_tags_that, 117 'with_any_tags': with_any_tags, 118 'with_all_tags': with_all_tags, 119 'with_tag': with_tag, 120 'without_tags': without_tags, 121 'without_tag': without_tag, 122} 123 124Export(source_filter_factories) 125 126class SourceList(list): 127 def apply_filter(self, f): 128 def match(source): 129 return f.predicate(source.tags) 130 return SourceList(filter(match, self)) 131 132 def __getattr__(self, name): 133 func = source_filter_factories.get(name, None) 134 if not func: 135 raise AttributeError 136 137 @functools.wraps(func) 138 def wrapper(*args, **kwargs): 139 return self.apply_filter(func(*args, **kwargs)) 140 return wrapper 141 142class SourceMeta(type): 143 '''Meta class for source files that keeps track of all files of a 144 particular type.''' 145 def __init__(cls, name, bases, dict): 146 super(SourceMeta, cls).__init__(name, bases, dict) 147 cls.all = SourceList() 148 149class SourceFile(object): 150 '''Base object that encapsulates the notion of a source file. 151 This includes, the source node, target node, various manipulations 152 of those. A source file also specifies a set of tags which 153 describing arbitrary properties of the source file.''' 154 __metaclass__ = SourceMeta 155 156 static_objs = {} 157 shared_objs = {} 158 159 def __init__(self, source, tags=None, add_tags=None): 160 if tags is None: 161 tags='gem5 lib' 162 if isinstance(tags, basestring): 163 tags = set([tags]) 164 if not isinstance(tags, set): 165 tags = set(tags) 166 self.tags = tags 167 168 if add_tags: 169 if isinstance(add_tags, basestring): 170 add_tags = set([add_tags]) 171 if not isinstance(add_tags, set): 172 add_tags = set(add_tags) 173 self.tags |= add_tags 174 175 tnode = source 176 if not isinstance(source, SCons.Node.FS.File): 177 tnode = File(source) 178 179 self.tnode = tnode 180 self.snode = tnode.srcnode() 181 182 for base in type(self).__mro__: 183 if issubclass(base, SourceFile): 184 base.all.append(self) 185 186 def static(self, env): 187 key = (self.tnode, env['OBJSUFFIX']) 188 if not key in self.static_objs: 189 self.static_objs[key] = env.StaticObject(self.tnode) 190 return self.static_objs[key] 191 192 def shared(self, env): 193 key = (self.tnode, env['OBJSUFFIX']) 194 if not key in self.shared_objs: 195 self.shared_objs[key] = env.SharedObject(self.tnode) 196 return self.shared_objs[key] 197 198 @property 199 def filename(self): 200 return str(self.tnode) 201 202 @property 203 def dirname(self): 204 return dirname(self.filename) 205 206 @property 207 def basename(self): 208 return basename(self.filename) 209 210 @property 211 def extname(self): 212 index = self.basename.rfind('.') 213 if index <= 0: 214 # dot files aren't extensions 215 return self.basename, None 216 217 return self.basename[:index], self.basename[index+1:] 218 219 def __lt__(self, other): return self.filename < other.filename 220 def __le__(self, other): return self.filename <= other.filename 221 def __gt__(self, other): return self.filename > other.filename 222 def __ge__(self, other): return self.filename >= other.filename 223 def __eq__(self, other): return self.filename == other.filename 224 def __ne__(self, other): return self.filename != other.filename 225 226def blobToCpp(data, symbol, cpp_code, hpp_code=None, namespace=None): 227 ''' 228 Convert bytes data into C++ .cpp and .hh uint8_t byte array 229 code containing that binary data. 230 231 :param data: binary data to be converted to C++ 232 :param symbol: name of the symbol 233 :param cpp_code: append the generated cpp_code to this object 234 :param hpp_code: append the generated hpp_code to this object 235 If None, ignore it. Otherwise, also include it 236 in the .cpp file. 237 :param namespace: namespace to put the symbol into. If None, 238 don't put the symbols into any namespace. 239 ''' 240 symbol_len_declaration = 'const std::size_t {}_len'.format(symbol) 241 symbol_declaration = 'const std::uint8_t {}[]'.format(symbol) 242 if hpp_code is not None: 243 cpp_code('''\ 244#include "blobs/{}.hh" 245'''.format(symbol)) 246 hpp_code('''\ 247#include <cstddef> 248#include <cstdint> 249''') 250 if namespace is not None: 251 hpp_code('namespace {} {{'.format(namespace)) 252 hpp_code('extern ' + symbol_len_declaration + ';') 253 hpp_code('extern ' + symbol_declaration + ';') 254 if namespace is not None: 255 hpp_code('}') 256 if namespace is not None: 257 cpp_code('namespace {} {{'.format(namespace)) 258 cpp_code(symbol_len_declaration + ' = {};'.format(len(data))) 259 cpp_code(symbol_declaration + ' = {') 260 cpp_code.indent() 261 step = 16 262 for i in xrange(0, len(data), step): 263 x = array.array('B', data[i:i+step]) 264 cpp_code(''.join('%d,' % d for d in x)) 265 cpp_code.dedent() 266 cpp_code('};') 267 if namespace is not None: 268 cpp_code('}') 269 270def Blob(blob_path, symbol): 271 ''' 272 Embed an arbitrary blob into the gem5 executable, 273 and make it accessible to C++ as a byte array. 274 ''' 275 blob_path = os.path.abspath(blob_path) 276 blob_out_dir = os.path.join(env['BUILDDIR'], 'blobs') 277 path_noext = joinpath(blob_out_dir, symbol) 278 cpp_path = path_noext + '.cc' 279 hpp_path = path_noext + '.hh' 280 def embedBlob(target, source, env): 281 data = file(str(source[0]), 'r').read() 282 cpp_code = code_formatter() 283 hpp_code = code_formatter() 284 blobToCpp(data, symbol, cpp_code, hpp_code, namespace='Blobs') 285 cpp_path = str(target[0]) 286 hpp_path = str(target[1]) 287 cpp_dir = os.path.split(cpp_path)[0] 288 if not os.path.exists(cpp_dir): 289 os.makedirs(cpp_dir) 290 cpp_code.write(cpp_path) 291 hpp_code.write(hpp_path) 292 env.Command([cpp_path, hpp_path], blob_path, 293 MakeAction(embedBlob, Transform("EMBED BLOB"))) 294 Source(cpp_path) 295 296class Source(SourceFile): 297 ungrouped_tag = 'No link group' 298 source_groups = set() 299 300 _current_group_tag = ungrouped_tag 301 302 @staticmethod 303 def link_group_tag(group): 304 return 'link group: %s' % group 305 306 @classmethod 307 def set_group(cls, group): 308 new_tag = Source.link_group_tag(group) 309 Source._current_group_tag = new_tag 310 Source.source_groups.add(group) 311 312 def _add_link_group_tag(self): 313 self.tags.add(Source._current_group_tag) 314 315 '''Add a c/c++ source file to the build''' 316 def __init__(self, source, tags=None, add_tags=None): 317 '''specify the source file, and any tags''' 318 super(Source, self).__init__(source, tags, add_tags) 319 self._add_link_group_tag() 320 321class PySource(SourceFile): 322 '''Add a python source file to the named package''' 323 invalid_sym_char = re.compile('[^A-z0-9_]') 324 modules = {} 325 tnodes = {} 326 symnames = {} 327 328 def __init__(self, package, source, tags=None, add_tags=None): 329 '''specify the python package, the source file, and any tags''' 330 super(PySource, self).__init__(source, tags, add_tags) 331 332 modname,ext = self.extname 333 assert ext == 'py' 334 335 if package: 336 path = package.split('.') 337 else: 338 path = [] 339 340 modpath = path[:] 341 if modname != '__init__': 342 modpath += [ modname ] 343 modpath = '.'.join(modpath) 344 345 arcpath = path + [ self.basename ] 346 abspath = self.snode.abspath 347 if not exists(abspath): 348 abspath = self.tnode.abspath 349 350 self.package = package 351 self.modname = modname 352 self.modpath = modpath 353 self.arcname = joinpath(*arcpath) 354 self.abspath = abspath 355 self.compiled = File(self.filename + 'c') 356 self.cpp = File(self.filename + '.cc') 357 self.symname = PySource.invalid_sym_char.sub('_', modpath) 358 359 PySource.modules[modpath] = self 360 PySource.tnodes[self.tnode] = self 361 PySource.symnames[self.symname] = self 362 363class SimObject(PySource): 364 '''Add a SimObject python file as a python source object and add 365 it to a list of sim object modules''' 366 367 fixed = False 368 modnames = [] 369 370 def __init__(self, source, tags=None, add_tags=None): 371 '''Specify the source file and any tags (automatically in 372 the m5.objects package)''' 373 super(SimObject, self).__init__('m5.objects', source, tags, add_tags) 374 if self.fixed: 375 raise AttributeError, "Too late to call SimObject now." 376 377 bisect.insort_right(SimObject.modnames, self.modname) 378 379class ProtoBuf(SourceFile): 380 '''Add a Protocol Buffer to build''' 381 382 def __init__(self, source, tags=None, add_tags=None): 383 '''Specify the source file, and any tags''' 384 super(ProtoBuf, self).__init__(source, tags, add_tags) 385 386 # Get the file name and the extension 387 modname,ext = self.extname 388 assert ext == 'proto' 389 390 # Currently, we stick to generating the C++ headers, so we 391 # only need to track the source and header. 392 self.cc_file = File(modname + '.pb.cc') 393 self.hh_file = File(modname + '.pb.h') 394 395 396exectuable_classes = [] 397class ExecutableMeta(type): 398 '''Meta class for Executables.''' 399 all = [] 400 401 def __init__(cls, name, bases, d): 402 if not d.pop('abstract', False): 403 ExecutableMeta.all.append(cls) 404 super(ExecutableMeta, cls).__init__(name, bases, d) 405 406 cls.all = [] 407 408class Executable(object): 409 '''Base class for creating an executable from sources.''' 410 __metaclass__ = ExecutableMeta 411 412 abstract = True 413 414 def __init__(self, target, *srcs_and_filts): 415 '''Specify the target name and any sources. Sources that are 416 not SourceFiles are evalued with Source().''' 417 super(Executable, self).__init__() 418 self.all.append(self) 419 self.target = target 420 421 isFilter = lambda arg: isinstance(arg, SourceFilter) 422 self.filters = filter(isFilter, srcs_and_filts) 423 sources = filter(lambda a: not isFilter(a), srcs_and_filts) 424 425 srcs = SourceList() 426 for src in sources: 427 if not isinstance(src, SourceFile): 428 src = Source(src, tags=[]) 429 srcs.append(src) 430 431 self.sources = srcs 432 self.dir = Dir('.') 433 434 def path(self, env): 435 return self.dir.File(self.target + '.' + env['EXE_SUFFIX']) 436 437 def srcs_to_objs(self, env, sources): 438 return list([ s.static(env) for s in sources ]) 439 440 @classmethod 441 def declare_all(cls, env): 442 return list([ instance.declare(env) for instance in cls.all ]) 443 444 def declare(self, env, objs=None): 445 if objs is None: 446 objs = self.srcs_to_objs(env, self.sources) 447 448 if env['STRIP_EXES']: 449 stripped = self.path(env) 450 unstripped = env.File(str(stripped) + '.unstripped') 451 if sys.platform == 'sunos5': 452 cmd = 'cp $SOURCE $TARGET; strip $TARGET' 453 else: 454 cmd = 'strip $SOURCE -o $TARGET' 455 env.Program(unstripped, objs) 456 return env.Command(stripped, unstripped, 457 MakeAction(cmd, Transform("STRIP"))) 458 else: 459 return env.Program(self.path(env), objs) 460 461class UnitTest(Executable): 462 '''Create a UnitTest''' 463 def __init__(self, target, *srcs_and_filts, **kwargs): 464 super(UnitTest, self).__init__(target, *srcs_and_filts) 465 466 self.main = kwargs.get('main', False) 467 468 def declare(self, env): 469 sources = list(self.sources) 470 for f in self.filters: 471 sources = Source.all.apply_filter(f) 472 objs = self.srcs_to_objs(env, sources) + env['STATIC_OBJS'] 473 if self.main: 474 objs += env['MAIN_OBJS'] 475 return super(UnitTest, self).declare(env, objs) 476 477class GTest(Executable): 478 '''Create a unit test based on the google test framework.''' 479 all = [] 480 def __init__(self, *srcs_and_filts, **kwargs): 481 super(GTest, self).__init__(*srcs_and_filts) 482 483 self.skip_lib = kwargs.pop('skip_lib', False) 484 485 @classmethod 486 def declare_all(cls, env): 487 env = env.Clone() 488 env.Append(LIBS=env['GTEST_LIBS']) 489 env.Append(CPPFLAGS=env['GTEST_CPPFLAGS']) 490 env['GTEST_LIB_SOURCES'] = Source.all.with_tag('gtest lib') 491 env['GTEST_OUT_DIR'] = \ 492 Dir(env['BUILDDIR']).Dir('unittests.' + env['EXE_SUFFIX']) 493 return super(GTest, cls).declare_all(env) 494 495 def declare(self, env): 496 sources = list(self.sources) 497 if not self.skip_lib: 498 sources += env['GTEST_LIB_SOURCES'] 499 for f in self.filters: 500 sources += Source.all.apply_filter(f) 501 objs = self.srcs_to_objs(env, sources) 502 503 binary = super(GTest, self).declare(env, objs) 504 505 out_dir = env['GTEST_OUT_DIR'] 506 xml_file = out_dir.Dir(str(self.dir)).File(self.target + '.xml') 507 AlwaysBuild(env.Command(xml_file, binary, 508 "${SOURCES[0]} --gtest_output=xml:${TARGETS[0]}")) 509 510 return binary 511 512class Gem5(Executable): 513 '''Create a gem5 executable.''' 514 515 def __init__(self, target): 516 super(Gem5, self).__init__(target) 517 518 def declare(self, env): 519 objs = env['MAIN_OBJS'] + env['STATIC_OBJS'] 520 return super(Gem5, self).declare(env, objs) 521 522 523# Children should have access 524Export('Blob') 525Export('Source') 526Export('PySource') 527Export('SimObject') 528Export('ProtoBuf') 529Export('Executable') 530Export('UnitTest') 531Export('GTest') 532 533######################################################################## 534# 535# Debug Flags 536# 537debug_flags = {} 538def DebugFlag(name, desc=None): 539 if name in debug_flags: 540 raise AttributeError, "Flag %s already specified" % name 541 debug_flags[name] = (name, (), desc) 542 543def CompoundFlag(name, flags, desc=None): 544 if name in debug_flags: 545 raise AttributeError, "Flag %s already specified" % name 546 547 compound = tuple(flags) 548 debug_flags[name] = (name, compound, desc) 549 550Export('DebugFlag') 551Export('CompoundFlag') 552 553######################################################################## 554# 555# Set some compiler variables 556# 557 558# Include file paths are rooted in this directory. SCons will 559# automatically expand '.' to refer to both the source directory and 560# the corresponding build directory to pick up generated include 561# files. 562env.Append(CPPPATH=Dir('.')) 563 564for extra_dir in extras_dir_list: 565 env.Append(CPPPATH=Dir(extra_dir)) 566 567# Workaround for bug in SCons version > 0.97d20071212 568# Scons bug id: 2006 gem5 Bug id: 308 569for root, dirs, files in os.walk(base_dir, topdown=True): 570 Dir(root[len(base_dir) + 1:]) 571 572######################################################################## 573# 574# Walk the tree and execute all SConscripts in subdirectories 575# 576 577here = Dir('.').srcnode().abspath 578for root, dirs, files in os.walk(base_dir, topdown=True): 579 if root == here: 580 # we don't want to recurse back into this SConscript 581 continue 582 583 if 'SConscript' in files: 584 build_dir = joinpath(env['BUILDDIR'], root[len(base_dir) + 1:]) 585 Source.set_group(build_dir) 586 SConscript(joinpath(root, 'SConscript'), variant_dir=build_dir) 587 588for extra_dir in extras_dir_list: 589 prefix_len = len(dirname(extra_dir)) + 1 590 591 # Also add the corresponding build directory to pick up generated 592 # include files. 593 env.Append(CPPPATH=Dir(joinpath(env['BUILDDIR'], extra_dir[prefix_len:]))) 594 595 for root, dirs, files in os.walk(extra_dir, topdown=True): 596 # if build lives in the extras directory, don't walk down it 597 if 'build' in dirs: 598 dirs.remove('build') 599 600 if 'SConscript' in files: 601 build_dir = joinpath(env['BUILDDIR'], root[prefix_len:]) 602 SConscript(joinpath(root, 'SConscript'), variant_dir=build_dir) 603 604for opt in export_vars: 605 env.ConfigFile(opt) 606 607def makeTheISA(source, target, env): 608 isas = [ src.get_contents() for src in source ] 609 target_isa = env['TARGET_ISA'] 610 def define(isa): 611 return isa.upper() + '_ISA' 612 613 def namespace(isa): 614 return isa[0].upper() + isa[1:].lower() + 'ISA' 615 616 617 code = code_formatter() 618 code('''\ 619#ifndef __CONFIG_THE_ISA_HH__ 620#define __CONFIG_THE_ISA_HH__ 621 622''') 623 624 # create defines for the preprocessing and compile-time determination 625 for i,isa in enumerate(isas): 626 code('#define $0 $1', define(isa), i + 1) 627 code() 628 629 # create an enum for any run-time determination of the ISA, we 630 # reuse the same name as the namespaces 631 code('enum class Arch {') 632 for i,isa in enumerate(isas): 633 if i + 1 == len(isas): 634 code(' $0 = $1', namespace(isa), define(isa)) 635 else: 636 code(' $0 = $1,', namespace(isa), define(isa)) 637 code('};') 638 639 code(''' 640 641#define THE_ISA ${{define(target_isa)}} 642#define TheISA ${{namespace(target_isa)}} 643#define THE_ISA_STR "${{target_isa}}" 644 645#endif // __CONFIG_THE_ISA_HH__''') 646 647 code.write(str(target[0])) 648 649env.Command('config/the_isa.hh', map(Value, all_isa_list), 650 MakeAction(makeTheISA, Transform("CFG ISA", 0))) 651 652def makeTheGPUISA(source, target, env): 653 isas = [ src.get_contents() for src in source ] 654 target_gpu_isa = env['TARGET_GPU_ISA'] 655 def define(isa): 656 return isa.upper() + '_ISA' 657 658 def namespace(isa): 659 return isa[0].upper() + isa[1:].lower() + 'ISA' 660 661 662 code = code_formatter() 663 code('''\ 664#ifndef __CONFIG_THE_GPU_ISA_HH__ 665#define __CONFIG_THE_GPU_ISA_HH__ 666 667''') 668 669 # create defines for the preprocessing and compile-time determination 670 for i,isa in enumerate(isas): 671 code('#define $0 $1', define(isa), i + 1) 672 code() 673 674 # create an enum for any run-time determination of the ISA, we 675 # reuse the same name as the namespaces 676 code('enum class GPUArch {') 677 for i,isa in enumerate(isas): 678 if i + 1 == len(isas): 679 code(' $0 = $1', namespace(isa), define(isa)) 680 else: 681 code(' $0 = $1,', namespace(isa), define(isa)) 682 code('};') 683 684 code(''' 685 686#define THE_GPU_ISA ${{define(target_gpu_isa)}} 687#define TheGpuISA ${{namespace(target_gpu_isa)}} 688#define THE_GPU_ISA_STR "${{target_gpu_isa}}" 689 690#endif // __CONFIG_THE_GPU_ISA_HH__''') 691 692 code.write(str(target[0])) 693 694env.Command('config/the_gpu_isa.hh', map(Value, all_gpu_isa_list), 695 MakeAction(makeTheGPUISA, Transform("CFG ISA", 0))) 696 697######################################################################## 698# 699# Prevent any SimObjects from being added after this point, they 700# should all have been added in the SConscripts above 701# 702SimObject.fixed = True 703 704class DictImporter(object): 705 '''This importer takes a dictionary of arbitrary module names that 706 map to arbitrary filenames.''' 707 def __init__(self, modules): 708 self.modules = modules 709 self.installed = set() 710 711 def __del__(self): 712 self.unload() 713 714 def unload(self): 715 import sys 716 for module in self.installed: 717 del sys.modules[module] 718 self.installed = set() 719 720 def find_module(self, fullname, path): 721 if fullname == 'm5.defines': 722 return self 723 724 if fullname == 'm5.objects': 725 return self 726 727 if fullname.startswith('_m5'): 728 return None 729 730 source = self.modules.get(fullname, None) 731 if source is not None and fullname.startswith('m5.objects'): 732 return self 733 734 return None 735 736 def load_module(self, fullname): 737 mod = imp.new_module(fullname) 738 sys.modules[fullname] = mod 739 self.installed.add(fullname) 740 741 mod.__loader__ = self 742 if fullname == 'm5.objects': 743 mod.__path__ = fullname.split('.') 744 return mod 745 746 if fullname == 'm5.defines': 747 mod.__dict__['buildEnv'] = m5.util.SmartDict(build_env) 748 return mod 749 750 source = self.modules[fullname] 751 if source.modname == '__init__': 752 mod.__path__ = source.modpath 753 mod.__file__ = source.abspath 754 755 exec file(source.abspath, 'r') in mod.__dict__ 756 757 return mod 758 759import m5.SimObject 760import m5.params 761from m5.util import code_formatter 762 763m5.SimObject.clear() 764m5.params.clear() 765 766# install the python importer so we can grab stuff from the source 767# tree itself. We can't have SimObjects added after this point or 768# else we won't know about them for the rest of the stuff. 769importer = DictImporter(PySource.modules) 770sys.meta_path[0:0] = [ importer ] 771 772# import all sim objects so we can populate the all_objects list 773# make sure that we're working with a list, then let's sort it 774for modname in SimObject.modnames: 775 exec('from m5.objects import %s' % modname) 776 777# we need to unload all of the currently imported modules so that they 778# will be re-imported the next time the sconscript is run 779importer.unload() 780sys.meta_path.remove(importer) 781 782sim_objects = m5.SimObject.allClasses 783all_enums = m5.params.allEnums 784 785for name,obj in sorted(sim_objects.iteritems()): 786 for param in obj._params.local.values(): 787 # load the ptype attribute now because it depends on the 788 # current version of SimObject.allClasses, but when scons 789 # actually uses the value, all versions of 790 # SimObject.allClasses will have been loaded 791 param.ptype 792 793######################################################################## 794# 795# calculate extra dependencies 796# 797module_depends = ["m5", "m5.SimObject", "m5.params"] 798depends = [ PySource.modules[dep].snode for dep in module_depends ] 799depends.sort(key = lambda x: x.name) 800 801######################################################################## 802# 803# Commands for the basic automatically generated python files 804# 805 806# Generate Python file containing a dict specifying the current 807# buildEnv flags. 808def makeDefinesPyFile(target, source, env): 809 build_env = source[0].get_contents() 810 811 code = code_formatter() 812 code(""" 813import _m5.core 814import m5.util 815 816buildEnv = m5.util.SmartDict($build_env) 817 818compileDate = _m5.core.compileDate 819_globals = globals() 820for key,val in _m5.core.__dict__.iteritems(): 821 if key.startswith('flag_'): 822 flag = key[5:] 823 _globals[flag] = val 824del _globals 825""") 826 code.write(target[0].abspath) 827 828defines_info = Value(build_env) 829# Generate a file with all of the compile options in it 830env.Command('python/m5/defines.py', defines_info, 831 MakeAction(makeDefinesPyFile, Transform("DEFINES", 0))) 832PySource('m5', 'python/m5/defines.py') 833 834# Generate python file containing info about the M5 source code 835def makeInfoPyFile(target, source, env): 836 code = code_formatter() 837 for src in source: 838 data = ''.join(file(src.srcnode().abspath, 'r').xreadlines()) 839 code('$src = ${{repr(data)}}') 840 code.write(str(target[0])) 841 842# Generate a file that wraps the basic top level files 843env.Command('python/m5/info.py', 844 [ '#/COPYING', '#/LICENSE', '#/README', ], 845 MakeAction(makeInfoPyFile, Transform("INFO"))) 846PySource('m5', 'python/m5/info.py') 847 848######################################################################## 849# 850# Create all of the SimObject param headers and enum headers 851# 852 853def createSimObjectParamStruct(target, source, env): 854 assert len(target) == 1 and len(source) == 1 855 856 name = source[0].get_text_contents() 857 obj = sim_objects[name] 858 859 code = code_formatter() 860 obj.cxx_param_decl(code) 861 code.write(target[0].abspath) 862 863def createSimObjectCxxConfig(is_header): 864 def body(target, source, env): 865 assert len(target) == 1 and len(source) == 1 866 867 name = str(source[0].get_contents()) 868 obj = sim_objects[name] 869 870 code = code_formatter() 871 obj.cxx_config_param_file(code, is_header) 872 code.write(target[0].abspath) 873 return body 874 875def createEnumStrings(target, source, env): 876 assert len(target) == 1 and len(source) == 2 877 878 name = source[0].get_text_contents() 879 use_python = source[1].read() 880 obj = all_enums[name] 881 882 code = code_formatter() 883 obj.cxx_def(code) 884 if use_python: 885 obj.pybind_def(code) 886 code.write(target[0].abspath) 887 888def createEnumDecls(target, source, env): 889 assert len(target) == 1 and len(source) == 1 890 891 name = source[0].get_text_contents() 892 obj = all_enums[name] 893 894 code = code_formatter() 895 obj.cxx_decl(code) 896 code.write(target[0].abspath) 897 898def createSimObjectPyBindWrapper(target, source, env): 899 name = source[0].get_text_contents() 900 obj = sim_objects[name] 901 902 code = code_formatter() 903 obj.pybind_decl(code) 904 code.write(target[0].abspath) 905 906# Generate all of the SimObject param C++ struct header files 907params_hh_files = [] 908for name,simobj in sorted(sim_objects.iteritems()): 909 py_source = PySource.modules[simobj.__module__] 910 extra_deps = [ py_source.tnode ] 911 912 hh_file = File('params/%s.hh' % name) 913 params_hh_files.append(hh_file) 914 env.Command(hh_file, Value(name), 915 MakeAction(createSimObjectParamStruct, Transform("SO PARAM"))) 916 env.Depends(hh_file, depends + extra_deps) 917 918# C++ parameter description files 919if GetOption('with_cxx_config'): 920 for name,simobj in sorted(sim_objects.iteritems()): 921 py_source = PySource.modules[simobj.__module__] 922 extra_deps = [ py_source.tnode ] 923 924 cxx_config_hh_file = File('cxx_config/%s.hh' % name) 925 cxx_config_cc_file = File('cxx_config/%s.cc' % name) 926 env.Command(cxx_config_hh_file, Value(name), 927 MakeAction(createSimObjectCxxConfig(True), 928 Transform("CXXCPRHH"))) 929 env.Command(cxx_config_cc_file, Value(name), 930 MakeAction(createSimObjectCxxConfig(False), 931 Transform("CXXCPRCC"))) 932 env.Depends(cxx_config_hh_file, depends + extra_deps + 933 [File('params/%s.hh' % name), File('sim/cxx_config.hh')]) 934 env.Depends(cxx_config_cc_file, depends + extra_deps + 935 [cxx_config_hh_file]) 936 Source(cxx_config_cc_file) 937 938 cxx_config_init_cc_file = File('cxx_config/init.cc') 939 940 def createCxxConfigInitCC(target, source, env): 941 assert len(target) == 1 and len(source) == 1 942 943 code = code_formatter() 944 945 for name,simobj in sorted(sim_objects.iteritems()): 946 if not hasattr(simobj, 'abstract') or not simobj.abstract: 947 code('#include "cxx_config/${name}.hh"') 948 code() 949 code('void cxxConfigInit()') 950 code('{') 951 code.indent() 952 for name,simobj in sorted(sim_objects.iteritems()): 953 not_abstract = not hasattr(simobj, 'abstract') or \ 954 not simobj.abstract 955 if not_abstract and 'type' in simobj.__dict__: 956 code('cxx_config_directory["${name}"] = ' 957 '${name}CxxConfigParams::makeDirectoryEntry();') 958 code.dedent() 959 code('}') 960 code.write(target[0].abspath) 961 962 py_source = PySource.modules[simobj.__module__] 963 extra_deps = [ py_source.tnode ] 964 env.Command(cxx_config_init_cc_file, Value(name), 965 MakeAction(createCxxConfigInitCC, Transform("CXXCINIT"))) 966 cxx_param_hh_files = ["cxx_config/%s.hh" % simobj 967 for name,simobj in sorted(sim_objects.iteritems()) 968 if not hasattr(simobj, 'abstract') or not simobj.abstract] 969 Depends(cxx_config_init_cc_file, cxx_param_hh_files + 970 [File('sim/cxx_config.hh')]) 971 Source(cxx_config_init_cc_file) 972 973# Generate all enum header files 974for name,enum in sorted(all_enums.iteritems()): 975 py_source = PySource.modules[enum.__module__] 976 extra_deps = [ py_source.tnode ] 977 978 cc_file = File('enums/%s.cc' % name) 979 env.Command(cc_file, [Value(name), Value(env['USE_PYTHON'])], 980 MakeAction(createEnumStrings, Transform("ENUM STR"))) 981 env.Depends(cc_file, depends + extra_deps) 982 Source(cc_file) 983 984 hh_file = File('enums/%s.hh' % name) 985 env.Command(hh_file, Value(name), 986 MakeAction(createEnumDecls, Transform("ENUMDECL"))) 987 env.Depends(hh_file, depends + extra_deps) 988 989# Generate SimObject Python bindings wrapper files 990if env['USE_PYTHON']: 991 for name,simobj in sorted(sim_objects.iteritems()): 992 py_source = PySource.modules[simobj.__module__] 993 extra_deps = [ py_source.tnode ] 994 cc_file = File('python/_m5/param_%s.cc' % name) 995 env.Command(cc_file, Value(name), 996 MakeAction(createSimObjectPyBindWrapper, 997 Transform("SO PyBind"))) 998 env.Depends(cc_file, depends + extra_deps) 999 Source(cc_file) 1000 1001# Build all protocol buffers if we have got protoc and protobuf available 1002if env['HAVE_PROTOBUF']: 1003 for proto in ProtoBuf.all: 1004 # Use both the source and header as the target, and the .proto 1005 # file as the source. When executing the protoc compiler, also 1006 # specify the proto_path to avoid having the generated files 1007 # include the path. 1008 env.Command([proto.cc_file, proto.hh_file], proto.tnode, 1009 MakeAction('$PROTOC --cpp_out ${TARGET.dir} ' 1010 '--proto_path ${SOURCE.dir} $SOURCE', 1011 Transform("PROTOC"))) 1012 1013 # Add the C++ source file 1014 Source(proto.cc_file, tags=proto.tags) 1015elif ProtoBuf.all: 1016 print('Got protobuf to build, but lacks support!') 1017 Exit(1) 1018 1019# 1020# Handle debug flags 1021# 1022def makeDebugFlagCC(target, source, env): 1023 assert(len(target) == 1 and len(source) == 1) 1024 1025 code = code_formatter() 1026 1027 # delay definition of CompoundFlags until after all the definition 1028 # of all constituent SimpleFlags 1029 comp_code = code_formatter() 1030 1031 # file header 1032 code(''' 1033/* 1034 * DO NOT EDIT THIS FILE! Automatically generated by SCons. 1035 */ 1036 1037#include "base/debug.hh" 1038 1039namespace Debug { 1040 1041''') 1042 1043 for name, flag in sorted(source[0].read().iteritems()): 1044 n, compound, desc = flag 1045 assert n == name 1046 1047 if not compound: 1048 code('SimpleFlag $name("$name", "$desc");') 1049 else: 1050 comp_code('CompoundFlag $name("$name", "$desc",') 1051 comp_code.indent() 1052 last = len(compound) - 1 1053 for i,flag in enumerate(compound): 1054 if i != last: 1055 comp_code('&$flag,') 1056 else: 1057 comp_code('&$flag);') 1058 comp_code.dedent() 1059 1060 code.append(comp_code) 1061 code() 1062 code('} // namespace Debug') 1063 1064 code.write(str(target[0])) 1065 1066def makeDebugFlagHH(target, source, env): 1067 assert(len(target) == 1 and len(source) == 1) 1068 1069 val = eval(source[0].get_contents()) 1070 name, compound, desc = val 1071 1072 code = code_formatter() 1073 1074 # file header boilerplate 1075 code('''\ 1076/* 1077 * DO NOT EDIT THIS FILE! Automatically generated by SCons. 1078 */ 1079 1080#ifndef __DEBUG_${name}_HH__ 1081#define __DEBUG_${name}_HH__ 1082 1083namespace Debug { 1084''') 1085 1086 if compound: 1087 code('class CompoundFlag;') 1088 code('class SimpleFlag;') 1089 1090 if compound: 1091 code('extern CompoundFlag $name;') 1092 for flag in compound: 1093 code('extern SimpleFlag $flag;') 1094 else: 1095 code('extern SimpleFlag $name;') 1096 1097 code(''' 1098} 1099 1100#endif // __DEBUG_${name}_HH__ 1101''') 1102 1103 code.write(str(target[0])) 1104 1105for name,flag in sorted(debug_flags.iteritems()): 1106 n, compound, desc = flag 1107 assert n == name 1108 1109 hh_file = 'debug/%s.hh' % name 1110 env.Command(hh_file, Value(flag), 1111 MakeAction(makeDebugFlagHH, Transform("TRACING", 0))) 1112 1113env.Command('debug/flags.cc', Value(debug_flags), 1114 MakeAction(makeDebugFlagCC, Transform("TRACING", 0))) 1115Source('debug/flags.cc') 1116 1117# version tags 1118tags = \ 1119env.Command('sim/tags.cc', None, 1120 MakeAction('util/cpt_upgrader.py --get-cc-file > $TARGET', 1121 Transform("VER TAGS"))) 1122env.AlwaysBuild(tags) 1123 1124# Embed python files. All .py files that have been indicated by a 1125# PySource() call in a SConscript need to be embedded into the M5 1126# library. To do that, we compile the file to byte code, marshal the 1127# byte code, compress it, and then generate a c++ file that 1128# inserts the result into an array. 1129def embedPyFile(target, source, env): 1130 def c_str(string): 1131 if string is None: 1132 return "0" 1133 return '"%s"' % string 1134 1135 '''Action function to compile a .py into a code object, marshal 1136 it, compress it, and stick it into an asm file so the code appears 1137 as just bytes with a label in the data section''' 1138 1139 src = file(str(source[0]), 'r').read() 1140 1141 pysource = PySource.tnodes[source[0]] 1142 compiled = compile(src, pysource.abspath, 'exec') 1143 marshalled = marshal.dumps(compiled) 1144 compressed = zlib.compress(marshalled) 1145 data = compressed 1146 sym = pysource.symname 1147 1148 code = code_formatter() 1149 code('''\ 1150#include "sim/init.hh" 1151 1152namespace { 1153 1154''') 1155 blobToCpp(data, 'data_' + sym, code) 1156 code('''\ 1157 1158 1159EmbeddedPython embedded_${sym}( 1160 ${{c_str(pysource.arcname)}}, 1161 ${{c_str(pysource.abspath)}}, 1162 ${{c_str(pysource.modpath)}}, 1163 data_${sym}, 1164 ${{len(data)}}, 1165 ${{len(marshalled)}}); 1166 1167} // anonymous namespace 1168''') 1169 code.write(str(target[0])) 1170 1171for source in PySource.all: 1172 env.Command(source.cpp, source.tnode, 1173 MakeAction(embedPyFile, Transform("EMBED PY"))) 1174 Source(source.cpp, tags=source.tags, add_tags='python') 1175 1176######################################################################## 1177# 1178# Define binaries. Each different build type (debug, opt, etc.) gets 1179# a slightly different build environment. 1180# 1181 1182# List of constructed environments to pass back to SConstruct 1183date_source = Source('base/date.cc', tags=[]) 1184 1185gem5_binary = Gem5('gem5') 1186 1187# Function to create a new build environment as clone of current 1188# environment 'env' with modified object suffix and optional stripped 1189# binary. Additional keyword arguments are appended to corresponding 1190# build environment vars. 1191def makeEnv(env, label, objsfx, strip=False, disable_partial=False, **kwargs): 1192 # SCons doesn't know to append a library suffix when there is a '.' in the 1193 # name. Use '_' instead. 1194 libname = 'gem5_' + label 1195 secondary_exename = 'm5.' + label 1196 1197 new_env = env.Clone(OBJSUFFIX=objsfx, SHOBJSUFFIX=objsfx + 's') 1198 new_env.Label = label 1199 new_env.Append(**kwargs) 1200 1201 lib_sources = Source.all.with_tag('gem5 lib') 1202 1203 # Without Python, leave out all Python content from the library 1204 # builds. The option doesn't affect gem5 built as a program 1205 if GetOption('without_python'): 1206 lib_sources = lib_sources.without_tag('python') 1207 1208 static_objs = [] 1209 shared_objs = [] 1210 1211 for s in lib_sources.with_tag(Source.ungrouped_tag): 1212 static_objs.append(s.static(new_env)) 1213 shared_objs.append(s.shared(new_env)) 1214 1215 for group in Source.source_groups: 1216 srcs = lib_sources.with_tag(Source.link_group_tag(group)) 1217 if not srcs: 1218 continue 1219 1220 group_static = [ s.static(new_env) for s in srcs ] 1221 group_shared = [ s.shared(new_env) for s in srcs ] 1222 1223 # If partial linking is disabled, add these sources to the build 1224 # directly, and short circuit this loop. 1225 if disable_partial: 1226 static_objs.extend(group_static) 1227 shared_objs.extend(group_shared) 1228 continue 1229 1230 # Set up the static partially linked objects. 1231 file_name = new_env.subst("${OBJPREFIX}lib${OBJSUFFIX}.partial") 1232 target = File(joinpath(group, file_name)) 1233 partial = env.PartialStatic(target=target, source=group_static) 1234 static_objs.extend(partial) 1235 1236 # Set up the shared partially linked objects. 1237 file_name = new_env.subst("${SHOBJPREFIX}lib${SHOBJSUFFIX}.partial") 1238 target = File(joinpath(group, file_name)) 1239 partial = env.PartialShared(target=target, source=group_shared) 1240 shared_objs.extend(partial) 1241 1242 static_date = date_source.static(new_env) 1243 new_env.Depends(static_date, static_objs) 1244 static_objs.extend(static_date) 1245 1246 shared_date = date_source.shared(new_env) 1247 new_env.Depends(shared_date, shared_objs) 1248 shared_objs.extend(shared_date) 1249 1250 main_objs = [ s.static(new_env) for s in Source.all.with_tag('main') ] 1251 1252 # First make a library of everything but main() so other programs can 1253 # link against m5. 1254 static_lib = new_env.StaticLibrary(libname, static_objs) 1255 shared_lib = new_env.SharedLibrary(libname, shared_objs) 1256 1257 # Keep track of the object files generated so far so Executables can 1258 # include them. 1259 new_env['STATIC_OBJS'] = static_objs 1260 new_env['SHARED_OBJS'] = shared_objs 1261 new_env['MAIN_OBJS'] = main_objs 1262 1263 new_env['STATIC_LIB'] = static_lib 1264 new_env['SHARED_LIB'] = shared_lib 1265 1266 # Record some settings for building Executables. 1267 new_env['EXE_SUFFIX'] = label 1268 new_env['STRIP_EXES'] = strip 1269 1270 for cls in ExecutableMeta.all: 1271 cls.declare_all(new_env) 1272 1273 new_env.M5Binary = File(gem5_binary.path(new_env)) 1274 1275 new_env.Command(secondary_exename, new_env.M5Binary, 1276 MakeAction('ln $SOURCE $TARGET', Transform("HARDLINK"))) 1277 1278 # Set up regression tests. 1279 SConscript(os.path.join(env.root.abspath, 'tests', 'SConscript'), 1280 variant_dir=Dir('tests').Dir(new_env.Label), 1281 exports={ 'env' : new_env }, duplicate=False) 1282 1283# Start out with the compiler flags common to all compilers, 1284# i.e. they all use -g for opt and -g -pg for prof 1285ccflags = {'debug' : [], 'opt' : ['-g'], 'fast' : [], 'prof' : ['-g', '-pg'], 1286 'perf' : ['-g']} 1287 1288# Start out with the linker flags common to all linkers, i.e. -pg for 1289# prof, and -lprofiler for perf. The -lprofile flag is surrounded by 1290# no-as-needed and as-needed as the binutils linker is too clever and 1291# simply doesn't link to the library otherwise. 1292ldflags = {'debug' : [], 'opt' : [], 'fast' : [], 'prof' : ['-pg'], 1293 'perf' : ['-Wl,--no-as-needed', '-lprofiler', '-Wl,--as-needed']} 1294 1295# For Link Time Optimization, the optimisation flags used to compile 1296# individual files are decoupled from those used at link time 1297# (i.e. you can compile with -O3 and perform LTO with -O0), so we need 1298# to also update the linker flags based on the target. 1299if env['GCC']: 1300 if sys.platform == 'sunos5': 1301 ccflags['debug'] += ['-gstabs+'] 1302 else: 1303 ccflags['debug'] += ['-ggdb3'] 1304 ldflags['debug'] += ['-O0'] 1305 # opt, fast, prof and perf all share the same cc flags, also add 1306 # the optimization to the ldflags as LTO defers the optimization 1307 # to link time 1308 for target in ['opt', 'fast', 'prof', 'perf']: 1309 ccflags[target] += ['-O3'] 1310 ldflags[target] += ['-O3'] 1311 1312 ccflags['fast'] += env['LTO_CCFLAGS'] 1313 ldflags['fast'] += env['LTO_LDFLAGS'] 1314elif env['CLANG']: 1315 ccflags['debug'] += ['-g', '-O0'] 1316 # opt, fast, prof and perf all share the same cc flags 1317 for target in ['opt', 'fast', 'prof', 'perf']: 1318 ccflags[target] += ['-O3'] 1319else: 1320 print('Unknown compiler, please fix compiler options') 1321 Exit(1) 1322 1323 1324# To speed things up, we only instantiate the build environments we 1325# need. We try to identify the needed environment for each target; if 1326# we can't, we fall back on instantiating all the environments just to 1327# be safe. 1328target_types = ['debug', 'opt', 'fast', 'prof', 'perf'] 1329obj2target = {'do': 'debug', 'o': 'opt', 'fo': 'fast', 'po': 'prof', 1330 'gpo' : 'perf'} 1331 1332def identifyTarget(t): 1333 ext = t.split('.')[-1] 1334 if ext in target_types: 1335 return ext 1336 if obj2target.has_key(ext): 1337 return obj2target[ext] 1338 match = re.search(r'/tests/([^/]+)/', t) 1339 if match and match.group(1) in target_types: 1340 return match.group(1) 1341 return 'all' 1342 1343needed_envs = [identifyTarget(target) for target in BUILD_TARGETS] 1344if 'all' in needed_envs: 1345 needed_envs += target_types 1346 1347disable_partial = False 1348if env['PLATFORM'] == 'darwin': 1349 # Up until Apple LLVM version 10.0.0 (clang-1000.11.45.5), partial 1350 # linked objects do not expose symbols that are marked with the 1351 # hidden visibility and consequently building gem5 on Mac OS 1352 # fails. As a workaround, we disable partial linking, however, we 1353 # may want to revisit in the future. 1354 disable_partial = True 1355 1356# Debug binary 1357if 'debug' in needed_envs: 1358 makeEnv(env, 'debug', '.do', 1359 CCFLAGS = Split(ccflags['debug']), 1360 CPPDEFINES = ['DEBUG', 'TRACING_ON=1'], 1361 LINKFLAGS = Split(ldflags['debug']), 1362 disable_partial=disable_partial) 1363 1364# Optimized binary 1365if 'opt' in needed_envs: 1366 makeEnv(env, 'opt', '.o', 1367 CCFLAGS = Split(ccflags['opt']), 1368 CPPDEFINES = ['TRACING_ON=1'], 1369 LINKFLAGS = Split(ldflags['opt']), 1370 disable_partial=disable_partial) 1371 1372# "Fast" binary 1373if 'fast' in needed_envs: 1374 disable_partial = disable_partial and \ 1375 env.get('BROKEN_INCREMENTAL_LTO', False) and \ 1376 GetOption('force_lto') 1377 makeEnv(env, 'fast', '.fo', strip = True, 1378 CCFLAGS = Split(ccflags['fast']), 1379 CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'], 1380 LINKFLAGS = Split(ldflags['fast']), 1381 disable_partial=disable_partial) 1382 1383# Profiled binary using gprof 1384if 'prof' in needed_envs: 1385 makeEnv(env, 'prof', '.po', 1386 CCFLAGS = Split(ccflags['prof']), 1387 CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'], 1388 LINKFLAGS = Split(ldflags['prof']), 1389 disable_partial=disable_partial) 1390 1391# Profiled binary using google-pprof 1392if 'perf' in needed_envs: 1393 makeEnv(env, 'perf', '.gpo', 1394 CCFLAGS = Split(ccflags['perf']), 1395 CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'], 1396 LINKFLAGS = Split(ldflags['perf']), 1397 disable_partial=disable_partial) 1398