AST: use untyped registers as argument for show_reachingdefs

Author: sipma

chb/astinterface/ASTInterface.py

@@ -970,7 +970,7 @@ def introduce_ssa_variables(
             self,
             rdeflocs: Dict[str, List[List[str]]],
             ftypes: Dict[str, Dict[str, "BCTyp"]],
-            ssanames: Dict[str, str] = {}) -> None:
+            ssanames: Dict[str, str] = {}) -> Dict[str, Dict[str, List[str]]]:
         """Creates ssa variables based on reaching definition locations.
 
         Lists with multiple locations will give rise to a single variable
@@ -985,10 +985,10 @@ def introduce_ssa_variables(
         where <reg> is the name of the register being assigned.
         """
 
+        untyped: Dict[str, Dict[str, List[str]]] = {}
         for (reg, locs) in rdeflocs.items():
             for lst in locs:
                 if len(lst) > 0:
-                    # print("DEBUG: " + str(reg) + ": [" + ", ".join(str(loc) for loc in lst) + "]")
                     loc1 = lst[0]
                     vtype = None
                     if loc1 in ftypes:
@@ -997,11 +997,16 @@ def introduce_ssa_variables(
                             vtype = vbctype.convert(self.typconverter)
                     vinfo = self.mk_ssa_register_varinfo(
                         reg, loc1, vtype=vtype, prefix=ssanames.get(loc1))
+                    if vtype is None:
+                        untyped.setdefault(reg, {})
+                        untyped[reg].setdefault(vinfo.vname, [])
+                        untyped[reg][vinfo.vname].append(loc1)
                     self._ssa_addresses.setdefault(vinfo.vname, set([]))
                     for loc in lst:
                         self._ssa_intros.setdefault(loc, {})
                         self._ssa_intros[loc][reg] = vinfo
                         self._ssa_addresses[vinfo.vname].add(loc)
+        return untyped
 
     def introduce_stack_variables(
             self,

chb/cmdline/astcmds.py

@@ -150,7 +150,8 @@ def buildast(args: argparse.Namespace) -> NoReturn:
     xpatchresultsfile = args.patch_results_file
     hide_globals: bool = args.hide_globals
     hide_annotations: bool = args.hide_annotations
-    show_reachingdefs: str = args.show_reachingdefs
+    show_reachingdefs: bool = args.show_reachingdefs
+    reachingdefs_registers: List[str] = args.reachingdefs_registers
     output_reachingdefs: str = args.output_reachingdefs
     fileformat: str = args.format
     verbose: bool = args.verbose
@@ -349,13 +350,26 @@ def buildast(args: argparse.Namespace) -> NoReturn:
             # Introduce ssa variables for all reaching definitions referenced in
             # 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(
+            untyped = astinterface.introduce_ssa_variables(
                 f.rdef_location_partition(), f.register_lhs_types, f.lhs_names)
 
             # Introduce stack variables for all stack buffers with types
             astinterface.introduce_stack_variables(
                 f.stackframe, f.stack_variable_types)
 
+            regsuntyped: List[str] = []
+            for (reg, varlocs) in untyped.items():
+                for (var, locs) in varlocs.items():
+                    if len(locs) == 1 and locs[0] == "init":
+                        continue
+                    if "_spill" in var:
+                        continue
+                    if reg == "SP":
+                        continue
+                    # print(" Untyped: " + reg + ": " + var + " [" + ",".join(locs) + "]")
+                    if not reg in regsuntyped:
+                        regsuntyped.append(reg)
+
             astfunction = ASTInterfaceFunction(
                 faddr, fname, f, astinterface, patchevents=patchevents)
 
@@ -396,14 +410,18 @@ def buildast(args: argparse.Namespace) -> NoReturn:
                     UC.print_error("\nSpecify a file to save the reaching defs")
                     continue
 
-                register = show_reachingdefs
-                if not register in f.rdef_location_partition():
-                    UC.print_status_update(
-                        "Register " + register + " not found in rdeflocations")
-                    continue
+                if len(reachingdefs_registers) == 0:
+                    reachingdefs_registers = regsuntyped
 
-                print_reachingdefs(
-                    app, astinterface, output_reachingdefs, fileformat, f, register)
+                for register in reachingdefs_registers:
+                    if not register in f.rdef_location_partition():
+                        UC.print_status_update(
+                            "Register " + register + " not found in rdeflocations")
+                        continue
+
+                for reg in reachingdefs_registers:
+                    print_reachingdefs(
+                        app, astinterface, output_reachingdefs + "__" + reg, fileformat, f, reg)
 
         else:
             UC.print_error("Unable to find function " + faddr)
@@ -510,21 +528,23 @@ def print_reachingdefs(
         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)
+    if len(printgraphs) > 0:
+        pdffilename = UD.print_dot_subgraphs(
+            app.path,
+            "paths",
+            filename,
+            fileformat,
+            printgraphs)
+
+        UC.print_status_update("Printed " + pdffilename)
+        if len(possibly_spurious_rdefs) > 0:
+            print("\nPossibly spurious reachingdefs to be removed for register "
+                  + register + ": ")
+            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):

chb/cmdline/chkx

@@ -744,10 +744,16 @@ def parse() -> argparse.Namespace:
         action="store_true")
     buildast.add_argument(
         "--show_reachingdefs",
+        action="store_true",
         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(
+        "--reachingdefs_registers",
+        help="show reachingdefs for these registers only (default: generate automatically)",
+        nargs="*",
+        default=[])
     buildast.add_argument(
         "--format",
         choices=["pdf", "png"],