XPR: remove MemoryAddress

Author: sipma

chb/arm/opcodes/ARMTest.py

@@ -87,6 +87,10 @@ def __init__(self, d: "ARMDictionary", ixval: IndexedTableValue) -> None:
         ARMOpcode.__init__(self, d, ixval)
         self.check_key(2, 3, "Test")
 
+    @property
+    def opargs(self) -> List[ARMOperand]:
+        return [self.armd.arm_operand(self.args[i]) for i in [0, 1]]
+
     @property
     def operands(self) -> List[ARMOperand]:
         return [self.armd.arm_operand(self.args[i]) for i in [0, 1]]

chb/invariants/VConstantValueVariable.py

@@ -61,8 +61,6 @@
       ctxt_iaddress_t
       * string
       * bool
-  | MemoryAddress of
-        int * memory_offset_t * string option      "ma"       1      2
   | BridgeVariable of ctxt_iaddress_t * int        "bv"       2      1
   | FieldValue of string * int * string            "fv"       1      3
   | SymbolicValue of xpr_t                         "sv"       1      1
@@ -124,10 +122,6 @@ def is_frozen_test_value(self) -> bool:
     def is_bridge_variable(self) -> bool:
         return False
 
-    @property
-    def is_memory_address(self) -> bool:
-        return False
-
     @property
     def is_global_value(self) -> bool:
         return False
@@ -739,58 +733,6 @@ def __str__(self) -> str:
         return self.name
 
 
-@varregistry.register_tag("ma", VConstantValueVariable)
-class MemoryAddress(VConstantValueVariable):
-    """Address of memory variable.
-
-    args[0]: index of memory base in vardictionary
-    args[1]: index of memory offset in vardictionary
-    args[2]: index of optional name or -1
-    """
-
-    def __init__(
-            self,
-            vd: "FnVarDictionary",
-            ixval: IndexedTableValue) -> None:
-        VConstantValueVariable.__init__(self, vd, ixval)
-
-    @property
-    def is_memory_address(self) -> bool:
-        return True
-
-    @property
-    def base(self) -> VMemoryBase:
-        return self.vd.memory_base(self.args[0])
-
-    @property
-    def offset(self) -> VMemoryOffset:
-        return self.vd.memory_offset(self.args[1])
-
-    @property
-    def name(self) -> Optional[str]:
-        if self.args[2] == -1:
-            return None
-        else:
-            return self.bd.string(self.args[2])
-
-    def to_json_result(self) -> JSONResult:
-        jbase = self.base.to_json_result()
-        if not jbase.is_ok:
-            return JSONResult("auxvariable", {}, "fail", jbase.reason)
-        joffset = self.offset.to_json_result()
-        if not joffset.is_ok:
-            return JSONResult("auxvariable", {}, "fail", joffset.reason)
-        content: Dict[str, Any] = {}
-        content["kind"] = "ma"
-        content["base"] = jbase.content
-        content["offset"] = joffset.content
-        content["txtrep"] = str(self)
-        return JSONResult("auxvariable", content, "ok")
-
-    def __str__(self) -> str:
-        return str(self.base) + " + " + str(self.offset)
-
-
 @varregistry.register_tag("fv", VConstantValueVariable)
 class FieldValue(VConstantValueVariable):
     """Symbolic representation of a field in a struct.

chb/invariants/XVariable.py

@@ -123,13 +123,6 @@ def is_typecast_value(self) -> bool:
             and self.denotation.is_auxiliary_variable
             and self.denotation.auxvar.is_typecast_value)
 
-    @property
-    def is_memory_address_value(self) -> bool:
-        return (
-            self.has_denotation()
-            and self.denotation.is_auxiliary_variable
-            and self.denotation.auxvar.is_memory_address)
-
     @property
     def is_symbolic_expr_value(self) -> bool:
         return (

chb/invariants/XXpr.py

@@ -164,10 +164,6 @@ def is_attr(self) -> bool:
     def is_four_multiple(self) -> bool:
         return False
 
-    @property
-    def is_memory_address_value(self) -> bool:
-        return False
-
     @property
     def is_stack_base_address(self) -> bool:
         return False
@@ -370,10 +366,6 @@ def is_initial_register_value(self) -> bool:
     def is_var(self) -> bool:
         return True
 
-    @property
-    def is_memory_address_value(self) -> bool:
-        return self.variable.is_memory_address_value
-
     @property
     def is_tmp_variable(self) -> bool:
         return self.variable.is_tmp

chb/invariants/XXprUtil.py

@@ -28,7 +28,9 @@
 
 Note: the boolean argument 'anonymous' is used for lvals: when true no new
   lvalid is generated for that lval. The argument is primarily used in the
-  conversion of invariants to available expressions.
+  conversion of invariants to available expressions. Also, errors are not
+  generated if anonymous is true.
+
 """
 
 from codecs import decode
@@ -55,7 +57,7 @@
         VMemoryVariable, VAuxiliaryVariable, VRegisterVariable)
     from chb.invariants.VConstantValueVariable import (
         VInitialRegisterValue, VInitialMemoryValue, VFunctionReturnValue,
-        VTypeCastValue, SymbolicValue, MemoryAddress)
+        VTypeCastValue, SymbolicValue)
     from chb.invariants.VMemoryBase import (
         VMemoryBase,
         VMemoryBaseBaseVar,
@@ -181,44 +183,6 @@ def xxpr_to_ast_expr(
         return astree.mk_temp_lval_expression()
 
 
-def xxpr_memory_address_value_to_ast_expr(
-        xpr: X.XXpr,
-        xdata: "InstrXData",
-        iaddr: str,
-        astree: ASTInterface,
-        anonymous: bool = False) -> AST.ASTExpr:
-
-    if not xpr.is_memory_address_value:
-        chklogger.logger.error(
-            "Encountered expression that is not a memory address value: %s "
-            + "at address %s",
-            str(xpr), iaddr)
-
-    xvar = cast(X.XprVariable, xpr).variable
-    addr = cast("MemoryAddress", xvar.denotation.auxvar)
-    name = addr.name
-    if name is None:
-        chklogger.logger.error(
-            "AST conversion of unnamed memory address value %s not yet "
-            + "supported at address %s",
-            str(xvar), iaddr)
-        return astree.mk_temp_lval_expression()
-
-    if not astree.globalsymboltable.has_symbol(name):
-        chklogger.logger.error(
-            "AST conversion of memory address value %s not in global symbol "
-            + "table not yet supported at address %s",
-            str(xvar), iaddr)
-        return astree.mk_temp_lval_expression()
-
-    vinfo = astree.globalsymboltable.get_symbol(name)
-    lval = astree.mk_vinfo_lval(vinfo)
-    if vinfo.vtype is not None and vinfo.vtype.is_array:
-        return astree.mk_start_of(lval)
-    else:
-        return astree.mk_address_of(lval)
-
-
 def vinitregister_value_to_ast_lval_expression(
         vconstvar: "VInitialRegisterValue",
         xdata: "InstrXData",
@@ -849,25 +813,6 @@ def xvariable_to_ast_def_lval_expression(
         return memory_variable_to_lval_expression(
             memvar.base, memvar.offset, xdata, iaddr, astree, anonymous=anonymous)
 
-    if xvar.is_memory_address_value:
-        addr = cast("MemoryAddress", xvar.denotation.auxvar)
-        name = addr.name
-        if name is None:
-            chklogger.logger.error(
-                "AST def conversion of unnamed memory address variable %s to "
-                + "lval at address %s not yet supported",
-                str(xvar), iaddr)
-            return astree.mk_temp_lval_expression()
-
-        if not astree.globalsymboltable.has_symbol(name):
-            chklogger.logger.error(
-                "AST def conversion of memory address % to lval at address %s "
-                + "not yet supported",
-                name, iaddr)
-
-        vinfo = astree.globalsymboltable.get_symbol(name)
-        return astree.mk_vinfo_lval_expression(vinfo, anonymous=anonymous)
-
     if xvar.is_typecast_value:
         tcvar = cast("VTypeCastValue", xvar.denotation.auxvar)
         variaddr = tcvar.iaddr
@@ -1326,10 +1271,6 @@ def xxpr_to_ast_def_expr(
     if xpr.is_constant:
         return xxpr_to_ast_expr(xpr, xdata, iaddr, astree, anonymous=anonymous)
 
-    if xpr.is_memory_address_value:
-        return xxpr_memory_address_value_to_ast_expr(
-            xpr, xdata, iaddr, astree, anonymous=anonymous)
-
     if xpr.is_stack_address:
         return stack_address_to_ast_expr(
             xpr, xdata, iaddr, astree, anonymous=anonymous)
@@ -1453,95 +1394,6 @@ def field_offset_to_ast_offset(
         offset.fieldname, offset.ckey, offset=suboffset)
 
 
-def array_variable_to_ast_lval(
-        base: "MemoryAddress",
-        elementtyp: AST.ASTTyp,
-        offset: "VMemoryOffset",
-        xdata: "InstrXData",
-        iaddr: str,
-        astree: ASTInterface,
-        anonymous: bool = False) -> AST.ASTLval:
-
-    name = base.name
-    if name is None:
-        chklogger.logger.error(
-            "AST conversion of array variable at %s encountered nameless "
-            + "base %s",
-            str(iaddr), str(base))
-        return astree.mk_temp_lval()
-
-    if not astree.globalsymboltable.has_symbol(name):
-        chklogger.logger.error(
-            "AST conversion of memory address value %s not in global symbol "
-            + " table not yet supported at address %s",
-            str(name), iaddr)
-        return astree.mk_temp_lval()
-
-    vinfo = astree.globalsymboltable.get_symbol(name)
-    if not offset.is_array_index_offset:
-        chklogger.logger.error(
-            "AST conversion of array variable expected to find array index "
-            + "offset, but found %s at address %s",
-            str(offset), iaddr)
-        return astree.mk_temp_lval()
-
-    astoffset = array_offset_to_ast_offset(
-        cast("VMemoryOffsetArrayIndexOffset", offset),
-        xdata,
-        iaddr,
-        astree,
-        anonymous=anonymous)
-
-    return astree.mk_vinfo_lval(vinfo, offset=astoffset, anonymous=anonymous)
-
-    chklogger.logger.error(
-        "Array variable to astlval still in progress at %s for %s with offset %s",
-        iaddr, str(base), str(offset))
-    return astree.mk_temp_lval()
-
-
-def struct_variable_to_ast_lval(
-        base: "MemoryAddress",
-        structtyp: AST.ASTTypComp,
-        offset: "VMemoryOffset",
-        xdata: "InstrXData",
-        iaddr: str,
-        astree: ASTInterface,
-        anonymous: bool = False) -> AST.ASTLval:
-
-    name = base.name
-    if name is None:
-        chklogger.logger.error(
-            "AST conversion of struct variable at %s encountered nameless "
-            + "base %s",
-            str(iaddr), str(base))
-        return astree.mk_temp_lval()
-
-    if not astree.globalsymboltable.has_symbol(name):
-        chklogger.logger.error(
-            "AST conversion of memory address value %s not in global symbol "
-            + " table not yet supported at address %s",
-            str(name), iaddr)
-        return astree.mk_temp_lval()
-
-    vinfo = astree.globalsymboltable.get_symbol(name)
-    if not offset.is_field_offset:
-        chklogger.logger.error(
-            "AST conversion of struct variable expected to find field offset "
-            + "but found %s at address %s",
-            str(offset), iaddr)
-        return astree.mk_temp_lval()
-
-    astoffset = field_offset_to_ast_offset(
-        cast("VMemoryOffsetFieldOffset", offset),
-        xdata,
-        iaddr,
-        astree,
-        anonymous=anonymous)
-
-    return astree.mk_vinfo_lval(vinfo, offset=astoffset, anonymous=anonymous)
-
-
 def global_variable_to_ast_lval(
         offset: "VMemoryOffset",
         xdata: "InstrXData",
@@ -1700,54 +1552,6 @@ def xvariable_to_ast_lval(
             memaddr=memaddr,
             anonymous=anonymous)
 
-    elif (
-            xv.is_memory_variable
-            and cast("VMemoryVariable",
-                     xv.denotation).base.is_basearray):
-        xvmem = cast("VMemoryVariable", xv.denotation)
-        base = cast("VMemoryBaseBaseArray", xvmem.base).basearray
-        if not base.is_memory_address_value:
-            chklogger.logger.error(
-                "AST conversion of lval %s encountered invalid BaseArray at %s",
-                str(xv), iaddr)
-            return astree.mk_temp_lval()
-        basevar = cast("MemoryAddress", base.denotation.auxvar)
-        basetyp = cast(
-            "VMemoryBaseBaseArray",
-            xvmem.base).basetyp.convert(astree.typconverter)
-        return array_variable_to_ast_lval(
-            basevar,
-            cast(AST.ASTTypArray, basetyp).tgttyp,
-            xvmem.offset,
-            xdata,
-            iaddr,
-            astree,
-            anonymous=anonymous)
-
-    elif (
-            xv.is_memory_variable
-            and cast("VMemoryVariable",
-                     xv.denotation).base.is_basestruct):
-        xvmem = cast("VMemoryVariable", xv.denotation)
-        base = cast("VMemoryBaseBaseStruct", xvmem.base).basestruct
-        if not base.is_memory_address_value:
-            chklogger.logger.error(
-                "AST conversion of lval %s encountered invalie BaseStruct at %s",
-                str(xv), iaddr)
-            return astree.mk_temp_lval()
-        basevar = cast("MemoryAddress", base.denotation.auxvar)
-        basetyp = cast(
-            "VMemoryBaseBaseStruct",
-            xvmem.base).basetyp.convert(astree.typconverter)
-        return struct_variable_to_ast_lval(
-            basevar,
-            cast(AST.ASTTypComp, basetyp),
-            xvmem.offset,
-            xdata,
-            iaddr,
-            astree,
-            anonymous=anonymous)
-
     elif (
             xv.is_memory_variable
             and cast("VMemoryVariable",