esp-idf/tools/idf_size.py

1235 wiersze
55 KiB
Python
Executable File

#!/usr/bin/env python
#
# esp-idf alternative to "size" to print ELF file sizes, also analyzes
# the linker map file to dump higher resolution details.
#
# Includes information which is not shown in "xtensa-esp32-elf-size",
# or easy to parse from "xtensa-esp32-elf-objdump" or raw map files.
#
# SPDX-FileCopyrightText: 2017-2022 Espressif Systems (Shanghai) CO LTD
# SPDX-License-Identifier: Apache-2.0
#
import argparse
import collections
import json
import os.path
import re
import sys
from typing import Any, Callable, Collection, Dict, Iterable, List, Optional, TextIO, Tuple, Union
import yaml
class Section(Dict):
# define for python type hints
size: int
address: int
name: str
sources: List[Dict]
SectionDict = Dict[str, Section]
try:
basestring
except NameError:
basestring = str
GLOBAL_JSON_INDENT = 4
GLOBAL_JSON_SEPARATORS = (',', ': ')
class MemRegions(object):
"""
Regions determined by the chip target.
"""
# DIRAM is not added here. The DIRAM is indicated by the `secondary_addr` of each MemRegDef
(DRAM_ID, IRAM_ID, CACHE_D_ID, CACHE_I_ID, RTC_FAST_D_ID, RTC_FAST_I_ID, RTC_SLOW_D_ID) = range(7)
# The order of variables in the tuple is the same as in the soc_memory_layout.c files
MemRegDef = collections.namedtuple('MemRegDef', ['primary_addr', 'length', 'type', 'secondary_addr'])
class Region(object):
# Helper class to store region information
def __init__(self, start: int, length: int, region: 'MemRegions.MemRegDef', section: Optional[str]=None) -> None:
self.start = start
self.len = length
self.region = region
self.section = section
@staticmethod
def get_mem_regions(target: str) -> List:
"""
Get memory regions for specific target
"""
# The target specific memory structure is deduced from soc_memory_types defined in
# $IDF_PATH/components/soc/**/soc_memory_layout.c files.
MemRegDef = MemRegions.MemRegDef
def change_to_proper_format(length: Union[str, bytes]) -> Any:
'''
Change `length` if it is string like `'0x8000 + 6 * 0x10000'` to resolve of this math equation
or if `length` is number function return it without changing.
'''
try:
return eval(length)
except TypeError:
return length
def get_mem_reg_def(chip_info: Dict, memory_reg: str) -> Tuple:
chip_info[memory_reg]['secondary_address'] = chip_info[memory_reg].get('secondary_address') or 0
return MemRegDef(chip_info[memory_reg]['primary_address'], change_to_proper_format(chip_info[memory_reg]['length']),
getattr(MemRegions, memory_reg.strip('_12') + '_ID'), chip_info[memory_reg]['secondary_address'])
try:
with open(os.path.join(os.path.dirname(__file__), 'idf_size_yaml', target + '_data_info.yaml'), 'r') as stream:
chip_info = (yaml.safe_load(stream))
except FileNotFoundError:
raise RuntimeError('Target not detected.')
return sorted([get_mem_reg_def(chip_info, item) for item in chip_info])
def __init__(self, target: str) -> None:
self.chip_mem_regions = self.get_mem_regions(target)
if not self.chip_mem_regions:
raise RuntimeError('Target {} is not implemented in idf_size'.format(target))
def _get_first_region(self, start: int, length: int) -> Tuple[Union['MemRegions.MemRegDef', None], int]:
for region in self.chip_mem_regions: # type: ignore
if region.primary_addr <= start < region.primary_addr + region.length:
return (region, length)
if region.secondary_addr and region.secondary_addr <= start < region.secondary_addr + region.length:
return (region, length)
print('WARNING: Given section not found in any memory region.')
print('Check whether the LD file is compatible with the definitions in get_mem_regions in idf_size.py')
return (None, length)
def _get_regions(self, start: int, length: int, name: Optional[str]=None) -> List:
ret = []
while length > 0:
(region, cur_len) = self._get_first_region(start, length)
if region is None:
# skip regions that not in given section
length -= cur_len
start += cur_len
continue
ret.append(MemRegions.Region(start, cur_len, region, name))
length -= cur_len
start += cur_len
return ret
def fit_segments_into_regions(self, segments: Dict) -> List:
region_list = []
for segment in segments.values():
sorted_segments = self._get_regions(segment['origin'], segment['length'])
region_list.extend(sorted_segments)
return region_list
def fit_sections_into_regions(self, sections: Dict) -> List:
region_list = []
for section in sections.values():
sorted_sections = self._get_regions(section['address'], section['size'], section['name'])
region_list.extend(sorted_sections)
return region_list
class LinkingSections(object):
_section_type_dict = {key: re.compile(value) for key, value in {
'text': r'.*\.text',
'data': r'.*\.data',
'bss': r'.*\.bss',
'rodata': r'.*\.rodata',
'noinit': r'.*noinit',
'vectors': r'.*\.vectors',
'flash': r'.*flash.*',
}.items()}
@staticmethod
def in_section(section: str, section_name_or_list: Union[str, Iterable]) -> bool:
"""
Check if section in section_name_or_list
"""
if isinstance(section_name_or_list, basestring):
section_name_or_list = [section_name_or_list]
for section_name in section_name_or_list:
if LinkingSections._section_type_dict[section_name].match(section):
return True
return False
@staticmethod
def filter_sections(sections: Dict) -> Dict:
return {key: v for key, v in sections.items()
if LinkingSections.in_section(key, LinkingSections._section_type_dict.keys())}
@staticmethod
def get_display_name_order(section_name_list: List[str]) -> Tuple[List[str], List[str]]:
'''
Return two lists, in the suggested display order.
First list is the reordered section_name_list, second list is the suggested display name, corresponding to the first list
'''
def get_memory_name(split_name: List) -> Tuple[str, str]:
memory_name = '.{}'.format(split_name[1])
display_name = section
for seg_name in ['iram','dram','flash']:
if seg_name in split_name[1]:
memory_name = '.{}'.format(seg_name)
seg_name = seg_name.upper() if seg_name != 'flash' else seg_name.capitalize()
display_name = ''.join([seg_name,
split_name[1].replace('iram', '') if seg_name == 'IRAM' else '',
' .{}'.format(split_name[2]) if len(split_name) > 2 else ''])
return memory_name, display_name
ordered_name_list = sorted(section_name_list)
display_name_list = ordered_name_list.copy()
memory_name = ''
ordered_name_list = sort_dict(ordered_name_list)
for i, section in enumerate(ordered_name_list):
if memory_name and section.startswith(memory_name):
# If the section has same memory type with the previous one, use shorter name
display_name_list[i] = section.replace(memory_name, '& ')
continue
memory_name = ''
split_name = section.split('.')
if len(split_name) > 1:
# If the section has a memory type, update the type and try to display the type properly
assert split_name[0] == '', 'Unexpected section name "{}"'.format(section)
memory_name, display_name_list[i] = get_memory_name(split_name)
continue
# Otherwise use its original name
display_name_list[i] = section
return ordered_name_list, display_name_list
def scan_to_header(file: Iterable, header_line: str) -> None:
""" Scan forward in a file until you reach 'header_line', then return """
for line in file:
if line.strip() == header_line:
return
raise RuntimeError("Didn't find line '%s' in file" % header_line)
def format_json(json_object: Dict) -> str:
return json.dumps(json_object,
allow_nan=True,
indent=GLOBAL_JSON_INDENT,
separators=GLOBAL_JSON_SEPARATORS) + os.linesep
def load_map_data(map_file: TextIO) -> Tuple[str, Dict, Dict]:
segments = load_segments(map_file)
detected_chip = detect_target_chip(map_file)
sections = load_sections(map_file)
# Exclude the dummy and .text_end section, which usually means shared region among I/D buses
for key in list(sections.keys()):
if key.endswith(('dummy', '.text_end')):
sections.pop(key)
return detected_chip, segments, sections
def load_segments(map_file: TextIO) -> Dict:
""" Memory Configuration section is the total size of each segment """
result = {} # type: Dict[Any, Dict]
scan_to_header(map_file, 'Memory Configuration')
RE_MEMORY_SECTION = re.compile(r'(?P<name>[^ ]+) +0x(?P<origin>[\da-f]+) +0x(?P<length>[\da-f]+)')
for line in map_file:
match_section = RE_MEMORY_SECTION.match(line)
if match_section is None:
if len(result) == 0:
continue # whitespace or a header, before the content we want
else:
return result # we're at the end of the Memory Configuration
segment = {
'name': match_section.group('name'),
'origin': int(match_section.group('origin'), 16),
'length': int(match_section.group('length'), 16),
}
if segment['name'] != '*default*':
result[segment['name']] = segment
raise RuntimeError('End of file while scanning memory configuration?')
def detect_target_chip(map_file: Iterable) -> str:
''' Detect target chip based on the target archive name in the linker script part of the MAP file '''
scan_to_header(map_file, 'Linker script and memory map')
RE_TARGET = re.compile(r'IDF_TARGET_(\S*) =')
# For back-compatible with cmake in idf version before 5.0
RE_TARGET_CMAKEv4x = re.compile(r'project_elf_src_(\S*)\.c.obj')
# For back-compatible with make
RE_TARGET_MAKE = re.compile(r'^LOAD .*?/xtensa-([^-]+)-elf/')
for line in map_file:
match_target = RE_TARGET.search(line)
if match_target:
return match_target.group(1).lower()
match_target = RE_TARGET_CMAKEv4x.search(line)
if match_target:
return match_target.group(1)
match_target = RE_TARGET_MAKE.search(line)
if match_target:
return match_target.group(1)
line = line.strip()
# There could be empty line(s) between the "Linker script and memory map" header and "LOAD lines". Therefore,
# line stripping and length is checked as well. The "LOAD lines" are between START GROUP and END GROUP for
# older MAP files.
if not line.startswith(('LOAD', 'START GROUP', 'END GROUP')) and len(line) > 0:
# This break is a failsafe to not process anything load_sections() might want to analyze.
break
raise RuntimeError('Target not detected')
def load_sections(map_file: TextIO) -> Dict:
""" Load section size information from the MAP file.
Returns a dict of 'sections', where each key is a section name and the value
is a dict with details about this section, including a "sources" key which holds a list of source file line
information for each symbol linked into the section.
There are two kinds of lines:
- symbol_only: [optional space]<sym_name>
- full line: [optional space][optional sym_name] <address> <size> [optional file_info]
If <sym_name> doesn't exist, ues the symbol name from the symbol_only line above
If the line is the starting of a section, the <file> should be empty, otherwise if the line is for a source
line, the <file> must exist, or the <sym_name> should be is no *fill*. This rule is used to tell sections from
source lines.
"""
# Check for lines which only contain the sym name (and rest is on following lines)
RE_SYMBOL_ONLY_LINE = re.compile(r'^\s*(?P<sym_name>\S*)$')
# Fast check to see if line is a potential source line before running the slower full regex against it
RE_PRE_FILTER = re.compile(r'.*0x[\da-f]+\s*0x[\da-f]+.*')
# source file line, ie
# 0x0000000040080400 0xa4 /home/gus/esp/32/idf/examples/get-started/hello_world/build/esp32/libesp32.a(cpu_start.o)
# cmake build system links some object files directly, not part of any archive, so make that part optional
# .xtensa.info 0x0000000000000000 0x38 CMakeFiles/hello_world.elf.dir/project_elf_src.c.obj
# *fill* 0x00000000400e2967 0x1
RE_FULL_LINE = re.compile(r'\s*(?P<sym_name>\S*) +0x(?P<address>[\da-f]+) +0x(?P<size>[\da-f]+)\s*(?P<file>.*)$')
# Extract archive and object_file from the file_info field
# The object file extention (.obj or .o) is optional including the dot. This is necessary for some third-party
# libraries. Since the dot is optional and the search gready the parsing of the object name must stop at ). Hence
# the [^ )] part of the regex.
RE_FILE = re.compile(r'((?P<archive>[^ ]+\.a)?\(?(?P<object_file>[^ )]+(\.(o|obj))?)\)?)')
def dump_src_line(src: Dict) -> str:
return '%s(%s) addr: 0x%08x, size: 0x%x+%d' % (src['sym_name'], src['file'], src['address'], src['size'], src['fill'])
sections = {} # type: Dict[Any, Dict]
section = {} # type: Dict[str, Any]
sym_backup = ''
for line in map_file:
if line.strip() == 'Cross Reference Table':
# Stop processing lines because we are at the next section in the map file
break
match_line = RE_SYMBOL_ONLY_LINE.match(line)
if match_line:
# In some cases the section name appears on the previous line, back it up in here
sym_backup = match_line.group('sym_name')
continue
if not RE_PRE_FILTER.match(line):
# Line does not match our quick check, so skip to next line
continue
match_line = RE_FULL_LINE.match(line)
if not match_line:
assert not sym_backup, 'Symbol only line must be followed by a line with address and size'
continue
name = match_line.group('sym_name') if match_line.group('sym_name') else sym_backup
sym_backup = ''
is_section = not match_line.group('file') and name != '*fill*'
if is_section:
# section
section = {
'name': name,
'address': int(match_line.group('address'), 16),
'size': int(match_line.group('size'), 16),
'sources': [],
}
sections[name] = section
else:
# symbol
if not section:
continue
# There are some source lines in rodata section doesn't actually take any space, but have size
# Make size of those sections zero
srcs = section['sources'] # type: List[Dict]
if srcs:
last_src = srcs[-1]
if last_src['size'] > 0 and last_src['address'] == int(match_line.group('address'), 16):
if section['name'] not in ['.comment', '.debug_str', '.debug_line_str'] and 'rodata' not in last_src['sym_name']:
raise RuntimeError('Due to overlap with following lines, size of the line set to 0:\n %s' % dump_src_line(last_src))
last_src['size'] = 0
# Count the padding size into the last valid (size > 0) source in the section
if name == '*fill*':
for src in reversed(srcs):
if src['size'] > 0:
src['fill'] += int(match_line.group('size'), 16)
break
continue
# Extract archive and file information
match_arch_and_file = RE_FILE.match(match_line.group('file'))
assert match_arch_and_file, 'Archive and file information not found for "{}"'.format(match_line.group('file'))
archive = match_arch_and_file.group('archive')
if archive is None:
# optional named group "archive" was not matched, so assign a value to it
archive = '(exe)'
file = match_arch_and_file.group('object_file')
assert name
source = {
'size': int(match_line.group('size'), 16),
'address': int(match_line.group('address'), 16),
'archive': os.path.basename(archive),
'object_file': os.path.basename(file),
'sym_name': name,
'fill': 0, # padding size ofter the source
}
source['file'] = '%s:%s' % (source['archive'], source['object_file'])
section['sources'].append(source) # type: ignore
# Validate the map file
for section in sections.values():
src_curr = {} # type: Dict[str, Any]
for src in section['sources']:
if src['size'] == 0:
continue
expected_addr = src_curr['address'] + src_curr['size'] + src_curr['fill'] if src_curr else section['sources'][0]['address']
if src['address'] != expected_addr:
print('Warning: source line overlap:')
print(' ' + dump_src_line(src_curr))
print(' ' + dump_src_line(src))
src_curr = src
return sections
def check_target(target: str, map_file: TextIO) -> None:
if target is None:
raise RuntimeError('The target chip cannot be detected for {}. '
'Please report the issue.'.format(map_file.name))
def main() -> None:
parser = argparse.ArgumentParser(description='idf_size - a tool to print size information from an IDF MAP file')
parser.add_argument(
'map_file', help='MAP file produced by linker',
type=argparse.FileType('r'))
format_group = parser.add_mutually_exclusive_group()
format_group.add_argument(
'--format',
help='Specify output format: text, csv or json',
choices=['text','csv', 'json'],
default='text')
format_group.add_argument(
'--json', help=argparse.SUPPRESS, action='store_true')
parser.add_argument(
'--archives', help='Print per-archive sizes', action='store_true')
parser.add_argument(
'--archive_details', help='Print detailed symbols per archive')
parser.add_argument(
'--files', help='Print per-file sizes', action='store_true')
parser.add_argument(
'--target', help='Set target chip', default=None)
parser.add_argument(
'--diff', help='Show the differences in comparison with another MAP file',
metavar='ANOTHER_MAP_FILE',
default=None,
dest='another_map_file')
parser.add_argument(
'-o',
'--output-file',
type=argparse.FileType('w'),
default=sys.stdout,
help='Print output to the specified file instead of stdout')
args = parser.parse_args()
if args.json:
print('WARNING: --json argument is deprecated in favour of the --format argument')
detected_target, segments, sections = load_map_data(args.map_file)
args.map_file.close()
check_target(detected_target, args.map_file)
if args.another_map_file:
with open(args.another_map_file, 'r') as f:
detected_target_diff, segments_diff, sections_diff = load_map_data(f)
check_target(detected_target_diff, f)
if detected_target_diff != detected_target:
print('WARNING: The target of the reference and other MAP files is {} and {}, respectively.'
''.format(detected_target, detected_target_diff))
else:
segments_diff, sections_diff, detected_target_diff = {}, {}, ''
if args.target is not None:
if args.target != detected_target or (detected_target_diff and args.target != detected_target_diff):
print('WARNING: The detected chip target overwritten to {} by command line argument!'.format(args.target))
detected_target = args.target
detected_target_diff = args.target
output = ''
if not args.format == 'json' or not (args.archives or args.files or args.archive_details):
output += get_summary(args.map_file.name, segments, sections, detected_target,
args.format, args.another_map_file, segments_diff,
sections_diff, detected_target_diff, not (args.archives or args.files))
if args.archives:
output += get_detailed_sizes(sections, 'archive', 'Archive File', args.format, sections_diff)
if args.files:
output += get_detailed_sizes(sections, 'file', 'Object File', args.format, sections_diff)
if args.archive_details:
output += get_archive_symbols(sections, args.archive_details, args.format, sections_diff)
args.output_file.write(output)
args.output_file.close()
class StructureForSummary(object):
dram_data, dram_bss, dram_rodata, dram_other, used_dram, dram_total, dram_remain = (0, ) * 7
used_dram_ratio = 0.
iram_vectors, iram_text, iram_other, used_iram, iram_total, iram_remain = (0, ) * 6
used_iram_ratio = 0.
diram_data, diram_bss, diram_text, diram_vectors, diram_rodata, diram_other, diram_total, used_diram, diram_remain = (0, ) * 9
used_diram_ratio = 0.
flash_code, flash_rodata, flash_other, used_flash_non_ram, total_size = (0, ) * 5
def __sub__(self, rhs: 'StructureForSummary') -> 'StructureForSummary':
assert isinstance(rhs, StructureForSummary)
ret = self
for key in StructureForSummary.get_required_items():
setattr(ret, key, getattr(self, key) - getattr(rhs, key))
return ret
def get_dram_overflowed(self) -> bool:
return self.used_dram_ratio > 1.0
def get_iram_overflowed(self) -> bool:
return self.used_iram_ratio > 1.0
def get_diram_overflowed(self) -> bool:
return self.used_diram_ratio > 1.0
@classmethod
def get_required_items(cls: Any) -> List:
whole_list = list(filter(lambda x: not (x.startswith('__') or x.endswith('__') or callable(getattr(cls, x))), dir(cls)))
return whole_list
@staticmethod
def get(segments: List, sections: List) -> 'StructureForSummary':
def get_size(sections: Iterable) -> int:
return sum([x.len for x in sections])
def in_diram(x: MemRegions.Region) -> bool:
return x.region.type in (MemRegions.DRAM_ID, MemRegions.IRAM_ID) and x.region.secondary_addr > 0
def in_dram(x: MemRegions.Region) -> bool:
return x.region.type == MemRegions.DRAM_ID and x.region.secondary_addr == 0 # type: ignore
def in_iram(x: MemRegions.Region) -> bool:
return x.region.type == MemRegions.IRAM_ID and x.region.secondary_addr == 0 # type: ignore
r = StructureForSummary()
diram_filter = filter(in_diram, segments)
r.diram_total = get_size(diram_filter)
dram_filter = filter(in_dram, segments)
r.dram_total = get_size(dram_filter)
iram_filter = filter(in_iram, segments)
r.iram_total = get_size(iram_filter)
# This fixes counting the diram twice if the cache fills the iram entirely
if r.iram_total == 0:
r.diram_total //= 2
def filter_in_section(sections: Iterable[MemRegions.Region], section_to_check: str) -> List[MemRegions.Region]:
return list(filter(lambda x: LinkingSections.in_section(x.section, section_to_check), sections)) # type: ignore
dram_sections = list(filter(in_dram, sections))
iram_sections = list(filter(in_iram, sections))
diram_sections = list(filter(in_diram, sections))
flash_sections = filter_in_section(sections, 'flash')
dram_data_list = filter_in_section(dram_sections, 'data')
dram_bss_list = filter_in_section(dram_sections, 'bss')
dram_rodata_list = filter_in_section(dram_sections, 'rodata')
dram_other_list = [x for x in dram_sections if x not in dram_data_list + dram_bss_list + dram_rodata_list]
iram_vectors_list = filter_in_section(iram_sections, 'vectors')
iram_text_list = filter_in_section(iram_sections, 'text')
iram_other_list = [x for x in iram_sections if x not in iram_vectors_list + iram_text_list]
diram_vectors_list = filter_in_section(diram_sections, 'vectors')
diram_data_list = filter_in_section(diram_sections, 'data')
diram_bss_list = filter_in_section(diram_sections, 'bss')
diram_text_list = filter_in_section(diram_sections, 'text')
diram_rodata_list = filter_in_section(diram_sections, 'rodata')
diram_other_list = [x for x in diram_sections if x not in diram_data_list + diram_bss_list + diram_text_list + diram_vectors_list + diram_rodata_list]
flash_text_list = filter_in_section(flash_sections, 'text')
flash_rodata_list = filter_in_section(flash_sections, 'rodata')
flash_other_list = [x for x in flash_sections if x not in flash_text_list + flash_rodata_list]
r.dram_data = get_size(dram_data_list)
r.dram_bss = get_size(dram_bss_list)
r.dram_rodata = get_size(dram_rodata_list)
r.dram_other = get_size(dram_other_list)
r.used_dram = r.dram_data + r.dram_bss + r.dram_other + r.dram_rodata
try:
r.used_dram_ratio = r.used_dram / r.dram_total
except ZeroDivisionError:
r.used_dram_ratio = float('nan') if r.used_dram != 0 else 0
r.dram_remain = r.dram_total - r.used_dram
r.iram_vectors = get_size((iram_vectors_list))
r.iram_text = get_size((iram_text_list))
r.iram_other = get_size((iram_other_list))
r.used_iram = r.iram_vectors + r.iram_text + r.iram_other
try:
r.used_iram_ratio = r.used_iram / r.iram_total
except ZeroDivisionError:
r.used_iram_ratio = float('nan') if r.used_iram != 0 else 0
r.iram_remain = r.iram_total - r.used_iram
r.diram_data = get_size(diram_data_list)
r.diram_bss = get_size(diram_bss_list)
r.diram_text = get_size(diram_text_list)
r.diram_vectors = get_size(diram_vectors_list)
r.diram_rodata = get_size(diram_rodata_list)
r.diram_other = get_size(diram_other_list)
r.used_diram = r.diram_data + r.diram_bss + r.diram_text + r.diram_vectors + r.diram_other + r.diram_rodata
try:
r.used_diram_ratio = r.used_diram / r.diram_total
except ZeroDivisionError:
r.used_diram_ratio = float('nan') if r.used_diram != 0 else 0
r.diram_remain = r.diram_total - r.used_diram
r.flash_code = get_size(flash_text_list)
r.flash_rodata = get_size(flash_rodata_list)
r.flash_other = get_size(flash_other_list)
r.used_flash_non_ram = r.flash_code + r.flash_rodata + r.flash_other
# The used DRAM BSS is counted into the "Used static DRAM" but not into the "Total image size"
r.total_size = r.used_dram - r.dram_bss + r.used_iram + r.used_diram - r.diram_bss + r.used_flash_non_ram
return r
def get_dict(self) -> collections.OrderedDict:
ret = collections.OrderedDict([
('dram_data', self.dram_data),
('dram_bss', self.dram_bss),
('dram_rodata', self.dram_rodata),
('dram_other', self.dram_other),
('used_dram', self.used_dram),
('dram_total', self.dram_total),
('used_dram_ratio', self.used_dram_ratio if self.used_dram_ratio is not float('nan') else 0),
('dram_remain', self.dram_remain),
('iram_vectors', self.iram_vectors),
('iram_text', self.iram_text),
('iram_other', self.iram_other),
('used_iram', self.used_iram),
('iram_total', self.iram_total),
('used_iram_ratio', self.used_iram_ratio),
('iram_remain', self.iram_remain),
('diram_data', self.diram_data),
('diram_bss', self.diram_bss),
('diram_text', self.diram_text),
('diram_vectors', self.diram_vectors),
('diram_rodata', self.diram_rodata),
('diram_other', self.diram_other),
('diram_total', self.diram_total),
('used_diram', self.used_diram),
('used_diram_ratio', self.used_diram_ratio),
('diram_remain', self.diram_remain),
('flash_code', self.flash_code),
('flash_rodata', self.flash_rodata),
('flash_other', self.flash_other),
('used_flash_non_ram', self.used_flash_non_ram), # text/data in D/I RAM not included
('total_size', self.total_size) # bss not included
])
assert len(ret) == len(StructureForSummary.get_required_items())
return ret
def get_structure_for_target(segments: Dict, sections: Dict, target: str) -> StructureForSummary:
"""
Return StructureForSummary for specific target
"""
mem_regions = MemRegions(target)
segment_layout = mem_regions.fit_segments_into_regions(segments)
section_layout = mem_regions.fit_sections_into_regions(LinkingSections.filter_sections(sections))
current = StructureForSummary.get(segment_layout, section_layout)
return current
def get_summary(path: str, segments: Dict, sections: Dict, target: str, output_format: str='',
path_diff: str='', segments_diff: Optional[Dict]=None, sections_diff: Optional[Dict]=None,
target_diff: str='', print_suggestions: bool=True) -> str:
segments_diff = segments_diff or {}
sections_diff = sections_diff or {}
current = get_structure_for_target(segments, sections, target)
if path_diff:
diff_en = True
mem_regions_diff = MemRegions(target_diff)
segment_layout_diff = mem_regions_diff.fit_segments_into_regions(segments_diff)
section_layout_diff = mem_regions_diff.fit_sections_into_regions(LinkingSections.filter_sections(sections_diff))
reference = StructureForSummary.get(segment_layout_diff, section_layout_diff)
else:
diff_en = False
reference = StructureForSummary()
if output_format == 'json':
current_json_dic = current.get_dict()
if diff_en:
reference_json_dic = reference.get_dict()
diff_json_dic = collections.OrderedDict([
(k, v - reference_json_dic[k]) for k, v in current_json_dic.items()])
output = format_json(collections.OrderedDict([('current', current_json_dic),
('reference', reference_json_dic),
('diff', diff_json_dic),
]))
else:
output = format_json(current_json_dic)
else:
class LineDef(object):
def __init__(self, title: str, name: str) -> None:
self.title = title
self.name = name
def format_line(self) -> Tuple[str, str, str, str]:
return ('%16s: {%s:>7} bytes' % (self.title, self.name),
'{%s:>7}' % self.name,
'{%s:+}' % self.name,
'')
def format_line_csv(self) -> Tuple[str, str, str, str]:
return ('%s,{%s} bytes' % (self.title, self.name),
'{%s}' % self.name,
'{%s:+}' % self.name,
'')
class HeadLineDef(LineDef):
def __init__(self, title: str, name: str, remain: str, ratio: str, total: str, warning_message: str) -> None:
super(HeadLineDef, self).__init__(title, name)
self.remain = remain
self.ratio = ratio
self.total = total
self.warning_message = warning_message
def format_line(self) -> Tuple[str, str, str, str]:
return ('%-1s: {%s:>7} bytes ({%s:>7} remain, {%s:.1%%} used)%s' % (self.title, self.name, self.remain, self.ratio, self.warning_message),
'{%s:>7}' % self.name,
'{%s:+}' % self.name,
'({%s:>+7} remain, {%s:>+7} total)' % (self.remain, self.total))
def format_line_csv(self) -> Tuple[str, str, str, str]:
return ('%s,{%s} bytes ({%s} remain {%s:.1%%} used)%s' % (self.title, self.name, self.remain, self.ratio, self.warning_message),
'{%s}' % self.name,
'{%s:+}' % self.name,
'{%s} remain,{%s} total' % (self.remain, self.total))
class TotalLineDef(LineDef):
def format_line(self) -> Tuple[str, str, str, str]:
return ('%16s: {%s:>7} bytes (.bin may be padded larger)' % (self.title, self.name),
'{%s:>7}' % self.name,
'{%s:+}' % self.name,
'')
def format_line_csv(self) -> Tuple[str, str, str, str]:
return ('%s,{%s} bytes (.bin may be padded larger)' % (self.title, self.name),
'{%s}' % self.name,
'{%s:+}' % self.name,
'')
warning_message = ' Overflow detected!' + (' You can run idf.py size-files for more information.' if print_suggestions else '')
format_list = [
HeadLineDef('Used static DRAM', 'used_dram', remain='dram_remain', ratio='used_dram_ratio', total='dram_total',
warning_message=warning_message if current.get_dram_overflowed() else ''),
LineDef('.data size', 'dram_data'),
LineDef('.bss size', 'dram_bss'),
LineDef('.rodata size', 'dram_rodata'),
LineDef('DRAM other size', 'dram_other'),
HeadLineDef('Used static IRAM', 'used_iram', remain='iram_remain', ratio='used_iram_ratio', total='iram_total',
warning_message=warning_message if current.get_iram_overflowed() else ''),
LineDef('.text size', 'iram_text'),
LineDef('.vectors size', 'iram_vectors'),
HeadLineDef('Used stat D/IRAM', 'used_diram', remain='diram_remain', ratio='used_diram_ratio', total='diram_total',
warning_message=warning_message if current.get_diram_overflowed() else ''),
LineDef('.data size', 'diram_data'),
LineDef('.bss size', 'diram_bss'),
LineDef('.text size', 'diram_text'),
LineDef('.vectors size', 'diram_vectors'),
LineDef('.rodata size', 'diram_rodata'),
LineDef('other', 'diram_other'),
LineDef('Used Flash size ', 'used_flash_non_ram'),
LineDef('.text', 'flash_code'),
LineDef('.rodata', 'flash_rodata'),
TotalLineDef('Total image size', 'total_size')
]
current_dict = current.get_dict()
if diff_en:
reference_dict = reference.get_dict()
diff_dict = (current - reference).get_dict()
if output_format == 'csv':
line_format = '{},{},{},{}'
else:
line_format = '{:60}{:>15}{:>15} {}' # Width for a, b, c, d columns
def print_in_columns(a: str, b: Optional[str]='', c: Optional[str]='', d: Optional[str]='') -> str:
return line_format.format(a, b, c, d).rstrip() + os.linesep
output = ''
if diff_en:
if output_format == 'csv':
output += print_in_columns('','<CURRENT>:', '<REFERENCE>', 'Difference')
output += print_in_columns('File', path, path_diff, '<CURRENT> - <REFERENCE>')
else:
output += print_in_columns('<CURRENT> MAP file: ' + path)
output += print_in_columns('<REFERENCE> MAP file: ' + path_diff)
output += print_in_columns('Difference is counted as <CURRENT> - <REFERENCE>, ',
'i.e. a positive number means that <CURRENT> is larger.')
output += print_in_columns('Total sizes of <CURRENT>:', '<REFERENCE>', 'Difference')
for line in format_list:
if getattr(current, line.name) > 0 or getattr(reference, line.name) > 0 or line.name == 'total_size':
if output_format == 'csv':
main_string_format, reference_format, sign_format, main_diff_format = line.format_line_csv()
else:
main_string_format, reference_format, sign_format, main_diff_format = line.format_line()
output += print_in_columns(
main_string_format.format(**current_dict),
reference_format.format(**reference_dict),
sign_format.format(**diff_dict) if not sign_format.format(**diff_dict).startswith('+0') else '',
main_diff_format.format(**diff_dict))
else:
output += print_in_columns('Total sizes:')
for line in format_list:
if getattr(current, line.name) > 0 or line.name == 'total_size':
if output_format == 'csv':
main_string_format, _, _, _ = line.format_line_csv()
else:
main_string_format, _, _, _ = line.format_line()
output += print_in_columns(main_string_format.format(**current_dict))
return output
def sort_dict(non_sort_list: List) -> List:
'''
sort with keeping the order data, bss, other, iram, diram, ram_st_total, flash_text, flash_rodata, flash_total
'''
start_of_other = 0
props_sort = [] # type: List
props_elem = ['.data', '.bss', 'other', 'iram', 'diram', 'ram_st_total', 'flash.text', 'flash.rodata', 'flash', 'flash_total']
for i in props_elem:
for j in non_sort_list:
if i == 'other':
# remembering where 'other' will start
start_of_other = len(props_sort)
elif i in j and j not in props_sort:
props_sort.append(j)
for j in non_sort_list:
if j not in props_sort:
# add all item that fit in other in dict
props_sort.insert(start_of_other, j)
return props_sort
class StructureForDetailedSizes(object):
@staticmethod
def sizes_by_key(sections: SectionDict, key: str, include_padding: Optional[bool]=False) -> Dict[str, Dict[str, int]]:
""" Takes a dict of sections (from load_sections) and returns
a dict keyed by 'key' with aggregate output size information.
Key can be either "archive" (for per-archive data) or "file" (for per-file data) in the result.
"""
result = {} # type: Dict[str, Dict[str, int]]
for _, section in sections.items():
for s in section['sources']:
if not s[key] in result:
result[s[key]] = {}
archive = result[s[key]]
if not section['name'] in archive:
archive[section['name']] = 0
archive[section['name']] += s['size']
if include_padding:
archive[section['name']] += s['fill']
return result
@staticmethod
def get(sections: SectionDict, by_key: str) -> collections.OrderedDict:
"""
Get the detailed structure before using the filter to remove undesired sections,
to show entries without desired sections
"""
sizes = StructureForDetailedSizes.sizes_by_key(sections, by_key)
for key_name in sizes:
sizes[key_name] = LinkingSections.filter_sections(sizes[key_name])
s = []
for key, section_dict in sizes.items():
ram_st_total = sum([x[1] for x in section_dict.items() if not LinkingSections.in_section(x[0], 'flash')])
flash_total = sum([x[1] for x in section_dict.items() if not LinkingSections.in_section(x[0], 'bss')]) # type: int
section_dict['ram_st_total'] = ram_st_total
section_dict['flash_total'] = flash_total
sorted_dict = sorted(section_dict.items(), key=lambda elem: elem[0])
s.append((key, collections.OrderedDict(sorted_dict)))
s = sorted(s, key=lambda elem: elem[0])
# do a secondary sort in order to have consistent order (for diff-ing the output)
s = sorted(s, key=lambda elem: elem[1]['flash_total'], reverse=True)
return collections.OrderedDict(s)
def get_detailed_sizes(sections: Dict, key: str, header: str, output_format: str, sections_diff: Dict=None) -> str:
key_name_set = set()
current = StructureForDetailedSizes.get(sections, key)
for section_dict in current.values():
key_name_set.update(section_dict.keys())
if sections_diff:
reference = StructureForDetailedSizes.get(sections_diff, key)
for section_dict in reference.values():
key_name_set.update(section_dict.keys())
diff_en = True
else:
diff_en = False
key_name_list = list(key_name_set)
ordered_key_list, display_name_list = LinkingSections.get_display_name_order(key_name_list)
if output_format == 'json':
if diff_en:
diff_json_dic = collections.OrderedDict()
for name in sorted(list(frozenset(current.keys()) | frozenset(reference.keys()))):
cur_name_dic = current.get(name, {})
ref_name_dic = reference.get(name, {})
all_keys = sorted(list(frozenset(cur_name_dic.keys()) | frozenset(ref_name_dic.keys())))
diff_json_dic[name] = collections.OrderedDict([(k,
cur_name_dic.get(k, 0) -
ref_name_dic.get(k, 0)) for k in all_keys])
output = format_json(collections.OrderedDict([('current', current),
('reference', reference),
('diff', diff_json_dic),
]))
else:
output = format_json(current)
else:
def _get_header_format(disp_list: List=display_name_list, output_format: str='') -> str:
if output_format == 'csv':
return '{},' * (len(disp_list) - 1) + '{}' + os.linesep
len_list = [len(x) for x in disp_list]
len_list.insert(0, 24)
return ' '.join(['{:>%d}' % x for x in len_list]) + os.linesep
def _get_output(data: Dict[str, Dict[str, int]], selection: Collection, output_format: str,
key_list: List=ordered_key_list, disp_list: List=display_name_list) -> str:
header_format = _get_header_format(disp_list, output_format)
output = header_format.format(header, *disp_list)
for key, data_info in data.items():
if key not in selection:
continue
try:
_, key = key.split(':', 1)
# print subheadings for key of format archive:file
except ValueError:
# k remains the same
pass
def get_section_size(section_dict: Dict) -> Callable[[str], int]:
return lambda x: section_dict.get(x, 0)
section_size_list = map(get_section_size(section_dict=data_info), key_list)
output += header_format.format(key[:24], *(section_size_list))
return output
def _get_header_format_diff(disp_list: List=display_name_list, columns: bool=False, output_format: str='') -> str:
if output_format == 'csv':
if columns:
return '{},' * len(disp_list) + '{}' + os.linesep
# This makes sure that every archive in the header has 3 columns (curr, reference and diff)
return '{},,,' * len(disp_list) + '{}' + os.linesep
if columns:
len_list = (24, ) + (7, ) * 3 * len(disp_list)
return '|'.join(['{:>%d}' % x for x in len_list]) + os.linesep
len_list = (24, ) + (23, ) * len(disp_list)
return ' '.join(['{:>%d}' % x for x in len_list]) + os.linesep
def _get_output_diff(curr: Dict, ref: Dict, output_format: str, key_list: List=ordered_key_list, disp_list: List=display_name_list) -> str:
# First header without Current/Ref/Diff columns
header_format = _get_header_format_diff(columns=False, output_format=output_format)
output = header_format.format(header, *disp_list)
if output_format != 'csv':
f_print = ('-' * 23, '') * len(key_list)
f_print = f_print[0:len(key_list)]
header_line = header_format.format('', *f_print)
header_format = _get_header_format_diff(columns=True, output_format=output_format)
f_print = ('<C>', '<R>', '<C>-<R>') * len(key_list)
output += header_format.format('', *f_print)
output += header_line
line_format = header_format
else:
header_format = _get_header_format_diff(columns=True, output_format=output_format)
# When formatting with CSV we have 3 entries per key (curr, reference and diff)
f_print = ('<C>', '<R>', '<C>-<R>') * len(key_list) * 3
output += header_format.format('', *f_print)
line_format = '{},' * len(disp_list) * 3 + '{}' + os.linesep
for key, data_info in curr.items():
try:
v2 = ref[key]
except KeyError:
continue
try:
_, key = key.split(':', 1)
# print subheadings for key of format archive:file
except ValueError:
# k remains the same
pass
def _get_items(name: str, section_dict: Dict=data_info, section_dict_ref: Dict=v2) -> Tuple[str, str, str]:
a = section_dict.get(name, 0)
b = section_dict_ref.get(name, 0)
diff = a - b
# the sign is added here and not in line_format in order to be able to print empty strings
return (a or '', b or '', '' if diff == 0 else '{:+}'.format(diff))
x = [] # type: List[str]
for section in key_list:
x.extend(_get_items(section))
output += line_format.format(key[:24], *(x))
return output
output = 'Per-{} contributions to ELF file:{}'.format(key, os.linesep)
if diff_en:
output += _get_output_diff(current, reference, output_format)
in_current = frozenset(current.keys())
in_reference = frozenset(reference.keys())
only_in_current = in_current - in_reference
only_in_reference = in_reference - in_current
if len(only_in_current) > 0:
output += 'The following entries are present in <CURRENT> only:{}'.format(os.linesep)
output += _get_output(current, only_in_current, output_format)
if len(only_in_reference) > 0:
output += 'The following entries are present in <REFERENCE> only:{}'.format(os.linesep)
output += _get_output(reference, only_in_reference, output_format)
else:
output += _get_output(current, current, output_format)
return output
class StructureForArchiveSymbols(object):
@staticmethod
def get(archive: str, sections: Dict) -> Dict:
interested_sections = LinkingSections.filter_sections(sections)
result = dict([(t, {}) for t in interested_sections]) # type: Dict[str, Dict[str, int]]
for _, section in sections.items():
section_name = section['name']
if section_name not in interested_sections:
continue
for s in section['sources']:
if archive != s['archive']:
continue
s['sym_name'] = re.sub('(.text.|.literal.|.data.|.bss.|.rodata.)', '', s['sym_name'])
result[section_name][s['sym_name']] = result[section_name].get(s['sym_name'], 0) + s['size']
# build a new ordered dict of each section, where each entry is an ordereddict of symbols to sizes
section_symbols = collections.OrderedDict()
for t in sorted(list(interested_sections)):
s = sorted(result[t].items(), key=lambda k_v: str(k_v[0]))
# do a secondary sort in order to have consistent order (for diff-ing the output)
s = sorted(s, key=lambda k_v: int(k_v[1]), reverse=True)
section_symbols[t] = collections.OrderedDict(s)
return section_symbols
def get_archive_symbols(sections: Dict, archive: str, output_format: str, sections_diff: Dict=None) -> str:
diff_en = bool(sections_diff)
current = StructureForArchiveSymbols.get(archive, sections)
reference = StructureForArchiveSymbols.get(archive, sections_diff) if sections_diff else {}
if output_format == 'json':
if diff_en:
diff_json_dic = collections.OrderedDict()
for name in sorted(list(frozenset(current.keys()) | frozenset(reference.keys()))):
cur_name_dic = current.get(name, {})
ref_name_dic = reference.get(name, {})
all_keys = sorted(list(frozenset(cur_name_dic.keys()) | frozenset(ref_name_dic.keys())))
diff_json_dic[name] = collections.OrderedDict([(key,
cur_name_dic.get(key, 0) -
ref_name_dic.get(key, 0)) for key in all_keys])
output = format_json(collections.OrderedDict([('current', current),
('reference', reference),
('diff', diff_json_dic),
]))
else:
output = format_json(current)
else:
def _get_item_pairs(name: str, section: collections.OrderedDict) -> collections.OrderedDict:
return collections.OrderedDict([(key.replace(name + '.', ''), val) for key, val in section.items()])
def _get_max_len(symbols_dict: Dict) -> Tuple[int, int]:
# the lists have 0 in them because max() doesn't work with empty lists
names_max_len = 0
numbers_max_len = 0
for t, s in symbols_dict.items():
numbers_max_len = max([numbers_max_len, *[len(str(x)) for _, x in s.items()]])
names_max_len = max([names_max_len, *[len(x) for x in _get_item_pairs(t, s)]])
return names_max_len, numbers_max_len
def _get_output(section_symbols: Dict) -> str:
output = ''
names_max_len, numbers_max_len = _get_max_len(section_symbols)
if output_format == 'csv':
line_format = '{},{}' + os.linesep
else:
line_format = ' {:<%d} : {:>%d}' % (names_max_len,numbers_max_len) + os.linesep
for t, s in section_symbols.items():
output += '{}Symbols from section: {}{}'.format(os.linesep, t, os.linesep)
item_pairs = _get_item_pairs(t, s)
for key, val in item_pairs.items():
output += line_format.format(key, val)
section_total = sum([val for _, val in item_pairs.items()])
output += 'Section total: {}{}'.format(section_total, os.linesep)
return output
output = '{}Symbols within the archive: {} (Not all symbols may be reported){}'.format(os.linesep, archive, os.linesep)
if diff_en:
def _generate_line_tuple(curr: collections.OrderedDict, ref: collections.OrderedDict, name: str, indent: str) -> Tuple[str, int, int, str]:
cur_val = curr.get(name, 0)
ref_val = ref.get(name, 0)
diff_val = cur_val - ref_val
# string slicing is used just to make sure it will fit into the first column of line_format
return ((indent + name)[:40], cur_val, ref_val, '' if diff_val == 0 else '{:+}'.format(diff_val))
if output_format == 'csv':
line_format = '{},{},{},{}'
else:
line_format = '{:40} {:>12} {:>12} {:>25}'
all_section_names = sorted(list(frozenset(current.keys()) | frozenset(reference.keys())))
for section_name in all_section_names:
current_item_pairs = _get_item_pairs(section_name, current.get(section_name, {}))
reference_item_pairs = _get_item_pairs(section_name, reference.get(section_name, {}))
output += os.linesep + line_format.format(section_name[:40],
'<CURRENT>',
'<REFERENCE>',
'<CURRENT> - <REFERENCE>') + os.linesep
current_section_total = sum([val for _, val in current_item_pairs.items()])
reference_section_total = sum([val for _, val in reference_item_pairs.items()])
diff_section_total = current_section_total - reference_section_total
all_item_names = sorted(list(frozenset(current_item_pairs.keys()) |
frozenset(reference_item_pairs.keys())))
indent = 4 * ' ' if output_format != 'csv' else ''
output += os.linesep.join(line_format.format(*_generate_line_tuple(current_item_pairs,
reference_item_pairs,
n,
indent)
).rstrip() for n in all_item_names)
output += os.linesep if current_section_total > 0 or reference_section_total > 0 else ''
output += line_format.format('Section total:',
current_section_total,
reference_section_total,
'' if diff_section_total == 0 else '{:+}'.format(diff_section_total)
).rstrip() + os.linesep
else:
output += _get_output(current)
return output
if __name__ == '__main__':
main()