ARM: convert annotations to handle result types

Author: sipma

chb/app/InstrXData.py

@@ -260,6 +260,20 @@ def is_ok(self) -> bool:
         else:
             return True
 
+    @property
+    def error_values(self) -> Tuple[List[int], List[int]]:
+
+        key = self.tags[0]
+        if key.startswith("ar:"):
+            vars_e: List[int] = [
+                i for i in range(0, len(self.vars_r)) if self.vars_r[i] is None]
+            xprs_e: List[int] = [
+                i for i in range(0, len(self.xprs_r)) if self.xprs_r[i] is None]
+            return (vars_e, xprs_e)
+        else:
+            return ([], [])
+
+
     def _expand(self) -> None:
         """Expand the arguments based on the argument string in the keys.
 
@@ -373,6 +387,11 @@ def is_bx_call(self) -> bool:
         return "bx-call" in self.tags
 
     def call_target_argument_count(self) -> Optional[int]:
+        if any(s.startswith("argcount:") for s in self.tags):
+            tag = next(s for s in self.tags if s.startswith("argcount:"))
+            argcount = int(tag[9:])
+            return argcount
+
         if len(self.tags) >= 3:
             if self.tags[1] == "call":
                 try:
@@ -385,7 +404,6 @@ def call_target_argument_count(self) -> Optional[int]:
 
         return None
 
-
     def has_inlined_call_target(self) -> bool:
         return len(self.tags) >= 3 and self.tags[2] == "inlined"
 

chb/arm/ARMCallOpcode.py

@@ -4,7 +4,7 @@
 # ------------------------------------------------------------------------------
 # The MIT License (MIT)
 #
-# Copyright (c) 2022-2024  Aarno Labs LLC
+# Copyright (c) 2022-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
@@ -54,12 +54,62 @@
 
 if TYPE_CHECKING:
     from chb.api.CallTarget import CallTarget, AppTarget, StaticStubTarget
+    from chb.api.InterfaceDictionary import InterfaceDictionary
     from chb.arm.ARMDictionary import ARMDictionary
     from chb.bctypes.BCTyp import BCTypFun
     from chb.invariants.VarInvariantFact import ReachingDefFact
     from chb.invariants.VAssemblyVariable import VRegisterVariable
     from chb.invariants.VConstantValueVariable import VFunctionReturnValue
-    from chb.invariants.XXpr import XprConstant, XprVariable
+    from chb.invariants.XVariable import XVariable
+    from chb.invariants.XXpr import XXpr, XprConstant, XprVariable
+
+
+class ARMCallOpcodeXData:
+
+    def __init__(
+            self,
+            xdata: InstrXData,
+            ixd: "InterfaceDictionary") -> None:
+        self._xdata = xdata
+        self._ixd = ixd
+
+    @property
+    def is_ok(self) -> bool:
+        return self._xdata.is_ok
+
+    @property
+    def argument_count(self) -> int:
+        argcount = self._xdata.call_target_argument_count()
+        if argcount is None:
+            chklogger.logger.error(
+                "No argument count found for call")
+            return 0
+        return argcount
+
+    @property
+    def arguments(self) -> List["XXpr"]:
+        argcount = self.argument_count
+        arguments: List["XXpr"] = []
+        for i in range(argcount):
+            x = self._xdata.xprs_r[i]
+            if x is None:
+                x = self._xdata.xprs_r[i + argcount]
+                if x is None:
+                    raise UF.CHBError(
+                        "Unexpected None-value call argument at index "
+                        + str(i))
+            arguments.append(x)
+        return arguments
+
+    @property
+    def calltarget(self) -> "CallTarget":
+        return self._xdata.call_target(self._ixd)
+
+    @property
+    def annotation(self) -> str:
+        tgt = str(self.calltarget)
+        args = ", ".join(str(x) for x in self.arguments)
+        return "call " + str(tgt) + "(" + args + ")"
 
 
 class ARMCallOpcode(ARMOpcode):
@@ -134,13 +184,8 @@ def is_call_instruction(self, xdata: InstrXData) -> bool:
         return xdata.has_call_target()
 
     def annotation(self, xdata: InstrXData) -> str:
-        if self.is_call(xdata) and xdata.has_call_target():
-            tgt = xdata.call_target(self.ixd)
-            args = ", ".join(str(x) for x in self.arguments(xdata))
-            return "call " + str(tgt) + "(" + args + ")"
-
-        ctgt = str(xdata.xprs[0])
-        return "call " + ctgt
+        xd = ARMCallOpcodeXData(xdata, self.ixd)
+        return xd.annotation
 
     def call_target(self, xdata: InstrXData) -> "CallTarget":
         if self.is_call(xdata):

chb/arm/opcodes/ARMBranchLink.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

chb/arm/opcodes/ARMCompare.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
@@ -43,7 +43,56 @@
 from chb.util.IndexedTable import IndexedTableValue
 
 if TYPE_CHECKING:
-    import chb.arm.ARMDictionary
+    from chb.arm.ARMDictionary import ARMDictionary
+    from chb.invariants.XXpr import XXpr
+
+
+class ARMCompareXData:
+
+    def __init__(self, xdata: InstrXData) -> None:
+        self._xdata = xdata
+
+    @property
+    def is_ok(self) -> bool:
+        return self._xdata.is_ok
+
+    def xpr(self, index: int, msg: str) -> "XXpr":
+        x = self._xdata.xprs_r[index]
+        if x is None:
+            raise UF.CHBError("ARMCompareXData:" + 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 tcond(self) -> "XXpr":
+        return self.xpr(3, "tcond")
+
+    @property
+    def fcond(self) -> "XXpr":
+        return self.xpr(4, "fcond")
+
+    @property
+    def annotation(self) -> str:
+        ann = "compare " + str(self.xrn) + " and " + str(self.xrm)
+        ann += " (" + str(self.result) + ")"
+        if self._xdata.has_unknown_instruction_condition():
+            return "if ? then " + ann
+        elif self._xdata.has_instruction_condition():
+            c = str(self.tcond)
+            return "if " + c + " then " + ann
+        else:
+            return ann
 
 
 @armregistry.register_tag("CMP", ARMOpcode)
@@ -72,10 +121,7 @@ class ARMCompare(ARMOpcode):
     rdefs[2..]: xrn - xrm (simplified)
     """
 
-    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, 3, "Compare")
 
@@ -93,17 +139,11 @@ def opargs(self) -> List[ARMOperand]:
         return [self.armd.arm_operand(i) for i in self.args[:-1]]
 
     def annotation(self, xdata: InstrXData) -> str:
-        rhs1 = str(xdata.xprs[0])
-        rhs2 = str(xdata.xprs[1])
-        result = str(xdata.xprs[2])
-        ann = "compare " + str(rhs1) + " and " + str(rhs2) + " (" + result + ")"
-        if xdata.has_unknown_instruction_condition():
-            return "if ? then " + ann
-        elif xdata.has_instruction_condition():
-            c = str(xdata.xprs[1])
-            return "if " + c + " then " + ann
+        xd = ARMCompareXData(xdata)
+        if xd.is_ok:
+            return xd.annotation
         else:
-            return ann
+            return "Error value"
 
     def ast_prov(
             self,