ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #5775 from theotherjimmy/pathsep-memap 

Correct memap path handling on windows
pull/5732/merge
Jimmy Brisson 2018-01-08 10:37:25 -06:00 committed by GitHub
parent 24b0387500 d94776f909
commit e301a5b746
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 258 additions and 247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

436
tools/memap.py
View File

@ -2,89 +2,42 @@
"""Memory Map File Analyser for ARM mbed""" """Memory Map File Analyser for ARM mbed"""
import sys from abc import abstractmethod, ABCMeta
import os from sys import stdout, exit, argv
from os import sep
from os.path import basename, dirname, join, relpath, commonprefix
import re import re
import csv import csv
import json import json
import argparse from argparse import ArgumentParser
from copy import deepcopy from copy import deepcopy
from prettytable import PrettyTable from prettytable import PrettyTable
from utils import argparse_filestring_type, \ from utils import argparse_filestring_type, \
argparse_lowercase_hyphen_type, argparse_uppercase_type argparse_lowercase_hyphen_type, argparse_uppercase_type
RE_ARMCC = re.compile(
r'^\s+0x(\w{8})\s+0x(\w{8})\s+(\w+)\s+(\w+)\s+(\d+)\s+[*]?.+\s+(.+)$')
RE_IAR = re.compile(
r'^\s+(.+)\s+(zero|const|ro code|inited|uninit)\s'
r'+0x(\w{8})\s+0x(\w+)\s+(.+)\s.+$')
RE_CMDLINE_FILE_IAR = re.compile(r'^#\s+(.+\.o)') class _Parser(object):
RE_LIBRARY_IAR = re.compile(r'^(.+\.a)\:.+$') """Internal interface for parsing"""
RE_OBJECT_LIBRARY_IAR = re.compile(r'^\s+(.+\.o)\s.*') __metaclass__ = ABCMeta
SECTIONS = ('.text', '.data', '.bss', '.heap', '.stack')
RE_OBJECT_FILE_GCC = re.compile(r'^(.+\/.+\.o)$') MISC_FLASH_SECTIONS = ('.interrupts', '.flash_config')
RE_LIBRARY_OBJECT_GCC = re.compile(r'^.+\/lib(.+\.a)\((.+\.o)\)$') OTHER_SECTIONS = ('.interrupts_ram', '.init', '.ARM.extab',
RE_STD_SECTION_GCC = re.compile(r'^\s+.*0x(\w{8,16})\s+0x(\w+)\s(.+)$')
RE_FILL_SECTION_GCC = re.compile(r'^\s*\*fill\*\s+0x(\w{8,16})\s+0x(\w+).*$')
RE_OBJECT_ARMCC = re.compile(r'(.+\.(l|ar))\((.+\.o)\)')
class MemapParser(object):
"""An object that represents parsed results, parses the memory map files,
and writes out different file types of memory results
"""
print_sections = ('.text', '.data', '.bss')
misc_flash_sections = ('.interrupts', '.flash_config')
other_sections = ('.interrupts_ram', '.init', '.ARM.extab',
'.ARM.exidx', '.ARM.attributes', '.eh_frame', '.ARM.exidx', '.ARM.attributes', '.eh_frame',
'.init_array', '.fini_array', '.jcr', '.stab', '.init_array', '.fini_array', '.jcr', '.stab',
'.stabstr', '.ARM.exidx', '.ARM') '.stabstr', '.ARM.exidx', '.ARM')
# sections to print info (generic for all toolchains)
sections = ('.text', '.data', '.bss', '.heap', '.stack')
def __init__(self): def __init__(self):
""" General initialization self.modules = dict()
"""
# list of all modules and their sections
self.modules = dict() # full list - doesn't change with depth
self.short_modules = dict() # short version with specific depth
# sections must be defined in this order to take irrelevant out
self.all_sections = self.sections + self.other_sections + \
self.misc_flash_sections + ('unknown', 'OUTPUT')
# Memory report (sections + summary)
self.mem_report = []
# Just the memory summary section
self.mem_summary = dict()
self.subtotal = dict()
self.misc_flash_mem = 0
# Modules passed to the linker on the command line
# this is a dict because modules are looked up by their basename
self.cmd_modules = {}
def module_add(self, object_name, size, section): def module_add(self, object_name, size, section):
""" Adds a module / section to the list """ Adds a module or section to the list
Positional arguments: Positional arguments:
object_name - name of the entry to add object_name - name of the entry to add
size - the size of the module being added size - the size of the module being added
section - the section the module contributes to section - the section the module contributes to
""" """
if not object_name or not size or not section: if not object_name or not size or not section:
return return
@ -93,7 +46,7 @@ class MemapParser(object):
self.modules[object_name][section] += size self.modules[object_name][section] += size
return return
obj_split = os.sep + os.path.basename(object_name) obj_split = sep + basename(object_name)
for module_path, contents in self.modules.items(): for module_path, contents in self.modules.items():
if module_path.endswith(obj_split) or module_path == object_name: if module_path.endswith(obj_split) or module_path == object_name:
contents.setdefault(section, 0) contents.setdefault(section, 0)
@ -110,15 +63,38 @@ class MemapParser(object):
self.modules[new_object] = self.modules[old_object] self.modules[new_object] = self.modules[old_object]
del self.modules[old_object] del self.modules[old_object]
def check_new_section_gcc(self, line): @abstractmethod
""" Check whether a new section in a map file has been detected (only def parse_mapfile(self, mapfile):
applies to gcc) """Parse a given file object pointing to a map file
Positional arguments:
mapfile - an open file object that reads a map file
return value - a dict mapping from object names to section dicts,
where a section dict maps from sections to sizes
"""
raise NotImplemented
class _GccParser(_Parser):
RE_OBJECT_FILE = re.compile(r'^(.+\/.+\.o)$')
RE_LIBRARY_OBJECT = re.compile(r'^.+' + sep + r'lib((.+\.a)\((.+\.o)\))$')
RE_STD_SECTION = re.compile(r'^\s+.*0x(\w{8,16})\s+0x(\w+)\s(.+)$')
RE_FILL_SECTION = re.compile(r'^\s*\*fill\*\s+0x(\w{8,16})\s+0x(\w+).*$')
ALL_SECTIONS = _Parser.SECTIONS + _Parser.OTHER_SECTIONS + \
_Parser.MISC_FLASH_SECTIONS + ('unknown', 'OUTPUT')
def check_new_section(self, line):
""" Check whether a new section in a map file has been detected
Positional arguments: Positional arguments:
line - the line to check for a new section line - the line to check for a new section
"""
for i in self.all_sections: return value - A section name, if a new section was found, False
otherwise
"""
for i in self.ALL_SECTIONS:
if line.startswith(i): if line.startswith(i):
# should name of the section (assuming it's a known one) # should name of the section (assuming it's a known one)
return i return i
@ -129,72 +105,65 @@ class MemapParser(object):
return False # everything else, means no change in section return False # everything else, means no change in section
def parse_object_name_gcc(self, line): def parse_object_name(self, line):
""" Parse a path to object file """ Parse a path to object file
Positional arguments: Positional arguments:
txt - the path to parse the object and module name from line - the path to parse the object and module name from
"""
line = line.replace('\\', '/') return value - an object file name
test_re_mbed_os_name = re.match(RE_OBJECT_FILE_GCC, line) """
test_re_mbed_os_name = re.match(self.RE_OBJECT_FILE, line)
if test_re_mbed_os_name: if test_re_mbed_os_name:
object_name = test_re_mbed_os_name.group(1) object_name = test_re_mbed_os_name.group(1)
# corner case: certain objects are provided by the GCC toolchain # corner case: certain objects are provided by the GCC toolchain
if 'arm-none-eabi' in line: if 'arm-none-eabi' in line:
return '[lib]/misc/' + object_name return join('[lib]', 'misc', basename(object_name))
return object_name return object_name
else: else:
test_re_obj_name = re.match(self.RE_LIBRARY_OBJECT, line)
test_re_obj_name = re.match(RE_LIBRARY_OBJECT_GCC, line)
if test_re_obj_name: if test_re_obj_name:
object_name = test_re_obj_name.group(1) + '/' + \ return join('[lib]', test_re_obj_name.group(2),
test_re_obj_name.group(2) test_re_obj_name.group(3))
return '[lib]/' + object_name
else: else:
print "Unknown object name found in GCC map file: %s" % line print "Unknown object name found in GCC map file: %s" % line
return '[misc]' return '[misc]'
def parse_section_gcc(self, line): def parse_section(self, line):
""" Parse data from a section of gcc map file """ Parse data from a section of gcc map file
examples: examples:
0x00004308 0x7c ./BUILD/K64F/GCC_ARM/mbed-os/hal/targets/hal/TARGET_Freescale/TARGET_KPSDK_MCUS/spi_api.o 0x00004308 0x7c ./BUILD/K64F/GCC_ARM/mbed-os/hal/targets/hal/TARGET_Freescale/TARGET_KPSDK_MCUS/spi_api.o
.text 0x00000608 0x198 ./BUILD/K64F/GCC_ARM/mbed-os/core/mbed-rtos/rtx/TARGET_CORTEX_M/TARGET_RTOS_M4_M7/TOOLCHAIN_GCC/HAL_CM4.o .text 0x00000608 0x198 ./BUILD/K64F/GCC_ARM/mbed-os/core/mbed-rtos/rtx/TARGET_CORTEX_M/TARGET_RTOS_M4_M7/TOOLCHAIN/HAL_CM4.o
Positional arguments: Positional arguments:
line - the line to parse a section from line - the line to parse a section from
""" """
is_fill = re.match(self.RE_FILL_SECTION, line)
is_fill = re.match(RE_FILL_SECTION_GCC, line)
if is_fill: if is_fill:
o_name = '[fill]' o_name = '[fill]'
o_size = int(is_fill.group(2), 16) o_size = int(is_fill.group(2), 16)
return [o_name, o_size] return [o_name, o_size]
is_section = re.match(RE_STD_SECTION_GCC, line) is_section = re.match(self.RE_STD_SECTION, line)
if is_section: if is_section:
o_size = int(is_section.group(2), 16) o_size = int(is_section.group(2), 16)
if o_size: if o_size:
o_name = self.parse_object_name_gcc(is_section.group(3)) o_name = self.parse_object_name(is_section.group(3))
return [o_name, o_size] return [o_name, o_size]
return ["", 0] return ["", 0]
def parse_map_file_gcc(self, file_desc): def parse_mapfile(self, file_desc):
""" Main logic to decode gcc map files """ Main logic to decode gcc map files
Positional arguments: Positional arguments:
file_desc - a stream object to parse as a gcc map file file_desc - a stream object to parse as a gcc map file
""" """
current_section = 'unknown' current_section = 'unknown'
with file_desc as infile: with file_desc as infile:
@ -204,101 +173,141 @@ class MemapParser(object):
break break
for line in infile: for line in infile:
next_section = self.check_new_section_gcc(line) next_section = self.check_new_section(line)
if next_section == "OUTPUT": if next_section == "OUTPUT":
break break
elif next_section: elif next_section:
current_section = next_section current_section = next_section
object_name, object_size = self.parse_section_gcc(line) object_name, object_size = self.parse_section(line)
self.module_add(object_name, object_size, current_section) self.module_add(object_name, object_size, current_section)
common_prefix = os.path.dirname(os.path.commonprefix([ common_prefix = dirname(commonprefix([
o for o in self.modules.keys() if (o.endswith(".o") and not o.startswith("[lib]"))])) o for o in self.modules.keys() if (o.endswith(".o") and not o.startswith("[lib]"))]))
new_modules = {} new_modules = {}
for name, stats in self.modules.items(): for name, stats in self.modules.items():
if name.startswith("[lib]"): if name.startswith("[lib]"):
new_modules[name] = stats new_modules[name] = stats
elif name.endswith(".o"): elif name.endswith(".o"):
new_modules[os.path.relpath(name, common_prefix)] = stats new_modules[relpath(name, common_prefix)] = stats
else: else:
new_modules[name] = stats new_modules[name] = stats
self.modules = new_modules return new_modules
def parse_object_name_armcc(self, line):
class _ArmccParser(_Parser):
RE = re.compile(
r'^\s+0x(\w{8})\s+0x(\w{8})\s+(\w+)\s+(\w+)\s+(\d+)\s+[*]?.+\s+(.+)$')
RE_OBJECT = re.compile(r'(.+\.(l|ar))\((.+\.o)\)')
def parse_object_name(self, line):
""" Parse object file """ Parse object file
Positional arguments: Positional arguments:
line - the line containing the object or library line - the line containing the object or library
""" """
if line.endswith(".o"):
# simple object (not library)
if line[-2] == '.' and line[-1] == 'o':
return line return line
else: else:
is_obj = re.match(RE_OBJECT_ARMCC, line) is_obj = re.match(self.RE_OBJECT, line)
if is_obj: if is_obj:
object_name = os.path.basename(is_obj.group(1)) + '/' + is_obj.group(3) return join('[lib]', basename(is_obj.group(1)), is_obj.group(3))
return '[lib]/' + object_name
else: else:
print "Malformed input found when parsing ARMCC map: %s" % line print "Malformed input found when parsing ARMCC map: %s" % line
return '[misc]' return '[misc]'
def parse_section(self, line):
def parse_section_armcc(self, line):
""" Parse data from an armcc map file """ Parse data from an armcc map file
Examples of armcc map file: Examples of armcc map file:
Base_Addr Size Type Attr Idx E Section Name Object Base_Addr Size Type Attr Idx E Section Name Object
0x00000000 0x00000400 Data RO 11222 RESET startup_MK64F12.o 0x00000000 0x00000400 Data RO 11222 self.RESET startup_MK64F12.o
0x00000410 0x00000008 Code RO 49364 * !!!main c_w.l(__main.o) 0x00000410 0x00000008 Code RO 49364 * !!!main c_w.l(__main.o)
Positional arguments: Positional arguments:
line - the line to parse the section data from line - the line to parse the section data from
""" """
test_re = re.match(self.RE, line)
test_re_armcc = re.match(RE_ARMCC, line) if test_re:
size = int(test_re.group(2), 16)
if test_re_armcc: if test_re.group(4) == 'RO':
size = int(test_re_armcc.group(2), 16)
if test_re_armcc.group(4) == 'RO':
section = '.text' section = '.text'
else: else:
if test_re_armcc.group(3) == 'Data': if test_re.group(3) == 'Data':
section = '.data' section = '.data'
elif test_re_armcc.group(3) == 'Zero': elif test_re.group(3) == 'Zero':
section = '.bss' section = '.bss'
elif test_re_armcc.group(3) == 'Code': elif test_re.group(3) == 'Code':
section = '.text' section = '.text'
else: else:
print "Malformed input found when parsing armcc map: %s, %r" %\ print "Malformed input found when parsing armcc map: %s, %r" %\
(line, test_re_armcc.groups()) (line, test_re.groups())
return ["", 0, ""] return ["", 0, ""]
# check name of object or library # check name of object or library
object_name = self.parse_object_name_armcc(\ object_name = self.parse_object_name(
test_re_armcc.group(6)) test_re.group(6))
return [object_name, size, section] return [object_name, size, section]
else: else:
return ["", 0, ""] return ["", 0, ""]
def parse_object_name_iar(self, object_name): def parse_mapfile(self, file_desc):
""" Main logic to decode armc5 map files
Positional arguments:
file_desc - a file like object to parse as an armc5 map file
"""
with file_desc as infile:
# Search area to parse
for line in infile:
if line.startswith(' Base Addr Size'):
break
# Start decoding the map file
for line in infile:
self.module_add(*self.parse_section(line))
common_prefix = dirname(commonprefix([
o for o in self.modules.keys() if (o.endswith(".o") and o != "anon$$obj.o" and not o.startswith("[lib]"))]))
new_modules = {}
for name, stats in self.modules.items():
if name == "anon$$obj.o" or name.startswith("[lib]"):
new_modules[name] = stats
elif name.endswith(".o"):
new_modules[relpath(name, common_prefix)] = stats
else:
new_modules[name] = stats
return new_modules
class _IarParser(_Parser):
RE = re.compile(
r'^\s+(.+)\s+(zero|const|ro code|inited|uninit)\s'
r'+0x(\w{8})\s+0x(\w+)\s+(.+)\s.+$')
RE_CMDLINE_FILE = re.compile(r'^#\s+(.+\.o)')
RE_LIBRARY = re.compile(r'^(.+\.a)\:.+$')
RE_OBJECT_LIBRARY = re.compile(r'^\s+(.+\.o)\s.*')
def __init__(self):
_Parser.__init__(self)
# Modules passed to the linker on the command line
# this is a dict because modules are looked up by their basename
self.cmd_modules = {}
def parse_object_name(self, object_name):
""" Parse object file """ Parse object file
Positional arguments: Positional arguments:
line - the line containing the object or library line - the line containing the object or library
""" """
# simple object (not library)
if object_name.endswith(".o"): if object_name.endswith(".o"):
try: try:
return self.cmd_modules[object_name] return self.cmd_modules[object_name]
@ -307,8 +316,7 @@ class MemapParser(object):
else: else:
return '[misc]' return '[misc]'
def parse_section(self, line):
def parse_section_iar(self, line):
""" Parse data from an IAR map file """ Parse data from an IAR map file
Examples of IAR map file: Examples of IAR map file:
@ -325,86 +333,48 @@ class MemapParser(object):
Positional_arguments: Positional_arguments:
line - the line to parse section data from line - the line to parse section data from
""" """
test_re = re.match(self.RE, line)
test_re_iar = re.match(RE_IAR, line) if test_re:
if (test_re.group(2) == 'const' or
if test_re_iar: test_re.group(2) == 'ro code'):
size = int(test_re_iar.group(4), 16)
if (test_re_iar.group(2) == 'const' or
test_re_iar.group(2) == 'ro code'):
section = '.text' section = '.text'
elif (test_re_iar.group(2) == 'zero' or elif (test_re.group(2) == 'zero' or
test_re_iar.group(2) == 'uninit'): test_re.group(2) == 'uninit'):
if test_re_iar.group(1)[0:4] == 'HEAP': if test_re.group(1)[0:4] == 'HEAP':
section = '.heap' section = '.heap'
elif test_re_iar.group(1)[0:6] == 'CSTACK': elif test_re.group(1)[0:6] == 'CSTACK':
section = '.stack' section = '.stack'
else: else:
section = '.bss' # default section section = '.bss' # default section
elif test_re_iar.group(2) == 'inited': elif test_re.group(2) == 'inited':
section = '.data' section = '.data'
else: else:
print "Malformed input found when parsing IAR map: %s" % line print "Malformed input found when parsing IAR map: %s" % line
return ["", 0, ""]
# lookup object in dictionary and return module name # lookup object in dictionary and return module name
object_name = self.parse_object_name_iar(test_re_iar.group(5)) object_name = self.parse_object_name(test_re.group(5))
size = int(test_re.group(4), 16)
return [object_name, size, section] return [object_name, size, section]
else: else:
return ["", 0, ""] # no valid entry return ["", 0, ""]
def parse_map_file_armcc(self, file_desc): def check_new_library(self, line):
""" Main logic to decode armc5 map files
Positional arguments:
file_desc - a file like object to parse as an armc5 map file
"""
with file_desc as infile:
# Search area to parse
for line in infile:
if line.startswith(' Base Addr Size'):
break
# Start decoding the map file
for line in infile:
self.module_add(*self.parse_section_armcc(line))
common_prefix = os.path.dirname(os.path.commonprefix([
o for o in self.modules.keys() if (o.endswith(".o") and o != "anon$$obj.o" and not o.startswith("[lib]"))]))
new_modules = {}
for name, stats in self.modules.items():
if name == "anon$$obj.o" or name.startswith("[lib]"):
new_modules[name] = stats
elif name.endswith(".o"):
new_modules[os.path.relpath(name, common_prefix)] = stats
else:
new_modules[name] = stats
self.modules = new_modules
def check_new_library_iar(self, line):
""" """
Searches for libraries and returns name. Example: Searches for libraries and returns name. Example:
m7M_tls.a: [43] m7M_tls.a: [43]
""" """
test_address_line = re.match(self.RE_LIBRARY, line)
test_address_line = re.match(RE_LIBRARY_IAR, line)
if test_address_line: if test_address_line:
return test_address_line.group(1) return test_address_line.group(1)
else: else:
return "" return ""
def check_new_object_lib_iar(self, line): def check_new_object_lib(self, line):
""" """
Searches for objects within a library section and returns name. Example: Searches for objects within a library section and returns name. Example:
rt7M_tl.a: [44] rt7M_tl.a: [44]
@ -415,15 +385,13 @@ class MemapParser(object):
I64DivZer.o 2 I64DivZer.o 2
""" """
test_address_line = re.match(self.RE_OBJECT_LIBRARY, line)
test_address_line = re.match(RE_OBJECT_LIBRARY_IAR, line)
if test_address_line: if test_address_line:
return test_address_line.group(1) return test_address_line.group(1)
else: else:
return "" return ""
def parse_iar_command_line(self, lines): def parse_command_line(self, lines):
"""Parse the files passed on the command line to the iar linker """Parse the files passed on the command line to the iar linker
Positional arguments: Positional arguments:
@ -432,51 +400,82 @@ class MemapParser(object):
for line in lines: for line in lines:
if line.startswith("*"): if line.startswith("*"):
break break
is_cmdline_file = RE_CMDLINE_FILE_IAR.match(line) for arg in line.split(" "):
if is_cmdline_file: arg = arg.rstrip(" \n")
full_path = is_cmdline_file.group(1) if (not arg.startswith("-")) and arg.endswith(".o"):
self.cmd_modules[os.path.basename(full_path)] = full_path self.cmd_modules[basename(arg)] = arg
common_prefix = os.path.dirname(os.path.commonprefix(self.cmd_modules.values())) common_prefix = dirname(commonprefix(self.cmd_modules.values()))
self.cmd_modules = {s: os.path.relpath(f, common_prefix) self.cmd_modules = {s: relpath(f, common_prefix)
for s, f in self.cmd_modules.items()} for s, f in self.cmd_modules.items()}
def parse_mapfile(self, file_desc):
def parse_map_file_iar(self, file_desc):
""" Main logic to decode IAR map files """ Main logic to decode IAR map files
Positional arguments: Positional arguments:
file_desc - a file like object to parse as an IAR map file file_desc - a file like object to parse as an IAR map file
""" """
with file_desc as infile: with file_desc as infile:
self.parse_iar_command_line(infile) self.parse_command_line(infile)
for line in infile: for line in infile:
if line.startswith(' Section '): if line.startswith(' Section '):
break break
for line in infile: for line in infile:
self.module_add(*self.parse_section_iar(line)) self.module_add(*self.parse_section(line))
if line.startswith('*** MODULE SUMMARY'): # finish section if line.startswith('*** MODULE SUMMARY'): # finish section
break break
current_library = "" current_library = ""
for line in infile: for line in infile:
library = self.check_new_library(line)
library = self.check_new_library_iar(line)
if library: if library:
current_library = library current_library = library
object_name = self.check_new_object_lib_iar(line) object_name = self.check_new_object_lib(line)
if object_name and current_library: if object_name and current_library:
temp = '[lib]' + '/'+ current_library + '/'+ object_name temp = join('[lib]', current_library, object_name)
self.module_replace(object_name, temp) self.module_replace(object_name, temp)
return self.modules
class MemapParser(object):
"""An object that represents parsed results, parses the memory map files,
and writes out different file types of memory results
"""
print_sections = ('.text', '.data', '.bss')
# sections to print info (generic for all toolchains)
sections = _Parser.SECTIONS
misc_flash_sections = _Parser.MISC_FLASH_SECTIONS
other_sections = _Parser.OTHER_SECTIONS
def __init__(self):
# list of all modules and their sections
# full list - doesn't change with depth
self.modules = dict()
# short version with specific depth
self.short_modules = dict()
# Memory report (sections + summary)
self.mem_report = []
# Memory summary
self.mem_summary = dict()
# Totals of ".text", ".data" and ".bss"
self.subtotal = dict()
# Flash no associated with a module
self.misc_flash_mem = 0
def reduce_depth(self, depth): def reduce_depth(self, depth):
""" """
populates the short_modules attribute with a truncated module list populates the short_modules attribute with a truncated module list
@ -496,16 +495,15 @@ class MemapParser(object):
else: else:
self.short_modules = dict() self.short_modules = dict()
for module_name, v in self.modules.items(): for module_name, v in self.modules.items():
split_name = module_name.split('/') split_name = module_name.split(sep)
if split_name[0] == '': if split_name[0] == '':
split_name = split_name[1:] split_name = split_name[1:]
new_name = "/".join(split_name[:depth]) new_name = join(*split_name[:depth])
self.short_modules.setdefault(new_name, {}) self.short_modules.setdefault(new_name, {})
for section_idx, value in v.items(): for section_idx, value in v.items():
self.short_modules[new_name].setdefault(section_idx, 0) self.short_modules[new_name].setdefault(section_idx, 0)
self.short_modules[new_name][section_idx] += self.modules[module_name][section_idx] self.short_modules[new_name][section_idx] += self.modules[module_name][section_idx]
export_formats = ["json", "csv-ci", "table"] export_formats = ["json", "csv-ci", "table"]
def generate_output(self, export_format, depth, file_output=None): def generate_output(self, export_format, depth, file_output=None):
@ -520,15 +518,13 @@ class MemapParser(object):
Returns: generated string for the 'table' format, otherwise None Returns: generated string for the 'table' format, otherwise None
""" """
self.reduce_depth(depth) self.reduce_depth(depth)
self.compute_report() self.compute_report()
try: try:
if file_output: if file_output:
file_desc = open(file_output, 'wb') file_desc = open(file_output, 'wb')
else: else:
file_desc = sys.stdout file_desc = stdout
except IOError as error: except IOError as error:
print "I/O error({0}): {1}".format(error.errno, error.strerror) print "I/O error({0}): {1}".format(error.errno, error.strerror)
return False return False
@ -538,7 +534,7 @@ class MemapParser(object):
'table': self.generate_table}[export_format] 'table': self.generate_table}[export_format]
output = to_call(file_desc) output = to_call(file_desc)
if file_desc is not sys.stdout: if file_desc is not stdout:
file_desc.close() file_desc.close()
return output return output
@ -551,7 +547,6 @@ class MemapParser(object):
""" """
file_desc.write(json.dumps(self.mem_report, indent=4)) file_desc.write(json.dumps(self.mem_report, indent=4))
file_desc.write('\n') file_desc.write('\n')
return None return None
def generate_csv(self, file_desc): def generate_csv(self, file_desc):
@ -578,7 +573,6 @@ class MemapParser(object):
csv_writer.writerow(csv_module_section) csv_writer.writerow(csv_module_section)
csv_writer.writerow(csv_sizes) csv_writer.writerow(csv_sizes)
return None return None
def generate_table(self, file_desc): def generate_table(self, file_desc):
@ -660,31 +654,29 @@ class MemapParser(object):
mapfile - the file name of the memory map file mapfile - the file name of the memory map file
toolchain - the toolchain used to create the file toolchain - the toolchain used to create the file
""" """
if toolchain in ("ARM", "ARM_STD", "ARM_MICRO", "ARMC6"):
result = True parser = _ArmccParser()
elif toolchain == "GCC_ARM" or toolchain == "GCC_CR":
parser = _GccParser()
elif toolchain == "IAR":
parser = _IarParser()
else:
return False
try: try:
with open(mapfile, 'r') as file_input: with open(mapfile, 'r') as file_input:
if toolchain in ("ARM", "ARM_STD", "ARM_MICRO", "ARMC6"): self.modules = parser.parse_mapfile(file_input)
self.parse_map_file_armcc(file_input) return True
elif toolchain == "GCC_ARM" or toolchain == "GCC_CR":
self.parse_map_file_gcc(file_input)
elif toolchain == "IAR":
self.parse_map_file_iar(file_input)
else:
result = False
except IOError as error: except IOError as error:
print "I/O error({0}): {1}".format(error.errno, error.strerror) print "I/O error({0}): {1}".format(error.errno, error.strerror)
result = False return False
return result
def main(): def main():
"""Entry Point""" """Entry Point"""
version = '0.4.0' version = '0.4.0'
# Parser handling # Parser handling
parser = argparse.ArgumentParser( parser = ArgumentParser(
description="Memory Map File Analyser for ARM mbed\nversion %s" % description="Memory Map File Analyser for ARM mbed\nversion %s" %
version) version)
@ -715,9 +707,9 @@ def main():
parser.add_argument('-v', '--version', action='version', version=version) parser.add_argument('-v', '--version', action='version', version=version)
# Parse/run command # Parse/run command
if len(sys.argv) <= 1: if len(argv) <= 1:
parser.print_help() parser.print_help()
sys.exit(1) exit(1)
args = parser.parse_args() args = parser.parse_args()
@ -727,7 +719,7 @@ def main():
# Parse and decode a map file # Parse and decode a map file
if args.file and args.toolchain: if args.file and args.toolchain:
if memap.parse(args.file, args.toolchain) is False: if memap.parse(args.file, args.toolchain) is False:
sys.exit(0) exit(0)
if args.depth is None: if args.depth is None:
depth = 2 # default depth level depth = 2 # default depth level
@ -745,7 +737,7 @@ def main():
if args.export == 'table' and returned_string: if args.export == 'table' and returned_string:
print returned_string print returned_string
sys.exit(0) exit(0)
if __name__ == "__main__": if __name__ == "__main__":
main() main()

1
tools/test/memap/gcc.map
View File

@ -8,6 +8,7 @@ Linker script and memory map
0x000000000001b200 0xc0 /common/path/startup/startup.o 0x000000000001b200 0xc0 /common/path/startup/startup.o
0x000000000001b200 startup() 0x000000000001b200 startup()
0x0000000000024020 0x8 /usr/lib/gcc/arm-none-eabi/7.1.0/../../../../arm-none-eabi/lib/armv6-m/libd16M_tlf.a(__main.o) 0x0000000000024020 0x8 /usr/lib/gcc/arm-none-eabi/7.1.0/../../../../arm-none-eabi/lib/armv6-m/libd16M_tlf.a(__main.o)
0x0000000000024020 0x8 /usr/lib/gcc/arm-none-eabi/7.1.0/../../../../arm-none-eabi/lib/armv6-m/foo.o
.data 0x0000000020002ef8 0xac8 load address 0x000000000002ca38 .data 0x0000000020002ef8 0xac8 load address 0x000000000002ca38
0x0000000020002ef8 __data_start__ = . 0x0000000020002ef8 __data_start__ = .

9
tools/test/memap/iar.map
View File

@ -10,12 +10,9 @@
# Command line = # Command line =
# -f # -f
# /common/path/.link_files.txt # /common/path/.link_files.txt
# (-o # (-o /common/path/project.elf
# --map=/common/path/project.map # --map=/common/path/project.map /common/path/main.o
# /common/path/project.elf # /common/path/startup/startup.o /common/path/irqs/irqs.o
# /common/path/main.o
# /common/path/startup/startup.o
# /common/path/irqs/irqs.o
# /common/path/data/data.o # /common/path/data/data.o
# #
############################################################################### ###############################################################################

28
tools/test/memap/memap_test.py
View File

@ -20,6 +20,7 @@ import json
import pytest import pytest
import tools.memap
from tools.memap import MemapParser from tools.memap import MemapParser
from copy import deepcopy from copy import deepcopy
@ -137,7 +138,7 @@ def memap_parser():
return memap_parser return memap_parser
def generate_test_helper(memap_parser, format, depth, file_output=None): def generate_test_helper(memap_parser, format, depth, sep, file_output=None):
""" """
Helper that tests that the member variables "modules" is Helper that tests that the member variables "modules" is
unchanged after calling "generate_output" unchanged after calling "generate_output"
@ -147,17 +148,21 @@ def generate_test_helper(memap_parser, format, depth, file_output=None):
:param format: the file type to output :param format: the file type to output
:param file_output: the file to output to :param file_output: the file to output to
""" """
old_modules = deepcopy(memap_parser.modules) old_modules = deepcopy(memap_parser.modules)
tools.memap.sep = sep
memap_parser.generate_output(format, depth, file_output=file_output) memap_parser.generate_output(format, depth, file_output=file_output)
assert memap_parser.modules == old_modules,\ assert memap_parser.modules == old_modules,\
"generate_output modified the 'modules' property" "generate_output modified the 'modules' property"
for file_name in memap_parser.short_modules:
assert(len(file_name.split(tools.memap.sep)) <= depth)
@pytest.mark.parametrize("depth", [1, 2, 20]) @pytest.mark.parametrize("depth", [1, 2, 20])
def test_report_computed(memap_parser, depth): @pytest.mark.parametrize("sep", ["\\", "/"])
def test_report_computed(memap_parser, depth, sep):
""" """
Test that a report and summary are computed Test that a report and summary are computed
@ -165,7 +170,7 @@ def test_report_computed(memap_parser, depth):
:param depth: the detail of the output :param depth: the detail of the output
""" """
memap_parser.generate_output('table', depth) memap_parser.generate_output('table', depth, sep)
# Report is created after generating output # Report is created after generating output
assert memap_parser.mem_summary assert memap_parser.mem_summary
@ -173,17 +178,19 @@ def test_report_computed(memap_parser, depth):
@pytest.mark.parametrize("depth", [1, 2, 20]) @pytest.mark.parametrize("depth", [1, 2, 20])
def test_generate_output_table(memap_parser, depth): @pytest.mark.parametrize("sep", ["\\", "/"])
def test_generate_output_table(memap_parser, depth, sep):
""" """
Test that an output of type "table" can be generated correctly Test that an output of type "table" can be generated correctly
:param memap_parser: Mocked parser :param memap_parser: Mocked parser
:param depth: the detail of the output :param depth: the detail of the output
""" """
generate_test_helper(memap_parser, 'table', depth) generate_test_helper(memap_parser, 'table', depth, sep)
@pytest.mark.parametrize("depth", [1, 2, 20]) @pytest.mark.parametrize("depth", [1, 2, 20])
def test_generate_output_json(memap_parser, tmpdir, depth): @pytest.mark.parametrize("sep", ["\\", "/"])
def test_generate_output_json(memap_parser, tmpdir, depth, sep):
""" """
Test that an output of type "json" can be generated correctly Test that an output of type "json" can be generated correctly
:param memap_parser: Mocked parser :param memap_parser: Mocked parser
@ -191,13 +198,14 @@ def test_generate_output_json(memap_parser, tmpdir, depth):
:param depth: the detail of the output :param depth: the detail of the output
""" """
file_name = str(tmpdir.join('output.json').realpath()) file_name = str(tmpdir.join('output.json').realpath())
generate_test_helper(memap_parser, 'json', depth, file_name) generate_test_helper(memap_parser, 'json', depth, sep, file_name)
assert isfile(file_name), "Failed to create json file" assert isfile(file_name), "Failed to create json file"
json.load(open(file_name)) json.load(open(file_name))
@pytest.mark.parametrize("depth", [1, 2, 20]) @pytest.mark.parametrize("depth", [1, 2, 20])
def test_generate_output_csv_ci(memap_parser, tmpdir, depth): @pytest.mark.parametrize("sep", ["\\", "/"])
def test_generate_output_csv_ci(memap_parser, tmpdir, depth, sep):
""" """
Test ensures that an output of type "csv-ci" can be generated correctly Test ensures that an output of type "csv-ci" can be generated correctly
@ -206,5 +214,5 @@ def test_generate_output_csv_ci(memap_parser, tmpdir, depth):
:param depth: the detail of the output :param depth: the detail of the output
""" """
file_name = str(tmpdir.join('output.csv').realpath()) file_name = str(tmpdir.join('output.csv').realpath())
generate_test_helper(memap_parser, 'csv-ci', depth, file_name) generate_test_helper(memap_parser, 'csv-ci', depth, sep, file_name)
assert isfile(file_name), "Failed to create csv-ci file" assert isfile(file_name), "Failed to create csv-ci file"

31
tools/test/memap/parse_test.py
View File

@ -5,7 +5,7 @@ import json
import pytest import pytest
from tools.memap import MemapParser from tools.memap import MemapParser, _ArmccParser
from copy import deepcopy from copy import deepcopy
@ -19,10 +19,12 @@ PARSED_ARM_DATA = {
def test_parse_armcc(): def test_parse_armcc():
memap = MemapParser() memap = MemapParser()
memap.parse_map_file_armcc(open(join(dirname(__file__), "arm.map"))) memap.parse(join(dirname(__file__), "arm.map"), "ARM")
assert memap.modules == PARSED_ARM_DATA
memap.parse(join(dirname(__file__), "arm.map"), "UARM")
assert memap.modules == PARSED_ARM_DATA assert memap.modules == PARSED_ARM_DATA
PARSED_IAR_GCC_DATA = { PARSED_IAR_DATA = {
"startup/startup.o": {".text": 0xc0}, "startup/startup.o": {".text": 0xc0},
"[lib]/d16M_tlf.a/__main.o": {".text": 8}, "[lib]/d16M_tlf.a/__main.o": {".text": 8},
"irqs/irqs.o": {".text": 0x98}, "irqs/irqs.o": {".text": 0x98},
@ -32,17 +34,28 @@ PARSED_IAR_GCC_DATA = {
def test_parse_iar(): def test_parse_iar():
memap = MemapParser() memap = MemapParser()
memap.parse_map_file_iar(open(join(dirname(__file__), "iar.map"))) memap.parse(join(dirname(__file__), "iar.map"), "IAR")
assert memap.modules == PARSED_IAR_GCC_DATA assert memap.modules == PARSED_IAR_DATA
PARSED_GCC_DATA = {
"startup/startup.o": {".text": 0xc0},
"[lib]/d16M_tlf.a/__main.o": {".text": 8},
"[lib]/misc/foo.o": {".text": 8},
"irqs/irqs.o": {".text": 0x98},
"data/data.o": {".data": 0x18, ".bss": 0x198},
"main.o": {".text": 0x36},
}
def test_parse_gcc(): def test_parse_gcc():
memap = MemapParser() memap = MemapParser()
memap.parse_map_file_gcc(open(join(dirname(__file__), "gcc.map"))) memap.parse(join(dirname(__file__), "gcc.map"), "GCC_ARM")
assert memap.modules == PARSED_IAR_GCC_DATA assert memap.modules == PARSED_GCC_DATA
memap.parse(join(dirname(__file__), "gcc.map"), "GCC_CR")
assert memap.modules == PARSED_GCC_DATA
def test_add_empty_module(): def test_add_empty_module():
memap = MemapParser() memap = _ArmccParser()
old_modules = deepcopy(memap.modules) old_modules = deepcopy(memap.modules)
memap.module_add("", 8, ".data") memap.module_add("", 8, ".data")
assert(old_modules == memap.modules) assert(old_modules == memap.modules)
@ -52,7 +65,7 @@ def test_add_empty_module():
assert(old_modules == memap.modules) assert(old_modules == memap.modules)
def test_add_full_module(): def test_add_full_module():
memap = MemapParser() memap = _ArmccParser()
old_modules = deepcopy(memap.modules) old_modules = deepcopy(memap.modules)
memap.module_add("main.o", 8, ".data") memap.module_add("main.o", 8, ".data")
assert(old_modules != memap.modules) assert(old_modules != memap.modules)