3 # esp-idf alternative to "size" to print ELF file sizes, also analyzes
4 # the linker map file to dump higher resolution details.
6 # Includes information which is not shown in "xtensa-esp32-elf-size",
7 # or easy to parse from "xtensa-esp32-elf-objdump" or raw map files.
9 # Copyright 2017 Espressif Systems (Shanghai) PTE LTD
11 # Licensed under the Apache License, Version 2.0 (the "License");
12 # you may not use this file except in compliance with the License.
13 # You may obtain a copy of the License at
15 # http://www.apache.org/licenses/LICENSE-2.0
17 # Unless required by applicable law or agreed to in writing, software
18 # distributed under the License is distributed on an "AS IS" BASIS,
19 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20 # See the License for the specific language governing permissions and
21 # limitations under the License.
23 import argparse, sys, subprocess, re
28 DEFAULT_TOOLCHAIN_PREFIX = "xtensa-esp32-elf-"
32 "total_iram" : 0x20000,
33 "total_irom" : 0x330000,
34 "total_drom" : 0x800000,
35 # total dram is determined from objdump output
39 def scan_to_header(f, header_line):
40 """ Scan forward in a file until you reach 'header_line', then return """
42 if line.strip() == header_line:
44 raise RuntimeError("Didn't find line '%s' in file" % header_line)
46 def load_map_data(map_file):
47 memory_config = load_memory_config(map_file)
48 sections = load_sections(map_file)
49 return memory_config, sections
51 def output_section_for_address(memory_config, address):
52 for m in memory_config.values():
53 if m["origin"] <= address and m["origin"] + m["length"] > address:
57 def load_memory_config(map_file):
58 """ Memory Configuration section is the total size of each output section """
60 scan_to_header(map_file, "Memory Configuration")
61 RE_MEMORY_SECTION = r"(?P<name>[^ ]+) +0x(?P<origin>[\da-f]+) +0x(?P<length>[\da-f]+)"
63 m = re.match(RE_MEMORY_SECTION, line)
66 continue # whitespace or a header, before the content we want
68 return result # we're at the end of the Memory Configuration
70 "name" : m.group("name"),
71 "origin" : int(m.group("origin"), 16),
72 "length" : int(m.group("length"), 16),
74 if section["name"] != "*default*":
75 result[section["name"]] = section
76 raise RuntimeError("End of file while scanning memory configuration?")
78 def load_sections(map_file):
79 """ Load section size information from the MAP file.
81 Returns a dict of 'sections', where each key is a section name and the value
82 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.
84 scan_to_header(map_file, "Linker script and memory map")
85 scan_to_header(map_file, "END GROUP")
90 # output section header, ie '.iram0.text 0x0000000040080400 0x129a5'
91 RE_SECTION_HEADER = r"(?P<name>[^ ]+) +0x(?P<address>[\da-f]+) +0x(?P<size>[\da-f]+)$"
92 m = re.match(RE_SECTION_HEADER, line)
93 if m is not None: # start of a new section
95 "name" : m.group("name"),
96 "address" : int(m.group("address"), 16),
97 "size" : int(m.group("size"), 16),
100 sections[section["name"]] = section
103 # source file line, ie
104 # 0x0000000040080400 0xa4 /home/gus/esp/32/idf/examples/get-started/hello_world/build/esp32/libesp32.a(cpu_start.o)
105 RE_SOURCE_LINE = r"\s*(?P<sym_name>\S*).* +0x(?P<address>[\da-f]+) +0x(?P<size>[\da-f]+) (?P<archive>.+\.a)\((?P<object_file>.+\.o)\)"
107 m = re.match(RE_SOURCE_LINE, line, re.M)
108 if section is not None and m is not None: # input source file details
109 sym_name = m.group("sym_name") if len(m.group("sym_name")) > 0 else sym_backup
111 "size" : int(m.group("size"), 16),
112 "address" : int(m.group("address"), 16),
113 "archive" : os.path.basename(m.group("archive")),
114 "object_file" : m.group("object_file"),
115 "sym_name" : sym_name,
117 source["file"] = "%s:%s" % (source["archive"], source["object_file"])
118 section["sources"] += [ source ]
120 # In some cases the section name appears on the previous line, back it up in here
121 RE_SYMBOL_ONLY_LINE = r"^ (?P<sym_name>\S*)$"
122 m = re.match(RE_SYMBOL_ONLY_LINE, line)
123 if section is not None and m is not None:
124 sym_backup = m.group("sym_name")
128 def sizes_by_key(sections, key):
129 """ Takes a dict of sections (from load_sections) and returns
130 a dict keyed by 'key' with aggregate output size information.
132 Key can be either "archive" (for per-archive data) or "file" (for per-file data) in the result.
135 for section in sections.values():
136 for s in section["sources"]:
137 if not s[key] in result:
139 archive = result[s[key]]
140 if not section["name"] in archive:
141 archive[section["name"]] = 0
142 archive[section["name"]] += s["size"]
146 parser = argparse.ArgumentParser("idf_size - a tool to print IDF elf file sizes")
149 '--toolchain-prefix',
150 help="Triplet prefix to add before objdump executable",
151 default=DEFAULT_TOOLCHAIN_PREFIX)
154 'map_file', help='MAP file produced by linker',
155 type=argparse.FileType('r'))
158 '--archives', help='Print per-archive sizes', action='store_true')
161 '--archive_details', help='Print detailed symbols per archive')
164 '--files', help='Print per-file sizes', action='store_true')
166 args = parser.parse_args()
168 memory_config, sections = load_map_data(args.map_file)
169 print_summary(memory_config, sections)
172 print("Per-archive contributions to ELF file:")
173 print_detailed_sizes(sections, "archive", "Archive File")
175 print("Per-file contributions to ELF file:")
176 print_detailed_sizes(sections, "file", "Object File")
177 if args.archive_details:
178 print "Symbols within the archive:", args.archive_details, "(Not all symbols may be reported)"
179 print_archive_symbols(sections, args.archive_details)
181 def print_summary(memory_config, sections):
182 def get_size(section):
184 return sections[section]["size"]
188 # if linker script changes, these need to change
189 total_iram = memory_config["iram0_0_seg"]["length"]
190 total_dram = memory_config["dram0_0_seg"]["length"]
191 used_data = get_size(".dram0.data")
192 used_bss = get_size(".dram0.bss")
193 used_dram = used_data + used_bss
194 used_iram = sum( get_size(s) for s in sections.keys() if s.startswith(".iram0") )
195 flash_code = get_size(".flash.text")
196 flash_rodata = get_size(".flash.rodata")
197 total_size = used_data + used_iram + flash_code + flash_rodata
199 print("Total sizes:")
200 print(" DRAM .data size: %7d bytes" % used_data)
201 print(" DRAM .bss size: %7d bytes" % used_bss)
202 print("Used static DRAM: %7d bytes (%7d available, %.1f%% used)" %
203 (used_dram, total_dram - used_dram,
204 100.0 * used_dram / total_dram))
205 print("Used static IRAM: %7d bytes (%7d available, %.1f%% used)" %
206 (used_iram, total_iram - used_iram,
207 100.0 * used_iram / total_iram))
208 print(" Flash code: %7d bytes" % flash_code)
209 print(" Flash rodata: %7d bytes" % flash_rodata)
210 print("Total image size:~%7d bytes (.bin may be padded larger)" % (total_size))
212 def print_detailed_sizes(sections, key, header):
213 sizes = sizes_by_key(sections, key)
223 print("%24s %10s %6s %6s %10s %8s %7s" % headings)
225 for k in (sizes.keys()):
228 result[k]["data"] = v.get(".dram0.data", 0)
229 result[k]["bss"] = v.get(".dram0.bss", 0)
230 result[k]["iram"] = sum(t for (s,t) in v.items() if s.startswith(".iram0"))
231 result[k]["flash_text"] = v.get(".flash.text", 0)
232 result[k]["flash_rodata"] = v.get(".flash.rodata", 0)
233 result[k]["total"] = sum(result[k].values())
235 def return_total_size(elem):
238 for k,v in sorted(result.items(), key=return_total_size, reverse=True):
239 if ":" in k: # print subheadings for key of format archive:file
241 print("%24s %10d %6d %6d %10d %8d %7d" % (k[:24],
249 def print_archive_symbols(sections, archive):
250 interested_sections = [".dram0.data", ".dram0.bss", ".iram0.text", ".iram0.vectors", ".flash.text", ".flash.rodata"]
252 for t in interested_sections:
254 for section in sections.values():
255 section_name = section["name"]
256 if section_name not in interested_sections:
258 for s in section["sources"]:
259 if archive != s["archive"]:
261 s["sym_name"] = re.sub("(.text.|.literal.|.data.|.bss.|.rodata.)", "", s["sym_name"]);
262 result[section_name][s["sym_name"]] = result[section_name].get(s["sym_name"], 0) + s["size"]
263 for t in interested_sections:
264 print "\nSymbols from section:", t
266 for key,val in sorted(result[t].items(), key=lambda (k,v): v, reverse=True):
267 print("%s(%d)"% (key.replace(t + ".", ""), val)),
269 print "\nSection total:",section_total
271 if __name__ == "__main__":