ARM:AST: updates for conversion to C expressions

Author: sipma

chb/app/CHVersion.py

@@ -1 +1 @@
-chbversion: str = "0.3.0-20250318"
+chbversion: str = "0.3.0-20250325"

chb/app/InstrXData.py

@@ -73,9 +73,11 @@ def __init__(
         self.expanded = False
         self._vars: List[XVariable] = []
         self._vars_r: List[Optional[XVariable]] = []
+        self._cvars_r: List[Optional[XVariable]] = []
         self._types: List["BCTyp"] = []
         self._xprs: List[XXpr] = []
         self._xprs_r: List[Optional[XXpr]] = []
+        self._cxprs_r: List[Optional[XXpr]] = []
         self._intervals: List[XInterval] = []
         self._strs: List[str] = []
         self._ints: List[int] = []
@@ -128,6 +130,12 @@ def vars_r(self) -> List[Optional[XVariable]]:
             self._expand()
         return self._vars_r
 
+    @property
+    def cvars_r(self) -> List[Optional[XVariable]]:
+        if not self.expanded:
+            self._expand()
+        return self._cvars_r
+
     @property
     def types(self) -> List["BCTyp"]:
         if not self.expanded:
@@ -156,6 +164,17 @@ def get_var_x(self, index: int) -> Optional[XVariable]:
                 + str(len(self.vars))
                 + ")")
 
+    def get_cvar_r(self, index: int) -> Optional[XVariable]:
+        if index < len(self.cvars_r):
+            return self.cvars_r[index]
+        else:
+            raise UF.CHBError(
+                "xdata: cvar-index out-of-bound: "
+                + str(index)
+                + " (length is "
+                + str(len(self.cvars_r))
+                + ")")
+
     @property
     def xprs(self) -> List[XXpr]:
         if not self.expanded:
@@ -168,6 +187,12 @@ def xprs_r(self) -> List[Optional[XXpr]]:
             self._expand()
         return self._xprs_r
 
+    @property
+    def cxprs_r(self) -> List[Optional[XXpr]]:
+        if not self.expanded:
+            self._expand()
+        return self._cxprs_r
+
     @property
     def intervals(self) -> List[XInterval]:
         if not self.expanded:
@@ -232,22 +257,60 @@ def is_ok(self) -> bool:
 
         key = self.tags[0]
         if key.startswith("ar:"):
-            return all(self.vars_r) and all(self.xprs_r)
+            return all(self.vars_r) and all(self.xprs_r) and all(self.cxprs_r)
         else:
             return True
 
+    def has_var_r(self, index: int) -> bool:
+        return index >= 0 and index < len(self.vars_r)
+
+    def is_var_ok(self, index: int) -> bool:
+        if self.has_var_r(index):
+            v = self.vars_r[index]
+            return v is not None
+        return False
+
+    def has_cvar_r(self, index: int) -> bool:
+        return index >= 0 and index < len(self.cvars_r)
+
+    def is_cvar_ok(self, index: int) -> bool:
+        if self.has_cvar_r(index):
+            v = self.cvars_r[index]
+            return v is not None
+        return False
+
+    def has_xpr_r(self, index: int) -> bool:
+        return index >= 0 and index < len(self.xprs_r)
+
+    def is_xpr_ok(self, index: int) -> bool:
+        if self.has_xpr_r(index):
+            x = self.xprs_r[index]
+            return x is not None
+        return False
+
+    def has_cxpr_r(self, index: int) -> bool:
+        return index >= 0 and index < len(self.cxprs_r)
+
+    def is_cxpr_ok(self, index: int) -> bool:
+        if self.has_cxpr_r(index):
+            cx = self.cxprs_r[index]
+            return cx is not None
+        return False
+
     @property
-    def error_values(self) -> Tuple[List[int], List[int]]:
+    def error_values(self) -> Tuple[List[int], 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)
+            cxprs_e: List[int] = [
+                i for i in range(0, len(self.cxprs_r)) if self.cxprs_r[i] is None]
+            return (vars_e, xprs_e, cxprs_e)
         else:
-            return ([], [])
+            return ([], [], [])
 
 
     def _expand(self) -> None:
@@ -290,6 +353,12 @@ def _expand(self) -> None:
                 else:
                     self._vars.append(xd.variable(arg))
 
+            elif c == "w":
+                if arg == -2:
+                    self._cvars_r.append(None)
+                else:
+                    self._cvars_r.append(xd.variable(arg))
+
             elif c == "x":
                 if use_result:
                     if arg == -2:
@@ -299,6 +368,11 @@ def _expand(self) -> None:
                 else:
                     self._xprs.append(xd.xpr(arg))
 
+            elif c == "c":
+                if arg == -2:
+                    self._cxprs_r.append(None)
+                else:
+                    self._cxprs_r.append(xd.xpr(arg))
             elif c == "a":
                 self._xprs.append(xd.xpr(arg))
             elif c == "s":
@@ -338,6 +412,7 @@ def is_function_argument(self) -> bool:
 
     @property
     def function_argument_callsite(self) -> AsmAddress:
+        # Currently only used in x86
         if self.is_function_argument:
             return self.bdictionary.address(self.args[2])
         else:
@@ -474,6 +549,15 @@ def get_base_update_xpr(self) -> XXpr:
     def has_return_xpr(self) -> bool:
         return any(s.startswith("return:") for s in self.tags)
 
+    def has_return_cxpr(self) -> bool:
+        if any(s.startswith("return:") for s in self.tags):
+            rvtag = next(t for t in self.tags if t.startswith("return:"))
+            rvix = int(rvtag[7:])
+            rval = self.args[rvix + 2]
+            return rval >= 0
+        else:
+            return False
+
     def get_return_xpr(self) -> XXpr:
         rvtag = next(t for t in self.tags if t.startswith("return:"))
         rvix = int(rvtag[7:])
@@ -490,6 +574,14 @@ def get_return_xxpr(self) -> XXpr:
             raise UF.CHBError("Unexpected error in rewritten return value")
         return self.xprdictionary.xpr(rval)
 
+    def get_return_cxpr(self) -> XXpr:
+        rvtag = next(t for t in self.tags if t.startswith("return:"))
+        rvix = int(rvtag[7:])
+        rval = self.args[rvix + 2]
+        if rval == -2:
+            raise UF.CHBError("Unexpected error in C return value")
+        return self.xprdictionary.xpr(rval)
+
     @property
     def is_aggregate_jumptable(self) -> bool:
         return "agg-jt" in self.tags

chb/arm/ARMOpcode.py

@@ -119,7 +119,7 @@ def is_ok(self) -> bool:
         return self.xdata.is_ok
 
     def var(self, index: int, name: str) -> "XVariable":
-        if index >= len(self.xdata.vars_r):
+        if not self.has_var(index):
             raise UF.CHBError(
                 self.__class__.__name__ + ":"
                 + name + " index out of bounds: " + str(index))
@@ -129,8 +129,31 @@ def var(self, index: int, name: str) -> "XVariable":
                 self.__class__.__name__ + ":" + name + " has an error value")
         return v
 
+    def has_var(self, index: int) -> bool:
+        return self.xdata.has_var_r(index)
+
+    def is_var_ok(self, index: int) -> bool:
+        return self.xdata.is_var_ok(index)
+
+    def cvar(self, index: int, name: str) -> "XVariable":
+        if not self.has_cvar(index):
+            raise UF.CHBError(
+                self.__class__.__name__ + ":"
+                + name + " index out of bounds: " + str(index))
+        cv = self.xdata.cvars_r[index]
+        if cv is None:
+            raise UF.CHBError(
+                self.__class__.__name__ + ":" + name + " has an error value")
+        return cv
+
+    def has_cvar(self, index: int) -> bool:
+        return self.xdata.has_cxpr_r(index)
+
+    def is_cvar_ok(self, index: int) -> bool:
+        return self.xdata.is_cvar_ok(index)
+
     def xpr(self, index: int, name: str) -> "XXpr":
-        if index >= len(self.xdata.xprs_r):
+        if not self.has_xpr(index):
             raise UF.CHBError(
                 self.__class__.__name__ + ":"
                 + name + " index out of bounds: " + str(index))
@@ -140,6 +163,29 @@ def xpr(self, index: int, name: str) -> "XXpr":
                 self.__class__.__name__ + ":" + name + " has an error value")
         return x
 
+    def has_xpr(self, index: int) -> bool:
+        return self.xdata.has_xpr_r(index)
+
+    def is_xpr_ok(self, index: int) -> bool:
+        return self.xdata.is_xpr_ok(index)
+
+    def cxpr(self, index: int, name: str) -> "XXpr":
+        if index >= len(self.xdata.cxprs_r):
+            raise UF.CHBError(
+                self.__class__.__name__ + ":"
+                + name + " cxpr index out of bounds: " + str(index))
+        cx = self.xdata.cxprs_r[index]
+        if cx is None:
+            raise UF.CHBError(
+                self.__class__.__name__ + ":" + name + " has an error value")
+        return cx
+
+    def has_cxpr(self, index: int) -> bool:
+        return self.xdata.has_cxpr_r(index)
+
+    def is_cxpr_ok(self, index: int) -> bool:
+        return self.xdata.is_cxpr_ok(index)
+
     def add_instruction_condition(self, s: str) -> str:
         if self.xdata.has_unknown_instruction_condition():
             return "if ? then " + s

chb/ast/ASTNode.py

@@ -2772,6 +2772,9 @@ def is_union(self) -> bool:
     def is_compinfo(self) -> bool:
         return True
 
+    def has_fields(self) -> bool:
+        return len(self.fieldinfos) > 0
+
     def has_field_offsets(self) -> bool:
         return all(finfo.has_byteoffset() for finfo in self.fieldinfos)
 

chb/cmdline/commandutil.py

@@ -647,7 +647,7 @@ def results_stats(args: argparse.Namespace) -> NoReturn:
     if sortby == "instrs":
         sortkey = lambda f: f.instruction_count
     elif sortby == "basicblocks":
-        sortkey = lambda f: f.block_count
+        sortkey = lambda f: (f.block_count, f.instruction_count, int(f.faddr, 16))
     elif sortby == "loopdepth":
         sortkey = lambda f: f.loop_depth
     elif sortby == "time":

chb/invariants/XXprUtil.py

@@ -358,6 +358,21 @@ def field_pointer_to_ast_memref_expr(
 
     subfoffset: AST.ASTOffset = nooffset
     compinfo = astree.compinfo(compkey)
+
+    if not compinfo.has_fields():
+        if not anonymous:
+            chklogger.logger.error(
+                "Struct definition is missing for %s at address %s (no fields found)",
+                compinfo.compname, iaddr)
+        return astree.mk_temp_lval_expression()
+
+    if not compinfo.has_field_offsets():
+        if not anonymous:
+            chklogger.logger.error(
+                "Struct definition for %s does not have field offsets at address %s",
+                compinfo.compname, iaddr)
+        return astree.mk_temp_lval_expression()
+
     (field, restoffset) = compinfo.field_at_offset(offset)
     if restoffset > 0:
         if field.fieldtype.is_compound:
@@ -750,11 +765,6 @@ def vinitmemory_value_to_ast_lval_expression(
         return vglobal_variable_value_to_ast_lval_expression(
             avar.offset, xdata, iaddr, astree, size=size, anonymous=anonymous)
 
-    if vconstvar.is_argument_deref_value:
-        avar = vconstvar.variable.denotation
-        return vargument_deref_value_to_ast_lval_expression(
-            avar.basevar, avar.offset, xdata, iaddr, astree, anonymous=anonymous)
-
     if vconstvar.is_function_return_deref_value:
         avar = vconstvar.variable.denotation
         return vreturn_deref_value_to_ast_lval_expression(