def main():
# Parse command line arguments.
options = parse_args(constants.TOOL_PARSER)
log.set_verbosity(options.verbosity)
# Parse each source.
ast = []
if options.file:
for f in options.file:
s = f.read()
try:
ast += parse_to_ast(s, options.cpp, options.cpp_flag)
if options.resolve_imports:
ast, _ = resolve_imports(ast, \
os.path.dirname(f.name), options.import_path,
options.cpp, options.cpp_flag)
except CAmkESSyntaxError as e:
e.set_column(s)
log.error('%s:%s' % (f.name, str(e)))
return -1
except Exception:
log.exception('Error during lexing/parsing \'%s\''% f.name)
return -1
finally:
f.close()
else:
s = sys.stdin.read()
try:
ast += parse_to_ast(s, options.cpp, options.cpp_flag)
if options.resolve_imports:
ast, _ = resolve_imports(ast, \
os.curdir, options.import_path, options.cpp,
options.cpp_flag)
except Exception:
log.exception('Error during lexing/parsing')
return -1
ast = dedupe(ast)
if options.resolve_references:
ast = resolve_references(ast)
# Generate the output and print this.
out = show(ast)
print pretty(out)
return 0
def add_debug_declarations(target_ast, debug_components, target_assembly):
# Cheat a little bit by parsing the new debug declarations separately then adding them in
# Saves us having to manually call object constructors etc.
with open(DEBUG_CAMKES) as debug_file:
camkes_text = debug_file.readlines()
i = 0
for component in debug_components:
camkes_text.insert(-1, "connection seL4Debug debug%d_delegate(from debug.%s_GDB_delegate, \
to %s.GDB_delegate);" % (i, component, component))
camkes_text.insert(-1, "connection seL4GDB debug%d(from %s.fault, to debug.%s_fault);"
% (i, component, component))
i += 1
camkes_text = "\n".join(camkes_text)
debug_ast = parser.parse_to_ast(camkes_text)
debug_instances = debug_ast[0].instances
debug_connections = debug_ast[0].connections
for assembly in target_ast:
if assembly == target_assembly:
for obj in assembly.children():
if isinstance(obj, ast.Objects.Composition):
obj.instances += debug_instances
obj.connections += debug_connections
elif isinstance(obj, ast.Objects.Configuration):
serial_irq = ast.Objects.Setting("debug_hw_serial", "irq_attributes", \
SERIAL_IRQ_NUM)
obj.settings.append(serial_irq)
serial_attr = ast.Objects.Setting("debug_hw_serial", "serial_attributes",\
"\"%s\"" % SERIAL_PORTS)
obj.settings.append(serial_attr)
return target_ast
def main():
# Input text.
s = 'assembly { composition { component foo bar; } }'
print 'Input:\n%s\n' % s
# 2. Translate your input into an AST.
ast = camkes.parse_to_ast(s)
# At this point, ast contains a list of objects whose types are defined in
# GenericObjects.py, IDLObjects.py and ADLObjects.py. If you want to
# manipulate the AST you will want to import these.
# 3. If your input contains import statements that refer to other files,
# you can use resolve_imports to inline and parse these into your ast.
ast, _ = camkes.resolve_imports(ast, curdir)
# 4. If your input contains any references these will be present in the AST
# as objects of type GenericObjects.Reference. For example, in the input in
# this example the component type 'foo' is a reference to a component
# definition that is expected to be provided elsewhere. After performing
# reference resolution there may still be references in the AST. This
# occurs when your references cannot be resolved. For example, in the input
# here 'foo' is never actually defined.
ast = camkes.resolve_references(ast, False)
# 5. If you want to get the AST in an output format call show(). This
# accepts the AST itself.
print 'Output:\n%s\n' % camkes.show(ast)
# 6. Some output printers implement a pretty printing function to format the
# output in a human-readable way. Access this with pretty().
print 'Pretty printed:\n%s\n' % camkes.pretty(camkes.show(ast))
return 0
def main():
if len(sys.argv) != 2:
sys.stderr.write('Usage: %s inputfile\n' % sys.argv[0])
return -1
with open(sys.argv[1], 'rt') as f:
s = f.read()
a = parser.parse_to_ast(s)
sys.stdout.write('Traverse the AST and print the types of nodes:\n')
ast.traverse(a, basic_visit, None, None)
sys.stdout.write('\nNow let\'s try some basic online code generation:\n')
ast.traverse(a, code_gen_enter, code_gen_exit, {})
sys.stdout.write('\nHow about the same offline:\n')
state = {
'functions':{},
'infunction':None,
}
ast.traverse(a, code_constructor, None, state)
for k, v in state['functions'].items():
if v[0] is not None:
sys.stdout.write(v[0])
else:
sys.stdout.write('void ')
sys.stdout.write('%(name)s(%(params)s) {\n /* hello world */\n}\n' % {
'name':k,
'params':', '.join(map(lambda x: '%s %s' % (x.type, x.name), v[1:])),
})
return 0
def main():
if len(sys.argv) != 2:
print >> sys.stderr, 'Usage: %s inputfile' % sys.argv[0]
return -1
with open(sys.argv[1], 'r') as f:
s = f.read()
a = parser.parse_to_ast(s)
print 'Traverse the AST and print the types of nodes:'
ast.traverse(a, basic_visit, None, None)
print '\nNow let\'s try some basic online code generation:'
ast.traverse(a, code_gen_enter, code_gen_exit, {})
print '\nHow about the same offline:'
state = {
'functions': {},
'infunction': None,
}
ast.traverse(a, code_constructor, None, state)
for k, v in state['functions'].items():
if v[0] is not None:
print v[0],
else:
print 'void ',
print '%(name)s(%(params)s) {\n /* hello world */\n}' % {
'name': k,
'params': ', '.join(
map(lambda x: '%s %s' % (x.type, x.name), v[1:])),
}
return 0
def main():
# Input text.
s = 'assembly { composition { component foo bar; } }'
sys.stdout.write('Input:\n%s\n\n' % s)
# 2. Translate your input into an AST.
ast = camkes.parse_to_ast(s)
# At this point, ast contains a list of objects whose types are defined in
# Objects.py. If you want to manipulate the AST you will want to import the
# AST module.
# 3. If your input contains import statements that refer to other files,
# you can use resolve_imports to inline and parse these into your ast.
ast, _ = camkes.resolve_imports(ast, curdir)
# 4. If your input contains any references these will be present in the AST
# as objects of type camkes.ast.Reference. For example, in the input in
# this example the component type 'foo' is a reference to a component
# definition that is expected to be provided elsewhere. After performing
# reference resolution there may still be references in the AST. This
# occurs when your references cannot be resolved. For example, in the input
# here 'foo' is never actually defined.
ast = camkes.resolve_references(ast, False)
# 5. If you want to get the AST in an output format call show(). This
# accepts the AST itself.
sys.stdout.write('Output:\n%s\n\n' % camkes.show(ast))
# 6. Some output printers implement a pretty printing function to format the
# output in a human-readable way. Access this with pretty().
sys.stdout.write('Pretty printed:\n%s\n\n' %
camkes.pretty(camkes.show(ast)))
return 0
def main():
p = argparse.ArgumentParser('standalone RPC stub generator')
p.add_argument('--input',
'-i',
type=argparse.FileType('r'),
default=sys.stdin,
help='interface specification')
p.add_argument('--output',
'-o',
type=argparse.FileType('w'),
default=sys.stdout,
help='file to write output to')
p.add_argument('--procedure',
'-p',
help='procedure to operate on '
'(defaults to the first available)')
p.add_argument('--template',
'-t',
type=argparse.FileType('r'),
required=True,
help='template to use')
opts = p.parse_args()
# Parse the input specification.
try:
spec = parser.parse_to_ast(opts.input.read())
except parser.CAmkESSyntaxError as e:
sys.stderr.write('syntax error: %s\n' % str(e))
return -1
# Find the procedure the user asked for. If they didn't explicitly specify
# one, we just take the first.
for obj in spec:
if isinstance(obj, ast.Procedure):
if opts.procedure is None or opts.procedure == obj.name:
proc = obj
break
else:
sys.stderr.write('no matching procedure found\n')
return -1
# Simplify the CAmkES AST representation into a representation involving
# strings and simpler objects.
proc = simplify(proc)
# Render the template.
opts.output.write(render(proc, opts.template.read()))
return 0
def main():
args = parse_args(constants.TOOL_LINT)
log.set_verbosity(args.verbosity)
# Parse the input and form the AST.
ast = []
for f in args.file:
try:
items = parser.parse_to_ast(f)
except Exception as inst:
log.critical('Failed to parse input: %s' % str(inst))
return CRITICAL
if args.resolve_imports:
try:
items, _ = parser.resolve_imports(items, \
os.path.dirname(f.name), args.import_path)
except Exception as inst:
log.critical('Failed to resolve imports: %s' % str(inst))
return CRITICAL
ast += items
if args.resolve_references:
try:
ast = parser.resolve_references(ast)
except Exception as inst:
log.critical('Failed to resolve references: %s' % str(inst))
return CRITICAL
# Check it for inconsistencies.
ret = 0
for m in lint.check(ast):
if isinstance(m, lint.ProblemWarning):
log.warning(str(m))
if ret != ERROR:
ret = WARNING
else: # isinstance(m, lint.ProblemError)
log.error(str(m))
ret = ERROR
return ret
def main():
args = parse_args(constants.TOOL_LINT)
log.set_verbosity(args.verbosity)
# Parse the input and form the AST.
ast = []
for f in args.file:
try:
items = parser.parse_to_ast(f)
except Exception as inst:
log.critical('Failed to parse input: %s' % str(inst))
return CRITICAL
if args.resolve_imports:
try:
items, _ = parser.resolve_imports(items, \
os.path.dirname(f.name), args.import_path)
except Exception as inst:
log.critical('Failed to resolve imports: %s' % str(inst))
return CRITICAL
ast += items
if args.resolve_references:
try:
ast = parser.resolve_references(ast, args.allow_forward_references)
except Exception as inst:
log.critical('Failed to resolve references: %s' % str(inst))
return CRITICAL
# Check it for inconsistencies.
ret = 0
for m in lint.check(ast):
if isinstance(m, lint.ProblemWarning):
log.warning(str(m))
if ret != ERROR:
ret = WARNING
else: # isinstance(m, lint.ProblemError)
log.error(str(m))
ret = ERROR
return ret
def create_debug_component_types(target_ast, debug_types):
for index, component in enumerate(target_ast):
if isinstance(component, ast.Objects.Component):
# Find the debug types and copy the definition
# Add the necessary interfaces
if component.name in debug_types:
debug_component = copy.copy(component)
debug_component.name = debug_types[component.name]
#Have to make a new component with the debug connections
# These are the debug interfaces
new_interface = "uses CAmkES_Debug fault;\n"
new_interface += "provides CAmkES_Debug GDB_delegate;\n"
# Get the component as a string and re-parse it with the new interfaces
string = debug_component.__repr__().split()
string[-1:-1] = new_interface.split()
string = " ".join(string)
debug_ast = parser.parse_to_ast(string)
# Replace the debug component
target_ast[index] = debug_ast[0]
return target_ast
def main():
p = argparse.ArgumentParser('standalone RPC stub generator')
p.add_argument('--input', '-i', type=argparse.FileType('r'),
default=sys.stdin, help='interface specification')
p.add_argument('--output', '-o', type=argparse.FileType('w'),
default=sys.stdout, help='file to write output to')
p.add_argument('--procedure', '-p', help='procedure to operate on ' \
'(defaults to the first available)')
p.add_argument('--template', '-t', type=argparse.FileType('r'),
required=True, help='template to use')
opts = p.parse_args()
# Parse the input specification.
try:
spec = parser.parse_to_ast(opts.input.read())
except parser.CAmkESSyntaxError as e:
print >>sys.stderr, 'syntax error: %s' % str(e)
return -1
# Find the procedure the user asked for. If they didn't explicitly specify
# one, we just take the first.
for obj in spec:
if isinstance(obj, ast.Procedure):
if opts.procedure is None or opts.procedure == obj.name:
proc = obj
break
else:
print >>sys.stderr, 'no matching procedure found'
return -1
# Simplify the CAmkES AST representation into a representation involving
# strings and simpler objects.
proc = simplify(proc)
# Render the template.
print >>opts.output, render(proc, opts.template.read())
return 0
def main(argv):
# Parse input
vm_mode = False
try:
opts, args = getopt.getopt(argv, "cmv:")
except getopt.GetoptError as err:
print str(err)
sys.exit(1)
if len(args) == 0:
print "Not enough arguments"
sys.exit(1)
elif len(args) > 1:
print "Too many args"
sys.exit(1)
else:
project_camkes = args[0]
if not os.path.isfile(APPS_FOLDER + project_camkes):
print "File not found: %s" % APPS_FOLDER + project_camkes
sys.exit(1)
for opt, arg in opts:
if opt == "-c":
clean_debug(project_camkes)
sys.exit(0)
if opt == "-v":
vm_mode = True
vm = arg
# Open camkes file for parsing
with open(APPS_FOLDER + project_camkes) as camkes_file:
lines = camkes_file.readlines()
# Save any imports and add them back in
imports = ""
import_regex = re.compile(r'import .*')
for line in lines:
if import_regex.match(line):
imports += line
camkes_text = "\n".join(lines)
# Parse using camkes parser
camkes_builtin_path = os.path.realpath(__file__ + '/../../camkes/include/builtin')
include_path = [camkes_builtin_path]
if vm_mode:
print "vm mode"
cpp = True
config_path = os.path.realpath(__file__ + '/../../../apps/%s/configurations' % vm)
vm_components_path = os.path.realpath(__file__ + '/../../../apps/%s/../../components/VM' % vm)
plat_includes = os.path.realpath(__file__ + '/../../../kernel/include/plat/%s' % PLAT)
cpp_options = ['-DCAMKES_VM_CONFIG=%s' % vm, "-I"+config_path, "-I"+vm_components_path, "-I"+plat_includes]
include_path.append(os.path.realpath(__file__ + "/../../../projects/vm/components"))
include_path.append(os.path.realpath(__file__ + "/../../../projects/vm/interfaces"))
else:
cpp = False
cpp_options = []
target_ast = parser.parse_to_ast(camkes_text, cpp, cpp_options)
# Resolve other imports
project_dir = os.path.dirname(os.path.realpath(APPS_FOLDER + project_camkes)) + "/"
target_ast, _ = parser.resolve_imports(target_ast, project_dir, include_path, cpp, cpp_options)
target_ast = parser.resolve_references(target_ast)
# Find debug components declared in the camkes file
debug_components = get_debug_components(target_ast)
# Use the declared debug components to find the types we must generate
debug_types, target_assembly = get_debug_component_types(target_ast, debug_components)
# Generate the new types
target_ast = create_debug_component_types(target_ast, debug_types)
# Add declarations for the new types
target_ast = add_debug_declarations(target_ast, debug_components, target_assembly)
# Get the static definitions needed every time
debug_definitions = get_debug_definitions()
# Generate server based on debug components
debug_definitions += generate_server_component(debug_components)
# Update makefile with the new debug camkes
update_makefile(project_camkes, debug_types)
# Copy the templates into the project directory
copy_templates(project_camkes)
# Add our debug definitions
new_camkes = parser.pretty(parser.show(target_ast))
# Reparse and rearrange the included code
procedures = []
main_ast = []
new_ast = parser.parse_to_ast(new_camkes, cpp, cpp_options)
for component in new_ast:
if isinstance(component, ast.Objects.Procedure):
procedures.append(component)
else:
main_ast.append(component)
final_camkes = imports + debug_definitions + parser.pretty(parser.show(procedures + main_ast))
# Write new camkes file
with open(APPS_FOLDER + project_camkes + ".dbg", 'w') as f:
for line in final_camkes:
f.write(line)
# Write a gdbinit file
name_regex = re.compile(r"(.*)/")
search = name_regex.search(project_camkes)
if debug_components:
write_gdbinit(search.group(1), debug_components)
else:
print "No debug components found"
def main():
options = parse_args(constants.TOOL_RUNNER)
# Save us having to pass debugging everywhere.
die = functools.partial(_die, options.verbosity >= 3)
log.set_verbosity(options.verbosity)
def done(s):
ret = 0
if s:
options.outfile.write(s)
options.outfile.close()
sys.exit(ret)
if not options.platform or options.platform in ('?', 'help') \
or options.platform not in PLATFORMS:
die('Valid --platform arguments are %s' % ', '.join(PLATFORMS))
if not options.file or len(options.file) > 1:
die('A single input file must be provided for this operation')
# Construct the compilation cache if requested.
cache = None
if options.cache in ('on', 'readonly', 'writeonly'):
cache = Cache(options.cache_dir)
f = options.file[0]
try:
s = f.read()
# Try to find this output in the compilation cache if possible. This is
# one of two places that we check in the cache. This check will 'hit'
# if the source files representing the input spec are identical to some
# previous execution.
if options.cache in ('on', 'readonly'):
key = [
version_hash(),
os.path.abspath(f.name), s,
cache_relevant_options(options), options.platform, options.item
]
value = cache.get(key)
assert value is None or isinstance(value, FileSet), \
'illegally cached a value for %s that is not a FileSet' % options.item
if value is not None and value.valid():
# Cache hit.
log.debug('Retrieved %(platform)s.%(item)s from cache' % \
options.__dict__)
done(value.output)
ast = parser.parse_to_ast(s, options.cpp, options.cpp_flag,
options.ply_optimise)
parser.assign_filenames(ast, f.name)
except parser.CAmkESSyntaxError as e:
e.set_column(s)
die('%s:%s' % (f.name, str(e)))
except Exception as inst:
die('While parsing \'%s\': %s' % (f.name, inst))
try:
for t in AST_TRANSFORMS[PRE_RESOLUTION]:
ast = t(ast)
except Exception as inst:
die('While transforming AST: %s' % str(inst))
try:
ast, imported = parser.resolve_imports(ast, \
os.path.dirname(os.path.abspath(f.name)), options.import_path,
options.cpp, options.cpp_flag, options.ply_optimise)
except Exception as inst:
die('While resolving imports of \'%s\': %s' % (f.name, inst))
try:
# if there are multiple assemblies, combine them now
compose_assemblies(ast)
except Exception as inst:
die('While combining assemblies: %s' % str(inst))
# If we have a readable cache check if our current target is in the cache.
# The previous check will 'miss' and this one will 'hit' when the input
# spec is identical to some previous execution modulo a semantically
# irrelevant element (e.g. an introduced comment). I.e. the previous check
# matches when the input is exactly the same and this one matches when the
# AST is unchanged.
if options.cache in ('on', 'readonly'):
key = [
version_hash(), ast,
cache_relevant_options(options), options.platform, options.item
]
value = cache.get(key)
if value is not None:
assert options.item not in NEVER_AST_CACHE, \
'%s, that is marked \'never cache\' is in your cache' % options.item
log.debug('Retrieved %(platform)s.%(item)s from cache' % \
options.__dict__)
done(value)
# If we have a writable cache, allow outputs to be saved to it.
if options.cache in ('on', 'writeonly'):
orig_ast = deepcopy(ast)
fs = FileSet(imported)
def save(item, value):
# Save an input-keyed cache entry. This one is based on the
# pre-parsed inputs to save having to derive the AST (parse the
# input) in order to locate a cache entry in following passes.
# This corresponds to the first cache check above.
key = [
version_hash(),
os.path.abspath(options.file[0].name), s,
cache_relevant_options(options), options.platform, item
]
specialised = fs.specialise(value)
if item == 'capdl':
specialised.extend(options.elf)
cache[key] = specialised
if item not in NEVER_AST_CACHE:
# Save an AST-keyed cache entry. This corresponds to the second
# cache check above.
cache[[
version_hash(), orig_ast,
cache_relevant_options(options), options.platform, item
]] = value
else:
def save(item, value):
pass
ast = parser.dedupe(ast)
try:
ast = parser.resolve_references(ast)
except Exception as inst:
die('While resolving references of \'%s\': %s' % (f.name, inst))
try:
parser.collapse_references(ast)
except Exception as inst:
die('While collapsing references of \'%s\': %s' % (f.name, inst))
try:
for t in AST_TRANSFORMS[POST_RESOLUTION]:
ast = t(ast)
except Exception as inst:
die('While transforming AST: %s' % str(inst))
try:
resolve_hierarchy(ast)
except Exception as inst:
die('While resolving hierarchy: %s' % str(inst))
# All references in the AST need to be resolved for us to continue.
unresolved = reduce(lambda a, x: a.union(x),
map(lambda x: x.unresolved(), ast), set())
if unresolved:
die('Unresolved references in input specification:\n %s' % \
'\n '.join(map(lambda x: '%(filename)s:%(lineno)s:\'%(name)s\' of type %(type)s' % {
'filename':x.filename or '<unnamed file>',
'lineno':x.lineno,
'name':x._symbol,
'type':x._type.__name__,
}, unresolved)))
# Locate the assembly
assembly = [x for x in ast if isinstance(x, AST.Assembly)]
if len(assembly) > 1:
die('Multiple assemblies found')
elif len(assembly) == 1:
assembly = assembly[0]
else:
die('No assembly found')
obj_space = ObjectAllocator()
obj_space.spec.arch = options.architecture
cspaces = {}
pds = {}
conf = assembly.configuration
shmem = defaultdict(dict)
templates = Templates(options.platform)
map(templates.add_root, options.templates)
r = Renderer(templates.get_roots(), options)
# The user may have provided their own connector definitions (with
# associated) templates, in which case they won't be in the built-in lookup
# dictionary. Let's add them now. Note, definitions here that conflict with
# existing lookup entries will overwrite the existing entries.
for c in (x for x in ast if isinstance(x, AST.Connector)):
if c.from_template:
templates.add(c.name, 'from.source', c.from_template)
if c.to_template:
templates.add(c.name, 'to.source', c.to_template)
# We're now ready to instantiate the template the user requested, but there
# are a few wrinkles in the process. Namely,
# 1. Template instantiation needs to be done in a deterministic order. The
# runner is invoked multiple times and template code needs to be
# allocated identical cap slots in each run.
# 2. Components and connections need to be instantiated before any other
# templates, regardless of whether they are the ones we are after. Some
# other templates, such as the Makefile depend on the obj_space and
# cspaces.
# 3. All actual code templates, up to the template that was requested,
# need to be instantiated. This is related to (1) in that the cap slots
# allocated are dependent on what allocations have been done prior to a
# given allocation call.
# Instantiate the per-component source and header files.
for id, i in enumerate(assembly.composition.instances):
# Don't generate any code for hardware components.
if i.type.hardware:
continue
if i.address_space not in cspaces:
p = Perspective(phase=RUNNER,
instance=i.name,
group=i.address_space)
cnode = obj_space.alloc(seL4_CapTableObject,
name=p['cnode'],
label=i.address_space)
cspaces[i.address_space] = CSpaceAllocator(cnode)
pd = obj_space.alloc(seL4_PageDirectoryObject,
name=p['pd'],
label=i.address_space)
pds[i.address_space] = pd
for t in ('%s.source' % i.name, '%s.header' % i.name,
'%s.linker' % i.name):
try:
template = templates.lookup(t, i)
g = ''
if template:
g = r.render(i, assembly, template, obj_space, cspaces[i.address_space], \
shmem, options=options, id=id, my_pd=pds[i.address_space])
save(t, g)
if options.item == t:
if not template:
log.warning('Warning: no template for %s' %
options.item)
done(g)
except Exception as inst:
die('While rendering %s: %s' % (i.name, inst))
# Instantiate the per-connection files.
conn_dict = {}
for id, c in enumerate(assembly.composition.connections):
tmp_name = c.name
key_from = (c.from_instance.name + '_' +
c.from_interface.name) in conn_dict
key_to = (c.to_instance.name + '_' + c.to_interface.name) in conn_dict
if not key_from and not key_to:
# We need a new connection name
conn_name = 'conn' + str(id)
c.name = conn_name
conn_dict[c.from_instance.name + '_' +
c.from_interface.name] = conn_name
conn_dict[c.to_instance.name + '_' +
c.to_interface.name] = conn_name
elif not key_to:
conn_name = conn_dict[c.from_instance.name + '_' +
c.from_interface.name]
c.name = conn_name
conn_dict[c.to_instance.name + '_' +
c.to_interface.name] = conn_name
elif not key_from:
conn_name = conn_dict[c.to_instance.name + '_' +
c.to_interface.name]
c.name = conn_name
conn_dict[c.from_instance.name + '_' +
c.from_interface.name] = conn_name
else:
continue
for t in (('%s.from.source' % tmp_name, c.from_instance.address_space),
('%s.from.header' % tmp_name, c.from_instance.address_space),
('%s.to.source' % tmp_name, c.to_instance.address_space),
('%s.to.header' % tmp_name, c.to_instance.address_space)):
try:
template = templates.lookup(t[0], c)
g = ''
if template:
g = r.render(c, assembly, template, obj_space, cspaces[t[1]], \
shmem, options=options, id=id, my_pd=pds[t[1]])
save(t[0], g)
if options.item == t[0]:
if not template:
log.warning('Warning: no template for %s' %
options.item)
done(g)
except Exception as inst:
die('While rendering %s: %s' % (t[0], inst))
c.name = tmp_name
# The following block handles instantiations of per-connection
# templates that are neither a 'source' or a 'header', as handled
# above. We assume that none of these need instantiation unless we are
# actually currently looking for them (== options.item). That is, we
# assume that following templates, like the CapDL spec, do not require
# these templates to be rendered prior to themselves.
# FIXME: This is a pretty ugly way of handling this. It would be nicer
# for the runner to have a more general notion of per-'thing' templates
# where the per-component templates, the per-connection template loop
# above, and this loop could all be done in a single unified control
# flow.
for t in (('%s.from.' % c.name, c.from_instance.address_space),
('%s.to.' % c.name, c.to_instance.address_space)):
if not options.item.startswith(t[0]):
# This is not the item we're looking for.
continue
try:
# If we've reached here then this is the exact item we're
# after.
template = templates.lookup(options.item, c)
if template is None:
raise Exception('no registered template for %s' %
options.item)
g = r.render(c, assembly, template, obj_space, cspaces[t[1]], \
shmem, options=options, id=id, my_pd=pds[t[1]])
save(options.item, g)
done(g)
except Exception as inst:
die('While rendering %s: %s' % (options.item, inst))
# Perform any per component simple generation. This needs to happen last
# as this template needs to run after all other capabilities have been
# allocated
for id, i in enumerate(assembly.composition.instances):
# Don't generate any code for hardware components.
if i.type.hardware:
continue
assert i.address_space in cspaces
if conf and conf.settings and [x for x in conf.settings if \
x.instance == i.name and x.attribute == 'simple' and x.value]:
for t in ('%s.simple' % i.name, ):
try:
template = templates.lookup(t, i)
g = ''
if template:
g = r.render(i, assembly, template, obj_space, cspaces[i.address_space], \
shmem, options=options, id=id, my_pd=pds[i.address_space])
save(t, g)
if options.item == t:
if not template:
log.warning('Warning: no template for %s' %
options.item)
done(g)
except Exception as inst:
die('While rendering %s: %s' % (i.name, inst))
# Derive a set of usable ELF objects from the filenames we were passed.
elfs = {}
for e in options.elf:
try:
name = os.path.basename(e)
if name in elfs:
raise Exception(
'duplicate ELF files of name \'%s\' encountered' % name)
elf = ELF(e, name, options.architecture)
p = Perspective(phase=RUNNER, elf_name=name)
group = p['group']
# Avoid inferring a TCB as we've already created our own.
elf_spec = elf.get_spec(infer_tcb=False,
infer_asid=False,
pd=pds[group],
use_large_frames=options.largeframe)
obj_space.merge(elf_spec, label=group)
elfs[name] = (e, elf)
except Exception as inst:
die('While opening \'%s\': %s' % (e, inst))
if options.item in ('capdl', 'label-mapping'):
# It's only relevant to run these filters if the final target is CapDL.
# Note, this will no longer be true if we add any other templates that
# depend on a fully formed CapDL spec. Guarding this loop with an if
# is just an optimisation and the conditional can be removed if
# desired.
for f in CAPDL_FILTERS:
try:
# Pass everything as named arguments to allow filters to
# easily ignore what they don't want.
f(ast=ast,
obj_space=obj_space,
cspaces=cspaces,
elfs=elfs,
options=options,
shmem=shmem)
except Exception as inst:
die('While forming CapDL spec: %s' % str(inst))
# Instantiate any other, miscellaneous template. If we've reached this
# point, we know the user did not request a code template.
try:
template = templates.lookup(options.item)
if template:
g = r.render(assembly, assembly, template, obj_space, None, \
shmem, imported=imported, options=options)
save(options.item, g)
done(g)
except Exception as inst:
die('While rendering %s: %s' % (options.item, inst))
die('No valid element matching --item %s' % options.item)
def main():
options = parse_args(constants.TOOL_RUNNER)
# Save us having to pass debugging everywhere.
die = functools.partial(_die, options.verbosity >= 3)
log.set_verbosity(options.verbosity)
def done(s):
ret = 0
if s:
print >>options.outfile, s
options.outfile.close()
if options.post_render_edit and \
raw_input('Edit rendered template %s [y/N]? ' % \
options.outfile.name) == 'y':
editor = os.environ.get('EDITOR', 'vim')
ret = subprocess.call([editor, options.outfile.name])
sys.exit(ret)
if not options.platform or options.platform in ['?', 'help'] \
or options.platform not in PLATFORMS:
die('Valid --platform arguments are %s' % ', '.join(PLATFORMS))
if not options.file or len(options.file) > 1:
die('A single input file must be provided for this operation')
try:
profiler = get_profiler(options.profiler, options.profile_log)
except Exception as inst:
die('Failed to create profiler: %s' % str(inst))
# Construct the compilation cache if requested.
cache = None
if options.cache in ['on', 'readonly', 'writeonly']:
cache = Cache(options.cache_dir)
f = options.file[0]
try:
with profiler('Reading input'):
s = f.read()
# Try to find this output in the compilation cache if possible. This is
# one of two places that we check in the cache. This check will 'hit'
# if the source files representing the input spec are identical to some
# previous execution.
if options.cache in ['on', 'readonly']:
with profiler('Looking for a cached version of this output'):
key = [version(), os.path.abspath(f.name), s,
cache_relevant_options(options), options.platform,
options.item]
value = cache.get(key)
if value is not None and value.valid():
# Cache hit.
assert isinstance(value, FileSet), \
'illegally cached a value for %s that is not a FileSet' % options.item
log.debug('Retrieved %(platform)s.%(item)s from cache' % \
options.__dict__)
done(value.output)
with profiler('Parsing input'):
ast = parser.parse_to_ast(s, options.cpp, options.cpp_flag, options.ply_optimise)
parser.assign_filenames(ast, f.name)
except parser.CAmkESSyntaxError as e:
e.set_column(s)
die('%s:%s' % (f.name, str(e)))
except Exception as inst:
die('While parsing \'%s\': %s' % (f.name, str(inst)))
try:
for t in AST_TRANSFORMS[PRE_RESOLUTION]:
with profiler('Running AST transform %s' % t.__name__):
ast = t(ast)
except Exception as inst:
die('While transforming AST: %s' % str(inst))
try:
with profiler('Resolving imports'):
ast, imported = parser.resolve_imports(ast, \
os.path.dirname(os.path.abspath(f.name)), options.import_path,
options.cpp, options.cpp_flag, options.ply_optimise)
except Exception as inst:
die('While resolving imports of \'%s\': %s' % (f.name, str(inst)))
try:
with profiler('Combining assemblies'):
# if there are multiple assemblies, combine them now
compose_assemblies(ast)
except Exception as inst:
die('While combining assemblies: %s' % str(inst))
with profiler('Caching original AST'):
orig_ast = deepcopy(ast)
with profiler('Deduping AST'):
ast = parser.dedupe(ast)
try:
with profiler('Resolving references'):
ast = parser.resolve_references(ast)
except Exception as inst:
die('While resolving references of \'%s\': %s' % (f.name, str(inst)))
try:
with profiler('Collapsing references'):
parser.collapse_references(ast)
except Exception as inst:
die('While collapsing references of \'%s\': %s' % (f.name, str(inst)))
try:
for t in AST_TRANSFORMS[POST_RESOLUTION]:
with profiler('Running AST transform %s' % t.__name__):
ast = t(ast)
except Exception as inst:
die('While transforming AST: %s' % str(inst))
try:
with profiler('Resolving hierarchy'):
resolve_hierarchy(ast)
except Exception as inst:
die('While resolving hierarchy: %s' % str(inst))
# If we have a readable cache check if our current target is in the cache.
# The previous check will 'miss' and this one will 'hit' when the input
# spec is identical to some previous execution modulo a semantically
# irrelevant element (e.g. an introduced comment). I.e. the previous check
# matches when the input is exactly the same and this one matches when the
# AST is unchanged.
if options.cache in ['on', 'readonly']:
with profiler('Looking for a cached version of this output'):
key = [version(), orig_ast, cache_relevant_options(options),
options.platform, options.item]
value = cache.get(key)
if value is not None:
assert options.item not in NEVER_AST_CACHE, \
'%s, that is marked \'never cache\' is in your cache' % options.item
log.debug('Retrieved %(platform)s.%(item)s from cache' % \
options.__dict__)
done(value)
# If we have a writable cache, allow outputs to be saved to it.
if options.cache in ['on', 'writeonly']:
fs = FileSet(imported)
def save(item, value):
# Save an input-keyed cache entry. This one is based on the
# pre-parsed inputs to save having to derive the AST (parse the
# input) in order to locate a cache entry in following passes.
# This corresponds to the first cache check above.
key = [version(), os.path.abspath(options.file[0].name), s,
cache_relevant_options(options), options.platform,
item]
specialised = fs.specialise(value)
if item == 'capdl':
specialised.extend(options.elf or [])
cache[key] = specialised
if item not in NEVER_AST_CACHE:
# Save an AST-keyed cache entry. This corresponds to the second
# cache check above.
cache[[version(), orig_ast, cache_relevant_options(options),
options.platform, item]] = value
else:
def save(item, value):
pass
# All references in the AST need to be resolved for us to continue.
unresolved = reduce(lambda a, x: a.union(x),
map(lambda x: x.unresolved(), ast), set())
if unresolved:
die('Unresolved references in input specification:\n %s' % \
'\n '.join(map(lambda x: '%(filename)s:%(lineno)s:\'%(name)s\' of type %(type)s' % {
'filename':x.filename or '<unnamed file>',
'lineno':x.lineno,
'name':x._symbol,
'type':x._type.__name__,
}, unresolved)))
# Locate the assembly
assembly = [x for x in ast if isinstance(x, AST.Assembly)]
if len(assembly) > 1:
die('Multiple assemblies found')
elif len(assembly) == 1:
assembly = assembly[0]
else:
die('No assembly found')
obj_space = ObjectAllocator()
cspaces = {}
pds = {}
conf = assembly.configuration
shmem = defaultdict(dict)
# We need to create a phony instance and connection to cope with cases
# where the user has not defined any instances or connections (this would
# be an arguably useless system, but we should still support it). We append
# these to the template's view of the system below to ensure we always get
# a usable template dictionary. Note that this doesn't cause any problems
# because the phony items are named '' and thus unaddressable in ADL.
dummy_instance = AST.Instance(AST.Reference('', AST.Instance), '')
dummy_connection = AST.Connection(AST.Reference('', AST.Connector), '', \
AST.Reference('', AST.Instance), AST.Reference('', AST.Interface), \
AST.Reference('', AST.Instance), AST.Reference('', AST.Interface))
templates = Templates(options.platform,
instance=map(lambda x: x.name, assembly.composition.instances + \
[dummy_instance]), \
connection=map(lambda x: x.name, assembly.composition.connections + \
[dummy_connection]))
if options.templates:
templates.add_root(options.templates)
r = Renderer(templates.get_roots(), options)
# The user may have provided their own connector definitions (with
# associated) templates, in which case they won't be in the built-in lookup
# dictionary. Let's add them now. Note, definitions here that conflict with
# existing lookup entries will overwrite the existing entries.
for c in [x for x in ast if isinstance(x, AST.Connector)]:
if c.from_template:
templates.add(c.name, 'from.source', c.from_template)
if c.to_template:
templates.add(c.name, 'to.source', c.to_template)
# We're now ready to instantiate the template the user requested, but there
# are a few wrinkles in the process. Namely,
# 1. Template instantiation needs to be done in a deterministic order. The
# runner is invoked multiple times and template code needs to be
# allocated identical cap slots in each run.
# 2. Components and connections need to be instantiated before any other
# templates, regardless of whether they are the ones we are after. Some
# other templates, such as the Makefile depend on the obj_space and
# cspaces.
# 3. All actual code templates, up to the template that was requested,
# need to be instantiated. This is related to (1) in that the cap slots
# allocated are dependent on what allocations have been done prior to a
# given allocation call.
# Instantiate the per-component source and header files.
for id, i in enumerate(assembly.composition.instances):
# Don't generate any code for hardware components.
if i.type.hardware:
continue
if i.address_space not in cspaces:
p = Perspective(phase=RUNNER, instance=i.name,
group=i.address_space)
cnode = obj_space.alloc(seL4_CapTableObject,
name=p['cnode'], label=i.address_space)
cspaces[i.address_space] = CSpaceAllocator(cnode)
pd = obj_space.alloc(seL4_PageDirectoryObject, name=p['pd'],
label=i.address_space)
pds[i.address_space] = pd
for t in ['%s.source' % i.name, '%s.header' % i.name,
'%s.linker' % i.name]:
try:
template = templates.lookup(t, i)
g = ''
if template:
with profiler('Rendering %s' % t):
g = r.render(i, assembly, template, obj_space, cspaces[i.address_space], \
shmem, options=options, id=id, my_pd=pds[i.address_space])
save(t, g)
if options.item == t:
if not template:
log.warning('Warning: no template for %s' % options.item)
done(g)
except Exception as inst:
die('While rendering %s: %s' % (i.name, str(inst)))
# Instantiate the per-connection files.
conn_dict = {}
for id, c in enumerate(assembly.composition.connections):
tmp_name = c.name
key_from = (c.from_instance.name + '_' + c.from_interface.name) in conn_dict
key_to = (c.to_instance.name + '_' + c.to_interface.name) in conn_dict
if not key_from and not key_to:
# We need a new connection name
conn_name = 'conn' + str(id)
c.name = conn_name
conn_dict[c.from_instance.name + '_' + c.from_interface.name] = conn_name
conn_dict[c.to_instance.name + '_' + c.to_interface.name] = conn_name
elif not key_to:
conn_name = conn_dict[c.from_instance.name + '_' + c.from_interface.name]
c.name = conn_name
conn_dict[c.to_instance.name + '_' + c.to_interface.name] = conn_name
elif not key_from:
conn_name = conn_dict[c.to_instance.name + '_' + c.to_interface.name]
c.name = conn_name
conn_dict[c.from_instance.name + '_' + c.from_interface.name] = conn_name
else:
continue
for t in [('%s.from.source' % tmp_name, c.from_instance.address_space),
('%s.from.header' % tmp_name, c.from_instance.address_space),
('%s.to.source' % tmp_name, c.to_instance.address_space),
('%s.to.header' % tmp_name, c.to_instance.address_space)]:
try:
template = templates.lookup(t[0], c)
g = ''
if template:
with profiler('Rendering %s' % t[0]):
g = r.render(c, assembly, template, obj_space, cspaces[t[1]], \
shmem, options=options, id=id, my_pd=pds[t[1]])
save(t[0], g)
if options.item == t[0]:
if not template:
log.warning('Warning: no template for %s' % options.item)
done(g)
except Exception as inst:
die('While rendering %s: %s' % (t[0], str(inst)))
c.name = tmp_name
# The following block handles instantiations of per-connection
# templates that are neither a 'source' or a 'header', as handled
# above. We assume that none of these need instantiation unless we are
# actually currently looking for them (== options.item). That is, we
# assume that following templates, like the CapDL spec, do not require
# these templates to be rendered prior to themselves.
# FIXME: This is a pretty ugly way of handling this. It would be nicer
# for the runner to have a more general notion of per-'thing' templates
# where the per-component templates, the per-connection template loop
# above, and this loop could all be done in a single unified control
# flow.
for t in [('%s.from.' % c.name, c.from_instance.address_space),
('%s.to.' % c.name, c.to_instance.address_space)]:
if not options.item.startswith(t[0]):
# This is not the item we're looking for.
continue
try:
# If we've reached here then this is the exact item we're
# after.
template = templates.lookup(options.item, c)
if template is None:
raise Exception('no registered template for %s' % options.item)
with profiler('Rendering %s' % options.item):
g = r.render(c, assembly, template, obj_space, cspaces[t[1]], \
shmem, options=options, id=id, my_pd=pds[t[1]])
save(options.item, g)
done(g)
except Exception as inst:
die('While rendering %s: %s' % (options.item, str(inst)))
# Perform any per component simple generation. This needs to happen last
# as this template needs to run after all other capabilities have been
# allocated
for id, i in enumerate(assembly.composition.instances):
# Don't generate any code for hardware components.
if i.type.hardware:
continue
assert i.address_space in cspaces
if conf and conf.settings and [x for x in conf.settings if \
x.instance == i.name and x.attribute == 'simple' and x.value]:
for t in ['%s.simple' % i.name]:
try:
template = templates.lookup(t, i)
g = ''
if template:
with profiler('Rendering %s' % t):
g = r.render(i, assembly, template, obj_space, cspaces[i.address_space], \
shmem, options=options, id=id, my_pd=pds[i.address_space])
save(t, g)
if options.item == t:
if not template:
log.warning('Warning: no template for %s' % options.item)
done(g)
except Exception as inst:
die('While rendering %s: %s' % (i.name, str(inst)))
# Derive a set of usable ELF objects from the filenames we were passed.
elfs = {}
arch = None
for e in options.elf or []:
try:
name = os.path.basename(e)
if name in elfs:
raise Exception('duplicate ELF files of name \'%s\' encountered' % name)
elf = ELF(e, name)
if not arch:
# The spec's arch will have defaulted to ARM, but we want it to
# be the same as whatever ELF format we're parsing.
arch = elf.get_arch()
if arch == 'ARM':
obj_space.spec.arch = 'arm11'
elif arch == 'x86':
obj_space.spec.arch = 'ia32'
else:
raise NotImplementedError
else:
# All ELF files we're parsing should be the same format.
if arch != elf.get_arch():
raise Exception('ELF files are not all the same architecture')
# Pass 'False' to avoid inferring a TCB as we've already created
# our own.
p = Perspective(phase=RUNNER, elf_name=name)
group = p['group']
with profiler('Deriving CapDL spec from %s' % e):
elf_spec = elf.get_spec(infer_tcb=False, infer_asid=False,
pd=pds[group], use_large_frames=options.largeframe)
obj_space.merge(elf_spec, label=group)
elfs[name] = (e, elf)
except Exception as inst:
die('While opening \'%s\': %s' % (e, str(inst)))
if options.item in ['capdl', 'label-mapping']:
# It's only relevant to run these filters if the final target is CapDL.
# Note, this will no longer be true if we add any other templates that
# depend on a fully formed CapDL spec. Guarding this loop with an if
# is just an optimisation and the conditional can be removed if
# desired.
for f in CAPDL_FILTERS:
try:
with profiler('Running CapDL filter %s' % f.__name__):
# Pass everything as named arguments to allow filters to
# easily ignore what they don't want.
f(ast=ast, obj_space=obj_space, cspaces=cspaces, elfs=elfs,
profiler=profiler, options=options, shmem=shmem)
except Exception as inst:
die('While forming CapDL spec: %s' % str(inst))
# Instantiate any other, miscellaneous template. If we've reached this
# point, we know the user did not request a code template.
try:
template = templates.lookup(options.item)
g = ''
if template:
with profiler('Rendering %s' % options.item):
g = r.render(assembly, assembly, template, obj_space, None, \
shmem, imported=imported, options=options)
save(options.item, g)
done(g)
except Exception as inst:
die('While rendering %s: %s' % (options.item, str(inst)))
die('No valid element matching --item %s' % options.item)