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