SConscript revision 10454:dc49b13b6f79
1# -*- mode:python -*- 2 3# Copyright (c) 2004-2005 The Regents of The University of Michigan 4# All rights reserved. 5# 6# Redistribution and use in source and binary forms, with or without 7# modification, are permitted provided that the following conditions are 8# met: redistributions of source code must retain the above copyright 9# notice, this list of conditions and the following disclaimer; 10# redistributions in binary form must reproduce the above copyright 11# notice, this list of conditions and the following disclaimer in the 12# documentation and/or other materials provided with the distribution; 13# neither the name of the copyright holders nor the names of its 14# contributors may be used to endorse or promote products derived from 15# this software without specific prior written permission. 16# 17# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28# 29# Authors: Nathan Binkert 30 31import array 32import bisect 33import imp 34import marshal 35import os 36import re 37import sys 38import zlib 39 40from os.path import basename, dirname, exists, isdir, isfile, join as joinpath 41 42import SCons 43 44# This file defines how to build a particular configuration of gem5 45# based on variable settings in the 'env' build environment. 46 47Import('*') 48 49# Children need to see the environment 50Export('env') 51 52build_env = [(opt, env[opt]) for opt in export_vars] 53 54from m5.util import code_formatter, compareVersions 55 56######################################################################## 57# Code for adding source files of various types 58# 59# When specifying a source file of some type, a set of guards can be 60# specified for that file. When get() is used to find the files, if 61# get specifies a set of filters, only files that match those filters 62# will be accepted (unspecified filters on files are assumed to be 63# false). Current filters are: 64# main -- specifies the gem5 main() function 65# skip_lib -- do not put this file into the gem5 library 66# skip_no_python -- do not put this file into a no_python library 67# as it embeds compiled Python 68# <unittest> -- unit tests use filters based on the unit test name 69# 70# A parent can now be specified for a source file and default filter 71# values will be retrieved recursively from parents (children override 72# parents). 73# 74class SourceMeta(type): 75 '''Meta class for source files that keeps track of all files of a 76 particular type and has a get function for finding all functions 77 of a certain type that match a set of guards''' 78 def __init__(cls, name, bases, dict): 79 super(SourceMeta, cls).__init__(name, bases, dict) 80 cls.all = [] 81 82 def get(cls, **guards): 83 '''Find all files that match the specified guards. If a source 84 file does not specify a flag, the default is False''' 85 for src in cls.all: 86 for flag,value in guards.iteritems(): 87 # if the flag is found and has a different value, skip 88 # this file 89 if src.all_guards.get(flag, False) != value: 90 break 91 else: 92 yield src 93 94class SourceFile(object): 95 '''Base object that encapsulates the notion of a source file. 96 This includes, the source node, target node, various manipulations 97 of those. A source file also specifies a set of guards which 98 describing which builds the source file applies to. A parent can 99 also be specified to get default guards from''' 100 __metaclass__ = SourceMeta 101 def __init__(self, source, parent=None, **guards): 102 self.guards = guards 103 self.parent = parent 104 105 tnode = source 106 if not isinstance(source, SCons.Node.FS.File): 107 tnode = File(source) 108 109 self.tnode = tnode 110 self.snode = tnode.srcnode() 111 112 for base in type(self).__mro__: 113 if issubclass(base, SourceFile): 114 base.all.append(self) 115 116 @property 117 def filename(self): 118 return str(self.tnode) 119 120 @property 121 def dirname(self): 122 return dirname(self.filename) 123 124 @property 125 def basename(self): 126 return basename(self.filename) 127 128 @property 129 def extname(self): 130 index = self.basename.rfind('.') 131 if index <= 0: 132 # dot files aren't extensions 133 return self.basename, None 134 135 return self.basename[:index], self.basename[index+1:] 136 137 @property 138 def all_guards(self): 139 '''find all guards for this object getting default values 140 recursively from its parents''' 141 guards = {} 142 if self.parent: 143 guards.update(self.parent.guards) 144 guards.update(self.guards) 145 return guards 146 147 def __lt__(self, other): return self.filename < other.filename 148 def __le__(self, other): return self.filename <= other.filename 149 def __gt__(self, other): return self.filename > other.filename 150 def __ge__(self, other): return self.filename >= other.filename 151 def __eq__(self, other): return self.filename == other.filename 152 def __ne__(self, other): return self.filename != other.filename 153 154 @staticmethod 155 def done(): 156 def disabled(cls, name, *ignored): 157 raise RuntimeError("Additional SourceFile '%s'" % name,\ 158 "declared, but targets deps are already fixed.") 159 SourceFile.__init__ = disabled 160 161 162class Source(SourceFile): 163 '''Add a c/c++ source file to the build''' 164 def __init__(self, source, Werror=True, swig=False, **guards): 165 '''specify the source file, and any guards''' 166 super(Source, self).__init__(source, **guards) 167 168 self.Werror = Werror 169 self.swig = swig 170 171class PySource(SourceFile): 172 '''Add a python source file to the named package''' 173 invalid_sym_char = re.compile('[^A-z0-9_]') 174 modules = {} 175 tnodes = {} 176 symnames = {} 177 178 def __init__(self, package, source, **guards): 179 '''specify the python package, the source file, and any guards''' 180 super(PySource, self).__init__(source, **guards) 181 182 modname,ext = self.extname 183 assert ext == 'py' 184 185 if package: 186 path = package.split('.') 187 else: 188 path = [] 189 190 modpath = path[:] 191 if modname != '__init__': 192 modpath += [ modname ] 193 modpath = '.'.join(modpath) 194 195 arcpath = path + [ self.basename ] 196 abspath = self.snode.abspath 197 if not exists(abspath): 198 abspath = self.tnode.abspath 199 200 self.package = package 201 self.modname = modname 202 self.modpath = modpath 203 self.arcname = joinpath(*arcpath) 204 self.abspath = abspath 205 self.compiled = File(self.filename + 'c') 206 self.cpp = File(self.filename + '.cc') 207 self.symname = PySource.invalid_sym_char.sub('_', modpath) 208 209 PySource.modules[modpath] = self 210 PySource.tnodes[self.tnode] = self 211 PySource.symnames[self.symname] = self 212 213class SimObject(PySource): 214 '''Add a SimObject python file as a python source object and add 215 it to a list of sim object modules''' 216 217 fixed = False 218 modnames = [] 219 220 def __init__(self, source, **guards): 221 '''Specify the source file and any guards (automatically in 222 the m5.objects package)''' 223 super(SimObject, self).__init__('m5.objects', source, **guards) 224 if self.fixed: 225 raise AttributeError, "Too late to call SimObject now." 226 227 bisect.insort_right(SimObject.modnames, self.modname) 228 229class SwigSource(SourceFile): 230 '''Add a swig file to build''' 231 232 def __init__(self, package, source, **guards): 233 '''Specify the python package, the source file, and any guards''' 234 super(SwigSource, self).__init__(source, skip_no_python=True, **guards) 235 236 modname,ext = self.extname 237 assert ext == 'i' 238 239 self.module = modname 240 cc_file = joinpath(self.dirname, modname + '_wrap.cc') 241 py_file = joinpath(self.dirname, modname + '.py') 242 243 self.cc_source = Source(cc_file, swig=True, parent=self, **guards) 244 self.py_source = PySource(package, py_file, parent=self, **guards) 245 246class ProtoBuf(SourceFile): 247 '''Add a Protocol Buffer to build''' 248 249 def __init__(self, source, **guards): 250 '''Specify the source file, and any guards''' 251 super(ProtoBuf, self).__init__(source, **guards) 252 253 # Get the file name and the extension 254 modname,ext = self.extname 255 assert ext == 'proto' 256 257 # Currently, we stick to generating the C++ headers, so we 258 # only need to track the source and header. 259 self.cc_file = File(modname + '.pb.cc') 260 self.hh_file = File(modname + '.pb.h') 261 262class UnitTest(object): 263 '''Create a UnitTest''' 264 265 all = [] 266 def __init__(self, target, *sources, **kwargs): 267 '''Specify the target name and any sources. Sources that are 268 not SourceFiles are evalued with Source(). All files are 269 guarded with a guard of the same name as the UnitTest 270 target.''' 271 272 srcs = [] 273 for src in sources: 274 if not isinstance(src, SourceFile): 275 src = Source(src, skip_lib=True) 276 src.guards[target] = True 277 srcs.append(src) 278 279 self.sources = srcs 280 self.target = target 281 self.main = kwargs.get('main', False) 282 UnitTest.all.append(self) 283 284# Children should have access 285Export('Source') 286Export('PySource') 287Export('SimObject') 288Export('SwigSource') 289Export('ProtoBuf') 290Export('UnitTest') 291 292######################################################################## 293# 294# Debug Flags 295# 296debug_flags = {} 297def DebugFlag(name, desc=None): 298 if name in debug_flags: 299 raise AttributeError, "Flag %s already specified" % name 300 debug_flags[name] = (name, (), desc) 301 302def CompoundFlag(name, flags, desc=None): 303 if name in debug_flags: 304 raise AttributeError, "Flag %s already specified" % name 305 306 compound = tuple(flags) 307 debug_flags[name] = (name, compound, desc) 308 309Export('DebugFlag') 310Export('CompoundFlag') 311 312######################################################################## 313# 314# Set some compiler variables 315# 316 317# Include file paths are rooted in this directory. SCons will 318# automatically expand '.' to refer to both the source directory and 319# the corresponding build directory to pick up generated include 320# files. 321env.Append(CPPPATH=Dir('.')) 322 323for extra_dir in extras_dir_list: 324 env.Append(CPPPATH=Dir(extra_dir)) 325 326# Workaround for bug in SCons version > 0.97d20071212 327# Scons bug id: 2006 gem5 Bug id: 308 328for root, dirs, files in os.walk(base_dir, topdown=True): 329 Dir(root[len(base_dir) + 1:]) 330 331######################################################################## 332# 333# Walk the tree and execute all SConscripts in subdirectories 334# 335 336here = Dir('.').srcnode().abspath 337for root, dirs, files in os.walk(base_dir, topdown=True): 338 if root == here: 339 # we don't want to recurse back into this SConscript 340 continue 341 342 if 'SConscript' in files: 343 build_dir = joinpath(env['BUILDDIR'], root[len(base_dir) + 1:]) 344 SConscript(joinpath(root, 'SConscript'), variant_dir=build_dir) 345 346for extra_dir in extras_dir_list: 347 prefix_len = len(dirname(extra_dir)) + 1 348 349 # Also add the corresponding build directory to pick up generated 350 # include files. 351 env.Append(CPPPATH=Dir(joinpath(env['BUILDDIR'], extra_dir[prefix_len:]))) 352 353 for root, dirs, files in os.walk(extra_dir, topdown=True): 354 # if build lives in the extras directory, don't walk down it 355 if 'build' in dirs: 356 dirs.remove('build') 357 358 if 'SConscript' in files: 359 build_dir = joinpath(env['BUILDDIR'], root[prefix_len:]) 360 SConscript(joinpath(root, 'SConscript'), variant_dir=build_dir) 361 362for opt in export_vars: 363 env.ConfigFile(opt) 364 365def makeTheISA(source, target, env): 366 isas = [ src.get_contents() for src in source ] 367 target_isa = env['TARGET_ISA'] 368 def define(isa): 369 return isa.upper() + '_ISA' 370 371 def namespace(isa): 372 return isa[0].upper() + isa[1:].lower() + 'ISA' 373 374 375 code = code_formatter() 376 code('''\ 377#ifndef __CONFIG_THE_ISA_HH__ 378#define __CONFIG_THE_ISA_HH__ 379 380''') 381 382 for i,isa in enumerate(isas): 383 code('#define $0 $1', define(isa), i + 1) 384 385 code(''' 386 387#define THE_ISA ${{define(target_isa)}} 388#define TheISA ${{namespace(target_isa)}} 389#define THE_ISA_STR "${{target_isa}}" 390 391#endif // __CONFIG_THE_ISA_HH__''') 392 393 code.write(str(target[0])) 394 395env.Command('config/the_isa.hh', map(Value, all_isa_list), 396 MakeAction(makeTheISA, Transform("CFG ISA", 0))) 397 398######################################################################## 399# 400# Prevent any SimObjects from being added after this point, they 401# should all have been added in the SConscripts above 402# 403SimObject.fixed = True 404 405class DictImporter(object): 406 '''This importer takes a dictionary of arbitrary module names that 407 map to arbitrary filenames.''' 408 def __init__(self, modules): 409 self.modules = modules 410 self.installed = set() 411 412 def __del__(self): 413 self.unload() 414 415 def unload(self): 416 import sys 417 for module in self.installed: 418 del sys.modules[module] 419 self.installed = set() 420 421 def find_module(self, fullname, path): 422 if fullname == 'm5.defines': 423 return self 424 425 if fullname == 'm5.objects': 426 return self 427 428 if fullname.startswith('m5.internal'): 429 return None 430 431 source = self.modules.get(fullname, None) 432 if source is not None and fullname.startswith('m5.objects'): 433 return self 434 435 return None 436 437 def load_module(self, fullname): 438 mod = imp.new_module(fullname) 439 sys.modules[fullname] = mod 440 self.installed.add(fullname) 441 442 mod.__loader__ = self 443 if fullname == 'm5.objects': 444 mod.__path__ = fullname.split('.') 445 return mod 446 447 if fullname == 'm5.defines': 448 mod.__dict__['buildEnv'] = m5.util.SmartDict(build_env) 449 return mod 450 451 source = self.modules[fullname] 452 if source.modname == '__init__': 453 mod.__path__ = source.modpath 454 mod.__file__ = source.abspath 455 456 exec file(source.abspath, 'r') in mod.__dict__ 457 458 return mod 459 460import m5.SimObject 461import m5.params 462from m5.util import code_formatter 463 464m5.SimObject.clear() 465m5.params.clear() 466 467# install the python importer so we can grab stuff from the source 468# tree itself. We can't have SimObjects added after this point or 469# else we won't know about them for the rest of the stuff. 470importer = DictImporter(PySource.modules) 471sys.meta_path[0:0] = [ importer ] 472 473# import all sim objects so we can populate the all_objects list 474# make sure that we're working with a list, then let's sort it 475for modname in SimObject.modnames: 476 exec('from m5.objects import %s' % modname) 477 478# we need to unload all of the currently imported modules so that they 479# will be re-imported the next time the sconscript is run 480importer.unload() 481sys.meta_path.remove(importer) 482 483sim_objects = m5.SimObject.allClasses 484all_enums = m5.params.allEnums 485 486if m5.SimObject.noCxxHeader: 487 print >> sys.stderr, \ 488 "warning: At least one SimObject lacks a header specification. " \ 489 "This can cause unexpected results in the generated SWIG " \ 490 "wrappers." 491 492# Find param types that need to be explicitly wrapped with swig. 493# These will be recognized because the ParamDesc will have a 494# swig_decl() method. Most param types are based on types that don't 495# need this, either because they're based on native types (like Int) 496# or because they're SimObjects (which get swigged independently). 497# For now the only things handled here are VectorParam types. 498params_to_swig = {} 499for name,obj in sorted(sim_objects.iteritems()): 500 for param in obj._params.local.values(): 501 # load the ptype attribute now because it depends on the 502 # current version of SimObject.allClasses, but when scons 503 # actually uses the value, all versions of 504 # SimObject.allClasses will have been loaded 505 param.ptype 506 507 if not hasattr(param, 'swig_decl'): 508 continue 509 pname = param.ptype_str 510 if pname not in params_to_swig: 511 params_to_swig[pname] = param 512 513######################################################################## 514# 515# calculate extra dependencies 516# 517module_depends = ["m5", "m5.SimObject", "m5.params"] 518depends = [ PySource.modules[dep].snode for dep in module_depends ] 519 520######################################################################## 521# 522# Commands for the basic automatically generated python files 523# 524 525# Generate Python file containing a dict specifying the current 526# buildEnv flags. 527def makeDefinesPyFile(target, source, env): 528 build_env = source[0].get_contents() 529 530 code = code_formatter() 531 code(""" 532import m5.internal 533import m5.util 534 535buildEnv = m5.util.SmartDict($build_env) 536 537compileDate = m5.internal.core.compileDate 538_globals = globals() 539for key,val in m5.internal.core.__dict__.iteritems(): 540 if key.startswith('flag_'): 541 flag = key[5:] 542 _globals[flag] = val 543del _globals 544""") 545 code.write(target[0].abspath) 546 547defines_info = Value(build_env) 548# Generate a file with all of the compile options in it 549env.Command('python/m5/defines.py', defines_info, 550 MakeAction(makeDefinesPyFile, Transform("DEFINES", 0))) 551PySource('m5', 'python/m5/defines.py') 552 553# Generate python file containing info about the M5 source code 554def makeInfoPyFile(target, source, env): 555 code = code_formatter() 556 for src in source: 557 data = ''.join(file(src.srcnode().abspath, 'r').xreadlines()) 558 code('$src = ${{repr(data)}}') 559 code.write(str(target[0])) 560 561# Generate a file that wraps the basic top level files 562env.Command('python/m5/info.py', 563 [ '#/COPYING', '#/LICENSE', '#/README', ], 564 MakeAction(makeInfoPyFile, Transform("INFO"))) 565PySource('m5', 'python/m5/info.py') 566 567######################################################################## 568# 569# Create all of the SimObject param headers and enum headers 570# 571 572def createSimObjectParamStruct(target, source, env): 573 assert len(target) == 1 and len(source) == 1 574 575 name = str(source[0].get_contents()) 576 obj = sim_objects[name] 577 578 code = code_formatter() 579 obj.cxx_param_decl(code) 580 code.write(target[0].abspath) 581 582def createParamSwigWrapper(target, source, env): 583 assert len(target) == 1 and len(source) == 1 584 585 name = str(source[0].get_contents()) 586 param = params_to_swig[name] 587 588 code = code_formatter() 589 param.swig_decl(code) 590 code.write(target[0].abspath) 591 592def createEnumStrings(target, source, env): 593 assert len(target) == 1 and len(source) == 1 594 595 name = str(source[0].get_contents()) 596 obj = all_enums[name] 597 598 code = code_formatter() 599 obj.cxx_def(code) 600 code.write(target[0].abspath) 601 602def createEnumDecls(target, source, env): 603 assert len(target) == 1 and len(source) == 1 604 605 name = str(source[0].get_contents()) 606 obj = all_enums[name] 607 608 code = code_formatter() 609 obj.cxx_decl(code) 610 code.write(target[0].abspath) 611 612def createEnumSwigWrapper(target, source, env): 613 assert len(target) == 1 and len(source) == 1 614 615 name = str(source[0].get_contents()) 616 obj = all_enums[name] 617 618 code = code_formatter() 619 obj.swig_decl(code) 620 code.write(target[0].abspath) 621 622def createSimObjectSwigWrapper(target, source, env): 623 name = source[0].get_contents() 624 obj = sim_objects[name] 625 626 code = code_formatter() 627 obj.swig_decl(code) 628 code.write(target[0].abspath) 629 630# dummy target for generated code 631# we start out with all the Source files so they get copied to build/*/ also. 632SWIG = env.Dummy('swig', [s.tnode for s in Source.get()]) 633 634# Generate all of the SimObject param C++ struct header files 635params_hh_files = [] 636for name,simobj in sorted(sim_objects.iteritems()): 637 py_source = PySource.modules[simobj.__module__] 638 extra_deps = [ py_source.tnode ] 639 640 hh_file = File('params/%s.hh' % name) 641 params_hh_files.append(hh_file) 642 env.Command(hh_file, Value(name), 643 MakeAction(createSimObjectParamStruct, Transform("SO PARAM"))) 644 env.Depends(hh_file, depends + extra_deps) 645 env.Depends(SWIG, hh_file) 646 647# Generate any needed param SWIG wrapper files 648params_i_files = [] 649for name,param in params_to_swig.iteritems(): 650 i_file = File('python/m5/internal/%s.i' % (param.swig_module_name())) 651 params_i_files.append(i_file) 652 env.Command(i_file, Value(name), 653 MakeAction(createParamSwigWrapper, Transform("SW PARAM"))) 654 env.Depends(i_file, depends) 655 env.Depends(SWIG, i_file) 656 SwigSource('m5.internal', i_file) 657 658# Generate all enum header files 659for name,enum in sorted(all_enums.iteritems()): 660 py_source = PySource.modules[enum.__module__] 661 extra_deps = [ py_source.tnode ] 662 663 cc_file = File('enums/%s.cc' % name) 664 env.Command(cc_file, Value(name), 665 MakeAction(createEnumStrings, Transform("ENUM STR"))) 666 env.Depends(cc_file, depends + extra_deps) 667 env.Depends(SWIG, cc_file) 668 Source(cc_file) 669 670 hh_file = File('enums/%s.hh' % name) 671 env.Command(hh_file, Value(name), 672 MakeAction(createEnumDecls, Transform("ENUMDECL"))) 673 env.Depends(hh_file, depends + extra_deps) 674 env.Depends(SWIG, hh_file) 675 676 i_file = File('python/m5/internal/enum_%s.i' % name) 677 env.Command(i_file, Value(name), 678 MakeAction(createEnumSwigWrapper, Transform("ENUMSWIG"))) 679 env.Depends(i_file, depends + extra_deps) 680 env.Depends(SWIG, i_file) 681 SwigSource('m5.internal', i_file) 682 683# Generate SimObject SWIG wrapper files 684for name,simobj in sim_objects.iteritems(): 685 py_source = PySource.modules[simobj.__module__] 686 extra_deps = [ py_source.tnode ] 687 688 i_file = File('python/m5/internal/param_%s.i' % name) 689 env.Command(i_file, Value(name), 690 MakeAction(createSimObjectSwigWrapper, Transform("SO SWIG"))) 691 env.Depends(i_file, depends + extra_deps) 692 SwigSource('m5.internal', i_file) 693 694# Generate the main swig init file 695def makeEmbeddedSwigInit(target, source, env): 696 code = code_formatter() 697 module = source[0].get_contents() 698 code('''\ 699#include "sim/init.hh" 700 701extern "C" { 702 void init_${module}(); 703} 704 705EmbeddedSwig embed_swig_${module}(init_${module}); 706''') 707 code.write(str(target[0])) 708 709# Build all swig modules 710for swig in SwigSource.all: 711 env.Command([swig.cc_source.tnode, swig.py_source.tnode], swig.tnode, 712 MakeAction('$SWIG $SWIGFLAGS -outdir ${TARGETS[1].dir} ' 713 '-o ${TARGETS[0]} $SOURCES', Transform("SWIG"))) 714 cc_file = str(swig.tnode) 715 init_file = '%s/%s_init.cc' % (dirname(cc_file), basename(cc_file)) 716 env.Command(init_file, Value(swig.module), 717 MakeAction(makeEmbeddedSwigInit, Transform("EMBED SW"))) 718 env.Depends(SWIG, init_file) 719 Source(init_file, **swig.guards) 720 721# Build all protocol buffers if we have got protoc and protobuf available 722if env['HAVE_PROTOBUF']: 723 for proto in ProtoBuf.all: 724 # Use both the source and header as the target, and the .proto 725 # file as the source. When executing the protoc compiler, also 726 # specify the proto_path to avoid having the generated files 727 # include the path. 728 env.Command([proto.cc_file, proto.hh_file], proto.tnode, 729 MakeAction('$PROTOC --cpp_out ${TARGET.dir} ' 730 '--proto_path ${SOURCE.dir} $SOURCE', 731 Transform("PROTOC"))) 732 733 env.Depends(SWIG, [proto.cc_file, proto.hh_file]) 734 # Add the C++ source file 735 Source(proto.cc_file, **proto.guards) 736elif ProtoBuf.all: 737 print 'Got protobuf to build, but lacks support!' 738 Exit(1) 739 740# 741# Handle debug flags 742# 743def makeDebugFlagCC(target, source, env): 744 assert(len(target) == 1 and len(source) == 1) 745 746 val = eval(source[0].get_contents()) 747 name, compound, desc = val 748 compound = list(sorted(compound)) 749 750 code = code_formatter() 751 752 # file header 753 code(''' 754/* 755 * DO NOT EDIT THIS FILE! Automatically generated 756 */ 757 758#include "base/debug.hh" 759''') 760 761 for flag in compound: 762 code('#include "debug/$flag.hh"') 763 code() 764 code('namespace Debug {') 765 code() 766 767 if not compound: 768 code('SimpleFlag $name("$name", "$desc");') 769 else: 770 code('CompoundFlag $name("$name", "$desc",') 771 code.indent() 772 last = len(compound) - 1 773 for i,flag in enumerate(compound): 774 if i != last: 775 code('$flag,') 776 else: 777 code('$flag);') 778 code.dedent() 779 780 code() 781 code('} // namespace Debug') 782 783 code.write(str(target[0])) 784 785def makeDebugFlagHH(target, source, env): 786 assert(len(target) == 1 and len(source) == 1) 787 788 val = eval(source[0].get_contents()) 789 name, compound, desc = val 790 791 code = code_formatter() 792 793 # file header boilerplate 794 code('''\ 795/* 796 * DO NOT EDIT THIS FILE! 797 * 798 * Automatically generated by SCons 799 */ 800 801#ifndef __DEBUG_${name}_HH__ 802#define __DEBUG_${name}_HH__ 803 804namespace Debug { 805''') 806 807 if compound: 808 code('class CompoundFlag;') 809 code('class SimpleFlag;') 810 811 if compound: 812 code('extern CompoundFlag $name;') 813 for flag in compound: 814 code('extern SimpleFlag $flag;') 815 else: 816 code('extern SimpleFlag $name;') 817 818 code(''' 819} 820 821#endif // __DEBUG_${name}_HH__ 822''') 823 824 code.write(str(target[0])) 825 826for name,flag in sorted(debug_flags.iteritems()): 827 n, compound, desc = flag 828 assert n == name 829 830 hh_file = 'debug/%s.hh' % name 831 cc_file = 'debug/%s.cc' % name 832 env.Command(hh_file, Value(flag), 833 MakeAction(makeDebugFlagHH, Transform("TRACING", 0))) 834 env.Command(cc_file, Value(flag), 835 MakeAction(makeDebugFlagCC, Transform("TRACING", 0))) 836 env.Depends(SWIG, [hh_file, cc_file]) 837 Source('debug/%s.cc' % name) 838 839# Embed python files. All .py files that have been indicated by a 840# PySource() call in a SConscript need to be embedded into the M5 841# library. To do that, we compile the file to byte code, marshal the 842# byte code, compress it, and then generate a c++ file that 843# inserts the result into an array. 844def embedPyFile(target, source, env): 845 def c_str(string): 846 if string is None: 847 return "0" 848 return '"%s"' % string 849 850 '''Action function to compile a .py into a code object, marshal 851 it, compress it, and stick it into an asm file so the code appears 852 as just bytes with a label in the data section''' 853 854 src = file(str(source[0]), 'r').read() 855 856 pysource = PySource.tnodes[source[0]] 857 compiled = compile(src, pysource.abspath, 'exec') 858 marshalled = marshal.dumps(compiled) 859 compressed = zlib.compress(marshalled) 860 data = compressed 861 sym = pysource.symname 862 863 code = code_formatter() 864 code('''\ 865#include "sim/init.hh" 866 867namespace { 868 869const uint8_t data_${sym}[] = { 870''') 871 code.indent() 872 step = 16 873 for i in xrange(0, len(data), step): 874 x = array.array('B', data[i:i+step]) 875 code(''.join('%d,' % d for d in x)) 876 code.dedent() 877 878 code('''}; 879 880EmbeddedPython embedded_${sym}( 881 ${{c_str(pysource.arcname)}}, 882 ${{c_str(pysource.abspath)}}, 883 ${{c_str(pysource.modpath)}}, 884 data_${sym}, 885 ${{len(data)}}, 886 ${{len(marshalled)}}); 887 888} // anonymous namespace 889''') 890 code.write(str(target[0])) 891 892for source in PySource.all: 893 env.Command(source.cpp, source.tnode, 894 MakeAction(embedPyFile, Transform("EMBED PY"))) 895 env.Depends(SWIG, source.cpp) 896 Source(source.cpp, skip_no_python=True) 897 898######################################################################## 899# 900# Define binaries. Each different build type (debug, opt, etc.) gets 901# a slightly different build environment. 902# 903 904# List of constructed environments to pass back to SConstruct 905date_source = Source('base/date.cc', skip_lib=True) 906 907# Capture this directory for the closure makeEnv, otherwise when it is 908# called, it won't know what directory it should use. 909variant_dir = Dir('.').path 910def variant(*path): 911 return os.path.join(variant_dir, *path) 912def variantd(*path): 913 return variant(*path)+'/' 914 915# Function to create a new build environment as clone of current 916# environment 'env' with modified object suffix and optional stripped 917# binary. Additional keyword arguments are appended to corresponding 918# build environment vars. 919def makeEnv(env, label, objsfx, strip = False, **kwargs): 920 # SCons doesn't know to append a library suffix when there is a '.' in the 921 # name. Use '_' instead. 922 libname = variant('gem5_' + label) 923 exename = variant('gem5.' + label) 924 secondary_exename = variant('m5.' + label) 925 926 new_env = env.Clone(OBJSUFFIX=objsfx, SHOBJSUFFIX=objsfx + 's') 927 new_env.Label = label 928 new_env.Append(**kwargs) 929 930 swig_env = new_env.Clone() 931 932 # Both gcc and clang have issues with unused labels and values in 933 # the SWIG generated code 934 swig_env.Append(CCFLAGS=['-Wno-unused-label', '-Wno-unused-value']) 935 936 # Add additional warnings here that should not be applied to 937 # the SWIG generated code 938 new_env.Append(CXXFLAGS='-Wmissing-declarations') 939 940 if env['GCC']: 941 # Depending on the SWIG version, we also need to supress 942 # warnings about uninitialized variables and missing field 943 # initializers. 944 swig_env.Append(CCFLAGS=['-Wno-uninitialized', 945 '-Wno-missing-field-initializers', 946 '-Wno-unused-but-set-variable']) 947 948 # If gcc supports it, also warn for deletion of derived 949 # classes with non-virtual desctructors. For gcc >= 4.7 we 950 # also have to disable warnings about the SWIG code having 951 # potentially uninitialized variables. 952 if compareVersions(env['GCC_VERSION'], '4.7') >= 0: 953 new_env.Append(CXXFLAGS='-Wdelete-non-virtual-dtor') 954 swig_env.Append(CCFLAGS='-Wno-maybe-uninitialized') 955 if env['CLANG']: 956 # Always enable the warning for deletion of derived classes 957 # with non-virtual destructors 958 new_env.Append(CXXFLAGS=['-Wdelete-non-virtual-dtor']) 959 960 swig_env.Append(CCFLAGS=[ 961 # Some versions of SWIG can return uninitialized values 962 '-Wno-sometimes-uninitialized', 963 # Register storage is requested in a lot of places in 964 # SWIG-generated code. 965 '-Wno-deprecated-register', 966 ]) 967 968 werror_env = new_env.Clone() 969 werror_env.Append(CCFLAGS='-Werror') 970 971 def make_obj(source, static, extra_deps = None): 972 '''This function adds the specified source to the correct 973 build environment, and returns the corresponding SCons Object 974 nodes''' 975 976 if source.swig: 977 env = swig_env 978 elif source.Werror: 979 env = werror_env 980 else: 981 env = new_env 982 983 if static: 984 obj = env.StaticObject(source.tnode) 985 else: 986 obj = env.SharedObject(source.tnode) 987 988 if extra_deps: 989 env.Depends(obj, extra_deps) 990 991 return obj 992 993 lib_guards = {'main': False, 'skip_lib': False} 994 995 # Without Python, leave out all SWIG and Python content from the 996 # library builds. The option doesn't affect gem5 built as a program 997 if GetOption('without_python'): 998 lib_guards['skip_no_python'] = False 999 1000 static_objs = [ make_obj(s, True) for s in Source.get(**lib_guards) ] 1001 shared_objs = [ make_obj(s, False) for s in Source.get(**lib_guards) ] 1002 1003 static_date = make_obj(date_source, static=True, extra_deps=static_objs) 1004 static_objs.append(static_date) 1005 1006 shared_date = make_obj(date_source, static=False, extra_deps=shared_objs) 1007 shared_objs.append(shared_date) 1008 1009 # First make a library of everything but main() so other programs can 1010 # link against m5. 1011 static_lib = new_env.StaticLibrary(libname, static_objs) 1012 shared_lib = new_env.SharedLibrary(libname, shared_objs) 1013 1014 # Now link a stub with main() and the static library. 1015 main_objs = [ make_obj(s, True) for s in Source.get(main=True) ] 1016 1017 for test in UnitTest.all: 1018 flags = { test.target : True } 1019 test_sources = Source.get(**flags) 1020 test_objs = [ make_obj(s, static=True) for s in test_sources ] 1021 if test.main: 1022 test_objs += main_objs 1023 path = variant('unittest/%s.%s' % (test.target, label)) 1024 new_env.Program(path, test_objs + static_objs) 1025 1026 progname = exename 1027 if strip: 1028 progname += '.unstripped' 1029 1030 targets = new_env.Program(progname, main_objs + static_objs) 1031 1032 if strip: 1033 if sys.platform == 'sunos5': 1034 cmd = 'cp $SOURCE $TARGET; strip $TARGET' 1035 else: 1036 cmd = 'strip $SOURCE -o $TARGET' 1037 targets = new_env.Command(exename, progname, 1038 MakeAction(cmd, Transform("STRIP"))) 1039 1040 new_env.Command(secondary_exename, exename, 1041 MakeAction('ln $SOURCE $TARGET', Transform("HARDLINK"))) 1042 1043 new_env.M5Binary = targets[0] 1044 return new_env 1045 1046# Start out with the compiler flags common to all compilers, 1047# i.e. they all use -g for opt and -g -pg for prof 1048ccflags = {'debug' : [], 'opt' : ['-g'], 'fast' : [], 'prof' : ['-g', '-pg'], 1049 'perf' : ['-g']} 1050 1051# Start out with the linker flags common to all linkers, i.e. -pg for 1052# prof, and -lprofiler for perf. The -lprofile flag is surrounded by 1053# no-as-needed and as-needed as the binutils linker is too clever and 1054# simply doesn't link to the library otherwise. 1055ldflags = {'debug' : [], 'opt' : [], 'fast' : [], 'prof' : ['-pg'], 1056 'perf' : ['-Wl,--no-as-needed', '-lprofiler', '-Wl,--as-needed']} 1057 1058# For Link Time Optimization, the optimisation flags used to compile 1059# individual files are decoupled from those used at link time 1060# (i.e. you can compile with -O3 and perform LTO with -O0), so we need 1061# to also update the linker flags based on the target. 1062if env['GCC']: 1063 if sys.platform == 'sunos5': 1064 ccflags['debug'] += ['-gstabs+'] 1065 else: 1066 ccflags['debug'] += ['-ggdb3'] 1067 ldflags['debug'] += ['-O0'] 1068 # opt, fast, prof and perf all share the same cc flags, also add 1069 # the optimization to the ldflags as LTO defers the optimization 1070 # to link time 1071 for target in ['opt', 'fast', 'prof', 'perf']: 1072 ccflags[target] += ['-O3'] 1073 ldflags[target] += ['-O3'] 1074 1075 ccflags['fast'] += env['LTO_CCFLAGS'] 1076 ldflags['fast'] += env['LTO_LDFLAGS'] 1077elif env['CLANG']: 1078 ccflags['debug'] += ['-g', '-O0'] 1079 # opt, fast, prof and perf all share the same cc flags 1080 for target in ['opt', 'fast', 'prof', 'perf']: 1081 ccflags[target] += ['-O3'] 1082else: 1083 print 'Unknown compiler, please fix compiler options' 1084 Exit(1) 1085 1086 1087# To speed things up, we only instantiate the build environments we 1088# need. We try to identify the needed environment for each target; if 1089# we can't, we fall back on instantiating all the environments just to 1090# be safe. 1091target_types = ['debug', 'opt', 'fast', 'prof', 'perf'] 1092obj2target = {'do': 'debug', 'o': 'opt', 'fo': 'fast', 'po': 'prof', 1093 'gpo' : 'perf'} 1094 1095def identifyTarget(t): 1096 ext = t.split('.')[-1] 1097 if ext in target_types: 1098 return ext 1099 if obj2target.has_key(ext): 1100 return obj2target[ext] 1101 match = re.search(r'/tests/([^/]+)/', t) 1102 if match and match.group(1) in target_types: 1103 return match.group(1) 1104 return 'all' 1105 1106needed_envs = [identifyTarget(target) for target in BUILD_TARGETS] 1107if 'all' in needed_envs: 1108 needed_envs += target_types 1109 1110gem5_root = Dir('.').up().up().abspath 1111def makeEnvirons(target, source, env): 1112 # cause any later Source() calls to be fatal, as a diagnostic. 1113 Source.done() 1114 1115 envList = [] 1116 1117 # Debug binary 1118 if 'debug' in needed_envs: 1119 envList.append( 1120 makeEnv(env, 'debug', '.do', 1121 CCFLAGS = Split(ccflags['debug']), 1122 CPPDEFINES = ['DEBUG', 'TRACING_ON=1'], 1123 LINKFLAGS = Split(ldflags['debug']))) 1124 1125 # Optimized binary 1126 if 'opt' in needed_envs: 1127 envList.append( 1128 makeEnv(env, 'opt', '.o', 1129 CCFLAGS = Split(ccflags['opt']), 1130 CPPDEFINES = ['TRACING_ON=1'], 1131 LINKFLAGS = Split(ldflags['opt']))) 1132 1133 # "Fast" binary 1134 if 'fast' in needed_envs: 1135 envList.append( 1136 makeEnv(env, 'fast', '.fo', strip = True, 1137 CCFLAGS = Split(ccflags['fast']), 1138 CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'], 1139 LINKFLAGS = Split(ldflags['fast']))) 1140 1141 # Profiled binary using gprof 1142 if 'prof' in needed_envs: 1143 envList.append( 1144 makeEnv(env, 'prof', '.po', 1145 CCFLAGS = Split(ccflags['prof']), 1146 CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'], 1147 LINKFLAGS = Split(ldflags['prof']))) 1148 1149 # Profiled binary using google-pprof 1150 if 'perf' in needed_envs: 1151 envList.append( 1152 makeEnv(env, 'perf', '.gpo', 1153 CCFLAGS = Split(ccflags['perf']), 1154 CPPDEFINES = ['NDEBUG', 'TRACING_ON=0'], 1155 LINKFLAGS = Split(ldflags['perf']))) 1156 1157 # Set up the regression tests for each build. 1158 for e in envList: 1159 SConscript(os.path.join(gem5_root, 'tests', 'SConscript'), 1160 variant_dir = variantd('tests', e.Label), 1161 exports = { 'env' : e }, duplicate = False) 1162 1163# The MakeEnvirons Builder defers the full dependency collection until 1164# after processing the ISA definition (due to dynamically generated 1165# source files). Add this dependency to all targets so they will wait 1166# until the environments are completely set up. Otherwise, a second 1167# process (e.g. -j2 or higher) will try to compile the requested target, 1168# not know how, and fail. 1169env.Append(BUILDERS = {'MakeEnvirons' : 1170 Builder(action=MakeAction(makeEnvirons, 1171 Transform("ENVIRONS", 1)))}) 1172 1173isa_target = env['PHONY_BASE'] + '-deps' 1174environs = env['PHONY_BASE'] + '-environs' 1175env.Depends('#all-deps', isa_target) 1176env.Depends('#all-environs', environs) 1177env.ScanISA(isa_target, File('arch/%s/generated/inc.d' % env['TARGET_ISA'])) 1178envSetup = env.MakeEnvirons(environs, isa_target) 1179 1180# make sure no -deps targets occur before all ISAs are complete 1181env.Depends(isa_target, '#all-isas') 1182# likewise for -environs targets and all the -deps targets 1183env.Depends(environs, '#all-deps') 1184