build_env = [(opt, env[opt]) for opt in export_vars]
+from m5.util import code_formatter
+
########################################################################
# Code for adding source files of various types
#
for base in type(self).__mro__:
if issubclass(base, SourceFile):
- bisect.insort_right(base.all, self)
+ base.all.append(self)
def __lt__(self, other): return self.filename < other.filename
def __le__(self, other): return self.filename <= other.filename
modpath = '.'.join(modpath)
arcpath = path + [ self.basename ]
- debugname = self.snode.abspath
- if not exists(debugname):
- debugname = self.tnode.abspath
+ abspath = self.snode.abspath
+ if not exists(abspath):
+ abspath = self.tnode.abspath
self.package = package
self.modname = modname
self.modpath = modpath
self.arcname = joinpath(*arcpath)
- self.debugname = debugname
+ self.abspath = abspath
self.compiled = File(self.filename + 'c')
- self.assembly = File(self.filename + '.s')
- self.symname = "PyEMB_" + PySource.invalid_sym_char.sub('_', modpath)
+ self.cpp = File(self.filename + '.cc')
+ self.symname = PySource.invalid_sym_char.sub('_', modpath)
PySource.modules[modpath] = self
PySource.tnodes[self.tnode] = self
if 'SConscript' in files:
build_dir = joinpath(env['BUILDDIR'], root[len(base_dir) + 1:])
- SConscript(joinpath(root, 'SConscript'), build_dir=build_dir)
+ SConscript(joinpath(root, 'SConscript'), variant_dir=build_dir)
for extra_dir in extras_dir_list:
prefix_len = len(dirname(extra_dir)) + 1
for root, dirs, files in os.walk(extra_dir, topdown=True):
if 'SConscript' in files:
build_dir = joinpath(env['BUILDDIR'], root[prefix_len:])
- SConscript(joinpath(root, 'SConscript'), build_dir=build_dir)
+ SConscript(joinpath(root, 'SConscript'), variant_dir=build_dir)
for opt in export_vars:
env.ConfigFile(opt)
def makeTheISA(source, target, env):
- f = file(str(target[0]), 'w')
-
isas = [ src.get_contents() for src in source ]
- target = env['TARGET_ISA']
+ target_isa = env['TARGET_ISA']
def define(isa):
return isa.upper() + '_ISA'
return isa[0].upper() + isa[1:].lower() + 'ISA'
- print >>f, '#ifndef __CONFIG_THE_ISA_HH__'
- print >>f, '#define __CONFIG_THE_ISA_HH__'
- print >>f
+ code = code_formatter()
+ code('''\
+#ifndef __CONFIG_THE_ISA_HH__
+#define __CONFIG_THE_ISA_HH__
+
+''')
+
for i,isa in enumerate(isas):
- print >>f, '#define %s %d' % (define(isa), i + 1)
- print >>f
- print >>f, '#define THE_ISA %s' % (define(target))
- print >>f, '#define TheISA %s' % (namespace(target))
- print >>f
- print >>f, '#endif // __CONFIG_THE_ISA_HH__'
+ code('#define $0 $1', define(isa), i + 1)
+
+ code('''
+
+#define THE_ISA ${{define(target_isa)}}
+#define TheISA ${{namespace(target_isa)}}
+
+#endif // __CONFIG_THE_ISA_HH__''')
+
+ code.write(str(target[0]))
env.Command('config/the_isa.hh', map(Value, all_isa_list), makeTheISA)
source = self.modules[fullname]
if source.modname == '__init__':
mod.__path__ = source.modpath
- mod.__file__ = source.snode.abspath
+ mod.__file__ = source.abspath
- exec file(source.snode.abspath, 'r') in mod.__dict__
+ exec file(source.abspath, 'r') in mod.__dict__
return mod
import m5.SimObject
import m5.params
+from m5.util import code_formatter
m5.SimObject.clear()
m5.params.clear()
# calculate extra dependencies
#
module_depends = ["m5", "m5.SimObject", "m5.params"]
-depends = [ PySource.modules[dep].tnode for dep in module_depends ]
+depends = [ PySource.modules[dep].snode for dep in module_depends ]
########################################################################
#
def makeDefinesPyFile(target, source, env):
build_env, hg_info = [ x.get_contents() for x in source ]
- code = m5.util.code_formatter()
+ code = code_formatter()
code("""
import m5.internal
import m5.util
_globals[flag] = val
del _globals
""")
- code.write(str(target[0]))
+ code.write(target[0].abspath)
defines_info = [ Value(build_env), Value(env['HG_INFO']) ]
# Generate a file with all of the compile options in it
# Generate python file containing info about the M5 source code
def makeInfoPyFile(target, source, env):
- f = file(str(target[0]), 'w')
+ code = code_formatter()
for src in source:
data = ''.join(file(src.srcnode().abspath, 'r').xreadlines())
- print >>f, "%s = %s" % (src, repr(data))
- f.close()
+ code('$src = ${{repr(data)}}')
+ code.write(str(target[0]))
# Generate a file that wraps the basic top level files
env.Command('python/m5/info.py',
makeInfoPyFile)
PySource('m5', 'python/m5/info.py')
-# Generate the __init__.py file for m5.objects
-def makeObjectsInitFile(target, source, env):
- f = file(str(target[0]), 'w')
- print >>f, 'from params import *'
- print >>f, 'from m5.SimObject import *'
- for module in source:
- print >>f, 'from %s import *' % module.get_contents()
- f.close()
-
-# Generate an __init__.py file for the objects package
-env.Command('python/m5/objects/__init__.py',
- map(Value, SimObject.modnames),
- makeObjectsInitFile)
-PySource('m5.objects', 'python/m5/objects/__init__.py')
-
########################################################################
#
# Create all of the SimObject param headers and enum headers
def createSimObjectParam(target, source, env):
assert len(target) == 1 and len(source) == 1
- hh_file = file(target[0].abspath, 'w')
name = str(source[0].get_contents())
obj = sim_objects[name]
- print >>hh_file, obj.cxx_decl()
- hh_file.close()
+ code = code_formatter()
+ obj.cxx_decl(code)
+ code.write(target[0].abspath)
def createSwigParam(target, source, env):
assert len(target) == 1 and len(source) == 1
- i_file = file(target[0].abspath, 'w')
name = str(source[0].get_contents())
param = all_params[name]
- for line in param.swig_decl():
- print >>i_file, line
- i_file.close()
+ code = code_formatter()
+ code('%module(package="m5.internal") $0_${name}', param.file_ext)
+ param.swig_decl(code)
+ code.write(target[0].abspath)
def createEnumStrings(target, source, env):
assert len(target) == 1 and len(source) == 1
- cc_file = file(target[0].abspath, 'w')
name = str(source[0].get_contents())
obj = all_enums[name]
- print >>cc_file, obj.cxx_def()
- cc_file.close()
+ code = code_formatter()
+ obj.cxx_def(code)
+ code.write(target[0].abspath)
def createEnumParam(target, source, env):
assert len(target) == 1 and len(source) == 1
- hh_file = file(target[0].abspath, 'w')
name = str(source[0].get_contents())
obj = all_enums[name]
- print >>hh_file, obj.cxx_decl()
- hh_file.close()
+ code = code_formatter()
+ obj.cxx_decl(code)
+ code.write(target[0].abspath)
+
+def createEnumSwig(target, source, env):
+ assert len(target) == 1 and len(source) == 1
+
+ name = str(source[0].get_contents())
+ obj = all_enums[name]
+
+ code = code_formatter()
+ code('''\
+%module(package="m5.internal") enum_$name
+
+%{
+#include "enums/$name.hh"
+%}
+
+%include "enums/$name.hh"
+''')
+ code.write(target[0].abspath)
# Generate all of the SimObject param struct header files
params_hh_files = []
# Generate any parameter header files needed
params_i_files = []
for name,param in all_params.iteritems():
- i_file = File('params/%s_%s.i' % (name, param.file_ext))
+ i_file = File('python/m5/internal/%s_%s.i' % (param.file_ext, name))
params_i_files.append(i_file)
env.Command(i_file, Value(name), createSwigParam)
env.Depends(i_file, depends)
+ SwigSource('m5.internal', i_file)
# Generate all enum header files
for name,enum in sorted(all_enums.iteritems()):
env.Command(hh_file, Value(name), createEnumParam)
env.Depends(hh_file, depends + extra_deps)
-# Build the big monolithic swigged params module (wraps all SimObject
-# param structs and enum structs)
-def buildParams(target, source, env):
- names = [ s.get_contents() for s in source ]
- objs = [ sim_objects[name] for name in names ]
- out = file(target[0].abspath, 'w')
-
- ordered_objs = []
- obj_seen = set()
- def order_obj(obj):
- name = str(obj)
- if name in obj_seen:
- return
-
- obj_seen.add(name)
- if str(obj) != 'SimObject':
- order_obj(obj.__bases__[0])
-
- ordered_objs.append(obj)
-
- for obj in objs:
- order_obj(obj)
-
- enums = set()
- predecls = []
- pd_seen = set()
-
- def add_pds(*pds):
- for pd in pds:
- if pd not in pd_seen:
- predecls.append(pd)
- pd_seen.add(pd)
-
- for obj in ordered_objs:
- params = obj._params.local.values()
- for param in params:
- ptype = param.ptype
- if issubclass(ptype, m5.params.Enum):
- if ptype not in enums:
- enums.add(ptype)
- pds = param.swig_predecls()
- if isinstance(pds, (list, tuple)):
- add_pds(*pds)
- else:
- add_pds(pds)
-
- print >>out, '%module params'
-
- print >>out, '%{'
- for obj in ordered_objs:
- print >>out, '#include "params/%s.hh"' % obj
- print >>out, '%}'
-
- for pd in predecls:
- print >>out, pd
-
- enums = list(enums)
- enums.sort()
- for enum in enums:
- print >>out, '%%include "enums/%s.hh"' % enum.__name__
- print >>out
-
- for obj in ordered_objs:
- if obj.swig_objdecls:
- for decl in obj.swig_objdecls:
- print >>out, decl
- continue
-
- class_path = obj.cxx_class.split('::')
- classname = class_path[-1]
- namespaces = class_path[:-1]
- namespaces.reverse()
-
- code = ''
-
- if namespaces:
- code += '// avoid name conflicts\n'
- sep_string = '_COLONS_'
- flat_name = sep_string.join(class_path)
- code += '%%rename(%s) %s;\n' % (flat_name, classname)
-
- code += '// stop swig from creating/wrapping default ctor/dtor\n'
- code += '%%nodefault %s;\n' % classname
- code += 'class %s ' % classname
- if obj._base:
- code += ': public %s' % obj._base.cxx_class
- code += ' {};\n'
+ i_file = File('python/m5/internal/enum_%s.i' % name)
+ env.Command(i_file, Value(name), createEnumSwig)
+ env.Depends(i_file, depends + extra_deps)
+ SwigSource('m5.internal', i_file)
- for ns in namespaces:
- new_code = 'namespace %s {\n' % ns
- new_code += code
- new_code += '}\n'
- code = new_code
-
- print >>out, code
-
- print >>out, '%%include "src/sim/sim_object_params.hh"' % obj
- for obj in ordered_objs:
- print >>out, '%%include "params/%s.hh"' % obj
-
-params_file = File('params/params.i')
-names = sorted(sim_objects.keys())
-env.Command(params_file, map(Value, names), buildParams)
-env.Depends(params_file, params_hh_files + params_i_files + depends)
-SwigSource('m5.objects', params_file)
+def buildParam(target, source, env):
+ name = source[0].get_contents()
+ obj = sim_objects[name]
+ class_path = obj.cxx_class.split('::')
+ classname = class_path[-1]
+ namespaces = class_path[:-1]
+ params = obj._params.local.values()
+
+ code = code_formatter()
+
+ code('%module(package="m5.internal") param_$name')
+ code()
+ code('%{')
+ code('#include "params/$obj.hh"')
+ for param in params:
+ param.cxx_predecls(code)
+ code('%}')
+ code()
+
+ for param in params:
+ param.swig_predecls(code)
+
+ code()
+ if obj._base:
+ code('%import "python/m5/internal/param_${{obj._base}}.i"')
+ code()
+ obj.swig_objdecls(code)
+ code()
+
+ code('%include "params/$obj.hh"')
+
+ code.write(target[0].abspath)
+
+for name in sim_objects.iterkeys():
+ params_file = File('python/m5/internal/param_%s.i' % name)
+ env.Command(params_file, Value(name), buildParam)
+ env.Depends(params_file, depends)
+ SwigSource('m5.internal', params_file)
+# Generate the main swig init file
+def makeEmbeddedSwigInit(target, source, env):
+ code = code_formatter()
+ module = source[0].get_contents()
+ code('''\
+#include "sim/init.hh"
+
+extern "C" {
+ void init_${module}();
+}
+
+EmbeddedSwig embed_swig_${module}(init_${module});
+''')
+ code.write(str(target[0]))
+
# Build all swig modules
for swig in SwigSource.all:
env.Command([swig.cc_source.tnode, swig.py_source.tnode], swig.tnode,
'$SWIG $SWIGFLAGS -outdir ${TARGETS[1].dir} '
'-o ${TARGETS[0]} $SOURCES')
+ init_file = 'python/swig/init_%s.cc' % swig.module
+ env.Command(init_file, Value(swig.module), makeEmbeddedSwigInit)
+ Source(init_file)
env.Depends(swig.py_source.tnode, swig.tnode)
env.Depends(swig.cc_source.tnode, swig.tnode)
-# Generate the main swig init file
-def makeSwigInit(target, source, env):
- f = file(str(target[0]), 'w')
- print >>f, 'extern "C" {'
- for module in source:
- print >>f, ' void init_%s();' % module.get_contents()
- print >>f, '}'
- print >>f, 'void initSwig() {'
- for module in source:
- print >>f, ' init_%s();' % module.get_contents()
- print >>f, '}'
- f.close()
-
-env.Command('python/swig/init.cc',
- map(Value, sorted(s.module for s in SwigSource.all)),
- makeSwigInit)
-Source('python/swig/init.cc')
-
def getFlags(source_flags):
flagsMap = {}
flagsList = []
# Generate traceflags.py
def traceFlagsPy(target, source, env):
assert(len(target) == 1)
+ code = code_formatter()
- f = file(str(target[0]), 'w')
-
allFlags = getFlags(source)
- print >>f, 'basic = ['
+ code('basic = [')
+ code.indent()
for flag, compound, desc in allFlags:
if not compound:
- print >>f, " '%s'," % flag
- print >>f, " ]"
- print >>f
-
- print >>f, 'compound = ['
- print >>f, " 'All',"
+ code("'$flag',")
+ code(']')
+ code.dedent()
+ code()
+
+ code('compound = [')
+ code.indent()
+ code("'All',")
for flag, compound, desc in allFlags:
if compound:
- print >>f, " '%s'," % flag
- print >>f, " ]"
- print >>f
+ code("'$flag',")
+ code("]")
+ code.dedent()
+ code()
- print >>f, "all = frozenset(basic + compound)"
- print >>f
+ code("all = frozenset(basic + compound)")
+ code()
- print >>f, 'compoundMap = {'
+ code('compoundMap = {')
+ code.indent()
all = tuple([flag for flag,compound,desc in allFlags if not compound])
- print >>f, " 'All' : %s," % (all, )
+ code("'All' : $all,")
for flag, compound, desc in allFlags:
if compound:
- print >>f, " '%s' : %s," % (flag, compound)
- print >>f, " }"
- print >>f
-
- print >>f, 'descriptions = {'
- print >>f, " 'All' : 'All flags',"
+ code("'$flag' : $compound,")
+ code('}')
+ code.dedent()
+ code()
+
+ code('descriptions = {')
+ code.indent()
+ code("'All' : 'All flags',")
for flag, compound, desc in allFlags:
- print >>f, " '%s' : '%s'," % (flag, desc)
- print >>f, " }"
+ code("'$flag' : '$desc',")
+ code("}")
+ code.dedent()
- f.close()
+ code.write(str(target[0]))
def traceFlagsCC(target, source, env):
assert(len(target) == 1)
- f = file(str(target[0]), 'w')
-
allFlags = getFlags(source)
+ code = code_formatter()
# file header
- print >>f, '''
+ code('''
/*
* DO NOT EDIT THIS FILE! Automatically generated
*/
using namespace Trace;
const char *Trace::flagStrings[] =
-{'''
+{''')
+ code.indent()
# The string array is used by SimpleEnumParam to map the strings
# provided by the user to enum values.
for flag, compound, desc in allFlags:
if not compound:
- print >>f, ' "%s",' % flag
+ code('"$flag",')
- print >>f, ' "All",'
+ code('"All",')
for flag, compound, desc in allFlags:
if compound:
- print >>f, ' "%s",' % flag
+ code('"$flag",')
+ code.dedent()
+
+ code('''\
+};
+
+const int Trace::numFlagStrings = ${{len(allFlags) + 1}};
- print >>f, '};'
- print >>f
- print >>f, 'const int Trace::numFlagStrings = %d;' % (len(allFlags) + 1)
- print >>f
+''')
- #
# Now define the individual compound flag arrays. There is an array
# for each compound flag listing the component base flags.
- #
all = tuple([flag for flag,compound,desc in allFlags if not compound])
- print >>f, 'static const Flags AllMap[] = {'
+ code('static const Flags AllMap[] = {')
+ code.indent()
for flag, compound, desc in allFlags:
if not compound:
- print >>f, " %s," % flag
- print >>f, '};'
- print >>f
+ code('$flag,')
+ code.dedent()
+ code('};')
+ code()
for flag, compound, desc in allFlags:
if not compound:
continue
- print >>f, 'static const Flags %sMap[] = {' % flag
+ code('static const Flags ${flag}Map[] = {')
+ code.indent()
for flag in compound:
- print >>f, " %s," % flag
- print >>f, " (Flags)-1"
- print >>f, '};'
- print >>f
+ code('$flag,')
+ code('(Flags)-1')
+ code.dedent()
+ code('};')
+ code()
- #
# Finally the compoundFlags[] array maps the compound flags
# to their individual arrays/
- #
- print >>f, 'const Flags *Trace::compoundFlags[] ='
- print >>f, '{'
- print >>f, ' AllMap,'
+ code('const Flags *Trace::compoundFlags[] = {')
+ code.indent()
+ code('AllMap,')
for flag, compound, desc in allFlags:
if compound:
- print >>f, ' %sMap,' % flag
+ code('${flag}Map,')
# file trailer
- print >>f, '};'
+ code.dedent()
+ code('};')
- f.close()
+ code.write(str(target[0]))
def traceFlagsHH(target, source, env):
assert(len(target) == 1)
- f = file(str(target[0]), 'w')
-
allFlags = getFlags(source)
+ code = code_formatter()
# file header boilerplate
- print >>f, '''
+ code('''\
/*
* DO NOT EDIT THIS FILE!
*
namespace Trace {
-enum Flags {'''
+enum Flags {''')
# Generate the enum. Base flags come first, then compound flags.
idx = 0
+ code.indent()
for flag, compound, desc in allFlags:
if not compound:
- print >>f, ' %s = %d,' % (flag, idx)
+ code('$flag = $idx,')
idx += 1
numBaseFlags = idx
- print >>f, ' NumFlags = %d,' % idx
+ code('NumFlags = $idx,')
+ code.dedent()
+ code()
# put a comment in here to separate base from compound flags
- print >>f, '''
+ code('''
// The remaining enum values are *not* valid indices for Trace::flags.
// They are "compound" flags, which correspond to sets of base
-// flags, and are used by changeFlag.'''
+// flags, and are used by changeFlag.''')
- print >>f, ' All = %d,' % idx
+ code.indent()
+ code('All = $idx,')
idx += 1
for flag, compound, desc in allFlags:
if compound:
- print >>f, ' %s = %d,' % (flag, idx)
+ code('$flag = $idx,')
idx += 1
numCompoundFlags = idx - numBaseFlags
- print >>f, ' NumCompoundFlags = %d' % numCompoundFlags
+ code('NumCompoundFlags = $numCompoundFlags')
+ code.dedent()
# trailer boilerplate
- print >>f, '''\
+ code('''\
}; // enum Flags
// Array of strings for SimpleEnumParam
/* namespace Trace */ }
#endif // __BASE_TRACE_FLAGS_HH__
-'''
+''')
- f.close()
+ code.write(str(target[0]))
flags = map(Value, trace_flags.values())
env.Command('base/traceflags.py', flags, traceFlagsPy)
env.Command('base/traceflags.cc', flags, traceFlagsCC)
Source('base/traceflags.cc')
-# embed python files. All .py files that have been indicated by a
+# Embed python files. All .py files that have been indicated by a
# PySource() call in a SConscript need to be embedded into the M5
# library. To do that, we compile the file to byte code, marshal the
-# byte code, compress it, and then generate an assembly file that
-# inserts the result into the data section with symbols indicating the
-# beginning, and end (and with the size at the end)
-def objectifyPyFile(target, source, env):
+# byte code, compress it, and then generate a c++ file that
+# inserts the result into an array.
+def embedPyFile(target, source, env):
+ def c_str(string):
+ if string is None:
+ return "0"
+ return '"%s"' % string
+
'''Action function to compile a .py into a code object, marshal
it, compress it, and stick it into an asm file so the code appears
as just bytes with a label in the data section'''
src = file(str(source[0]), 'r').read()
- dst = file(str(target[0]), 'w')
pysource = PySource.tnodes[source[0]]
- compiled = compile(src, pysource.debugname, 'exec')
+ compiled = compile(src, pysource.abspath, 'exec')
marshalled = marshal.dumps(compiled)
compressed = zlib.compress(marshalled)
data = compressed
+ sym = pysource.symname
- # Some C/C++ compilers prepend an underscore to global symbol
- # names, so if they're going to do that, we need to prepend that
- # leading underscore to globals in the assembly file.
- if env['LEADING_UNDERSCORE']:
- sym = '_' + pysource.symname
- else:
- sym = pysource.symname
+ code = code_formatter()
+ code('''\
+#include "sim/init.hh"
+
+namespace {
+const char data_${sym}[] = {
+''')
+ code.indent()
step = 16
- print >>dst, ".data"
- print >>dst, ".globl %s_beg" % sym
- print >>dst, ".globl %s_end" % sym
- print >>dst, "%s_beg:" % sym
for i in xrange(0, len(data), step):
x = array.array('B', data[i:i+step])
- print >>dst, ".byte", ','.join([str(d) for d in x])
- print >>dst, "%s_end:" % sym
- print >>dst, ".long %d" % len(marshalled)
-
-for source in PySource.all:
- env.Command(source.assembly, source.tnode, objectifyPyFile)
- Source(source.assembly)
-
-# Generate init_python.cc which creates a bunch of EmbeddedPyModule
-# structs that describe the embedded python code. One such struct
-# contains information about the importer that python uses to get at
-# the embedded files, and then there's a list of all of the rest that
-# the importer uses to load the rest on demand.
-def pythonInit(target, source, env):
- dst = file(str(target[0]), 'w')
-
- def dump_mod(sym, endchar=','):
- pysource = PySource.symnames[sym]
- print >>dst, ' { "%s",' % pysource.arcname
- print >>dst, ' "%s",' % pysource.modpath
- print >>dst, ' %s_beg, %s_end,' % (sym, sym)
- print >>dst, ' %s_end - %s_beg,' % (sym, sym)
- print >>dst, ' *(int *)%s_end }%s' % (sym, endchar)
+ code(''.join('%d,' % d for d in x))
+ code.dedent()
- print >>dst, '#include "sim/init.hh"'
-
- for sym in source:
- sym = sym.get_contents()
- print >>dst, "extern const char %s_beg[], %s_end[];" % (sym, sym)
-
- print >>dst, "const EmbeddedPyModule embeddedPyImporter = "
- dump_mod("PyEMB_importer", endchar=';');
- print >>dst
-
- print >>dst, "const EmbeddedPyModule embeddedPyModules[] = {"
- for i,sym in enumerate(source):
- sym = sym.get_contents()
- if sym == "PyEMB_importer":
- # Skip the importer since we've already exported it
- continue
- dump_mod(sym)
- print >>dst, " { 0, 0, 0, 0, 0, 0 }"
- print >>dst, "};"
-
+ code('''};
+
+EmbeddedPython embedded_${sym}(
+ ${{c_str(pysource.arcname)}},
+ ${{c_str(pysource.abspath)}},
+ ${{c_str(pysource.modpath)}},
+ data_${sym},
+ ${{len(data)}},
+ ${{len(marshalled)}});
+
+/* namespace */ }
+''')
+ code.write(str(target[0]))
-env.Command('sim/init_python.cc',
- map(Value, (s.symname for s in PySource.all)),
- pythonInit)
-Source('sim/init_python.cc')
+for source in PySource.all:
+ env.Command(source.cpp, source.tnode, embedPyFile)
+ Source(source.cpp)
########################################################################
#
projects / gem5.git / blobdiff