From ee5abed3cda095115d5afb72c860819d9369fc45 Mon Sep 17 00:00:00 2001 From: "Luke T. Shumaker" Date: Mon, 31 Mar 2025 04:22:52 -0600 Subject: measurestack: Split into several files --- build-aux/measurestack/util.py | 123 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 123 insertions(+) create mode 100644 build-aux/measurestack/util.py (limited to 'build-aux/measurestack/util.py') diff --git a/build-aux/measurestack/util.py b/build-aux/measurestack/util.py new file mode 100644 index 0000000..e878ffa --- /dev/null +++ b/build-aux/measurestack/util.py @@ -0,0 +1,123 @@ +# build-aux/measurestack/util.py - Analyze stack sizes for compiled objects +# +# Copyright (C) 2024-2025 Luke T. Shumaker +# SPDX-License-Identifier: AGPL-3.0-or-later + +import re +import typing + +from . import vcg +from .analyze import BaseName, Node, QName + +# pylint: disable=unused-variable +__all__ = [ + "synthetic_node", + "read_source", + "get_zero_or_one", + "re_call_other", + "Plugin", + "PluginApplication", +] + + +def synthetic_node( + name: str, nstatic: int, calls: typing.Collection[str] = frozenset() +) -> Node: + n = Node() + + n.funcname = QName(name) + + n.location = "" + n.usage_kind = "static" + n.nstatic = nstatic + n.ndynamic = 0 + + n.calls = dict((QName(c), False) for c in calls) + + return n + + +def read_source(location: str) -> str: + re_location = re.compile(r"(?P.+):(?P[0-9]+):(?P[0-9]+)") + m = re_location.fullmatch(location) + if not m: + raise ValueError(f"unexpected label value {location!r}") + filename = m.group("filename") + row = int(m.group("row")) - 1 + col = int(m.group("col")) - 1 + with open(filename, "r", encoding="utf-8") as fh: + return fh.readlines()[row][col:].rstrip() + + +def get_zero_or_one( + pred: typing.Callable[[str], bool], fnames: typing.Collection[str] +) -> str | None: + count = sum(1 for fname in fnames if pred(fname)) + assert count < 2 + if count: + return next(fname for fname in fnames if pred(fname)) + return None + + +re_call_other = re.compile(r"(?P[^(]+)\(.*") + + +class Plugin(typing.Protocol): + def is_intrhandler(self, name: QName) -> bool: ... + + # init_array returns a list of functions that are placed in the + # `.init_array.*` section; AKA functions marked with + # `__attribute__((constructor))`. + def init_array(self) -> typing.Collection[QName]: ... + + # extra_includes returns a list of functions that are never + # called, but are included in the binary anyway. This may because + # it is an unused method in a used vtable. This may be because it + # is an atexit() callback (we never exit). + def extra_includes(self) -> typing.Collection[BaseName]: ... + + def extra_nodes(self) -> typing.Collection[Node]: ... + def indirect_callees( + self, loc: str, line: str + ) -> tuple[typing.Collection[QName], bool] | None: ... + def skip_call(self, chain: typing.Sequence[QName], call: QName) -> bool: ... + + +class PluginApplication: + _location_xform: typing.Callable[[str], str] + _plugins: list[Plugin] + + def __init__( + self, location_xform: typing.Callable[[str], str], plugins: list[Plugin] + ) -> None: + self._location_xform = location_xform + self._plugins = plugins + + def extra_nodes(self) -> typing.Collection[Node]: + ret: list[Node] = [] + for plugin in self._plugins: + ret.extend(plugin.extra_nodes()) + return ret + + def indirect_callees( + self, elem: vcg.VCGElem + ) -> tuple[typing.Collection[QName], bool]: + loc = elem.attrs.get("label", "") + line = read_source(loc) + + for plugin in self._plugins: + ret = plugin.indirect_callees(loc, line) + if ret is not None: + return ret + + placeholder = "__indirect_call" + if m := re_call_other.fullmatch(line): + placeholder += ":" + m.group("func") + placeholder += " at " + self._location_xform(elem.attrs.get("label", "")) + return [QName(placeholder)], False + + def skip_call(self, chain: typing.Sequence[QName], funcname: QName) -> bool: + for plugin in self._plugins: + if plugin.skip_call(chain, funcname): + return True + return False -- cgit v1.2.3-2-g168b From 2ced5e02eacfc6b9e67435fe3a24dcb6c3a29037 Mon Sep 17 00:00:00 2001 From: "Luke T. Shumaker" Date: Mon, 31 Mar 2025 15:58:51 -0600 Subject: measurestack: Compile all regexes upfront --- build-aux/measurestack/util.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'build-aux/measurestack/util.py') diff --git a/build-aux/measurestack/util.py b/build-aux/measurestack/util.py index e878ffa..5367da9 100644 --- a/build-aux/measurestack/util.py +++ b/build-aux/measurestack/util.py @@ -37,8 +37,10 @@ def synthetic_node( return n +re_location = re.compile(r"(?P.+):(?P[0-9]+):(?P[0-9]+)") + + def read_source(location: str) -> str: - re_location = re.compile(r"(?P.+):(?P[0-9]+):(?P[0-9]+)") m = re_location.fullmatch(location) if not m: raise ValueError(f"unexpected label value {location!r}") -- cgit v1.2.3-2-g168b From 8e3d2a904fe046910ee831e6fd9d2316aafc260a Mon Sep 17 00:00:00 2001 From: "Luke T. Shumaker" Date: Sun, 30 Mar 2025 03:09:19 -0600 Subject: measurestack: Rework the skip-call API to speed things up --- build-aux/measurestack/util.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'build-aux/measurestack/util.py') diff --git a/build-aux/measurestack/util.py b/build-aux/measurestack/util.py index 5367da9..47b2617 100644 --- a/build-aux/measurestack/util.py +++ b/build-aux/measurestack/util.py @@ -6,7 +6,7 @@ import re import typing -from . import vcg +from . import analyze, vcg from .analyze import BaseName, Node, QName # pylint: disable=unused-variable @@ -82,7 +82,7 @@ class Plugin(typing.Protocol): def indirect_callees( self, loc: str, line: str ) -> tuple[typing.Collection[QName], bool] | None: ... - def skip_call(self, chain: typing.Sequence[QName], call: QName) -> bool: ... + def skipmodels(self) -> dict[BaseName, analyze.SkipModel]: ... class PluginApplication: @@ -118,8 +118,8 @@ class PluginApplication: placeholder += " at " + self._location_xform(elem.attrs.get("label", "")) return [QName(placeholder)], False - def skip_call(self, chain: typing.Sequence[QName], funcname: QName) -> bool: + def skipmodels(self) -> dict[BaseName, analyze.SkipModel]: + ret: dict[BaseName, analyze.SkipModel] = {} for plugin in self._plugins: - if plugin.skip_call(chain, funcname): - return True - return False + ret.update(plugin.skipmodels()) + return ret -- cgit v1.2.3-2-g168b