AST: visual representation of reaching defs

Author: sipma

chb/app/CHVersion.py

@@ -1 +1 @@
-chbversion: str = "0.3.0-20250902"
+chbversion: str = "0.3.0-20250908"

chb/app/Function.py

@@ -525,14 +525,36 @@ def instruction(self, iaddr: str) -> Instruction:
         else:
             raise UF.CHBError("No instruction found at address " + iaddr)
 
-    def rdef_locations(self) -> Dict[str, List[List[str]]]:
+    def rdef_location_partition(self) -> Dict[str, List[List[str]]]:
+        """Return a map of registers to partitions of their reaching definitions."""
+
         result: Dict[str, List[List[str]]] = {}
 
         for (iaddr, instr) in self.instructions.items():
             irdefs = instr.rdef_locations()
-            for (reg, rdeflists) in irdefs.items():
+            for (reg, rdeflist) in irdefs.items():
                 result.setdefault(reg, [])
-                result[reg].extend(rdeflists)
+                for rrlist in result[reg]:
+                    if set(rrlist) == set(rdeflist):
+                        break
+                else:
+                    result[reg].append(rdeflist)
+        return result
+
+    def use_location_partition(self) -> Dict[str, List[List[str]]]:
+        """Return a map of registers to partitions of their use locations."""
+
+        result: Dict[str, List[List[str]]] = {}
+
+        for (iaddr, instr) in self.instructions.items():
+            iuses = instr.use_locations()
+            for (reg, uselist) in iuses.items():
+                result.setdefault(reg, [])
+                for rrlist in result[reg]:
+                    if set(rrlist) == set(uselist):
+                        break
+                else:
+                    result[reg].append(uselist)
         return result
 
     def lhs_types(self) -> Dict[str, Dict[str, "BCTyp"]]:
@@ -545,7 +567,6 @@ def lhs_types(self) -> Dict[str, Dict[str, "BCTyp"]]:
             result[iaddr] = {}
             for (vname, vtype) in ilhs_types.items():
                 result[iaddr][vname] = vtype
-
         return result
 
     def globalrefs(self) -> Dict[str, List["GlobalReference"]]:

chb/app/Instruction.py

@@ -340,11 +340,16 @@ def ast_switch_condition_prov(
             Optional[AST.ASTExpr], Optional[AST.ASTExpr]]:
         raise UF.CHBError("ast-switch-condition-prov not defined")
 
-    def rdef_locations(self) -> Dict[str, List[List[str]]]:
+    def rdef_locations(self) -> Dict[str, List[str]]:
         """Returns for each register, which locations must be combined."""
 
         return {}
 
+    def use_locations(self) -> Dict[str, List[str]]:
+        """Returns for each register defined, which locations use the definition."""
+
+        return {}
+
     def lhs_types(self) -> Dict[str, "BCTyp"]:
         """Returns a mapping from lhs assigned to its type."""
 

chb/arm/ARMInstruction.py

@@ -411,20 +411,25 @@ def lhs_variables(
     def rhs_expressions(self, filter: Callable[[XXpr], bool]) -> List[XXpr]:
         return [x for x in self.opcode.rhs(self.xdata) if filter(x)]
 
-    def rdef_locations(self) -> Dict[str, List[List[str]]]:
-        result: Dict[str, Dict[str, List[str]]] = {}
+    def rdef_locations(self) -> Dict[str, List[str]]:
+        result: Dict[str, List[str]] = {}
 
         for rdef in self.xdata.reachingdefs:
             if rdef is not None:
-                rdefvar = str(rdef.vardefuse.variable)
-                rdeflocs = [str(s) for s in rdef.valid_deflocations]
-                result.setdefault(rdefvar, {})
-                for sx in rdeflocs:
-                    result[rdefvar].setdefault(sx, [])
-                    for sy in rdeflocs:
-                        if sy not in result[rdefvar][sx]:
-                            result[rdefvar][sx].append(sy)
-        return {x:list(r.values()) for (x, r) in result.items()}
+                rdefvar = str(rdef.variable)
+                rdeflocs = sorted([str(s) for s in rdef.valid_deflocations])
+                result[rdefvar] = rdeflocs
+        return result
+
+    def use_locations(self) -> Dict[str, List[str]]:
+        result: Dict[str, List[str]] = {}
+
+        for use in self.xdata.defuses:
+            if use is not None:
+                usevar = str(use.variable)
+                uselocs = sorted([str(s) for s in use.uselocations])
+                result[usevar] = uselocs
+        return result
 
     def lhs_types(self) -> Dict[str, "BCTyp"]:
         result: Dict[str, "BCTyp"] = {}

chb/cmdline/astcmds.py

@@ -36,6 +36,7 @@
     Any, cast, Dict, List, NoReturn, Optional, Set, Tuple, TYPE_CHECKING)
 
 from chb.app.AppAccess import AppAccess
+from chb.app.Function import Function
 
 from chb.ast.AbstractSyntaxTree import AbstractSyntaxTree
 from chb.ast.ASTApplicationInterface import ASTApplicationInterface
@@ -62,6 +63,7 @@
 from chb.userdata.UserHints import UserHints
 
 import chb.util.dotutil as UD
+from chb.util.DotGraph import DotGraph
 import chb.util.fileutil as UF
 import chb.util.graphutil as UG
 from chb.util.loggingutil import chklogger, LogLevel
@@ -150,6 +152,7 @@ def buildast(args: argparse.Namespace) -> NoReturn:
     hide_annotations: bool = args.hide_annotations
     show_reachingdefs: str = args.show_reachingdefs
     output_reachingdefs: str = args.output_reachingdefs
+    fileformat: str = args.format
     verbose: bool = args.verbose
     loglevel: str = args.loglevel
     logfilename: Optional[str] = args.logfilename
@@ -347,7 +350,7 @@ def buildast(args: argparse.Namespace) -> NoReturn:
             # xdata records for all instructions in the function. Locations that
             # have a common user are merged. Types are provided by lhs_types.
             astinterface.introduce_ssa_variables(
-                f.rdef_locations(), f.register_lhs_types, f.lhs_names)
+                f.rdef_location_partition(), f.register_lhs_types, f.lhs_names)
 
             # Introduce stack variables for all stack buffers with types
             astinterface.introduce_stack_variables(
@@ -393,51 +396,14 @@ def buildast(args: argparse.Namespace) -> NoReturn:
                     UC.print_error("\nSpecify a file to save the reaching defs")
                     continue
 
-                rdefspec = show_reachingdefs.split(":")
-                if len(rdefspec) != 2:
-                    UC.print_error(
-                        "\nArgument to show_reachingdefs not recognized")
-                    continue
-
-                useloc = rdefspec[0]
-                register = rdefspec[1]
-
-                if not f.has_instruction(useloc):
-                    UC.print_status_update("Useloc: " + useloc + " not found")
-                    continue
-
-                tgtinstr = f.instruction(useloc)
-
-                if not register in f.rdef_locations():
+                register = show_reachingdefs
+                if not register in f.rdef_location_partition():
                     UC.print_status_update(
                         "Register " + register + " not found in rdeflocations")
                     continue
 
-                cblock = f.containing_block(useloc)
-                graph = UG.DirectedGraph(list(f.cfg.blocks.keys()), f.cfg.edges)
-                rdefs = tgtinstr.reaching_definitions(register)
-                dotpaths: List[DotRdefPath] = []
-                graph.find_paths(f.faddr, cblock)
-                for (i, p) in enumerate(
-                    sorted(graph.get_paths(), key=lambda p: len(p))):
-                    cfgpath = DotRdefPath(
-                        "path" + str(i),
-                        f,
-                        astinterface,
-                        p,
-                        subgraph=True,
-                        nodeprefix = str(i) +":",
-                        rdefinstrs = rdefs)
-                    dotpaths.append(cfgpath)
-
-                pdffilename = UD.print_dot_subgraphs(
-                    app.path,
-                    "paths",
-                    output_reachingdefs,
-                    "pdf",
-                    [dotcfg.build() for dotcfg in dotpaths])
-
-                UC.print_status_update("Printed " + pdffilename)
+                print_reachingdefs(
+                    app, astinterface, output_reachingdefs, fileformat, f, register)
 
         else:
             UC.print_error("Unable to find function " + faddr)
@@ -469,6 +435,102 @@ def buildast(args: argparse.Namespace) -> NoReturn:
     exit(0)
 
 
+def print_reachingdefs(
+        app: AppAccess,
+        astinterface: ASTInterface,
+        filename: str,
+        fileformat: str,
+        f: Function,
+        register: str) -> None:
+    dotpaths: List[Tuple[DotRdefPath, str, str]] = []
+    regspill = register + "_spill"
+    for (iaddr, instr) in f.instructions.items():
+        if register in instr.rdef_locations():
+            register_o = app.bdictionary.register_by_name(register)
+            cblock = f.containing_block(iaddr)
+            rdefs = instr.reaching_definitions(register)
+            for rdef in rdefs:
+                if rdef == "init":
+                    if regspill in instr.annotation:
+                        continue
+                    rdblock = f.faddr
+                    graph = UG.DirectedGraph(list(f.cfg.blocks.keys()), f.cfg.edges)
+                    graph.find_paths(rdblock, cblock)
+                    for (i, p) in enumerate(
+                            sorted(graph.get_paths(), key=lambda p: len(p))):
+                        p = ["init"] + p
+                        cfgpath = DotRdefPath(
+                            "path_" + str(rdef) + "_" + str(iaddr) + "_" + str(i),
+                            f,
+                            astinterface,
+                            p,
+                            register_o,
+                            subgraph=True,
+                            nodeprefix = str(iaddr) + str(rdef) + str(i) + ":",
+                            rdefinstrs = rdefs,
+                            useinstrs=[iaddr])
+                        dotpaths.append((cfgpath, rdef, iaddr))
+                else:
+                    rdblock = f.containing_block(rdef)
+                    graph = UG.DirectedGraph(list(f.cfg.blocks.keys()), f.cfg.edges)
+                    graph.find_paths(rdblock, cblock)
+                    for (i, p) in enumerate(
+                            sorted(graph.get_paths(), key=lambda p: len(p))):
+                        cfgpath = DotRdefPath(
+                            "path_" + str(rdef) + "_" + str(iaddr) + "_" + str(i),
+                            f,
+                            astinterface,
+                            p,
+                            subgraph=True,
+                            nodeprefix = str(iaddr) + str(rdef) + str(i) + ":",
+                            rdefinstrs = rdefs,
+                            useinstrs=[iaddr])
+                        dotpaths.append((cfgpath, rdef, iaddr))
+
+    possibly_spurious_rdefs: List[Tuple[str, str]] = []
+    legitimate_rdefs: List[Tuple[str, str]] = []
+    dotgraphs: List[Tuple[DotRdefPath, DotGraph, str, str]] = []
+
+    for (dotcfg, rdef, iaddr) in dotpaths:
+        dotgr = dotcfg.build()
+        if dotgr is not None:
+            if dotcfg.is_potentially_spurious():
+                possibly_spurious_rdefs.append((rdef, iaddr))
+            else:
+                legitimate_rdefs.append((rdef, iaddr))
+            dotgraphs.append((dotcfg, dotgr, rdef, iaddr))
+
+    printgraphs: List[DotGraph] = []
+    for (dotcfg, dg, rdef, iaddr) in dotgraphs:
+        if dotcfg.is_potentially_spurious():
+            if (rdef, iaddr) in legitimate_rdefs:
+                pass
+            else:
+                printgraphs.append(dg)
+        else:
+            printgraphs.append(dg)
+
+    pdffilename = UD.print_dot_subgraphs(
+        app.path,
+        "paths",
+        filename,
+        fileformat,
+        printgraphs)
+
+    UC.print_status_update("Printed " + pdffilename)
+    if len(possibly_spurious_rdefs) > 0:
+        print("Possibly spurious reachingdefs to be removed: ")
+        print("~" * 80)
+        for (rdef, iaddr) in set(possibly_spurious_rdefs):
+            if not (rdef, iaddr) in legitimate_rdefs:
+                print("  rdefloc: " + rdef + "; useloc: " + iaddr)
+        print("~" * 80)
+
+    # print("\nLegitimate reaching defs:")
+    # for (rdef, iaddr) in set(legitimate_rdefs):
+    #      print("  rdefloc: " + rdef + "; useloc: " + iaddr)
+
+
 def showast(args: argparse.Namespace) -> NoReturn:
     print("still under construction ..")
     exit(1)

chb/cmdline/chkx

@@ -744,10 +744,15 @@ def parse() -> argparse.Namespace:
         action="store_true")
     buildast.add_argument(
         "--show_reachingdefs",
-        help="create a dot file for the reaching defs of <addr>:<reg>")
+        help="create a dot file for the reaching defs of <reg>")
     buildast.add_argument(
         "--output_reachingdefs",
         help="name of output file (without extension) to store dot/pdf file of reachingdefs")
+    buildast.add_argument(
+        "--format",
+        choices=["pdf", "png"],
+        default="pdf",
+        help="format for the graph file generated from dot")
     buildast.add_argument(
         "--loglevel", "-log",
         choices=UL.LogLevel.options(),