granicus.if.org Git - esp-idf/blob - tools/idf_size.py

   1 #!/usr/bin/env python
   2 #
   3 # esp-idf alternative to "size" to print ELF file sizes, also analyzes
   4 # the linker map file to dump higher resolution details.
   5 #
   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.
   8 #
   9 # Copyright 2017-2018 Espressif Systems (Shanghai) PTE LTD
  10 #
  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
  14 #
  15 #     http://www.apache.org/licenses/LICENSE-2.0
  16 #
  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.
  22 #
  23 from __future__ import print_function
  24 from __future__ import unicode_literals
  25 from builtins import dict
  26 import argparse, sys, subprocess, re
  27 import os.path
  28 import pprint
  29 import operator
  30
  31 DEFAULT_TOOLCHAIN_PREFIX = "xtensa-esp32-elf-"
  32
  33 CHIP_SIZES = {
  34     "esp32" : {
  35         "total_iram" : 0x20000,
  36         "total_irom" : 0x330000,
  37         "total_drom" : 0x800000,
  38         # total dram is determined from objdump output
  39     }
  40 }
  41
  42 def scan_to_header(f, header_line):
  43     """ Scan forward in a file until you reach 'header_line', then return """
  44     for line in f:
  45         if line.strip() == header_line:
  46             return
  47     raise RuntimeError("Didn't find line '%s' in file" % header_line)
  48
  49 def load_map_data(map_file):
  50     memory_config = load_memory_config(map_file)
  51     sections  = load_sections(map_file)
  52     return memory_config, sections
  53
  54 def load_memory_config(map_file):
  55     """ Memory Configuration section is the total size of each output section """
  56     result = {}
  57     scan_to_header(map_file, "Memory Configuration")
  58     RE_MEMORY_SECTION = r"(?P<name>[^ ]+) +0x(?P<origin>[\da-f]+) +0x(?P<length>[\da-f]+)"
  59     for line in map_file:
  60         m = re.match(RE_MEMORY_SECTION, line)
  61         if m is None:
  62             if len(result) == 0:
  63                 continue  # whitespace or a header, before the content we want
  64             else:
  65                 return result  # we're at the end of the Memory Configuration
  66         section = {
  67             "name" : m.group("name"),
  68             "origin" : int(m.group("origin"), 16),
  69             "length" : int(m.group("length"), 16),
  70         }
  71         if section["name"] != "*default*":
  72             result[section["name"]] = section
  73     raise RuntimeError("End of file while scanning memory configuration?")
  74
  75 def load_sections(map_file):
  76     """ Load section size information from the MAP file.
  77
  78     Returns a dict of 'sections', where each key is a section name and the value
  79     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.
  80     """
  81     scan_to_header(map_file, "Linker script and memory map")
  82     sections = {}
  83     section = None
  84     sym_backup = None
  85     for line in map_file:
  86         # output section header, ie '.iram0.text     0x0000000040080400    0x129a5'
  87         RE_SECTION_HEADER = r"(?P<name>[^ ]+) +0x(?P<address>[\da-f]+) +0x(?P<size>[\da-f]+)$"
  88         m = re.match(RE_SECTION_HEADER, line)
  89         if m is not None:  # start of a new section
  90             section = {
  91                 "name" : m.group("name"),
  92                 "address" : int(m.group("address"), 16),
  93                 "size" : int(m.group("size"), 16),
  94                 "sources" : [],
  95             }
  96             sections[section["name"]] = section
  97             continue
  98
  99         # source file line, ie
 100         # 0x0000000040080400       0xa4 /home/gus/esp/32/idf/examples/get-started/hello_world/build/esp32/libesp32.a(cpu_start.o)
 101         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>.+\.ob?j?)\)"
 102
 103         m = re.match(RE_SOURCE_LINE, line, re.M)
 104         if not m:
 105             # cmake build system links some object files directly, not part of any archive
 106             RE_SOURCE_LINE = r"\s*(?P<sym_name>\S*).* +0x(?P<address>[\da-f]+) +0x(?P<size>[\da-f]+) (?P<object_file>.+\.ob?j?)"
 107             m = re.match(RE_SOURCE_LINE, line)
 108         if section is not None and m is not None:  # input source file details=ma,e
 109             sym_name = m.group("sym_name") if len(m.group("sym_name")) > 0 else sym_backup
 110             try:
 111                 archive = m.group("archive")
 112             except IndexError:
 113                 archive = "(exe)"
 114
 115             source = {
 116                 "size" : int(m.group("size"), 16),
 117                 "address" : int(m.group("address"), 16),
 118                 "archive" : os.path.basename(archive),
 119                 "object_file" : os.path.basename(m.group("object_file")),
 120                 "sym_name" : sym_name,
 121             }
 122             source["file"] = "%s:%s" % (source["archive"], source["object_file"])
 123             section["sources"] += [ source ]
 124
 125         # In some cases the section name appears on the previous line, back it up in here
 126         RE_SYMBOL_ONLY_LINE = r"^ (?P<sym_name>\S*)$"
 127         m = re.match(RE_SYMBOL_ONLY_LINE, line)
 128         if section is not None and m is not None:
 129             sym_backup = m.group("sym_name")
 130
 131     return sections
 132
 133 def sizes_by_key(sections, key):
 134     """ Takes a dict of sections (from load_sections) and returns
 135     a dict keyed by 'key' with aggregate output size information.
 136
 137     Key can be either "archive" (for per-archive data) or "file" (for per-file data) in the result.
 138     """
 139     result = {}
 140     for section in sections.values():
 141         for s in section["sources"]:
 142             if not s[key] in result:
 143                 result[s[key]] = {}
 144             archive = result[s[key]]
 145             if not section["name"] in archive:
 146                 archive[section["name"]] = 0
 147             archive[section["name"]] += s["size"]
 148     return result
 149
 150 def main():
 151     parser = argparse.ArgumentParser("idf_size - a tool to print IDF elf file sizes")
 152
 153     parser.add_argument(
 154         '--toolchain-prefix',
 155         help="Triplet prefix to add before objdump executable",
 156         default=DEFAULT_TOOLCHAIN_PREFIX)
 157
 158     parser.add_argument(
 159         'map_file', help='MAP file produced by linker',
 160         type=argparse.FileType('r'))
 161
 162     parser.add_argument(
 163         '--archives', help='Print per-archive sizes', action='store_true')
 164
 165     parser.add_argument(
 166         '--archive_details', help='Print detailed symbols per archive')
 167
 168     parser.add_argument(
 169         '--files', help='Print per-file sizes', action='store_true')
 170
 171     args = parser.parse_args()
 172
 173     memory_config, sections = load_map_data(args.map_file)
 174     print_summary(memory_config, sections)
 175
 176     if args.archives:
 177         print("Per-archive contributions to ELF file:")
 178         print_detailed_sizes(sections, "archive", "Archive File")
 179     if args.files:
 180         print("Per-file contributions to ELF file:")
 181         print_detailed_sizes(sections, "file", "Object File")
 182     if args.archive_details:
 183         print("Symbols within the archive:", args.archive_details, "(Not all symbols may be reported)")
 184         print_archive_symbols(sections, args.archive_details)
 185
 186 def print_summary(memory_config, sections):
 187     def get_size(section):
 188         try:
 189             return sections[section]["size"]
 190         except KeyError:
 191             return 0
 192
 193     # if linker script changes, these need to change
 194     total_iram = memory_config["iram0_0_seg"]["length"]
 195     total_dram = memory_config["dram0_0_seg"]["length"]
 196     used_data = get_size(".dram0.data")
 197     used_bss = get_size(".dram0.bss")
 198     used_dram = used_data + used_bss
 199     used_iram = sum( get_size(s) for s in sections if s.startswith(".iram0") )
 200     flash_code = get_size(".flash.text")
 201     flash_rodata = get_size(".flash.rodata")
 202     total_size = used_data + used_iram + flash_code + flash_rodata
 203
 204     print("Total sizes:")
 205     print(" DRAM .data size: %7d bytes" % used_data)
 206     print(" DRAM .bss  size: %7d bytes" % used_bss)
 207     print("Used static DRAM: %7d bytes (%7d available, %.1f%% used)" %
 208           (used_dram, total_dram - used_dram,
 209            100.0 * used_dram / total_dram))
 210     print("Used static IRAM: %7d bytes (%7d available, %.1f%% used)" %
 211           (used_iram, total_iram - used_iram,
 212            100.0 * used_iram / total_iram))
 213     print("      Flash code: %7d bytes" % flash_code)
 214     print("    Flash rodata: %7d bytes" % flash_rodata)
 215     print("Total image size:~%7d bytes (.bin may be padded larger)" % (total_size))
 216
 217 def print_detailed_sizes(sections, key, header):
 218     sizes = sizes_by_key(sections, key)
 219
 220     sub_heading = None
 221     headings = (header,
 222                 "DRAM .data",
 223                 "& .bss",
 224                 "IRAM",
 225                 "Flash code",
 226                 "& rodata",
 227                 "Total")
 228     print("%24s %10s %6s %6s %10s %8s %7s" % headings)
 229     result = {}
 230     for k in sizes:
 231         v = sizes[k]
 232         result[k] = {}
 233         result[k]["data"] = v.get(".dram0.data", 0)
 234         result[k]["bss"] = v.get(".dram0.bss", 0)
 235         result[k]["iram"] = sum(t for (s,t) in v.items() if s.startswith(".iram0"))
 236         result[k]["flash_text"] = v.get(".flash.text", 0)
 237         result[k]["flash_rodata"] = v.get(".flash.rodata", 0)
 238         result[k]["total"] = sum(result[k].values())
 239
 240     def return_total_size(elem):
 241         val = elem[1]
 242         return val["total"]
 243     def return_header(elem):
 244         return elem[0]
 245     s = sorted(list(result.items()), key=return_header)
 246     # do a secondary sort in order to have consistent order (for diff-ing the output)
 247     for k,v in sorted(s, key=return_total_size, reverse=True):
 248         if ":" in k:  # print subheadings for key of format archive:file
 249             sh,k = k.split(":")
 250         print("%24s %10d %6d %6d %10d %8d %7d" % (k[:24],
 251                                                   v["data"],
 252                                                   v["bss"],
 253                                                   v["iram"],
 254                                                   v["flash_text"],
 255                                                   v["flash_rodata"],
 256                                                   v["total"]))
 257
 258 def print_archive_symbols(sections, archive):
 259     interested_sections = [".dram0.data", ".dram0.bss", ".iram0.text", ".iram0.vectors", ".flash.text", ".flash.rodata"]
 260     result = {}
 261     for t in interested_sections:
 262         result[t] = {}
 263     for section in sections.values():
 264         section_name = section["name"]
 265         if section_name not in interested_sections:
 266             continue
 267         for s in section["sources"]:
 268             if archive != s["archive"]:
 269                 continue
 270             s["sym_name"] = re.sub("(.text.|.literal.|.data.|.bss.|.rodata.)", "", s["sym_name"]);
 271             result[section_name][s["sym_name"]] = result[section_name].get(s["sym_name"], 0) + s["size"]
 272     for t in interested_sections:
 273         print("\nSymbols from section:", t)
 274         section_total = 0
 275         s = sorted(list(result[t].items()), key=lambda k_v: k_v[0])
 276         # do a secondary sort in order to have consistent order (for diff-ing the output)
 277         for key,val in sorted(s, key=lambda k_v: k_v[1], reverse=True):
 278             print(("%s(%d)"% (key.replace(t + ".", ""), val)), end=' ')
 279             section_total += val
 280         print("\nSection total:",section_total)
 281
 282 if __name__ == "__main__":
 283     main()
 284