1# Copyright (c) 2023, Auterion AG
  2# SPDX-License-Identifier: BSD-3-Clause
  3
  4"""
  5.. include:: callgraph.md
  6"""
  7
  8from __future__ import annotations
  9import re, os
 10import itertools
 11import logging
 12from pathlib import Path
 13from collections import defaultdict
 14from .backtrace import Backtrace
 15from .utils import read_gdb_log
 16LOGGER = logging.getLogger(__name__)
 17
 18
 19def callgraph_from_backtrace(backtraces: list[str],
 20                             BacktraceClass: Backtrace = None,
 21                             output_graphviz: Path = None,
 22                             output_pyvis: Path = None):
 23    """
 24    Convert a GDB backtrace log file into a dot, svg and pyvis file.
 25
 26    :param backtraces: list of strings each containing a backtrace.
 27    :param BacktraceClass: One of the classes of `emdbg.analyze.backtrace`.
 28    :param output_graphviz: Output path of the graphviz file (`.dot` suffix).
 29        If you set its suffix to `.svg`, the `dot` command is used to generate
 30        a SVG file instead.
 31    :param output_pyvis: Output path to a pyvis file. (Requires the `pyvis`
 32        module to be installed).
 33    """
 34
 35    if BacktraceClass is None:
 36        BacktraceClass = Backtrace
 37
 38    backts = defaultdict(set)
 39    for description in backtraces:
 40        bt = BacktraceClass(description)
 41        if bt.is_valid:
 42            backts[bt.type].add(bt)
 43            # if bt.type == "unknown":
 44            #     print(bt)
 45            #     print(bt.description)
 46        else:
 47            LOGGER.error(bt)
 48            LOGGER.error(bt.description)
 49
 50    nodes = {}
 51    edges = defaultdict(int)
 52
 53    def itertools_pairwise(iterable):
 54        a, b = itertools.tee(iterable)
 55        next(b, None)
 56        return zip(a, b)
 57
 58    for btype, bts in backts.items():
 59        for bt in bts:
 60            for frame in bt.frames:
 61                nodes[frame._unique_location] = frame
 62            for f1, f2 in itertools_pairwise(bt.frames):
 63                edges[(f2._unique_location, f1._unique_location, str((btype or "").lower()))] += 1
 64
 65    sources = set(nodes)
 66    sinks = set(nodes)
 67    max_calls = max(edges.values())
 68    for source, sink, _ in edges.keys():
 69        sources.discard(sink)
 70        sinks.discard(source)
 71
 72    def _n(name):
 73        return re.sub(r"[, :<>]", "_", name)
 74
 75    if output_pyvis:
 76        import pyvis
 77        net = pyvis.network.Network(height="100%", width="100%", select_menu=True)
 78        for node in sorted(nodes):
 79            kwargs = {"label": node}
 80            if node in sinks:
 81                kwargs.update({"borderWidth": 3, "color": "LightBlue"})
 82            elif node in sources:
 83                kwargs.update({"borderWidth": 3, "color": "LightGreen"})
 84            net.add_node(_n(node), label=node)
 85        for edge in sorted(edges):
 86            net.add_edge(_n(edge[0]), _n(edge[1]), label=edge[2], arrows="to")
 87        net.toggle_physics(True)
 88        net.show(output_pyvis, notebook=False)
 89
 90    if output_graphviz:
 91        output_graphviz = Path(output_graphviz)
 92        import graphviz
 93        dot = graphviz.Digraph()
 94        for node in sorted(nodes):
 95            frame = nodes[node]
 96            kwargs = {
 97                "label": f"{frame.function}:{frame.line}",
 98                "URL": f"subl://open?url={Path(frame.filename).absolute()}&line={frame.line}",
 99            }
100            for pattern, style in BacktraceClass.COLORS.items():
101                if re.search(pattern, node):
102                    kwargs.update(style)
103            if node in sinks:
104                kwargs.update({"style": "bold,filled", "fillcolor": "LightBlue"})
105            elif node in sources:
106                kwargs.update({"style": "bold,filled", "fillcolor": "LightGreen"})
107            dot.node(_n(node), **kwargs)
108        for edge in sorted(edges):
109            dot.edge(_n(edge[0]), _n(edge[1]), label=edge[2] or str(edges[edge]),
110                     penwidth=str(max(edges[edge]/max_calls * 10, 0.5)))
111        output_dot = output_graphviz.with_suffix(".dot")
112        output_dot.write_text(dot.source)
113        if output_graphviz.suffix == ".svg":
114            os.system(f"dot -Tsvg -o {output_graphviz} {output_dot}")
115            os.system(f"rm {output_dot}")
116
117
118# -----------------------------------------------------------------------------
119if __name__ == "__main__":
120    import argparse
121    from .backtrace import *
122
123    parser = argparse.ArgumentParser(description="Backtrace Analyzer")
124    parser.add_argument(
125        "file",
126        type=Path,
127        help="The GDB log containing the backtraces.")
128    parser.add_argument(
129        "--graphviz",
130        type=Path,
131        help="The file to render the dot graph in.")
132    parser.add_argument(
133        "--svg",
134        action="store_true",
135        default=False,
136        help="Render into SVG file using the same name as the input.")
137    parser.add_argument(
138        "--pyvis",
139        type=Path,
140        help="The file to render the pyvis graph in.")
141    values = {
142        "FileSystem": FileSystemBacktrace,
143        "SPI": SpiBacktrace,
144        "I2C": I2cBacktrace,
145        "CAN": CanBacktrace,
146        "UART": UartBacktrace,
147        "Semaphore": SemaphoreBacktrace,
148        "Generic": Backtrace,
149    }
150    parser.add_argument(
151        "--type",
152        choices=values.keys(),
153        help="The backtrace class to use.")
154    args = parser.parse_args()
155    BacktraceClass = values.get(args.type)
156
157    if BacktraceClass is None:
158        if "_sdmmc" in args.file.name:
159            BacktraceClass = FileSystemBacktrace
160        elif "_spi" in args.file.name:
161            BacktraceClass = SpiBacktrace
162        elif "_i2c" in args.file.name:
163            BacktraceClass = I2cBacktrace
164        elif "_can" in args.file.name:
165            BacktraceClass = CanBacktrace
166        elif "_uart" in args.file.name:
167            BacktraceClass = UartBacktrace
168        elif "_semaphore" in args.file.name:
169            BacktraceClass = SemaphoreBacktrace
170        else:
171            BacktraceClass = Backtrace
172
173    graphviz = args.graphviz
174    if args.svg:
175        graphviz = Path(str(args.file.with_suffix(".svg")).replace("calltrace_", "callgraph_"))
176
177    backtraces = re.split(r"(?:Breakpoint|Hardware .*?watchpoint) \d", read_gdb_log(args.file)[20:])
178    callgraph_from_backtrace(backtraces, BacktraceClass,
179                             output_graphviz=graphviz, output_pyvis=args.pyvis)