ARM: convert annotations to handle result types

Author: sipma

chb/app/InstrXData.py

@@ -4,7 +4,7 @@
 # ------------------------------------------------------------------------------
 # The MIT License (MIT)
 #
-# Copyright (c) 2021-2024  Aarno Labs LLC
+# Copyright (c) 2021-2025  Aarno Labs LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -73,8 +73,10 @@ def __init__(
         self.expanded = False
         self._ssavals: List[XVariable] = []
         self._vars: List[XVariable] = []
+        self._vars_r: List[Optional[XVariable]] = []
         self._types: List["BCTyp"] = []
         self._xprs: List[XXpr] = []
+        self._xprs_r: List[Optional[XXpr]] = []
         self._intervals: List[XInterval] = []
         self._strs: List[str] = []
         self._ints: List[int] = []
@@ -121,6 +123,12 @@ def vars(self) -> List[XVariable]:
             self._expand()
         return self._vars
 
+    @property
+    def vars_r(self) -> List[Optional[XVariable]]:
+        if not self.expanded:
+            self._expand()
+        return self._vars_r
+
     @property
     def types(self) -> List["BCTyp"]:
         if not self.expanded:
@@ -161,12 +169,29 @@ def get_var(self, index: int) -> XVariable:
                 + str(len(self.vars))
                 + ")")
 
+    def get_var_x(self, index: int) -> Optional[XVariable]:
+        if index < len(self.vars_r):
+            return self.vars_r[index]
+        else:
+            raise UF.CHBError(
+                "xdata: var-index out-of-bound: "
+                + str(index)
+                + " (length is "
+                + str(len(self.vars))
+                + ")")
+
     @property
     def xprs(self) -> List[XXpr]:
         if not self.expanded:
             self._expand()
         return self._xprs
 
+    @property
+    def xprs_r(self) -> List[Optional[XXpr]]:
+        if not self.expanded:
+            self._expand()
+        return self._xprs_r
+
     @property
     def intervals(self) -> List[XInterval]:
         if not self.expanded:
@@ -223,6 +248,18 @@ def reachingdeflocs_for_s(self, var: str) -> Sequence[XSymbol]:
                     return rdef.deflocations
         return []
 
+    @property
+    def is_ok(self) -> bool:
+        """Returns false if the data key is ar: and one or more of the
+        variables and/or expressions are error values (None). Returns true
+        otherwise."""
+
+        key = self.tags[0]
+        if key.startswith("ar:"):
+            return all(self.vars_r) and all(self.xprs_r)
+        else:
+            return True
+
     def _expand(self) -> None:
         """Expand the arguments based on the argument string in the keys.
 
@@ -240,49 +277,72 @@ def _expand(self) -> None:
         key = self.tags[0]
         if key.startswith("a:"):
             keyletters = key[2:]
-            for (i, c) in enumerate(keyletters):
-                arg = self.args[i]
-                xd = self.xprdictionary
-                bd = self.bdictionary
-                bcd = self.bcdictionary
-                if c == "v":
+            use_result = False
+        elif key.startswith("ar:"):
+            keyletters = key[3:]
+            use_result = True
+        else:
+            chklogger.logger.error(
+                "InstrXData tag: %s not recognized", key)
+            return
+
+        for (i, c) in enumerate(keyletters):
+            arg = self.args[i]
+            xd = self.xprdictionary
+            bd = self.bdictionary
+            bcd = self.bcdictionary
+            if c == "v":
+                if use_result:
+                    if arg == -2:
+                        self._vars_r.append(None)
+                    else:
+                        self._vars_r.append(xd.variable(arg))
+                else:
                     self._vars.append(xd.variable(arg))
-                elif c == "x":
-                    self._xprs.append(xd.xpr(arg))
-                elif c == "a":
-                    self._xprs.append(xd.xpr(arg))
-                elif c == "s":
-                    self._strs.append(bd.string(arg))
-                elif c == "i":
-                    self._intervals.append(xd.interval(arg))
-                elif c == "l":
-                    self._ints.append(arg)
-                elif c == "t":
-                    self._types.append(bcd.typ(arg))
-                elif c == "r":
-                    varinvd = self.varinvdictionary
-                    rdef = varinvd.var_invariant_fact(arg) if arg >= 0 else None
-                    rdef = cast(Optional[ReachingDefFact], rdef)
-                    self._reachingdefs.append(rdef)
-                elif c == "d":
-                    varinvd = self.varinvdictionary
-                    use = varinvd.var_invariant_fact(arg) if arg >= 0 else None
-                    use = cast(Optional[DefUse], use)
-                    self._defuses.append(use)
-                elif c == "h":
-                    varinvd = self.varinvdictionary
-                    usehigh = varinvd.var_invariant_fact(arg) if arg > 0 else None
-                    usehigh = cast(Optional[DefUseHigh], usehigh)
-                    self._defuseshigh.append(usehigh)
-                elif c == "f":
-                    varinvd = self.varinvdictionary
-                    flagrdef = varinvd.var_invariant_fact(arg) if arg >= 0 else None
-                    flagrdef = cast(Optional[FlagReachingDefFact], flagrdef)
-                    self._flagreachingdefs.append(flagrdef)
-                elif c == "c":
-                    self._ssavals.append(xd.variable(arg))
+
+            elif c == "x":
+                if use_result:
+                    if arg == -2:
+                        self._xprs_r.append(None)
+                    else:
+                        self._xprs_r.append(xd.xpr(arg))
                 else:
-                    raise UF.CHBError("Key letter not recognized: " + c)
+                    self._xprs.append(xd.xpr(arg))
+
+            elif c == "a":
+                self._xprs.append(xd.xpr(arg))
+            elif c == "s":
+                self._strs.append(bd.string(arg))
+            elif c == "i":
+                self._intervals.append(xd.interval(arg))
+            elif c == "l":
+                self._ints.append(arg)
+            elif c == "t":
+                self._types.append(bcd.typ(arg))
+            elif c == "r":
+                varinvd = self.varinvdictionary
+                rdef = varinvd.var_invariant_fact(arg) if arg >= 0 else None
+                rdef = cast(Optional[ReachingDefFact], rdef)
+                self._reachingdefs.append(rdef)
+            elif c == "d":
+                varinvd = self.varinvdictionary
+                use = varinvd.var_invariant_fact(arg) if arg >= 0 else None
+                use = cast(Optional[DefUse], use)
+                self._defuses.append(use)
+            elif c == "h":
+                varinvd = self.varinvdictionary
+                usehigh = varinvd.var_invariant_fact(arg) if arg > 0 else None
+                usehigh = cast(Optional[DefUseHigh], usehigh)
+                self._defuseshigh.append(usehigh)
+            elif c == "f":
+                varinvd = self.varinvdictionary
+                flagrdef = varinvd.var_invariant_fact(arg) if arg >= 0 else None
+                flagrdef = cast(Optional[FlagReachingDefFact], flagrdef)
+                self._flagreachingdefs.append(flagrdef)
+            elif c == "c":
+                self._ssavals.append(xd.variable(arg))
+            else:
+                raise UF.CHBError("Key letter not recognized: " + c)
 
     @property
     def is_function_argument(self) -> bool:

chb/arm/ARMInstruction.py

@@ -417,6 +417,7 @@ def to_string(
             pesp = str(self.stackpointer_offset) + "  " if sp else ""
             popcode = (
                 self.opcodetext.ljust(opcodewidth) if opcodetxt else "")
+            print("DEBUG: " + pesp + pbytes + popcode + self.annotation)
             return pesp + pbytes + popcode + self.annotation
         except Exception as e:
             print(

chb/arm/opcodes/ARMAdd.py

@@ -4,7 +4,7 @@
 # ------------------------------------------------------------------------------
 # The MIT License (MIT)
 #
-# Copyright (c) 2021-2024  Aarno Labs LLC
+# Copyright (c) 2021-2025  Aarno Labs LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -44,8 +44,108 @@
 
 
 if TYPE_CHECKING:
-    import chb.arm.ARMDictionary
-    from chb.invariants.XXpr import XprCompound, XprConstant
+    from  chb.arm.ARMDictionary import ARMDictionary
+    from chb.invariants.VarInvariantFact import ReachingDefFact
+    from chb.invariants.XVariable import XVariable
+    from chb.invariants.XXpr import XprCompound, XprConstant, XXpr
+
+
+class ARMAddXData:
+    """Add <rd> <rn> <rm>  ==> result
+
+    xdata format: a:vxxxxxxrrdh
+    -------------------------
+    vars[0]: vrd (Rd)
+    xprs[0]: xrn (Rn)
+    xprs[1]: xrm (Rm)
+    xprs[2]: result: xrn + xrm
+    xprs[3]: rresult: xrn + xrm (rewritten)
+    xprs[4]: xxrn (xrn rewritten)
+    xprs[5]: xxrm (xrm rewritten)
+    xprs[6]: tcond (optional)
+    xprs[7]: fcond (optional)
+    rdefs[0]: xrn
+    rdefs[1]: xrm
+    rdefs[2:..]: reaching definitions for simplified result expression
+    uses[0]: vrd
+    useshigh[0]: vrd
+    """
+
+    def __init__(self, xdata: InstrXData) -> None:
+        self._xdata = xdata
+
+    @property
+    def is_ok(self) -> bool:
+        return self._xdata.is_ok
+
+    @property
+    def vrd(self) -> "XVariable":
+        v = self._xdata.vars_r[0]
+        if v is None:
+            raise UF.CHBError("ARMAddXData:vrd")
+        return v
+
+    def xpr(self, index: int, msg: str) -> "XXpr":
+        x = self._xdata.xprs_r[index]
+        if x is None:
+            raise UF.CHBError("ARMAddXData:" + msg)
+        return x
+
+    @property
+    def xrn(self) -> "XXpr":
+        return self.xpr(0, "xrn")
+
+    @property
+    def xrm(self) -> "XXpr":
+        return self.xpr(1, "xrm")
+
+    @property
+    def result(self) -> "XXpr":
+        return self.xpr(2, "result")
+
+    @property
+    def rresult(self) -> "XXpr":
+        return self.xpr(3, "rresult")
+
+    @property
+    def result_simplified(self) -> str:
+        return simplify_result(
+            self._xdata.args[3], self._xdata.args[4], self.result, self.rresult)
+
+    @property
+    def xxrn(self) -> "XXpr":
+        return self.xpr(4, "xxrn")
+
+    @property
+    def xxrm(self) -> "XXpr":
+        return self.xpr(5, "xxrm")
+
+    @property
+    def tcond(self) -> "XXpr":
+        return self.xpr(6, "tcond")
+
+    @property
+    def fcond(self) -> "XXpr":
+        return self.xpr(7, "fcond")
+
+    @property
+    def rn_rdef(self) -> Optional["ReachingDefFact"]:
+        return self._xdata.reachingdefs[0]
+
+    @property
+    def rm_rdef(self) -> Optional["ReachingDefFact"]:
+        return self._xdata.reachingdefs[1]
+
+    @property
+    def annotation(self) -> str:
+        assignment = str(self.vrd) + " := " + self.result_simplified
+        if self._xdata.has_unknown_instruction_condition():
+            return "if ? then " + assignment
+        elif self._xdata.has_instruction_condition():
+            c = str(self.tcond)
+            return "if " + c + " then " + assignment
+        else:
+            return assignment
 
 
 @armregistry.register_tag("ADD", ARMOpcode)
@@ -69,26 +169,9 @@ class ARMAdd(ARMOpcode):
     args[3]: index of op3 in armdictionary
     args[4]: is-wide (thumb)
 
-    xdata format: a:vxxxxrrdh
-    -------------------------
-    vars[0]: lhs (Rd)
-    xprs[0]: rhs1 (Rn)
-    xprs[1]: rhs2 (Rm)
-    xprs[2]: rhs1 + rhs2
-    xprs[3]: rhs1 + rhs2 (simplified)
-    xprs[4]: rhs1 (simplified)
-    xprs[5]: rhs2 (simplified)
-    rdefs[0]: rhs1
-    rdefs[1]: rhs2
-    rdefs[2:..]: reaching definitions for simplified result expression
-    uses[0]: lhs
-    useshigh[0]: lhs
     """
 
-    def __init__(
-            self,
-            d: "chb.arm.ARMDictionary.ARMDictionary",
-            ixval: IndexedTableValue) -> None:
+    def __init__(self, d: "ARMDictionary", ixval: IndexedTableValue) -> None:
         ARMOpcode.__init__(self, d, ixval)
         self.check_key(2, 5, "Add")
 
@@ -111,18 +194,11 @@ def mnemonic_extension(self) -> str:
         return wb + cc + wide
 
     def annotation(self, xdata: InstrXData) -> str:
-        lhs = str(xdata.vars[0])
-        result = xdata.xprs[2]
-        rresult = xdata.xprs[3]
-        xresult = simplify_result(xdata.args[3], xdata.args[4], result, rresult)
-        assignment = lhs + " := " + xresult
-        if xdata.has_unknown_instruction_condition():
-            return "if ? then " + assignment
-        elif xdata.has_instruction_condition():
-            c = str(xdata.xprs[1])
-            return "if " + c + " then " + assignment
+        xd = ARMAddXData(xdata)
+        if xd.is_ok:
+            return xd.annotation
         else:
-            return assignment
+            return "Error Value"
 
     # --------------------------------------------------------------------------
     # AddWithCarry()