Feature/add memap cstack usage ports (#661)
* Added memap, avstack, and checkstackusage tools to STM32F4xx Makefile and CMake builds to calculate CSTACK depth and RAM usage * Added memap, cstack, and ram-usage recipes to stm32f10x port Makefile. Added Cmake build. * Removed local dlmstp.c module from stm32f10x port, and used the common datalink dlmstp.c module with MS/TP extended frames and zero-config support. * Added .nm and .su to .gitignore to skip the analysis file residue.
This commit is contained in:
Steve Karg
@@ -0,0 +1,3 @@
|
||||
.analysed
|
||||
.setup
|
||||
.venv/
|
||||
@@ -0,0 +1,9 @@
|
||||
MIT License
|
||||
|
||||
Copyright © 2021 Thanassis Tsiodras
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
@@ -0,0 +1,73 @@
|
||||
TARGET:= checkStackUsage.py
|
||||
PYTHON:=python3
|
||||
VENV:=.venv
|
||||
|
||||
all: .setup .analysed test ## Check everything
|
||||
|
||||
.analysed: ${TARGET}
|
||||
$(MAKE) flake8
|
||||
$(MAKE) pylint
|
||||
$(MAKE) mypy
|
||||
@touch $@
|
||||
|
||||
flake8: dev-install ## PEP8 compliance checks with Flake8
|
||||
@echo "============================================"
|
||||
@echo " Running flake8..."
|
||||
@echo "============================================"
|
||||
${VENV}/bin/flake8 ${TARGET}
|
||||
|
||||
pylint: dev-install ## Static analysis with Pylint
|
||||
@echo "============================================"
|
||||
@echo " Running pylint..."
|
||||
@echo "============================================"
|
||||
${VENV}/bin/pylint --disable=I --rcfile=pylint.cfg ${TARGET}
|
||||
|
||||
mypy: dev-install ## Type checking with mypy
|
||||
@echo "============================================"
|
||||
@echo " Running mypy..."
|
||||
@echo "============================================"
|
||||
${VENV}/bin/mypy --ignore-missing-imports ${TARGET}
|
||||
|
||||
dev-install: .setup | prereq
|
||||
|
||||
prereq:
|
||||
@${PYTHON} -c 'import sys; sys.exit(1 if (sys.version_info.major<3 or sys.version_info.minor<5) else 0)' || { \
|
||||
echo "=============================================" ; \
|
||||
echo "[x] You need at least Python 3.5 to run this." ; \
|
||||
echo "=============================================" ; \
|
||||
exit 1 ; \
|
||||
}
|
||||
|
||||
.setup: requirements.txt
|
||||
@if [ ! -d ${VENV} ] ; then \
|
||||
echo "[-] Installing VirtualEnv environment..." ; \
|
||||
${PYTHON} -m venv ${VENV} || exit 1 ; \
|
||||
fi
|
||||
echo "[-] Installing packages inside environment..." ; \
|
||||
. ${VENV}/bin/activate || exit 1 ; \
|
||||
${PYTHON} -m pip install -r requirements.txt || exit 1
|
||||
touch $@
|
||||
|
||||
test: ## Test proper functioning
|
||||
$(MAKE) -C tests/
|
||||
|
||||
clean: ## Cleanup artifacts
|
||||
rm -rf .cache/ .mypy_cache/ .analysed .setup __pycache__ \
|
||||
tests/__pycache__ .pytest_cache/ .processed .coverage
|
||||
$(MAKE) -C tests/ clean
|
||||
|
||||
help: ## Display this help section
|
||||
@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z0-9_-]+:.*?## / {printf "\033[36m%-18s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST)
|
||||
.DEFAULT_GOAL := help
|
||||
|
||||
define newline # a literal \n
|
||||
|
||||
|
||||
endef
|
||||
|
||||
# Makefile debugging trick:
|
||||
# call print-VARIABLE to see the runtime value of any variable
|
||||
# (hardened a bit against some special characters appearing in the output)
|
||||
print-%:
|
||||
@echo '$*=$(subst ','\'',$(subst $(newline),\n,$($*)))'
|
||||
.PHONY: flake8 pylint mypy clean dev-install prereq
|
||||
@@ -0,0 +1,173 @@
|
||||
*(Detailed blog post [here](https://www.thanassis.space/stackusage.html) )*
|
||||
|
||||
# Introduction
|
||||
|
||||
This is a utility that computes the stack usage per function. It is
|
||||
particularly useful in embedded systems programming, where memory is at a
|
||||
premium - and also in safety-critical SW *(blowing up from a stack overflow
|
||||
while you operate medical equipment or fly in space is not exactly optimal)*.
|
||||
|
||||
# In detail
|
||||
|
||||
*(Detailed blog post [here](https://www.thanassis.space/stackusage.html) )*
|
||||
|
||||
You can read many details about how this script works in the blog post
|
||||
linked above; but the executive summary is this:
|
||||
|
||||
- We expect the source code compilation to use GCC's `-fstack-usage`.
|
||||
This generates `.su` files with the stack usage of each function
|
||||
**(in isolation)** stored per compilation unit. Simply put, `file.c`
|
||||
compiled with `-fstack-usage` will create `file.o` *and* `file.su`.
|
||||
|
||||
- The script can then be launched like so:
|
||||
|
||||
checkStackUsage.py binaryELF folderTreeContainingSUfiles
|
||||
|
||||
For example, if after the build we have a tree like this:
|
||||
|
||||
bin/
|
||||
someBinary
|
||||
src/
|
||||
file1.c
|
||||
file1.o
|
||||
file1.su
|
||||
lib1_src/
|
||||
lib1.c
|
||||
lib1.o
|
||||
lib1.su
|
||||
lib2_src/
|
||||
lib2.c
|
||||
lib2.o
|
||||
lib2.su
|
||||
|
||||
...we run this:
|
||||
|
||||
checkStackUsage.py bin/someBinary src/
|
||||
|
||||
The script will scan all .su files in the `src` folder *(recursively,
|
||||
at any depth)* and collect the standalone use of stack for each function.
|
||||
|
||||
It will then launch the appropriate `objdump` with option `-d` - to
|
||||
disassemble the code, and create the call graph. Simplistically, it
|
||||
detects patterns like this:
|
||||
|
||||
<foo>:
|
||||
....
|
||||
call <func>
|
||||
|
||||
...and proceeds from there to create the entire call graph.
|
||||
It can then accumulate the use of all subordinate calls from each function,
|
||||
and therefore compute it's total stack usage.
|
||||
|
||||
Output looks like this:
|
||||
|
||||
176: foo (foo(16),func(160))
|
||||
288: func (func(288))
|
||||
304: bar (bar(16),func(288))
|
||||
320: main (main(16),bar(16),func(288))
|
||||
|
||||
...which means that function `foo` uses 176 bytes of stack; 16 because of
|
||||
itself, and 160 because it calls `func`. `main` uses 320 bytes, etc.
|
||||
|
||||
Notice that `bar` also uses `func` - but reports a larger stack size for it
|
||||
in that call chain. Read section "Repeated functions" below, to see why;
|
||||
suffice to say, this is one of the few stack checkers that can cope with
|
||||
symbols defined more than once.
|
||||
|
||||
# Platforms
|
||||
|
||||
The script needs to spawn the right `objdump`. It uses
|
||||
`file` to detect the ELF signature, and uses appropriate regexes
|
||||
to match disassembly `call` forms for:
|
||||
|
||||
- SPARC/LEONs (used in the European Space Agency missions)
|
||||
- x86/amd64 (both 32 and 64 bits)
|
||||
- 32-bit ARM
|
||||
|
||||
Adding additional platforms is very easy - just tell the script what
|
||||
`objdump` flavor to use, and what regex to scan for to locate the
|
||||
call sequences; [relevant code is here](checkStackUsage.py#L198).
|
||||
|
||||
# Repeated functions
|
||||
|
||||
Each function can only have a specific stack usage - right?
|
||||
|
||||
Sadly, no :-(
|
||||
|
||||
Feast yourself on moronic - yet perfectly valid - C code like this:
|
||||
|
||||
// a.c
|
||||
static int func() { ...}
|
||||
void foo() { func(); }
|
||||
|
||||
// b.c
|
||||
static int func() { ...}
|
||||
void bar() { func(); }
|
||||
|
||||
"Houston, we have a problem". While scanning the `.su` files for `a.c`
|
||||
and `b.c`, we find `func` twice - and due to the `static`, we want
|
||||
to use the right value on each call (from `foo`/`bar`) based on
|
||||
filescope. In effect, the .su files' content need to be read
|
||||
*prioritizing local static calls* when computing stack usage.
|
||||
|
||||
# Hidden calls
|
||||
|
||||
The scanning of `objdump` output for call sequences is the best we can do;
|
||||
but it's not perfect. For example, any calls made via function pointer
|
||||
indirections are "invisible" to this process.
|
||||
|
||||
And since fp-based calls can do all sorts of shenanigans - e.g.
|
||||
reading the call endpoint from an array of functions via some
|
||||
algorithm - statically deducing which functions are actually called
|
||||
is tantamount to the halting problem.
|
||||
|
||||
I am open to suggestions on this.
|
||||
|
||||
# Static Analysis
|
||||
|
||||
The script is written in Python - `make all` will check it with:
|
||||
|
||||
- `flake8` (PEP8 compliance)
|
||||
- `pylint` (Static Analysis)
|
||||
- ...and `mypy` (static type checking).
|
||||
|
||||
All dependencies to perform these checks will be automatically
|
||||
installed via `pip` in a local virtual environment (i.e.
|
||||
under folder `.venv`) the first time you invoke `make all`.
|
||||
|
||||
# Test example
|
||||
|
||||
The scenario of repeated functions is tested via `make test`;
|
||||
in my 64-bit Arch Linux I see this output:
|
||||
|
||||
$ make test
|
||||
...
|
||||
make[1]: Entering directory '/home/ttsiod/Github/checkStackUsage/tests'
|
||||
==============================================
|
||||
176: foo (foo(16),func(160))
|
||||
288: func (func(288))
|
||||
304: bar (bar(16),func(288))
|
||||
320: main (main(16),bar(16),func(288))
|
||||
==============================================
|
||||
1. The output shown above must contain 4 lines
|
||||
2. 'foo' and 'bar' must both be calling 'func'
|
||||
*but with different stack sizes in each*.
|
||||
3. 'main' must be using the largest 'func'
|
||||
(i.e. be going through 'bar')
|
||||
4. The reported sizes must properly accumulate
|
||||
==============================================
|
||||
make[1]: Leaving directory '/home/ttsiod/Github/checkStackUsage/tests'
|
||||
|
||||
Given the content of [a.c](tests/a.c), [b.c](tests/b.c) and
|
||||
[main.c](tests/main.c), the output looks good. Notice that for
|
||||
`func` we report the maximum of the two (the one reported by
|
||||
GCC inside `b.c`, when it is called by `bar`).
|
||||
|
||||
# Feedback
|
||||
|
||||
If you see something wrong in the script that isn't documented above,
|
||||
questions (and much better, pull requests) are most welcome.
|
||||
|
||||
Thanassis Tsiodras, Dr.-Ing.
|
||||
ttsiodras_at-no-spam_thanks-gmail_dot-com
|
||||
|
||||
Executable
+445
@@ -0,0 +1,445 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Utility to detect recursive calls and calculate total stack usage per function
|
||||
(via following the call graph).
|
||||
|
||||
Published under the GPL, (C) 2011 Thanassis Tsiodras
|
||||
Suggestions/comments: ttsiodras@gmail.com
|
||||
|
||||
Updated to use GCC-based .su files (-fstack-usage) in 2021.
|
||||
"""
|
||||
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
import operator
|
||||
|
||||
from typing import Dict, Set, Optional, List, Tuple
|
||||
|
||||
FunctionName = str
|
||||
FunctionNameToInt = Dict[FunctionName, int]
|
||||
|
||||
# For each function, what is the set of functions it calls?
|
||||
CallGraph = Dict[FunctionName, Optional[Set[FunctionName]]]
|
||||
|
||||
# .su files data
|
||||
Filename = str
|
||||
SuData = Dict[FunctionName, List[Tuple[Filename, int]]]
|
||||
|
||||
|
||||
# findStackUsage will return a tuple:
|
||||
# - The total stack size used
|
||||
# - A list of pairs, of the functions/stacksizes, adding up to the final use.
|
||||
UsageResult = Tuple[int, List[Tuple[FunctionName, int]]]
|
||||
|
||||
|
||||
class Matcher:
|
||||
"""regexp helper"""
|
||||
def __init__(self, pattern, flags=0):
|
||||
self._pattern = re.compile(pattern, flags)
|
||||
self._hit = None
|
||||
|
||||
def match(self, line):
|
||||
self._hit = re.match(self._pattern, line)
|
||||
return self._hit
|
||||
|
||||
def search(self, line):
|
||||
self._hit = re.search(self._pattern, line)
|
||||
return self._hit
|
||||
|
||||
def group(self, idx):
|
||||
return self._hit.group(idx)
|
||||
|
||||
|
||||
def lookupStackSizeOfFunction(
|
||||
fn: FunctionName,
|
||||
fns: List[Tuple[FunctionName, int]],
|
||||
suData: SuData,
|
||||
stackUsagePerFunction: FunctionNameToInt) -> int:
|
||||
"""
|
||||
What do you do when you have moronic C code like this?
|
||||
|
||||
===
|
||||
a.c
|
||||
===
|
||||
static int func() { ...}
|
||||
void foo() { func(); }
|
||||
|
||||
===
|
||||
b.c
|
||||
===
|
||||
static int func() { ...}
|
||||
void bar() { func(); }
|
||||
|
||||
You have a problem. There is only one entry in stackUsagePerFunction,
|
||||
since we assign as we scan the su files - but you basically want to
|
||||
use the right value, based on filescope (due to the static).
|
||||
In effect, the .su files need to be read *prioritizing local calls*
|
||||
when computing stack usage.
|
||||
|
||||
So what we do is this: we have suData - a dictionary that stores
|
||||
per each function name, WHERE we found it (at which .su filenames)
|
||||
and what size it had in each of them. We scan that list, looking for
|
||||
the last filename in our call chain so far (i.e. the last of the 'fns').
|
||||
|
||||
And we then report the associated stack use.
|
||||
"""
|
||||
# If the call chain so far is empty, or our function is not in the
|
||||
# .su files (e.g. it comes from a library we linked with), then we
|
||||
# use the 'su-agnostic' information we got during our symbol scan.
|
||||
if not fns or fn not in suData:
|
||||
return stackUsagePerFunction[fn]
|
||||
|
||||
# Otherwise, we first get the last function in the call chain...
|
||||
suFilename = None
|
||||
lastCallData = fns[-1]
|
||||
functionName = lastCallData[0]
|
||||
|
||||
# ...and use the .su files information to get the file it lives in
|
||||
# Remember, SuData is a Dict[FunctionName, List[Tuple[Filename, int]]]
|
||||
suList = suData.get(functionName, [])
|
||||
if suList:
|
||||
suFilename = suList[0][0] # Get the filename part of the first tuple
|
||||
if not suFilename:
|
||||
return stackUsagePerFunction[fn]
|
||||
|
||||
# Now that we have the filename of our last caller in the chain
|
||||
# that calls us, scan our OWN existence in the .su data, to find
|
||||
# the one that matches - thus prioritizing local calls!
|
||||
for elem in suData.get(fn, []):
|
||||
xFilename, xStackUsage = elem
|
||||
if xFilename == suFilename:
|
||||
return xStackUsage
|
||||
|
||||
# ...otherwise (no match in the .su data) we use the 'su-agnostic'
|
||||
# information we got during our symbol scan.
|
||||
return stackUsagePerFunction[fn]
|
||||
|
||||
|
||||
def findStackUsage(
|
||||
fn: FunctionName,
|
||||
fns: List[Tuple[FunctionName, int]],
|
||||
suData: SuData,
|
||||
stackUsagePerFunction: FunctionNameToInt,
|
||||
callGraph: CallGraph,
|
||||
badSymbols: Set[FunctionName]) -> UsageResult:
|
||||
"""
|
||||
Calculate the total stack usage of the input function,
|
||||
taking into account who it calls.
|
||||
"""
|
||||
if fn in [x[0] for x in fns]:
|
||||
# So, what to do with recursive functions?
|
||||
# We just reached this point with fns looking like this:
|
||||
# [a, b, c, d, a]
|
||||
# A "baseline" answer is better than no answer;
|
||||
# so we let the parent series of calls accumulate to
|
||||
# as + bs + cs + ds
|
||||
# ...ie. the stack sizes of all others.
|
||||
# We therefore return 0 for this "last step"
|
||||
# and stop the recursion here.
|
||||
totalStackUsage = sum(x[1] for x in fns)
|
||||
if fn not in badSymbols:
|
||||
# Report recursive functions.
|
||||
badSymbols.add(fn)
|
||||
print("[x] Recursion detected:", fn, 'is called from',
|
||||
fns[-1][0], 'in this chain:', fns)
|
||||
return (totalStackUsage, fns[:])
|
||||
|
||||
if fn not in stackUsagePerFunction:
|
||||
# Unknown function, what else to do? Count it as 0 stack usage...
|
||||
totalStackUsage = sum(x[1] for x in fns)
|
||||
return (totalStackUsage, fns[:] + [(fn, 0)])
|
||||
|
||||
thisFunctionStackSize = lookupStackSizeOfFunction(
|
||||
fn, fns, suData, stackUsagePerFunction)
|
||||
calledFunctions = callGraph.get(fn, set())
|
||||
|
||||
# If we call noone else, stack usage is just our own stack usage
|
||||
if fn not in callGraph or not calledFunctions:
|
||||
totalStackUsage = sum(x[1] for x in fns) + thisFunctionStackSize
|
||||
res = (totalStackUsage, fns[:] + [(fn, thisFunctionStackSize)])
|
||||
return res
|
||||
|
||||
# Otherwise, we check the stack usage for each function we call
|
||||
totalStackUsage = 0
|
||||
maxStackPath = []
|
||||
for x in sorted(calledFunctions):
|
||||
total, path = findStackUsage(
|
||||
x,
|
||||
fns[:] + [(fn, thisFunctionStackSize)],
|
||||
suData,
|
||||
stackUsagePerFunction,
|
||||
callGraph,
|
||||
badSymbols)
|
||||
if total > totalStackUsage:
|
||||
totalStackUsage = total
|
||||
maxStackPath = path
|
||||
return (totalStackUsage, maxStackPath[:])
|
||||
|
||||
|
||||
def ParseCmdLineArgs(cross_prefix: str) -> Tuple[
|
||||
str, str, Matcher, Matcher, Matcher]:
|
||||
if cross_prefix:
|
||||
objdump = cross_prefix + 'objdump'
|
||||
nm = cross_prefix + 'nm'
|
||||
functionNamePattern = Matcher(r'^(\S+) <([a-zA-Z0-9\._]+?)>:')
|
||||
callPattern = Matcher(r'^.*call\s+\S+\s+<([a-zA-Z0-9\._]+)>')
|
||||
stackUsagePattern = Matcher(
|
||||
r'^.*save.*%sp, (-[0-9]{1,}), %sp')
|
||||
else:
|
||||
binarySignature = os.popen(f"file \"{sys.argv[-2]}\"").readlines()[0]
|
||||
|
||||
x86 = Matcher(r'ELF 32-bit LSB.*80.86')
|
||||
x64 = Matcher(r'ELF 64-bit LSB.*x86-64')
|
||||
leon = Matcher(r'ELF 32-bit MSB.*SPARC')
|
||||
arm = Matcher(r'ELF 32-bit LSB.*ARM')
|
||||
|
||||
if x86.search(binarySignature):
|
||||
objdump = 'objdump'
|
||||
nm = 'nm'
|
||||
functionNamePattern = Matcher(r'^(\S+) <([a-zA-Z0-9_]+?)>:')
|
||||
callPattern = Matcher(r'^.*call\s+\S+\s+<([a-zA-Z0-9_]+)>')
|
||||
stackUsagePattern = Matcher(r'^.*[add|sub]\s+\$(0x\S+),%esp')
|
||||
elif x64.search(binarySignature):
|
||||
objdump = 'objdump'
|
||||
nm = 'nm'
|
||||
functionNamePattern = Matcher(r'^(\S+) <([a-zA-Z0-9_]+?)>:')
|
||||
callPattern = Matcher(r'^.*callq?\s+\S+\s+<([a-zA-Z0-9_]+)>')
|
||||
stackUsagePattern = Matcher(r'^.*[add|sub]\s+\$(0x\S+),%rsp')
|
||||
elif leon.search(binarySignature):
|
||||
objdump = 'sparc-rtems5-objdump'
|
||||
nm = 'sparc-rtems5-nm'
|
||||
functionNamePattern = Matcher(r'^(\S+) <([a-zA-Z0-9_]+?)>:')
|
||||
callPattern = Matcher(r'^.*call\s+\S+\s+<([a-zA-Z0-9_]+)>')
|
||||
stackUsagePattern = Matcher(
|
||||
r'^.*save.*%sp, (-([0-9]{2}|[3-9])[0-9]{2}), %sp')
|
||||
elif arm.search(binarySignature):
|
||||
objdump = 'arm-none-eabi-objdump'
|
||||
nm = 'arm-none-eabi-nm'
|
||||
functionNamePattern = Matcher(r'^(\S+) <([a-zA-Z0-9_]+?)>:')
|
||||
callPattern = Matcher(r'^.*bl\s+\S+\s+<([a-zA-Z0-9_]+)>')
|
||||
stackUsagePattern = Matcher(
|
||||
r'^.*sub.*sp, (#[0-9][0-9]*)')
|
||||
else:
|
||||
print("Unknown signature:", binarySignature, "please use -cross")
|
||||
sys.exit(1)
|
||||
return objdump, nm, functionNamePattern, callPattern, stackUsagePattern
|
||||
|
||||
|
||||
def GetSizeOfSymbols(nm: str, elf_binary: str) -> Tuple[
|
||||
FunctionNameToInt, FunctionNameToInt]:
|
||||
# Store .text symbol offsets and sizes (use nm)
|
||||
offsetOfSymbol = {} # type: FunctionNameToInt
|
||||
for line in os.popen(
|
||||
nm + " \"" + elf_binary + "\" | grep ' [Tt] '").readlines():
|
||||
offsetData, unused, symbolData = line.split()
|
||||
offsetOfSymbol[symbolData] = int(offsetData, 16)
|
||||
sizeOfSymbol = {}
|
||||
lastOffset = 0
|
||||
lastSymbol = ""
|
||||
sortedSymbols = sorted(
|
||||
offsetOfSymbol.items(), key=operator.itemgetter(1))
|
||||
for symbolStr, offsetInt in sortedSymbols:
|
||||
if lastSymbol != "":
|
||||
sizeOfSymbol[lastSymbol] = offsetInt - lastOffset
|
||||
lastSymbol = symbolStr
|
||||
lastOffset = offsetInt
|
||||
sizeOfSymbol[lastSymbol] = 2**31 # allow last .text symbol to roam free
|
||||
return sizeOfSymbol, offsetOfSymbol
|
||||
|
||||
|
||||
def GetCallGraph(
|
||||
objdump: str,
|
||||
offsetOfSymbol: FunctionNameToInt, sizeOfSymbol: FunctionNameToInt,
|
||||
functionNamePattern: Matcher, stackUsagePattern: Matcher,
|
||||
callPattern: Matcher) -> Tuple[CallGraph, FunctionNameToInt]:
|
||||
|
||||
# Parse disassembly to create callgraph (use objdump -d)
|
||||
functionName = ""
|
||||
stackUsagePerFunction = {} # type: FunctionNameToInt
|
||||
callGraph = {} # type: CallGraph
|
||||
insideFunctionBody = False
|
||||
|
||||
offsetPattern = Matcher(r'^([0-9A-Za-z]+):')
|
||||
for line in os.popen(objdump + " -d \"" + sys.argv[-2] + "\"").readlines():
|
||||
# Have we matched a function name yet?
|
||||
if functionName != "":
|
||||
# Yes, update "insideFunctionBody" boolean by checking
|
||||
# the current offset against the length of this symbol,
|
||||
# stored in sizeOfSymbol[functionName]
|
||||
offset = offsetPattern.match(line)
|
||||
if offset:
|
||||
offset = int(offset.group(1), 16)
|
||||
if functionName in offsetOfSymbol:
|
||||
startOffset = offsetOfSymbol[functionName]
|
||||
insideFunctionBody = \
|
||||
insideFunctionBody and \
|
||||
(offset - startOffset) < sizeOfSymbol[functionName]
|
||||
|
||||
# Check to see if we see a new function:
|
||||
# 08048be8 <_functionName>:
|
||||
fn = functionNamePattern.match(line)
|
||||
if fn:
|
||||
offset = int(fn.group(1), 16)
|
||||
functionName = fn.group(2)
|
||||
callGraph.setdefault(functionName, set())
|
||||
# make sure this is the function we found with nm
|
||||
# UPDATE: no, can't do - if a symbol is of local file scope
|
||||
# (i.e. if it was declared with 'static')
|
||||
# then it may appear in multiple offsets!...
|
||||
#
|
||||
# if functionName in offsetOfSymbol:
|
||||
# if offsetOfSymbol[functionName] != offset:
|
||||
# print "Weird,", functionName, \
|
||||
# "is not at offset reported by", nm
|
||||
# print hex(offsetOfSymbol[functionName]), hex(offset)
|
||||
insideFunctionBody = True
|
||||
foundFirstCall = False
|
||||
stackUsagePerFunction[functionName] = 0
|
||||
|
||||
# If we're inside a function body
|
||||
# (i.e. offset is not out of symbol size range)
|
||||
if insideFunctionBody:
|
||||
# Check to see if we have a call
|
||||
# 8048c0a: e8 a1 03 00 00 call 8048fb0 <frame_dummy>
|
||||
call = callPattern.match(line)
|
||||
if functionName != "" and call:
|
||||
foundFirstCall = True
|
||||
calledFunction = call.group(1)
|
||||
calledFunctions = callGraph[functionName]
|
||||
if calledFunctions is not None:
|
||||
calledFunctions.add(calledFunction)
|
||||
|
||||
# Check to see if we have a stack reduction opcode
|
||||
# 8048bec: 83 ec 04 sub $0x46,%esp
|
||||
if functionName != "" and not foundFirstCall:
|
||||
stackMatch = stackUsagePattern.match(line)
|
||||
if stackMatch:
|
||||
value = stackMatch.group(1)
|
||||
if value.startswith("0x"):
|
||||
# sub $0x46,%esp
|
||||
value = int(stackMatch.group(1), 16)
|
||||
if value > 2147483647:
|
||||
# unfortunately, GCC may also write:
|
||||
# add $0xFFFFFF86,%esp
|
||||
value = 4294967296 - value
|
||||
elif value.startswith("#"):
|
||||
# sub sp, sp, #1024
|
||||
value = int(value[1:])
|
||||
else:
|
||||
# save %sp, -104, %sp
|
||||
value = -int(value)
|
||||
assert(
|
||||
stackUsagePerFunction[functionName] is not None)
|
||||
stackUsagePerFunction[functionName] += value
|
||||
|
||||
# for fn,v in stackUsagePerFunction.items():
|
||||
# print fn,v
|
||||
# print "CALLS:", callGraph[fn]
|
||||
return callGraph, stackUsagePerFunction
|
||||
|
||||
|
||||
def ReadSU(fullPathToSuFile: str) -> Tuple[FunctionNameToInt, SuData]:
|
||||
stackUsagePerFunction = {} # type: FunctionNameToInt
|
||||
suData = {} # type: SuData
|
||||
# pylint: disable=R1732
|
||||
for line in open(fullPathToSuFile, encoding='utf-8'):
|
||||
data = line.strip().split()
|
||||
if len(data) == 3 and data[2] == 'static':
|
||||
try:
|
||||
functionName = data[0].split(':')[-1]
|
||||
functionStackUsage = int(data[1])
|
||||
except ValueError:
|
||||
continue
|
||||
stackUsagePerFunction[functionName] = functionStackUsage
|
||||
suData.setdefault(functionName, []).append(
|
||||
(fullPathToSuFile, functionStackUsage))
|
||||
return stackUsagePerFunction, suData
|
||||
|
||||
|
||||
def GetSizesFromSUfiles(root_path) -> Tuple[FunctionNameToInt, SuData]:
|
||||
stackUsagePerFunction = {} # type: FunctionNameToInt
|
||||
suData = {} # type: SuData
|
||||
for root, unused_dirs, files in os.walk(root_path):
|
||||
for f in files:
|
||||
if f.endswith('.su'):
|
||||
supf, sud = ReadSU(root + os.sep + f)
|
||||
for functionName, v1 in supf.items():
|
||||
stackUsagePerFunction[functionName] = max(
|
||||
v1, stackUsagePerFunction.get(functionName, 0))
|
||||
|
||||
# We need to augment the list of .su if there's
|
||||
# a symbol that appears in two or more .su files.
|
||||
# SuData = Dict[FunctionName, List[Tuple[Filename, int]]]
|
||||
for functionName, v2 in sud.items():
|
||||
suData.setdefault(functionName, []).extend(v2)
|
||||
return stackUsagePerFunction, suData
|
||||
|
||||
|
||||
def main() -> None:
|
||||
cross_prefix = ''
|
||||
try:
|
||||
idx = sys.argv.index("-cross")
|
||||
except ValueError:
|
||||
idx = -1
|
||||
if idx != -1:
|
||||
cross_prefix = sys.argv[idx + 1]
|
||||
del sys.argv[idx]
|
||||
del sys.argv[idx]
|
||||
|
||||
chosenFunctionNames = []
|
||||
if len(sys.argv) >= 4:
|
||||
chosenFunctionNames = sys.argv[3:]
|
||||
sys.argv = sys.argv[:3]
|
||||
|
||||
if len(sys.argv) < 3 or not os.path.exists(sys.argv[-2]) \
|
||||
or not os.path.isdir(sys.argv[-1]):
|
||||
print(f"Usage: {sys.argv[0]} [-cross PREFIX]"
|
||||
" ELFbinary root_path_for_su_files [functions...]")
|
||||
print("\nwhere the default prefix is:\n")
|
||||
print("\tarm-none-eabi- for ARM binaries")
|
||||
print("\tsparc-rtems5- for SPARC binaries")
|
||||
print("\t(no prefix) for x86/amd64 binaries")
|
||||
print("\nNote that if you use '-cross', SPARC opcodes are assumed.\n")
|
||||
sys.exit(1)
|
||||
|
||||
objdump, nm, functionNamePattern, callPattern, stackUsagePattern = \
|
||||
ParseCmdLineArgs(cross_prefix)
|
||||
sizeOfSymbol, offsetOfSymbol = GetSizeOfSymbols(nm, sys.argv[-2])
|
||||
callGraph, stackUsagePerFunction = GetCallGraph(
|
||||
objdump,
|
||||
offsetOfSymbol, sizeOfSymbol,
|
||||
functionNamePattern, stackUsagePattern, callPattern)
|
||||
|
||||
supf, suData = GetSizesFromSUfiles(sys.argv[-1])
|
||||
alreadySeen = set() # type: Set[Filename]
|
||||
badSymbols = set() # type: Set[Filename]
|
||||
for k, v in supf.items():
|
||||
if k in alreadySeen:
|
||||
badSymbols.add(k)
|
||||
alreadySeen.add(k)
|
||||
stackUsagePerFunction[k] = max(
|
||||
v, stackUsagePerFunction.get(k, 0))
|
||||
|
||||
# Then, navigate the graph to calculate stack needs per function
|
||||
results = []
|
||||
for fn, value in stackUsagePerFunction.items():
|
||||
if chosenFunctionNames and fn not in chosenFunctionNames:
|
||||
continue
|
||||
if value is not None:
|
||||
results.append(
|
||||
(fn,
|
||||
findStackUsage(
|
||||
fn, [], suData, stackUsagePerFunction, callGraph,
|
||||
badSymbols)))
|
||||
for fn, data in sorted(results, key=lambda x: x[1][0]):
|
||||
# pylint: disable=C0209
|
||||
print(
|
||||
"%10s: %s (%s)" % (
|
||||
data[0], fn, ",".join(
|
||||
x[0] + "(" + str(x[1]) + ")"
|
||||
for x in data[1])))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,381 @@
|
||||
[MASTER]
|
||||
|
||||
# Specify a configuration file.
|
||||
#rcfile=
|
||||
|
||||
# Python code to execute, usually for sys.path manipulation such as
|
||||
# pygtk.require().
|
||||
#init-hook=
|
||||
|
||||
# Add files or directories to the blacklist. They should be base names, not
|
||||
# paths.
|
||||
ignore=CVS
|
||||
|
||||
# Pickle collected data for later comparisons.
|
||||
persistent=yes
|
||||
|
||||
# List of plugins (as comma separated values of python modules names) to load,
|
||||
# usually to register additional checkers.
|
||||
load-plugins=
|
||||
|
||||
# Use multiple processes to speed up Pylint.
|
||||
jobs=1
|
||||
|
||||
# Allow loading of arbitrary C extensions. Extensions are imported into the
|
||||
# active Python interpreter and may run arbitrary code.
|
||||
unsafe-load-any-extension=no
|
||||
|
||||
# A comma-separated list of package or module names from where C extensions may
|
||||
# be loaded. Extensions are loading into the active Python interpreter and may
|
||||
# run arbitrary code
|
||||
extension-pkg-whitelist=lxml,clang
|
||||
|
||||
# Allow optimization of some AST trees. This will activate a peephole AST
|
||||
# optimizer, which will apply various small optimizations. For instance, it can
|
||||
# be used to obtain the result of joining multiple strings with the addition
|
||||
# operator. Joining a lot of strings can lead to a maximum recursion error in
|
||||
# Pylint and this flag can prevent that. It has one side effect, the resulting
|
||||
# AST will be different than the one from reality.
|
||||
optimize-ast=no
|
||||
|
||||
|
||||
[MESSAGES CONTROL]
|
||||
|
||||
# Only show warnings with the listed confidence levels. Leave empty to show
|
||||
# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED
|
||||
confidence=
|
||||
|
||||
# Enable the message, report, category or checker with the given id(s). You can
|
||||
# either give multiple identifier separated by comma (,) or put this option
|
||||
# multiple time (only on the command line, not in the configuration file where
|
||||
# it should appear only once). See also the "--disable" option for examples.
|
||||
#enable=
|
||||
|
||||
# Disable the message, report, category or checker with the given id(s). You
|
||||
# can either give multiple identifiers separated by comma (,) or put this
|
||||
# option multiple times (only on the command line, not in the configuration
|
||||
# file where it should appear only once).You can also use "--disable=all" to
|
||||
# disable everything first and then reenable specific checks. For example, if
|
||||
# you want to run only the similarities checker, you can use "--disable=all
|
||||
# --enable=similarities". If you want to run only the classes checker, but have
|
||||
# no Warning level messages displayed, use"--disable=all --enable=classes
|
||||
# --disable=W"
|
||||
disable=coerce-method,nonzero-method,buffer-builtin,unichr-builtin,reload-builtin,using-cmp-argument,reduce-builtin,filter-builtin-not-iterating,zip-builtin-not-iterating,raising-string,long-builtin,backtick,long-suffix,delslice-method,suppressed-message,cmp-method,old-octal-literal,basestring-builtin,metaclass-assignment,print-statement,execfile-builtin,round-builtin,oct-method,standarderror-builtin,hex-method,import-star-module-level,indexing-exception,map-builtin-not-iterating,old-ne-operator,setslice-method,input-builtin,apply-builtin,range-builtin-not-iterating,xrange-builtin,parameter-unpacking,no-absolute-import,old-raise-syntax,dict-iter-method,unicode-builtin,unpacking-in-except,old-division,file-builtin,next-method-called,useless-suppression,raw_input-builtin,intern-builtin,getslice-method,dict-view-method,cmp-builtin,coerce-builtin,line-too-long,missing-docstring,protected-access,global-statement,too-many-arguments,too-many-branches,too-many-locals,bare-except,invalid-name,too-many-statements,broad-except,too-many-instance-attributes,too-many-public-methods,too-few-public-methods,similarities,no-else-return,fixme,relative-beyond-top-level,import-outside-toplevel,too-many-nested-blocks
|
||||
|
||||
never-returning-functions=dmt.commonPy.utility.panic,sys.exit
|
||||
|
||||
[REPORTS]
|
||||
|
||||
# Set the output format. Available formats are text, parseable, colorized, msvs
|
||||
# (visual studio) and html. You can also give a reporter class, eg
|
||||
# mypackage.mymodule.MyReporterClass.
|
||||
output-format=text
|
||||
|
||||
# Put messages in a separate file for each module / package specified on the
|
||||
# command line instead of printing them on stdout. Reports (if any) will be
|
||||
# written in a file name "pylint_global.[txt|html]".
|
||||
files-output=no
|
||||
|
||||
# Tells whether to display a full report or only the messages
|
||||
reports=yes
|
||||
|
||||
# Python expression which should return a note less than 10 (10 is the highest
|
||||
# note). You have access to the variables errors warning, statement which
|
||||
# respectively contain the number of errors / warnings messages and the total
|
||||
# number of statements analyzed. This is used by the global evaluation report
|
||||
# (RP0004).
|
||||
evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
|
||||
|
||||
# Template used to display messages. This is a python new-style format string
|
||||
# used to format the message information. See doc for all details
|
||||
#msg-template=
|
||||
|
||||
|
||||
[BASIC]
|
||||
|
||||
# List of builtins function names that should not be used, separated by a comma
|
||||
bad-functions=map,filter
|
||||
|
||||
# Good variable names which should always be accepted, separated by a comma
|
||||
good-names=i,j,k,ex,Run,_
|
||||
|
||||
# Bad variable names which should always be refused, separated by a comma
|
||||
bad-names=foo,bar,baz,toto,tutu,tata
|
||||
|
||||
# Colon-delimited sets of names that determine each other's naming style when
|
||||
# the name regexes allow several styles.
|
||||
name-group=
|
||||
|
||||
# Include a hint for the correct naming format with invalid-name
|
||||
include-naming-hint=no
|
||||
|
||||
# Regular expression matching correct module names
|
||||
module-rgx=(([a-z_][A-Za-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
|
||||
|
||||
# Naming hint for module names
|
||||
module-name-hint=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
|
||||
|
||||
# Regular expression matching correct constant names
|
||||
const-rgx=(([a-zA-Z_][a-zA-Z0-9_]*)|(__.*__))$
|
||||
|
||||
# Naming hint for constant names
|
||||
const-name-hint=(([a-zA-Z_][A-Z0-9_]*)|(__.*__))$
|
||||
|
||||
# Regular expression matching correct class names
|
||||
class-rgx=[A-Z_][a-zA-Z0-9]+$
|
||||
|
||||
# Naming hint for class names
|
||||
class-name-hint=[A-Z_][a-zA-Z0-9]+$
|
||||
|
||||
# Regular expression matching correct method names
|
||||
method-rgx=[a-zA-Z_][a-zA-Z0-9_]{2,30}$
|
||||
|
||||
# Naming hint for method names
|
||||
method-name-hint=[a-z_][a-z0-9_]{2,30}$
|
||||
|
||||
# Regular expression matching correct argument names
|
||||
argument-rgx=[a-z_][A-Za-z0-9_]{2,30}$
|
||||
|
||||
# Naming hint for argument names
|
||||
argument-name-hint=[a-z_][A-Za-z0-9_]{2,30}$
|
||||
|
||||
# Regular expression matching correct class attribute names
|
||||
class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$
|
||||
|
||||
# Naming hint for class attribute names
|
||||
class-attribute-name-hint=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$
|
||||
|
||||
# Regular expression matching correct inline iteration names
|
||||
inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$
|
||||
|
||||
# Naming hint for inline iteration names
|
||||
inlinevar-name-hint=[A-Za-z_][A-Za-z0-9_]*$
|
||||
|
||||
# Regular expression matching correct function names
|
||||
function-rgx=[A-Za-z_][A-Za-z0-9_]{2,30}$
|
||||
|
||||
# Naming hint for function names
|
||||
function-name-hint=[a-z_][a-z0-9_]{2,30}$
|
||||
|
||||
# Regular expression matching correct attribute names
|
||||
attr-rgx=[a-z_][A-Za-z0-9_]{2,30}$
|
||||
|
||||
# Naming hint for attribute names
|
||||
attr-name-hint=[a-z_][a-z0-9_]{2,30}$
|
||||
|
||||
# Regular expression matching correct variable names
|
||||
variable-rgx=[a-z_][A-Za-z0-9_]{2,30}$
|
||||
|
||||
# Naming hint for variable names
|
||||
variable-name-hint=[a-z_][a-z0-9_]{2,30}$
|
||||
|
||||
# Regular expression which should only match function or class names that do
|
||||
# not require a docstring.
|
||||
no-docstring-rgx=^_
|
||||
|
||||
# Minimum line length for functions/classes that require docstrings, shorter
|
||||
# ones are exempt.
|
||||
docstring-min-length=-1
|
||||
|
||||
|
||||
[ELIF]
|
||||
|
||||
# Maximum number of nested blocks for function / method body
|
||||
max-nested-blocks=5
|
||||
|
||||
|
||||
[SIMILARITIES]
|
||||
|
||||
# Minimum lines number of a similarity.
|
||||
min-similarity-lines=4
|
||||
|
||||
# Ignore comments when computing similarities.
|
||||
ignore-comments=yes
|
||||
|
||||
# Ignore docstrings when computing similarities.
|
||||
ignore-docstrings=yes
|
||||
|
||||
# Ignore imports when computing similarities.
|
||||
ignore-imports=no
|
||||
|
||||
|
||||
[FORMAT]
|
||||
|
||||
# Maximum number of characters on a single line.
|
||||
max-line-length=140
|
||||
|
||||
# Regexp for a line that is allowed to be longer than the limit.
|
||||
ignore-long-lines=^\s*(# )?<?https?://\S+>?$
|
||||
|
||||
# Allow the body of an if to be on the same line as the test if there is no
|
||||
# else.
|
||||
single-line-if-stmt=no
|
||||
|
||||
# List of optional constructs for which whitespace checking is disabled. `dict-
|
||||
# separator` is used to allow tabulation in dicts, etc.: {1 : 1,\n222: 2}.
|
||||
# `trailing-comma` allows a space between comma and closing bracket: (a, ).
|
||||
# `empty-line` allows space-only lines.
|
||||
no-space-check=trailing-comma,dict-separator
|
||||
|
||||
# Maximum number of lines in a module
|
||||
max-module-lines=1000
|
||||
|
||||
# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1
|
||||
# tab).
|
||||
indent-string=' '
|
||||
|
||||
# Number of spaces of indent required inside a hanging or continued line.
|
||||
indent-after-paren=4
|
||||
|
||||
# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
|
||||
expected-line-ending-format=
|
||||
|
||||
|
||||
[VARIABLES]
|
||||
|
||||
# Tells whether we should check for unused import in __init__ files.
|
||||
init-import=no
|
||||
|
||||
# A regular expression matching the name of dummy variables (i.e. expectedly
|
||||
# not used).
|
||||
dummy-variables-rgx=_$|dummy|unused.*$|__*
|
||||
|
||||
# List of additional names supposed to be defined in builtins. Remember that
|
||||
# you should avoid to define new builtins when possible.
|
||||
additional-builtins=
|
||||
|
||||
# List of strings which can identify a callback function by name. A callback
|
||||
# name must start or end with one of those strings.
|
||||
callbacks=cb_,_cb
|
||||
|
||||
|
||||
[MISCELLANEOUS]
|
||||
|
||||
# List of note tags to take in consideration, separated by a comma.
|
||||
notes=FIXME,XXX,TODO
|
||||
|
||||
|
||||
[SPELLING]
|
||||
|
||||
# Spelling dictionary name. Available dictionaries: none. To make it working
|
||||
# install python-enchant package.
|
||||
spelling-dict=
|
||||
|
||||
# List of comma separated words that should not be checked.
|
||||
spelling-ignore-words=
|
||||
|
||||
# A path to a file that contains private dictionary; one word per line.
|
||||
spelling-private-dict-file=
|
||||
|
||||
# Tells whether to store unknown words to indicated private dictionary in
|
||||
# --spelling-private-dict-file option instead of raising a message.
|
||||
spelling-store-unknown-words=no
|
||||
|
||||
|
||||
[TYPECHECK]
|
||||
|
||||
# Tells whether missing members accessed in mixin class should be ignored. A
|
||||
# mixin class is detected if its name ends with "mixin" (case insensitive).
|
||||
ignore-mixin-members=yes
|
||||
|
||||
# List of module names for which member attributes should not be checked
|
||||
# (useful for modules/projects where namespaces are manipulated during runtime
|
||||
# and thus existing member attributes cannot be deduced by static analysis. It
|
||||
# supports qualified module names, as well as Unix pattern matching.
|
||||
ignored-modules=
|
||||
|
||||
# List of classes names for which member attributes should not be checked
|
||||
# (useful for classes with attributes dynamically set). This supports can work
|
||||
# with qualified names.
|
||||
ignored-classes=
|
||||
TokenKind
|
||||
|
||||
# List of members which are set dynamically and missed by pylint inference
|
||||
# system, and so shouldn't trigger E1101 when accessed. Python regular
|
||||
# expressions are accepted.
|
||||
generated-members=
|
||||
|
||||
|
||||
[LOGGING]
|
||||
|
||||
# Logging modules to check that the string format arguments are in logging
|
||||
# function parameter format
|
||||
logging-modules=logging
|
||||
|
||||
|
||||
[CLASSES]
|
||||
|
||||
# List of method names used to declare (i.e. assign) instance attributes.
|
||||
defining-attr-methods=__init__,__new__,setUp
|
||||
|
||||
# List of valid names for the first argument in a class method.
|
||||
valid-classmethod-first-arg=cls
|
||||
|
||||
# List of valid names for the first argument in a metaclass class method.
|
||||
valid-metaclass-classmethod-first-arg=mcs
|
||||
|
||||
# List of member names, which should be excluded from the protected access
|
||||
# warning.
|
||||
exclude-protected=_asdict,_fields,_replace,_source,_make
|
||||
|
||||
|
||||
[IMPORTS]
|
||||
|
||||
# Deprecated modules which should not be used, separated by a comma
|
||||
deprecated-modules=optparse
|
||||
|
||||
# Create a graph of every (i.e. internal and external) dependencies in the
|
||||
# given file (report RP0402 must not be disabled)
|
||||
import-graph=
|
||||
|
||||
# Create a graph of external dependencies in the given file (report RP0402 must
|
||||
# not be disabled)
|
||||
ext-import-graph=
|
||||
|
||||
# Create a graph of internal dependencies in the given file (report RP0402 must
|
||||
# not be disabled)
|
||||
int-import-graph=
|
||||
|
||||
|
||||
[DESIGN]
|
||||
|
||||
# Maximum number of arguments for function / method
|
||||
max-args=5
|
||||
|
||||
# Argument names that match this expression will be ignored. Default to name
|
||||
# with leading underscore
|
||||
ignored-argument-names=_.*|unused.*|dummy.*
|
||||
|
||||
# Maximum number of locals for function / method body
|
||||
max-locals=15
|
||||
|
||||
# Maximum number of return / yield for function / method body
|
||||
max-returns=6
|
||||
|
||||
# Maximum number of branch for function / method body
|
||||
max-branches=12
|
||||
|
||||
# Maximum number of statements in function / method body
|
||||
max-statements=50
|
||||
|
||||
# Maximum number of parents for a class (see R0901).
|
||||
max-parents=7
|
||||
|
||||
# Maximum number of attributes for a class (see R0902).
|
||||
max-attributes=7
|
||||
|
||||
# Minimum number of public methods for a class (see R0903).
|
||||
min-public-methods=2
|
||||
|
||||
# Maximum number of public methods for a class (see R0904).
|
||||
max-public-methods=20
|
||||
|
||||
# Maximum number of boolean expressions in a if statement
|
||||
max-bool-expr=5
|
||||
|
||||
|
||||
[EXCEPTIONS]
|
||||
|
||||
# Exceptions that will emit a warning when being caught. Defaults to
|
||||
# "Exception"
|
||||
overgeneral-exceptions=Exception
|
||||
@@ -0,0 +1,3 @@
|
||||
flake8>=3.9.0
|
||||
pylint>=2.6.2
|
||||
mypy>=0.812
|
||||
@@ -0,0 +1,3 @@
|
||||
*.o
|
||||
*.su
|
||||
main
|
||||
@@ -0,0 +1,23 @@
|
||||
OBJ:=$(patsubst %.c, %.o, $(wildcard *.c))
|
||||
CFLAGS:=-fstack-usage
|
||||
TARGET:=main
|
||||
CC?=gcc
|
||||
|
||||
all: ${TARGET}
|
||||
@echo "=============================================="
|
||||
@../checkStackUsage.py $< . 2>&1 | \
|
||||
grep -E '(func|foo|bar|main) '
|
||||
@echo "=============================================="
|
||||
@echo "1. The output shown above must contain 4 lines"
|
||||
@echo "2. 'foo' and 'bar' must both be calling 'func'"
|
||||
@echo " *but with different stack sizes in each*."
|
||||
@echo "3. 'main' must be using the largest 'func'"
|
||||
@echo " (i.e. be going through 'bar')"
|
||||
@echo "4. The reported sizes must properly accumulate"
|
||||
@echo "=============================================="
|
||||
|
||||
${TARGET}: ${OBJ}
|
||||
${CC} -o $@ ${CFLAGS} $^
|
||||
|
||||
clean:
|
||||
rm -f ${OBJ} ${TARGET} *.su
|
||||
@@ -0,0 +1,12 @@
|
||||
#include <string.h>
|
||||
|
||||
static void func()
|
||||
{
|
||||
char a[128];
|
||||
memset(a, ' ', sizeof(a));
|
||||
}
|
||||
|
||||
void foo()
|
||||
{
|
||||
func();
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
#include <string.h>
|
||||
|
||||
static void func()
|
||||
{
|
||||
char b[256];
|
||||
memset(b, ' ', sizeof(b));
|
||||
}
|
||||
|
||||
void bar()
|
||||
{
|
||||
func();
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
extern void foo();
|
||||
extern void bar();
|
||||
|
||||
int main()
|
||||
{
|
||||
foo();
|
||||
bar();
|
||||
}
|
||||
Reference in New Issue
Block a user