440 lines
14 KiB
Python
440 lines
14 KiB
Python
|
import re
|
||
|
|
import pprint
|
||
|
|
import os
|
||
|
|
from subprocess import check_output
|
||
|
|
from optparse import OptionParser
|
||
|
|
|
||
|
|
# Constants
|
||
|
|
rtl_ext_end = ".dfinish"
|
||
|
|
rtl_ext = None # e.g. '.c.270r.dfinish'. The number '270' will change with gcc version and is auto-detected by the
|
||
|
|
# function find_rtl_ext
|
||
|
|
dir = r'.' # Working directory
|
||
|
|
su_ext = '.su'
|
||
|
|
obj_ext = '.o'
|
||
|
|
manual_ext = '.msu'
|
||
|
|
read_elf_path = "arm-none-eabi-readelf.exe" # You may need to enter the full path here
|
||
|
|
stdout_encoding = "utf-8" # System dependant
|
||
|
|
|
||
|
|
|
||
|
|
class Printable:
|
||
|
|
def __repr__(self):
|
||
|
|
return "<" + type(self).__name__ + "> " + pprint.pformat(vars(self), indent=4, width=1)
|
||
|
|
|
||
|
|
|
||
|
|
class Symbol(Printable):
|
||
|
|
pass
|
||
|
|
|
||
|
|
|
||
|
|
def read_symbols(file):
|
||
|
|
from subprocess import check_output
|
||
|
|
|
||
|
|
def to_symbol(read_elf_line):
|
||
|
|
v = read_elf_line.split()
|
||
|
|
|
||
|
|
s2 = Symbol()
|
||
|
|
s2.value = int(v[1], 16)
|
||
|
|
s2.size = int(v[2])
|
||
|
|
s2.type = v[3]
|
||
|
|
s2.binding = v[4]
|
||
|
|
if len(v) >= 8:
|
||
|
|
s2.name = v[7]
|
||
|
|
else:
|
||
|
|
s2.name = ""
|
||
|
|
|
||
|
|
return s2
|
||
|
|
|
||
|
|
output = check_output([read_elf_path, "-s", "-W", file]).decode(stdout_encoding)
|
||
|
|
lines = output.splitlines()[3:]
|
||
|
|
return [to_symbol(line) for line in lines]
|
||
|
|
|
||
|
|
|
||
|
|
def read_obj(tu, call_graph):
|
||
|
|
"""
|
||
|
|
Reads the file tu.o and gets the binding (global or local) for each function
|
||
|
|
:param tu: name of the translation unit (e.g. for main.c, this would be 'main')
|
||
|
|
:param call_graph: a object used to store information about each function, results go here
|
||
|
|
"""
|
||
|
|
symbols = read_symbols(tu[0:tu.rindex(".")] + obj_ext)
|
||
|
|
|
||
|
|
for s in symbols:
|
||
|
|
|
||
|
|
if s.type == 'FUNC':
|
||
|
|
if s.binding == 'GLOBAL':
|
||
|
|
# Check for multiple declarations
|
||
|
|
if s.name in call_graph['globals'] or s.name in call_graph['locals']:
|
||
|
|
raise Exception('Multiple declarations of {}'.format(s.name))
|
||
|
|
call_graph['globals'][s.name] = {'tu': tu, 'name': s.name, 'binding': s.binding}
|
||
|
|
elif s.binding == 'LOCAL':
|
||
|
|
# Check for multiple declarations
|
||
|
|
if s.name in call_graph['locals'] and tu in call_graph['locals'][s.name]:
|
||
|
|
raise Exception('Multiple declarations of {}'.format(s.name))
|
||
|
|
|
||
|
|
if s.name not in call_graph['locals']:
|
||
|
|
call_graph['locals'][s.name] = {}
|
||
|
|
|
||
|
|
call_graph['locals'][s.name][tu] = {'tu': tu, 'name': s.name, 'binding': s.binding}
|
||
|
|
elif s.binding == 'WEAK':
|
||
|
|
if s.name in call_graph['weak']:
|
||
|
|
raise Exception('Multiple declarations of {}'.format(s.name))
|
||
|
|
call_graph['weak'][s.name] = {'tu': tu, 'name': s.name, 'binding': s.binding}
|
||
|
|
else:
|
||
|
|
raise Exception('Error Unknown Binding "{}" for symbol: {}'.format(s.binding, s.name))
|
||
|
|
|
||
|
|
|
||
|
|
def find_fxn(tu, fxn, call_graph):
|
||
|
|
"""
|
||
|
|
Looks up the dictionary associated with the function.
|
||
|
|
:param tu: The translation unit in which to look for locals functions
|
||
|
|
:param fxn: The function name
|
||
|
|
:param call_graph: a object used to store information about each function
|
||
|
|
:return: the dictionary for the given function or None
|
||
|
|
"""
|
||
|
|
|
||
|
|
if fxn in call_graph['globals']:
|
||
|
|
return call_graph['globals'][fxn]
|
||
|
|
else:
|
||
|
|
try:
|
||
|
|
return call_graph['locals'][fxn][tu]
|
||
|
|
except KeyError:
|
||
|
|
return None
|
||
|
|
|
||
|
|
|
||
|
|
def find_demangled_fxn(tu, fxn, call_graph):
|
||
|
|
"""
|
||
|
|
Looks up the dictionary associated with the function.
|
||
|
|
:param tu: The translation unit in which to look for locals functions
|
||
|
|
:param fxn: The function name
|
||
|
|
:param call_graph: a object used to store information about each function
|
||
|
|
:return: the dictionary for the given function or None
|
||
|
|
"""
|
||
|
|
for f in call_graph['globals'].values():
|
||
|
|
if 'demangledName' in f:
|
||
|
|
if f['demangledName'] == fxn:
|
||
|
|
return f
|
||
|
|
for f in call_graph['locals'].values():
|
||
|
|
if tu in f:
|
||
|
|
if 'demangledName' in f[tu]:
|
||
|
|
if f[tu]['demangledName'] == fxn:
|
||
|
|
return f[tu]
|
||
|
|
return None
|
||
|
|
|
||
|
|
|
||
|
|
def read_rtl(tu, call_graph):
|
||
|
|
"""
|
||
|
|
Read an RTL file and finds callees for each function and if there are calls via function pointer.
|
||
|
|
:param tu: the translation unit
|
||
|
|
:param call_graph: a object used to store information about each function, results go here
|
||
|
|
"""
|
||
|
|
|
||
|
|
# Construct A Call Graph
|
||
|
|
function = re.compile(r'^;; Function (.*) \((\S+), funcdef_no=\d+(, [a-z_]+=\d+)*\)( \([a-z ]+\))?$')
|
||
|
|
static_call = re.compile(r'^.*\(call.*"(.*)".*$')
|
||
|
|
other_call = re.compile(r'^.*call .*$')
|
||
|
|
|
||
|
|
for line_ in open(tu + rtl_ext).readlines():
|
||
|
|
m = function.match(line_)
|
||
|
|
if m:
|
||
|
|
fxn_name = m.group(2)
|
||
|
|
fxn_dict2 = find_fxn(tu, fxn_name, call_graph)
|
||
|
|
if not fxn_dict2:
|
||
|
|
pprint.pprint(call_graph)
|
||
|
|
raise Exception("Error locating function {} in {}".format(fxn_name, tu))
|
||
|
|
|
||
|
|
fxn_dict2['demangledName'] = m.group(1)
|
||
|
|
fxn_dict2['calls'] = set()
|
||
|
|
fxn_dict2['has_ptr_call'] = False
|
||
|
|
continue
|
||
|
|
|
||
|
|
m = static_call.match(line_)
|
||
|
|
if m:
|
||
|
|
fxn_dict2['calls'].add(m.group(1))
|
||
|
|
# print("Call: {0} -> {1}".format(current_fxn, m.group(1)))
|
||
|
|
continue
|
||
|
|
|
||
|
|
m = other_call.match(line_)
|
||
|
|
if m:
|
||
|
|
fxn_dict2['has_ptr_call'] = True
|
||
|
|
continue
|
||
|
|
|
||
|
|
|
||
|
|
def read_su(tu, call_graph):
|
||
|
|
"""
|
||
|
|
Reads the 'local_stack' for each function. Local stack ignores stack used by callees.
|
||
|
|
:param tu: the translation unit
|
||
|
|
:param call_graph: a object used to store information about each function, results go here
|
||
|
|
:return:
|
||
|
|
"""
|
||
|
|
|
||
|
|
su_line = re.compile(r'^([^ :]+):([\d]+):([\d]+):(.+)\t(\d+)\t(\S+)$')
|
||
|
|
i = 1
|
||
|
|
|
||
|
|
for line in open(tu[0:tu.rindex(".")] + su_ext).readlines():
|
||
|
|
m = su_line.match(line)
|
||
|
|
if m:
|
||
|
|
fxn = m.group(4)
|
||
|
|
fxn_dict2 = find_demangled_fxn(tu, fxn, call_graph)
|
||
|
|
fxn_dict2['local_stack'] = int(m.group(5))
|
||
|
|
else:
|
||
|
|
print("error parsing line {} in file {}".format(i, tu))
|
||
|
|
i += 1
|
||
|
|
|
||
|
|
|
||
|
|
def read_manual(file, call_graph):
|
||
|
|
"""
|
||
|
|
reads the manual stack useage files.
|
||
|
|
:param file: the file name
|
||
|
|
:param call_graph: a object used to store information about each function, results go here
|
||
|
|
"""
|
||
|
|
|
||
|
|
for line in open(file).readlines():
|
||
|
|
fxn, stack_sz = line.split()
|
||
|
|
if fxn in call_graph:
|
||
|
|
raise Exception("Redeclared Function {}".format(fxn))
|
||
|
|
call_graph['globals'][fxn] = {'wcs': int(stack_sz),
|
||
|
|
'calls': set(),
|
||
|
|
'has_ptr_call': False,
|
||
|
|
'local_stack': int(stack_sz),
|
||
|
|
'is_manual': True,
|
||
|
|
'name': fxn,
|
||
|
|
'tu': '#MANUAL',
|
||
|
|
'binding': 'GLOBAL'}
|
||
|
|
|
||
|
|
|
||
|
|
def validate_all_data(call_graph):
|
||
|
|
"""
|
||
|
|
Check that every entry in the call graph has the following fields:
|
||
|
|
.calls, .has_ptr_call, .local_stack, .scope, .src_line
|
||
|
|
"""
|
||
|
|
|
||
|
|
def validate_dict(d):
|
||
|
|
if not ('calls' in d and 'has_ptr_call' in d and 'local_stack' in d
|
||
|
|
and 'name' in d and 'tu' in d):
|
||
|
|
print("Error data is missing in fxn dictionary {}".format(d))
|
||
|
|
|
||
|
|
# Loop through every global and local function
|
||
|
|
# and resolve each call, save results in r_calls
|
||
|
|
for fxn_dict2 in call_graph['globals'].values():
|
||
|
|
validate_dict(fxn_dict2)
|
||
|
|
|
||
|
|
for l_dict in call_graph['locals'].values():
|
||
|
|
for fxn_dict2 in l_dict.values():
|
||
|
|
validate_dict(fxn_dict2)
|
||
|
|
|
||
|
|
def resolve_all_calls(call_graph):
|
||
|
|
def resolve_calls(fxn_dict2):
|
||
|
|
fxn_dict2['r_calls'] = []
|
||
|
|
fxn_dict2['unresolved_calls'] = set()
|
||
|
|
|
||
|
|
for call in fxn_dict2['calls']:
|
||
|
|
call_dict = find_fxn(fxn_dict2['tu'], call, call_graph)
|
||
|
|
if call_dict:
|
||
|
|
fxn_dict2['r_calls'].append(call_dict)
|
||
|
|
else:
|
||
|
|
fxn_dict2['unresolved_calls'].add(call)
|
||
|
|
|
||
|
|
# Loop through every global and local function
|
||
|
|
# and resolve each call, save results in r_calls
|
||
|
|
for fxn_dict in call_graph['globals'].values():
|
||
|
|
resolve_calls(fxn_dict)
|
||
|
|
|
||
|
|
for l_dict in call_graph['locals'].values():
|
||
|
|
for fxn_dict in l_dict.values():
|
||
|
|
resolve_calls(fxn_dict)
|
||
|
|
|
||
|
|
|
||
|
|
def calc_all_wcs(call_graph):
|
||
|
|
def calc_wcs(fxn_dict2, call_graph1, parents):
|
||
|
|
"""
|
||
|
|
Calculates the worst case stack for a fxn that is declared (or called from) in a given file.
|
||
|
|
:param parents: This function gets called recursively through the call graph. If a function has recursion the
|
||
|
|
tuple file, fxn will be in the parents stack and everything between the top of the stack and the matching entry
|
||
|
|
has recursion.
|
||
|
|
:return:
|
||
|
|
"""
|
||
|
|
|
||
|
|
# If the wcs is already known, then nothing to do
|
||
|
|
if 'wcs' in fxn_dict2:
|
||
|
|
return
|
||
|
|
|
||
|
|
# Check for pointer calls
|
||
|
|
if fxn_dict2['has_ptr_call']:
|
||
|
|
fxn_dict2['wcs'] = 'unbounded'
|
||
|
|
return
|
||
|
|
|
||
|
|
# Check for recursion
|
||
|
|
if fxn_dict2 in parents:
|
||
|
|
fxn_dict2['wcs'] = 'unbounded'
|
||
|
|
return
|
||
|
|
|
||
|
|
# Calculate WCS
|
||
|
|
call_max = 0
|
||
|
|
for call_dict in fxn_dict2['r_calls']:
|
||
|
|
|
||
|
|
# Calculate the WCS for the called function
|
||
|
|
parents.append(fxn_dict2)
|
||
|
|
calc_wcs(call_dict, call_graph1, parents)
|
||
|
|
parents.pop()
|
||
|
|
|
||
|
|
# If the called function is unbounded, so is this function
|
||
|
|
if call_dict['wcs'] == 'unbounded':
|
||
|
|
fxn_dict2['wcs'] = 'unbounded'
|
||
|
|
return
|
||
|
|
|
||
|
|
# Keep track of the call with the largest stack use
|
||
|
|
call_max = max(call_max, call_dict['wcs'])
|
||
|
|
|
||
|
|
# Propagate Unresolved Calls
|
||
|
|
for unresolved_call in call_dict['unresolved_calls']:
|
||
|
|
fxn_dict2['unresolved_calls'].add(unresolved_call)
|
||
|
|
|
||
|
|
fxn_dict2['wcs'] = call_max + fxn_dict2['local_stack']
|
||
|
|
|
||
|
|
# Loop through every global and local function
|
||
|
|
# and resolve each call, save results in r_calls
|
||
|
|
for fxn_dict in call_graph['globals'].values():
|
||
|
|
calc_wcs(fxn_dict, call_graph, [])
|
||
|
|
|
||
|
|
for l_dict in call_graph['locals'].values():
|
||
|
|
for fxn_dict in l_dict.values():
|
||
|
|
calc_wcs(fxn_dict, call_graph, [])
|
||
|
|
|
||
|
|
|
||
|
|
def print_all_fxns(call_graph):
|
||
|
|
|
||
|
|
def print_fxn(row_format, fxn_dict2):
|
||
|
|
unresolved = fxn_dict2['unresolved_calls']
|
||
|
|
stack = str(fxn_dict2['wcs'])
|
||
|
|
if unresolved:
|
||
|
|
unresolved_str = '({})'.format(' ,'.join(unresolved))
|
||
|
|
if stack != 'unbounded':
|
||
|
|
stack = "unbounded:" + stack
|
||
|
|
else:
|
||
|
|
unresolved_str = ''
|
||
|
|
|
||
|
|
print(row_format.format(fxn_dict2['tu'], fxn_dict2['demangledName'], stack, unresolved_str))
|
||
|
|
|
||
|
|
def get_order(val):
|
||
|
|
if val == 'unbounded':
|
||
|
|
return 1
|
||
|
|
else:
|
||
|
|
return -val
|
||
|
|
|
||
|
|
# Loop through every global and local function
|
||
|
|
# and resolve each call, save results in r_calls
|
||
|
|
d_list = []
|
||
|
|
for fxn_dict in call_graph['globals'].values():
|
||
|
|
d_list.append(fxn_dict)
|
||
|
|
|
||
|
|
for l_dict in call_graph['locals'].values():
|
||
|
|
for fxn_dict in l_dict.values():
|
||
|
|
d_list.append(fxn_dict)
|
||
|
|
|
||
|
|
d_list.sort(key=lambda item: get_order(item['wcs']))
|
||
|
|
|
||
|
|
# Calculate table width
|
||
|
|
tu_width = max(max([len(d['tu']) for d in d_list]), 16)
|
||
|
|
name_width = max(max([len(d['name']) for d in d_list]), 13)
|
||
|
|
row_format = "{:<" + str(tu_width + 2) + "} {:<" + str(name_width + 2) + "} {:>14} {:<17}"
|
||
|
|
|
||
|
|
# Print out the table
|
||
|
|
print("")
|
||
|
|
print(row_format.format('Translation Unit', 'Function Name', 'Stack', 'Unresolved Dependencies'))
|
||
|
|
for d in d_list:
|
||
|
|
print_fxn(row_format, d)
|
||
|
|
|
||
|
|
|
||
|
|
def find_rtl_ext():
|
||
|
|
# Find the rtl_extension
|
||
|
|
global rtl_ext
|
||
|
|
|
||
|
|
for root, directories, filenames in os.walk('.'):
|
||
|
|
for f in filenames:
|
||
|
|
if (f.endswith(rtl_ext_end)):
|
||
|
|
rtl_ext = f[f[:-len(rtl_ext_end)].rindex("."):]
|
||
|
|
print("rtl_ext = " + rtl_ext)
|
||
|
|
return
|
||
|
|
|
||
|
|
print("Could not find any files ending with '.dfinish'. Check that the script is being run from the correct "
|
||
|
|
"directory. Check that the code was compiled with the correct flags")
|
||
|
|
exit(-1)
|
||
|
|
|
||
|
|
|
||
|
|
def find_files():
|
||
|
|
tu = []
|
||
|
|
manual = []
|
||
|
|
all_files = []
|
||
|
|
for root, directories, filenames in os.walk(dir):
|
||
|
|
for filename in filenames:
|
||
|
|
all_files.append(os.path.join(root,filename))
|
||
|
|
|
||
|
|
files = [f for f in all_files if os.path.isfile(f) and f.endswith(rtl_ext)]
|
||
|
|
for f in files:
|
||
|
|
base = f[0:-len(rtl_ext)]
|
||
|
|
short_base = base[0:base.rindex(".")]
|
||
|
|
if short_base + su_ext in all_files and short_base + obj_ext in all_files:
|
||
|
|
tu.append(base)
|
||
|
|
print('Reading: {}{}, {}{}, {}{}'.format(base, rtl_ext, short_base, su_ext, short_base, obj_ext))
|
||
|
|
|
||
|
|
files = [f for f in all_files if os.path.isfile(f) and f.endswith(manual_ext)]
|
||
|
|
for f in files:
|
||
|
|
manual.append(f)
|
||
|
|
print('Reading: {}'.format(f))
|
||
|
|
|
||
|
|
# Print some diagnostic messages
|
||
|
|
if not tu:
|
||
|
|
print("Could not find any translation units to analyse")
|
||
|
|
exit(-1)
|
||
|
|
|
||
|
|
return tu, manual
|
||
|
|
|
||
|
|
|
||
|
|
def main():
|
||
|
|
|
||
|
|
# Find the appropriate RTL extension
|
||
|
|
find_rtl_ext()
|
||
|
|
|
||
|
|
# Find all input files
|
||
|
|
call_graph = {'locals': {}, 'globals': {}, 'weak': {}}
|
||
|
|
tu_list, manual_list = find_files()
|
||
|
|
|
||
|
|
# Read the input files
|
||
|
|
for tu in tu_list:
|
||
|
|
read_obj(tu, call_graph) # This must be first
|
||
|
|
|
||
|
|
for fxn in call_graph['weak'].values():
|
||
|
|
if fxn['name'] not in call_graph['globals'].keys():
|
||
|
|
call_graph['globals'][fxn['name']] = fxn
|
||
|
|
|
||
|
|
for tu in tu_list:
|
||
|
|
read_rtl(tu, call_graph)
|
||
|
|
for tu in tu_list:
|
||
|
|
read_su(tu, call_graph)
|
||
|
|
|
||
|
|
# Read manual files
|
||
|
|
for m in manual_list:
|
||
|
|
read_manual(m, call_graph)
|
||
|
|
|
||
|
|
# Validate Data
|
||
|
|
validate_all_data(call_graph)
|
||
|
|
|
||
|
|
# Resolve All Function Calls
|
||
|
|
resolve_all_calls(call_graph)
|
||
|
|
|
||
|
|
# Calculate Worst Case Stack For Each Function
|
||
|
|
calc_all_wcs(call_graph)
|
||
|
|
|
||
|
|
# Print A Nice Message With Each Function and the WCS
|
||
|
|
print_all_fxns(call_graph)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
def ThreadStackStaticAnalysis(env):
|
||
|
|
print('Start thread stack static analysis...')
|
||
|
|
|
||
|
|
import rtconfig
|
||
|
|
read_elf_path = rtconfig.EXEC_PATH + r'\readelf.exe'
|
||
|
|
main()
|
||
|
|
|
||
|
|
print('\nThread stack static analysis done!')
|
||
|
|
return
|