#!/usr/bin/env python3 # # Copyright (c) 2018 Intel Corporation # # SPDX-License-Identifier: Apache-2.0 """ Script to generate a linker script organizing application memory partitions Applications may declare build-time memory domain partitions with K_APPMEM_PARTITION_DEFINE, and assign globals to them using K_APP_DMEM or K_APP_BMEM macros. For each of these partitions, we need to route all their data into appropriately-sized memory areas which meet the size/alignment constraints of the memory protection hardware. This linker script is created very early in the build process, before the build attempts to link the kernel binary, as the linker script this tool generates is a necessary pre-condition for kernel linking. We extract the set of memory partitions to generate by looking for variables which have been assigned to input sections that follow a defined naming convention. We also allow entire libraries to be pulled in to assign their globals to a particular memory partition via command line directives. This script takes as inputs: - The base directory to look for compiled objects - key/value pairs mapping static library files to what partitions their globals should end up in. The output is a linker script fragment containing the definition of the app shared memory section, which is further divided, for each partition found, into data and BSS for each partition. """ import sys import argparse import json import os import re from collections import OrderedDict from elftools.elf.elffile import ELFFile from elftools.elf.sections import SymbolTableSection import elftools.common.exceptions SZ = 'size' SRC = 'sources' LIB = 'libraries' # This script will create sections and linker variables to place the # application shared memory partitions. # these are later read by the macros defined in app_memdomain.h for # initialization purpose when USERSPACE is enabled. data_template = """ /* Auto generated code do not modify */ SMEM_PARTITION_ALIGN(z_data_smem_{0}_bss_end - z_data_smem_{0}_part_start); z_data_smem_{0}_part_start = .; KEEP(*(data_smem_{0}_data*)) """ library_data_template = """ *{0}:*(.data .data.* .sdata .sdata.*) """ bss_template = """ z_data_smem_{0}_bss_start = .; KEEP(*(data_smem_{0}_bss*)) """ library_bss_template = """ *{0}:*(.bss .bss.* .sbss .sbss.* COMMON COMMON.*) """ footer_template = """ z_data_smem_{0}_bss_end = .; SMEM_PARTITION_ALIGN(z_data_smem_{0}_bss_end - z_data_smem_{0}_part_start); z_data_smem_{0}_part_end = .; """ linker_start_seq = """ SECTION_PROLOGUE(_APP_SMEM{1}_SECTION_NAME,,) {{ APP_SHARED_ALIGN; _app_smem{0}_start = .; """ linker_end_seq = """ APP_SHARED_ALIGN; _app_smem{0}_end = .; }} GROUP_DATA_LINK_IN(RAMABLE_REGION, ROMABLE_REGION) """ empty_app_smem = """ SECTION_PROLOGUE(_APP_SMEM{1}_SECTION_NAME,,) {{ #ifdef EMPTY_APP_SHARED_ALIGN EMPTY_APP_SHARED_ALIGN; #endif _app_smem{0}_start = .; _app_smem{0}_end = .; }} GROUP_DATA_LINK_IN(RAMABLE_REGION, ROMABLE_REGION) """ size_cal_string = """ z_data_smem_{0}_part_size = z_data_smem_{0}_part_end - z_data_smem_{0}_part_start; z_data_smem_{0}_bss_size = z_data_smem_{0}_bss_end - z_data_smem_{0}_bss_start; """ section_regex = re.compile(r'data_smem_([A-Za-z0-9_]*)_(data|bss)*') elf_part_size_regex = re.compile(r'z_data_smem_(.*)_part_size') def find_obj_file_partitions(filename, partitions): with open(filename, 'rb') as f: try: full_lib = ELFFile(f) except elftools.common.exceptions.ELFError as e: exit(f"Error: {filename}: {e}") if not full_lib: sys.exit("Error parsing file: " + filename) sections = [x for x in full_lib.iter_sections()] for section in sections: m = section_regex.match(section.name) if not m: continue partition_name = m.groups()[0] if partition_name not in partitions: partitions[partition_name] = {SZ: section.header.sh_size} if args.verbose: partitions[partition_name][SRC] = filename else: partitions[partition_name][SZ] += section.header.sh_size return partitions def parse_obj_files(partitions): # Iterate over all object files to find partitions for dirpath, _, files in os.walk(args.directory): for filename in files: if re.match(r".*\.obj$", filename): fullname = os.path.join(dirpath, filename) fsize = os.path.getsize(fullname) if fsize != 0: find_obj_file_partitions(fullname, partitions) def parse_compile_command_file(partitions): # Iterate over all entries to find object files. # Thereafter process each object file to find partitions object_pattern = re.compile(r'-o\s+(\S*)') with open(args.compile_commands_file, 'rb') as f: commands = json.load(f) for command in commands: build_dir = command.get('directory') compile_command = command.get('command') compile_arg = object_pattern.search(compile_command) obj_file = None if compile_arg is None else compile_arg.group(1) if obj_file: fullname = os.path.join(build_dir, obj_file) # Because of issue #40635, then not all objects referenced by # the compile_commands.json file may be available, therefore # only include existing files. if os.path.exists(fullname): find_obj_file_partitions(fullname, partitions) def parse_elf_file(partitions): with open(args.elf, 'rb') as f: try: elffile = ELFFile(f) except elftools.common.exceptions.ELFError as e: exit(f"Error: {args.elf}: {e}") symbol_tbls = [s for s in elffile.iter_sections() if isinstance(s, SymbolTableSection)] for section in symbol_tbls: for symbol in section.iter_symbols(): if symbol['st_shndx'] != "SHN_ABS": continue x = elf_part_size_regex.match(symbol.name) if not x: continue partition_name = x.groups()[0] size = symbol['st_value'] if partition_name not in partitions: partitions[partition_name] = {SZ: size} if args.verbose: partitions[partition_name][SRC] = args.elf else: partitions[partition_name][SZ] += size def generate_final_linker(linker_file, partitions, lnkr_sect=""): string = "" if len(partitions) > 0: string = linker_start_seq.format(lnkr_sect, lnkr_sect.upper()) size_string = '' for partition, item in partitions.items(): string += data_template.format(partition) if LIB in item: for lib in item[LIB]: string += library_data_template.format(lib) string += bss_template.format(partition, lnkr_sect) if LIB in item: for lib in item[LIB]: string += library_bss_template.format(lib) string += footer_template.format(partition) size_string += size_cal_string.format(partition) string += linker_end_seq.format(lnkr_sect) string += size_string else: string = empty_app_smem.format(lnkr_sect, lnkr_sect.upper()) with open(linker_file, "w") as fw: fw.write(string) def parse_args(): global args parser = argparse.ArgumentParser( description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument("-d", "--directory", required=False, default=None, help="Root build directory") parser.add_argument("-e", "--elf", required=False, default=None, help="ELF file") parser.add_argument("-f", "--compile-commands-file", required=False, default=None, help="CMake compile commands file") parser.add_argument("-o", "--output", required=False, help="Output ld file") parser.add_argument("-v", "--verbose", action="count", default=0, help="Verbose Output") parser.add_argument("-l", "--library", nargs=2, action="append", default=[], metavar=("LIBRARY", "PARTITION"), help="Include globals for a particular library or object filename into a designated partition") parser.add_argument("--pinoutput", required=False, help="Output ld file for pinned sections") parser.add_argument("--pinpartitions", action="store", required=False, default="", help="Comma separated names of partitions to be pinned in physical memory") args = parser.parse_args() def main(): parse_args() partitions = {} if args.directory is not None: parse_obj_files(partitions) if args.compile_commands_file is not None: parse_compile_command_file(partitions) elif args.elf is not None: parse_elf_file(partitions) else: return for lib, ptn in args.library: if ptn not in partitions: partitions[ptn] = {} if LIB not in partitions[ptn]: partitions[ptn][LIB] = [lib] else: partitions[ptn][LIB].append(lib) if args.pinoutput: pin_part_names = args.pinpartitions.split(',') generic_partitions = {key: value for key, value in partitions.items() if key not in pin_part_names} pinned_partitions = {key: value for key, value in partitions.items() if key in pin_part_names} else: generic_partitions = partitions # Sample partitions.items() list before sorting: # [ ('part1', {'size': 64}), ('part3', {'size': 64}, ... # ('part0', {'size': 334}) ] decreasing_tuples = sorted(generic_partitions.items(), key=lambda x: (x[1][SZ], x[0]), reverse=True) partsorted = OrderedDict(decreasing_tuples) generate_final_linker(args.output, partsorted) if args.verbose: print("Partitions retrieved:") for key in partsorted: print(" {0}: size {1}: {2}".format(key, partsorted[key][SZ], partsorted[key][SRC])) if args.pinoutput: decreasing_tuples = sorted(pinned_partitions.items(), key=lambda x: (x[1][SZ], x[0]), reverse=True) partsorted = OrderedDict(decreasing_tuples) generate_final_linker(args.pinoutput, partsorted, lnkr_sect="_pinned") if args.verbose: print("Pinned partitions retrieved:") for key in partsorted: print(" {0}: size {1}: {2}".format(key, partsorted[key][SZ], partsorted[key][SRC])) if __name__ == '__main__': main()