szuncover 0.1.0__tar.gz

szuncover-0.1.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.3
+Name: szuncover
+Version: 0.1.0
+Summary: Uncover stack-usages for your threads
+Author: Paul Würtz
+Author-email: Paul Würtz <paulwuertz@posteo.de>
+Requires-Dist: pydantic>=2.13.5
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+
+# szuncover
+
+Uncover your threads stack usage. Working only with GCC, using the .ci files generated by the `-callgraph-info=cu,da` options to construct a callgraph with stack-usages.
+
+## Installation and Usage
+
+Install with pip:
+
+```bash
+pip install szuncover
+```
+
+Create a config listing your thread entry functions:
+
+```json
+{ "threads": [
+    {
+        "thread_entry_name": "bg_thread_main",
+        "stack_size": 1024
+    },
+    {
+        "thread_entry_name": "gs_usb_tx_thread",
+        "stack_size": 1024
+    },
+    {
+        "thread_entry_name": "gs_usb_rx_thread",
+        "stack_size": 1024
+    },
+    {
+        "thread_entry_name": "log_process_thread_func",
+        "stack_size": 768
+    }
+]}
+```
+
+then build your firmware with `-callgraph-info=cu,da` and run `szuncover --build_dir ./build/ --config_file config.json` for some basic output:
+
+```md
+┌──────────────────────────────────────────────────────────────────────────────┐
+│ bg_thread_main                 - ( 68.0%)    696/  1024 │█████████████-------│
+│ gs_usb_tx_thread               - ( 68.8%)    704/  1024 │█████████████-------│
+│ gs_usb_rx_thread               - ( 60.2%)    616/  1024 │████████████--------│
+│ log_process_thread_func        - ( 34.4%)    264/   768 │██████--------------│
+└──────────────────────────────────────────────────────────────────────────────┘
+WARNING: Given calltree info may limit this analysis:
+
+* number of functions with unresolved calls in thread:
+        * bg_thread_main: 22 resulting in 34 missing calls in the calltree
+        * gs_usb_tx_thread: 4 resulting in 5 missing calls in the calltree
+        * gs_usb_rx_thread: 2 resulting in 2 missing calls in the calltree
+        * log_process_thread_func: 3 resulting in 4 missing calls in the calltree
+
+* number of functions with missing stacksize in calltree:
+        *  bg_thread_main :  29
+        *  gs_usb_tx_thread :  4
+        *  gs_usb_rx_thread :  0
+        *  log_process_thread_func :  2
+```
+
+## Running Tests
+
+python -m unittest

szuncover-0.1.0/README.md

@@ -0,0 +1,63 @@
+
+# szuncover
+
+Uncover your threads stack usage. Working only with GCC, using the .ci files generated by the `-callgraph-info=cu,da` options to construct a callgraph with stack-usages.
+
+## Installation and Usage
+
+Install with pip:
+
+```bash
+pip install szuncover
+```
+
+Create a config listing your thread entry functions:
+
+```json
+{ "threads": [
+    {
+        "thread_entry_name": "bg_thread_main",
+        "stack_size": 1024
+    },
+    {
+        "thread_entry_name": "gs_usb_tx_thread",
+        "stack_size": 1024
+    },
+    {
+        "thread_entry_name": "gs_usb_rx_thread",
+        "stack_size": 1024
+    },
+    {
+        "thread_entry_name": "log_process_thread_func",
+        "stack_size": 768
+    }
+]}
+```
+
+then build your firmware with `-callgraph-info=cu,da` and run `szuncover --build_dir ./build/ --config_file config.json` for some basic output:
+
+```md
+┌──────────────────────────────────────────────────────────────────────────────┐
+│ bg_thread_main                 - ( 68.0%)    696/  1024 │█████████████-------│
+│ gs_usb_tx_thread               - ( 68.8%)    704/  1024 │█████████████-------│
+│ gs_usb_rx_thread               - ( 60.2%)    616/  1024 │████████████--------│
+│ log_process_thread_func        - ( 34.4%)    264/   768 │██████--------------│
+└──────────────────────────────────────────────────────────────────────────────┘
+WARNING: Given calltree info may limit this analysis:
+
+* number of functions with unresolved calls in thread:
+        * bg_thread_main: 22 resulting in 34 missing calls in the calltree
+        * gs_usb_tx_thread: 4 resulting in 5 missing calls in the calltree
+        * gs_usb_rx_thread: 2 resulting in 2 missing calls in the calltree
+        * log_process_thread_func: 3 resulting in 4 missing calls in the calltree
+
+* number of functions with missing stacksize in calltree:
+        *  bg_thread_main :  29
+        *  gs_usb_tx_thread :  4
+        *  gs_usb_rx_thread :  0
+        *  log_process_thread_func :  2
+```
+
+## Running Tests
+
+python -m unittest

szuncover-0.1.0/pyproject.toml

@@ -0,0 +1,63 @@
+[project]
+name = "szuncover"
+version = "0.1.0"
+description = "Uncover stack-usages for your threads"
+long_description = """
+
+Stack size
+===========
+
+Estimate stack usage in RTOS threads when compiling with GCC -callgraph-info=cu,da option.
+
+From all .ci files a calltree with stack use for each function is constructed.
+
+Given a config file a list of threads and associtated stack sizes a report will be generated to each threads stack utilization.
+
+For dynamic function-calls not know at compile-time a list of dynamic-calls can complete this missing parts of the runtime callgraph to get better results in the estimation."""
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = ["pydantic>=2.13.5"]
+
+[[project.authors]]
+name = "Paul Würtz"
+email = "paulwuertz@posteo.de"
+
+[project.scripts]
+szuncover = "szuncover.szuncover:main"
+
+[tool.uv]
+default-groups = ["dev"]
+
+[tool.uv.build-backend]
+module-root = ""
+
+[tool.ruff]
+target-version = "py312"
+preview = true
+line-length = 100
+
+[tool.setuptools]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Natural Language :: English",
+]
+
+[tool.setuptools.packages.find]
+where = ["szuncover"]
+include = ["szuncover*"]
+namespaces = false
+
+[build-system]
+requires = ["uv_build >= 0.12.19, <0.13.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "codecov==2.1.13",
+    "tox==3.27.1; python_version < '3.12'",
+    "tox==4.11.3; python_version >= '3.12'",
+    "setuptools>=75",
+    "ruff>=0.12.10",
+    "pydantic>=2.13.3",
+]

szuncover-0.1.0/pyproject.toml.orig

@@ -0,0 +1,64 @@
+[project]
+name = "szuncover"
+version = "0.1.0"
+description = "Uncover stack-usages for your threads"
+long_description = """
+
+Stack size
+===========
+
+Estimate stack usage in RTOS threads when compiling with GCC -callgraph-info=cu,da option.
+
+From all .ci files a calltree with stack use for each function is constructed.
+
+Given a config file a list of threads and associtated stack sizes a report will be generated to each threads stack utilization.
+
+For dynamic function-calls not know at compile-time a list of dynamic-calls can complete this missing parts of the runtime callgraph to get better results in the estimation."""
+authors = [
+    { name = "Paul Würtz", email = "paulwuertz@posteo.de" }
+]
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "pydantic>=2.13.5",
+]
+
+[project.scripts]
+szuncover = "szuncover.szuncover:main"
+
+[tool.uv]
+default-groups = ["dev"]
+
+[tool.ruff]
+target-version = "py312"
+preview = true
+line-length = 100
+
+[build-system]
+requires = ["uv_build >= 0.12.19, <0.13.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-root = ""
+
+[dependency-groups]
+dev = [
+    "codecov==2.1.13",
+    "tox==3.27.1; python_version < '3.12'",
+    "tox==4.11.3; python_version >= '3.12'",
+    "setuptools>=75",
+    "ruff>=0.12.10",
+    "pydantic>=2.13.3",
+]
+
+[tool.setuptools]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Natural Language :: English",
+]
+
+[tool.setuptools.packages.find]
+where = ["szuncover"]
+include = [ "szuncover*" ]
+namespaces = false

szuncover-0.1.0/szuncover/__init__.py

@@ -0,0 +1,6 @@
+# Copyright (c) 2026 Paul Würtz
+# SPDX-License-Identifier: Apache-2.0
+
+__author__ = "paulwuertz"
+
+from . import *

szuncover-0.1.0/szuncover/calltree.py

@@ -0,0 +1,136 @@
+import fnmatch
+import os
+
+from gcc_vcg_parser import (
+    GCC_INDIRECT_CALL_LABEL,
+    FunctionCalleeEntry,
+    VCG_Edge,
+    VCG_Graph,
+    VCG_Parser,
+)
+from pydantic import BaseModel
+
+NO_WORST_STACK_SIZE_YET = -1
+
+
+class ThreadStats(BaseModel):
+    unresolved_calls: dict[str, int]
+    missing_stack_sizes: list[str]
+
+
+def find_files_with_extension(extension: str, top: str):
+    for path, dirlist, filelist in os.walk(top):
+        for name in fnmatch.filter(filelist, extension):
+            yield os.path.join(path, name)
+
+
+def get_vcg_graphs_from_build_dir(build_dir: str) -> list[VCG_Graph]:
+    # print("parsing callgraph starting at %s" % build_dir)
+    vcg_graphs = []
+    call_files = find_files_with_extension("*.ci", build_dir)
+
+    for ci_file in call_files:
+        with open(ci_file) as file:
+            ci_file_content = file.read()
+            vcg_graph = VCG_Parser.parse_vcg_graph(ci_file_content)
+            vcg_graphs += [vcg_graph]
+
+    return vcg_graphs
+
+
+def get_all_edges_from_vcg_graphs(vcg_graphs: list[VCG_Graph]) -> list[VCG_Edge]:
+    all_edges = []
+    for vcg_graph in vcg_graphs:
+        all_edges += vcg_graph.edges
+    return all_edges
+
+
+def map_vcg_nodes_to_call_entries(vcg_graphs: list[VCG_Graph]) -> dict[str, FunctionCalleeEntry]:
+    fn_callee_map: dict[str, FunctionCalleeEntry] = {}
+    for vcg_graph in vcg_graphs:
+        for n in vcg_graph.nodes:
+            has_label = "label" in n.model_fields_set
+            has_function_name = has_label and "function_name" in n.label.model_fields_set
+            fn_name = n.label.function_name if has_function_name else n.title
+            if "." in fn_name:  # removes .constprop.0, .isra, ...
+                split_dots = fn_name.split(".")
+                fn_name = split_dots[0]
+            is_symbol_mapped = fn_name in fn_callee_map
+            is_stack_size_defined = is_symbol_mapped and isinstance(
+                fn_callee_map[fn_name].node.label.stack_size, int
+            )
+            if not is_symbol_mapped:
+                fn_callee_map[fn_name] = FunctionCalleeEntry(
+                    title=fn_name,
+                    node=n,
+                    worst_stack_use=-1,
+                    edges=[],
+                    visited=False,
+                )
+            elif not is_stack_size_defined and isinstance(n.label.stack_size, int):
+                fn_callee_map[fn_name].node.label = n.label
+            else:
+                # TODO add definition or declaration source path?!
+                pass
+
+    return fn_callee_map
+
+
+def map_vcg_call_edges_to_call_entries(
+    fn_callee_map: dict[str, FunctionCalleeEntry], edges: list[VCG_Edge]
+) -> dict[str, FunctionCalleeEntry]:
+    err_unmatched_edges: set[str] = set()
+    for e in edges:
+        fn_name = e.sourcename
+        fn_name_and_path = fn_name.split(":", 1)
+        if fn_name not in fn_callee_map and len(fn_name_and_path) == 2:
+            fn_name = fn_name_and_path[1]
+        if "." in fn_name:  # removes .constprop.0, .isra, ...
+            split_dots = fn_name.split(".")
+            fn_name = split_dots[0]
+        if fn_name in fn_callee_map:
+            fn_callee_map[fn_name].edges += [e]
+        else:
+            err_unmatched_edges.add(fn_name)
+            print("err #", len(err_unmatched_edges), " no node matches call edge:", e)
+    return fn_callee_map
+
+
+def deepest_call_tree(
+    f: FunctionCalleeEntry,
+    fn_callee_map: dict[str, FunctionCalleeEntry],
+    stats: ThreadStats,
+    visited=None,
+) -> tuple[int, list[FunctionCalleeEntry]]:
+    if f.worst_stack_use != NO_WORST_STACK_SIZE_YET:
+        return (f.worst_stack_use, [])
+    visited = [f] + (visited or [])
+    result: tuple[int, list[FunctionCalleeEntry]] = (0, [])
+
+    for call_edge in f.edges:
+        if call_edge.targetname == GCC_INDIRECT_CALL_LABEL:
+            if f.title in stats.unresolved_calls:
+                stats.unresolved_calls[f.title] += 1
+            else:
+                stats.unresolved_calls[f.title] = 1
+        fn_target_name_and_path = call_edge.targetname.split(":", 1)
+        callee_name = call_edge.targetname
+        if callee_name not in fn_callee_map and len(fn_target_name_and_path) == 2:
+            callee_name = fn_target_name_and_path[1]
+        if "." in callee_name:  # removes .constprop.0, .isra, ...
+            split_dots = callee_name.split(".")
+            callee_name = split_dots[0]
+        if callee_name not in fn_callee_map:
+            continue
+        callee_node = fn_callee_map[callee_name]
+        if callee_node not in visited:
+            candidate = deepest_call_tree(callee_node, fn_callee_map, stats, visited)
+            if candidate[0] > result[0]:
+                result = candidate
+
+    if not isinstance(f.node.label.stack_size, int):
+        stats.missing_stack_sizes += [f.title]
+    stack_size = f.node.label.stack_size if isinstance(f.node.label.stack_size, int) else 0
+    result = (result[0] + stack_size, [f] + result[1])
+    f.worst_stack_use = result[0]
+    return result

szuncover-0.1.0/szuncover/config.py

@@ -0,0 +1,30 @@
+import logging
+
+from pydantic import BaseModel
+
+logger = logging.getLogger()
+
+
+class ThreadConfig(BaseModel):
+    thread_entry_name: str
+    stack_size: int
+    # TODO only functions so far, so cannot deduce from variable symbol atm...
+    # stack_variable_name
+
+
+class DynamicCallResolutions(BaseModel):
+    caller: str
+    callees: list[str | None]
+
+
+class SZuncoverConfig(BaseModel):
+    threads: list[ThreadConfig]
+    dynamic_calls: list[DynamicCallResolutions]
+
+
+def load_config(conf_path: str) -> SZuncoverConfig | None:
+    try:
+        return SZuncoverConfig.parse_file(path=conf_path)
+    except BaseException:
+        logger.exception("Error loading szuncover config file")
+        return None

szuncover-0.1.0/szuncover/gcc_vcg_parser.py

@@ -0,0 +1,160 @@
+import re
+
+from pydantic import BaseModel
+from pydantic.experimental.missing_sentinel import MISSING
+
+GCC_INDIRECT_CALL_LABEL = "__indirect_call"
+
+
+# TODO add dynamic allocation parsing?
+class VCG_Label(BaseModel):
+    file_name: str | MISSING = MISSING
+    function_name: str | MISSING = MISSING
+    line: int | MISSING = MISSING
+    column: int | MISSING = MISSING
+    stack_size: int | MISSING = MISSING
+    stack_qualifier: str | MISSING = MISSING
+
+
+class VCG_Node(BaseModel):
+    title: str
+    label: VCG_Label | MISSING = MISSING
+
+
+class VCG_Edge(BaseModel):
+    sourcename: str
+    targetname: str
+    label: str | MISSING = MISSING
+
+
+class VCG_Graph(BaseModel):
+    title: str
+    nodes: list[VCG_Node]
+    edges: list[VCG_Edge]
+
+
+class FunctionCalleeEntry(BaseModel):
+    title: str
+    node: VCG_Node
+    node_declaration: str | MISSING = MISSING
+    node_definition: str | MISSING = MISSING
+    edges: list[VCG_Edge]
+    worst_stack_use: int
+    visited: bool
+
+
+class FunctionCallTree(BaseModel):
+    root: FunctionCalleeEntry
+    node_declaration: str | MISSING = MISSING
+    node_definition: str | MISSING = MISSING
+    edges: list[VCG_Edge]
+
+
+class VCG_Parser:
+    su_marker_pattern = r"(\d+)\s+bytes\s+\((.*?)\)"
+
+    @staticmethod
+    def parse_vcg_label_attributes(label_str: str):
+        vcg_label_lines = label_str.split("\\n")
+
+        function_name = vcg_label_lines[0] if len(vcg_label_lines) >= 1 else None
+        fp_split = (
+            vcg_label_lines[1].split(":") if len(vcg_label_lines) >= 2 else [None, None, None]
+        )
+        line = int(fp_split[-2]) if len(fp_split) >= 3 and fp_split[-2] else None
+        column = int(fp_split[-1]) if len(fp_split) >= 3 and fp_split[-1] else None
+        file_name = ":".join(fp_split[:-2]) if len(fp_split) >= 3 and fp_split[0] else None
+        # callgraph with su MARKERS - Match stacksize and qualifier in i.e. '15 bytes (static)'
+        stacksize_marker = vcg_label_lines[2] if len(vcg_label_lines) >= 3 else ""
+        match = re.search(VCG_Parser.su_marker_pattern, stacksize_marker)
+        stack_size = int(match.group(1)) if match else None
+        stack_qualifier = match.group(2) if match else None
+        if function_name and len(vcg_label_lines) == 1:
+            return VCG_Label(
+                function_name=function_name,
+            )
+        if function_name and line and column and file_name and len(vcg_label_lines) == 2:
+            return VCG_Label(
+                function_name=function_name,
+                file_name=file_name,
+                line=line,
+                column=column,
+            )
+        elif function_name and line and column and file_name and stack_size and stack_qualifier:
+            return VCG_Label(
+                function_name=function_name,
+                file_name=file_name,
+                line=line,
+                column=column,
+                stack_size=stack_size,
+                stack_qualifier=stack_qualifier,
+            )
+        else:
+            # TODO log error/warning?
+            return VCG_Label()
+
+    @staticmethod
+    def parse_vcg_attributes(attr_str: str):
+        attribute_pattern = r'(\w+)\s*:\s*(?:"([^"]*)"|(\S+))'
+        attributes = re.findall(attribute_pattern, attr_str)
+        parsed_dict = {match[0]: match[1] or match[2] for match in attributes}
+        return parsed_dict
+
+    @staticmethod
+    def parse_node(node_str: str) -> VCG_Node:
+        attributes = VCG_Parser.parse_vcg_attributes(node_str)
+        title = attributes.get("title", "")
+        label = attributes.get("label", "")
+        vcg_label = VCG_Parser.parse_vcg_label_attributes(label)
+        if title and label:
+            return VCG_Node(title=title, label=vcg_label)
+        if title:
+            return VCG_Node(title=title)
+        else:
+            return VCG_Node(title=title)  # TODO error handling/logwarning?
+
+    @staticmethod
+    def parse_edge(node_str: str) -> VCG_Edge:
+        attributes = VCG_Parser.parse_vcg_attributes(node_str)
+        sourcename = attributes.get("sourcename", "")
+        targetname = attributes.get("targetname", "")
+        label = attributes.get("label", "")
+        if sourcename and targetname and label:
+            return VCG_Edge(sourcename=sourcename, targetname=targetname, label=label)
+        if sourcename and targetname:
+            return VCG_Edge(sourcename=sourcename, targetname=targetname)
+        else:
+            # TODO log error/warning or empty ok?
+            return VCG_Edge(sourcename=sourcename, targetname=targetname)
+
+    @staticmethod
+    def parse_vcg_graph(graph_str: str):
+        lines = graph_str.splitlines()
+        # looked at gcc/toplev.cc::lang_dependent_init
+        # assume exactly one edge / node per line and graph+title in first line
+        graph_decl = lines[0] if len(lines) >= 1 else ""
+        title = ""
+        # strip graph+title and quotes
+        if graph_decl.startswith("graph: { title: "):
+            title = graph_decl.replace("graph: { title: ", "")
+            title = title[1:-1]
+        else:
+            pass  # TODO error log
+
+        nodes = []
+        edges = []
+        for line in lines[1:]:
+            line = line.removesuffix(" }")
+            if line.startswith("node: { "):
+                node_str = line.replace("^node: { ", "")
+                n = VCG_Parser.parse_node(node_str)
+                nodes += [n]
+            elif line.startswith("edge: { "):
+                edge_str = line.replace("edge: { ", "")
+                e = VCG_Parser.parse_edge(edge_str)
+                edges += [e]
+            elif line.startswith("}"):
+                break
+
+        graph = VCG_Graph(title=title, edges=edges, nodes=nodes)
+        return graph

szuncover-0.1.0/szuncover/python_szuncover.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: python-szuncover
+Version: 0.1.0
+Summary: Add your description here
+Home-page: https://github.com/zephyrproject-rtos/zephyr
+Author: Zephyr Project
+Author-email: devel@lists.zephyrproject.org
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.13.5
+Requires-Dist: tox>=4.54.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: requires-python

szuncover-0.1.0/szuncover/python_szuncover.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+setup.py
+szuncover/python_szuncover.egg-info/PKG-INFO
+szuncover/python_szuncover.egg-info/SOURCES.txt
+szuncover/python_szuncover.egg-info/dependency_links.txt
+szuncover/python_szuncover.egg-info/requires.txt
+szuncover/python_szuncover.egg-info/top_level.txt
+tests/test_ctx.py
+tests/test_gcc_vcg_parser.py

szuncover-0.1.0/szuncover/python_szuncover.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

szuncover-0.1.0/szuncover/python_szuncover.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pydantic>=2.13.5
+tox>=4.54.0

szuncover-0.1.0/szuncover/python_szuncover.egg-info/top_level.txt

@@ -0,0 +1 @@
+

szuncover-0.1.0/szuncover/report_output.py

@@ -0,0 +1,44 @@
+import sys
+
+from calltree import ThreadStats, deepest_call_tree
+
+
+def print_stack_size_report(fn_callee_map, config):
+    overflows = False
+    print("┌" + 78 * "─" + "┐")
+    threadStats = {}
+    for thread in config.threads:
+        thread_fn_name = thread.thread_entry_name
+        thread_stack_size = thread.stack_size
+        if thread_fn_name in fn_callee_map:
+            fn_node = fn_callee_map[thread_fn_name]
+            stats = ThreadStats(unresolved_calls={}, missing_stack_sizes=[])
+            thread_calltree = deepest_call_tree(fn_node, fn_callee_map, stats)
+            threadStats[thread_fn_name] = stats
+            worst_stack_size = thread_calltree[0]
+            # stack_report = stack_report[function_name]
+            stack_use_percent = worst_stack_size / thread_stack_size * 100
+            progressbar_20_full = int(stack_use_percent / 100.0 * 20)
+            progressbar_20_empty = 20 - progressbar_20_full
+            # │ log_process_thread_func   - 100.0% - 11111/22222 - │███████████████-----│
+            print(
+                f"│ {thread_fn_name:<30} - ({f'{stack_use_percent:.1f}':>5}%) {worst_stack_size:>6}"
+                f"/{thread_stack_size:>6} │{progressbar_20_full * '█'}{progressbar_20_empty * '-'}│"
+            )
+        else:
+            print(f"│ {thread_fn_name:<30} - (function not found in build artifacts)     │")
+    print("└" + 78 * "─" + "┘")
+
+    print("WARNING: Given calltree info may limit this analysis: ")
+    print("* number of functions with unresolved calls in thread:")
+    for thread_fn_name, stats in threadStats.items():
+        total_calls_to_unresolved_all_calls = sum(stats.unresolved_calls.values())
+        print(
+            f"\t* {thread_fn_name}: {len(stats.unresolved_calls)} resulting in {total_calls_to_unresolved_all_calls} missing calls in the calltree"
+        )
+    print("* number of functions with missing stacksize in calltree:")
+    for thread_fn_name, stats in threadStats.items():
+        print("\t* ", thread_fn_name, ": ", len(stats.missing_stack_sizes))
+
+    if overflows:
+        sys.exit(1)

szuncover-0.1.0/szuncover/szuncover.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: szuncover
+Version: 0.1.0
+Summary: Add your description here
+Home-page: https://github.com/zephyrproject-rtos/zephyr
+Author: Paul Würtz
+Author-email: paulwuertz@posteo.de
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.13.5
+Requires-Dist: ruff>=0.17.1
+Requires-Dist: tox>=4.54.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: requires-python

szuncover-0.1.0/szuncover/szuncover.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+setup.py
+szuncover/szuncover.egg-info/PKG-INFO
+szuncover/szuncover.egg-info/SOURCES.txt
+szuncover/szuncover.egg-info/dependency_links.txt
+szuncover/szuncover.egg-info/requires.txt
+szuncover/szuncover.egg-info/top_level.txt
+tests/test_ctx.py
+tests/test_gcc_vcg_parser.py

szuncover-0.1.0/szuncover/szuncover.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

szuncover-0.1.0/szuncover/szuncover.egg-info/requires.txt

@@ -0,0 +1,3 @@
+pydantic>=2.13.5
+ruff>=0.17.1
+tox>=4.54.0

szuncover-0.1.0/szuncover/szuncover.egg-info/top_level.txt

@@ -0,0 +1 @@
+

szuncover-0.1.0/szuncover/szuncover.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+
+import argparse
+import logging
+import sys
+
+from calltree import (
+    get_all_edges_from_vcg_graphs,
+    get_vcg_graphs_from_build_dir,
+    map_vcg_call_edges_to_call_entries,
+    map_vcg_nodes_to_call_entries,
+)
+from config import load_config
+from report_output import print_stack_size_report
+
+logger = logging.getLogger()
+
+
+def parse_args():
+    """Parse command line arguments"""
+    argparser = argparse.ArgumentParser(allow_abbrev=False)
+
+    argparser.add_argument("--build_dir", help="")
+    argparser.add_argument("--config_file", help="")
+    argparser.add_argument("--debug", action="store_true", help="Print extra debugging information")
+
+    return argparser.parse_args()
+
+
+def main():
+    """Main function of log parser"""
+    args = parse_args()
+
+    if args.debug:
+        logger.setLevel(logging.DEBUG)
+    else:
+        logger.setLevel(logging.INFO)
+
+    conf = load_config(args.config_file)
+    if not conf:
+        print("Config file exception, exiting...")
+        sys.exit(1)
+
+    vcg_graphs = get_vcg_graphs_from_build_dir(args.build_dir)
+    edges = get_all_edges_from_vcg_graphs(vcg_graphs)
+    call_entries = map_vcg_nodes_to_call_entries(vcg_graphs)
+    fn_callee_map = map_vcg_call_edges_to_call_entries(call_entries, edges)
+
+    print_stack_size_report(fn_callee_map, conf)
+    print("hi")
+
+
+if __name__ == "__main__":
+    main()