You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
292 lines
11 KiB
292 lines
11 KiB
#!/usr/bin/env python3
|
|
# Copyright (c) 2019, Arm Limited. All rights reserved.
|
|
#
|
|
# SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
"""
|
|
This module contains a set of classes and a runner that can generate code for the romlib module
|
|
based on the templates in the 'templates' directory.
|
|
"""
|
|
|
|
import argparse
|
|
import os
|
|
import re
|
|
import subprocess
|
|
import string
|
|
import sys
|
|
|
|
class IndexFileParser:
|
|
"""
|
|
Parses the contents of the index file into the items and dependencies variables. It
|
|
also resolves included files in the index files recursively with circular inclusion detection.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.items = []
|
|
self.dependencies = {}
|
|
self.include_chain = []
|
|
|
|
def add_dependency(self, parent, dependency):
|
|
""" Adds a dependency into the dependencies variable. """
|
|
if parent in self.dependencies:
|
|
self.dependencies[parent].append(dependency)
|
|
else:
|
|
self.dependencies[parent] = [dependency]
|
|
|
|
def get_dependencies(self, parent):
|
|
""" Gets all the recursive dependencies of a parent file. """
|
|
parent = os.path.normpath(parent)
|
|
if parent in self.dependencies:
|
|
direct_deps = self.dependencies[parent]
|
|
deps = direct_deps
|
|
for direct_dep in direct_deps:
|
|
deps += self.get_dependencies(direct_dep)
|
|
return deps
|
|
|
|
return []
|
|
|
|
def parse(self, file_name):
|
|
""" Opens and parses index file. """
|
|
file_name = os.path.normpath(file_name)
|
|
|
|
if file_name not in self.include_chain:
|
|
self.include_chain.append(file_name)
|
|
self.dependencies[file_name] = []
|
|
else:
|
|
raise Exception("Circular dependency detected: " + file_name)
|
|
|
|
with open(file_name, "r") as index_file:
|
|
for line in index_file.readlines():
|
|
line_elements = line.split()
|
|
|
|
if line.startswith("#") or not line_elements:
|
|
# Comment or empty line
|
|
continue
|
|
|
|
if line_elements[0] == "reserved":
|
|
# Reserved slot in the jump table
|
|
self.items.append({"type": "reserved"})
|
|
elif line_elements[0] == "include" and len(line_elements) > 1:
|
|
# Include other index file
|
|
included_file = os.path.normpath(line_elements[1])
|
|
self.add_dependency(file_name, included_file)
|
|
self.parse(included_file)
|
|
elif len(line_elements) > 1:
|
|
# Library function
|
|
library_name = line_elements[0]
|
|
function_name = line_elements[1]
|
|
patch = bool(len(line_elements) > 2 and line_elements[2] == "patch")
|
|
|
|
self.items.append({"type": "function", "library_name": library_name,
|
|
"function_name": function_name, "patch": patch})
|
|
else:
|
|
raise Exception("Invalid line: '" + line + "'")
|
|
|
|
self.include_chain.pop()
|
|
|
|
class RomlibApplication:
|
|
""" Base class of romlib applications. """
|
|
TEMPLATE_DIR = os.path.dirname(os.path.realpath(__file__)) + "/templates/"
|
|
|
|
def __init__(self, prog):
|
|
self.args = argparse.ArgumentParser(prog=prog, description=self.__doc__)
|
|
self.config = None
|
|
|
|
def parse_arguments(self, argv):
|
|
""" Parses the arguments that should come from the command line arguments. """
|
|
self.config = self.args.parse_args(argv)
|
|
|
|
def build_template(self, name, mapping=None, remove_comment=False):
|
|
"""
|
|
Loads a template and builds it with the defined mapping. Template paths are always relative
|
|
to this script.
|
|
"""
|
|
|
|
with open(self.TEMPLATE_DIR + name, "r") as template_file:
|
|
if remove_comment:
|
|
# Removing copyright comment to make the generated code more readable when the
|
|
# template is inserted multiple times into the output.
|
|
template_lines = template_file.readlines()
|
|
end_of_comment_line = 0
|
|
for index, line in enumerate(template_lines):
|
|
if line.find("*/") != -1:
|
|
end_of_comment_line = index
|
|
break
|
|
template_data = "".join(template_lines[end_of_comment_line + 1:])
|
|
else:
|
|
template_data = template_file.read()
|
|
|
|
template = string.Template(template_data)
|
|
return template.substitute(mapping)
|
|
|
|
class IndexPreprocessor(RomlibApplication):
|
|
""" Removes empty and comment lines from the index file and resolves includes. """
|
|
|
|
def __init__(self, prog):
|
|
RomlibApplication.__init__(self, prog)
|
|
|
|
self.args.add_argument("-o", "--output", help="Output file", metavar="output",
|
|
default="jmpvar.s")
|
|
self.args.add_argument("--deps", help="Dependency file")
|
|
self.args.add_argument("file", help="Input file")
|
|
|
|
def main(self):
|
|
"""
|
|
After parsing the input index file it generates a clean output with all includes resolved.
|
|
Using --deps option it also outputs the dependencies in makefile format like gcc's with -M.
|
|
"""
|
|
|
|
index_file_parser = IndexFileParser()
|
|
index_file_parser.parse(self.config.file)
|
|
|
|
with open(self.config.output, "w") as output_file:
|
|
for item in index_file_parser.items:
|
|
if item["type"] == "function":
|
|
patch = "\tpatch" if item["patch"] else ""
|
|
output_file.write(
|
|
item["library_name"] + "\t" + item["function_name"] + patch + "\n")
|
|
else:
|
|
output_file.write("reserved\n")
|
|
|
|
if self.config.deps:
|
|
with open(self.config.deps, "w") as deps_file:
|
|
deps = [self.config.file] + index_file_parser.get_dependencies(self.config.file)
|
|
deps_file.write(self.config.output + ": " + " \\\n".join(deps) + "\n")
|
|
|
|
class TableGenerator(RomlibApplication):
|
|
""" Generates the jump table by parsing the index file. """
|
|
|
|
def __init__(self, prog):
|
|
RomlibApplication.__init__(self, prog)
|
|
|
|
self.args.add_argument("-o", "--output", help="Output file", metavar="output",
|
|
default="jmpvar.s")
|
|
self.args.add_argument("--bti", help="Branch Target Identification", type=int)
|
|
self.args.add_argument("file", help="Input file")
|
|
|
|
def main(self):
|
|
"""
|
|
Inserts the jmptbl definition and the jump entries into the output file. Also can insert
|
|
BTI related code before entries if --bti option set. It can output a dependency file of the
|
|
included index files. This can be directly included in makefiles.
|
|
"""
|
|
|
|
index_file_parser = IndexFileParser()
|
|
index_file_parser.parse(self.config.file)
|
|
|
|
with open(self.config.output, "w") as output_file:
|
|
output_file.write(self.build_template("jmptbl_header.S"))
|
|
bti = "_bti" if self.config.bti == 1 else ""
|
|
|
|
for item in index_file_parser.items:
|
|
template_name = "jmptbl_entry_" + item["type"] + bti + ".S"
|
|
output_file.write(self.build_template(template_name, item, True))
|
|
|
|
class LinkArgs(RomlibApplication):
|
|
""" Generates the link arguments to wrap functions. """
|
|
|
|
def __init__(self, prog):
|
|
RomlibApplication.__init__(self, prog)
|
|
self.args.add_argument("file", help="Input file")
|
|
|
|
def main(self):
|
|
index_file_parser = IndexFileParser()
|
|
index_file_parser.parse(self.config.file)
|
|
|
|
fns = [item["function_name"] for item in index_file_parser.items
|
|
if not item["patch"] and item["type"] != "reserved"]
|
|
|
|
print(" ".join("-Wl,--wrap " + f for f in fns))
|
|
|
|
class WrapperGenerator(RomlibApplication):
|
|
"""
|
|
Generates a wrapper function for each entry in the index file except for the ones that contain
|
|
the keyword patch. The generated wrapper file is called <lib>_<fn_name>.s.
|
|
"""
|
|
|
|
def __init__(self, prog):
|
|
RomlibApplication.__init__(self, prog)
|
|
|
|
self.args.add_argument("-b", help="Build directory", default=".", metavar="build")
|
|
self.args.add_argument("--bti", help="Branch Target Identification", type=int)
|
|
self.args.add_argument("--list", help="Only list assembly files", action="store_true")
|
|
self.args.add_argument("file", help="Input file")
|
|
|
|
def main(self):
|
|
"""
|
|
Iterates through the items in the parsed index file and builds the template for each entry.
|
|
"""
|
|
|
|
index_file_parser = IndexFileParser()
|
|
index_file_parser.parse(self.config.file)
|
|
|
|
bti = "_bti" if self.config.bti == 1 else ""
|
|
function_offset = 0
|
|
files = []
|
|
|
|
for item_index in range(0, len(index_file_parser.items)):
|
|
item = index_file_parser.items[item_index]
|
|
|
|
if item["type"] == "reserved" or item["patch"]:
|
|
continue
|
|
|
|
if not self.config.list:
|
|
# The jump instruction is 4 bytes but BTI requires and extra instruction so
|
|
# this makes it 8 bytes per entry.
|
|
function_offset = item_index * (8 if self.config.bti else 4)
|
|
|
|
item["function_offset"] = function_offset
|
|
files.append(self.build_template("wrapper" + bti + ".S", item))
|
|
|
|
if self.config.list:
|
|
print(self.config.b + "/wrappers.s")
|
|
else:
|
|
with open(self.config.b + "/wrappers.s", "w") as asm_file:
|
|
asm_file.write("\n".join(files))
|
|
|
|
class VariableGenerator(RomlibApplication):
|
|
""" Generates the jump table global variable with the absolute address in ROM. """
|
|
|
|
def __init__(self, prog):
|
|
RomlibApplication.__init__(self, prog)
|
|
|
|
self.args.add_argument("-o", "--output", help="Output file", metavar="output",
|
|
default="jmpvar.s")
|
|
self.args.add_argument("file", help="Input file")
|
|
|
|
def main(self):
|
|
"""
|
|
Runs nm -a command on the input file and inserts the address of the .text section into the
|
|
template as the ROM address of the jmp_table.
|
|
"""
|
|
symbols = subprocess.check_output(["nm", "-a", self.config.file])
|
|
|
|
matching_symbol = re.search("([0-9A-Fa-f]+) . \\.text", str(symbols))
|
|
if not matching_symbol:
|
|
raise Exception("No '.text' section was found in %s" % self.config.file)
|
|
|
|
mapping = {"jmptbl_address": matching_symbol.group(1)}
|
|
|
|
with open(self.config.output, "w") as output_file:
|
|
output_file.write(self.build_template("jmptbl_glob_var.S", mapping))
|
|
|
|
if __name__ == "__main__":
|
|
APPS = {"genvar": VariableGenerator, "pre": IndexPreprocessor,
|
|
"gentbl": TableGenerator, "genwrappers": WrapperGenerator,
|
|
"link-flags": LinkArgs}
|
|
|
|
if len(sys.argv) < 2 or sys.argv[1] not in APPS:
|
|
print("usage: romlib_generator.py [%s] [args]" % "|".join(APPS.keys()), file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
APP = APPS[sys.argv[1]]("romlib_generator.py " + sys.argv[1])
|
|
APP.parse_arguments(sys.argv[2:])
|
|
try:
|
|
APP.main()
|
|
sys.exit(0)
|
|
except FileNotFoundError as file_not_found_error:
|
|
print(file_not_found_error, file=sys.stderr)
|
|
except subprocess.CalledProcessError as called_process_error:
|
|
print(called_process_error.output, file=sys.stderr)
|
|
|
|
sys.exit(1)
|
|
|