ARM: update instruction liftings

Author: sipma

chb/arm/opcodes/ARMArithmeticShiftRight.py

@@ -4,7 +4,7 @@
 # ------------------------------------------------------------------------------
 # The MIT License (MIT)
 #
-# Copyright (c) 2021-2023  Aarno Labs LLC
+# Copyright (c) 2021-2024  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
@@ -123,6 +123,22 @@ def ast_prov(
 
         annotations: List[str] = [iaddr, "ASR"]
 
+        # low-level assignment
+
+        (ll_lhs, _, _) = self.opargs[0].ast_lvalue(astree)
+        (ll_rhs1, _, _) = self.opargs[1].ast_rvalue(astree)
+        (ll_rhs2, _, _) = self.opargs[2].ast_rvalue(astree)
+        ll_asr = astree.mk_binary_op("asr", ll_rhs1, ll_rhs2)
+
+        ll_assign = astree.mk_assign(
+            ll_lhs,
+            ll_asr,
+            iaddr=iaddr,
+            bytestring=bytestring,
+            annotations=annotations)
+
+        # high-level assignment
+
         lhs = xdata.vars[0]
         rhs1 = xdata.xprs[0]
         rhs2 = xdata.xprs[1]
@@ -131,43 +147,25 @@ def ast_prov(
         defuses = xdata.defuses
         defuseshigh = xdata.defuseshigh
 
-        (ll_lhs, _, _) = self.opargs[0].ast_lvalue(astree)
-        (ll_rhs1, _, _) = self.opargs[1].ast_rvalue(astree)
-        (ll_rhs2, _, _) = self.opargs[2].ast_rvalue(astree)
-        ll_asr_expr = astree.mk_binary_op("asr", ll_rhs1, ll_rhs2)
+        hl_lhs = XU.xvariable_to_ast_lval(lhs, xdata, iaddr, astree)
+        hl_rhs = XU.xxpr_to_ast_def_expr(rhs3, xdata, iaddr, astree)
 
-        ll_assign = astree.mk_assign(
-            ll_lhs,
-            ll_asr_expr,
+        hl_assign = astree.mk_assign(
+            hl_lhs,
+            hl_rhs,
             iaddr=iaddr,
             bytestring=bytestring,
             annotations=annotations)
 
-        hl_lhss = XU.xvariable_to_ast_lvals(lhs, xdata, astree)
-        hl_rhss = XU.xxpr_to_ast_exprs(rhs3, xdata, iaddr, astree)
-        if len(hl_lhss) == 1 and len(hl_rhss) == 1:
-            hl_lhs = hl_lhss[0]
-            hl_rhs = hl_rhss[0]
-            hl_assign = astree.mk_assign(
-                hl_lhs,
-                hl_rhs,
-                iaddr=iaddr,
-                bytestring=bytestring,
-                annotations=annotations)
-
-            astree.add_instr_mapping(hl_assign, ll_assign)
-            astree.add_instr_address(hl_assign, [iaddr])
-            astree.add_expr_mapping(hl_rhs, ll_asr_expr)
-            astree.add_lval_mapping(hl_lhs, ll_lhs)
-            astree.add_expr_reachingdefs(ll_asr_expr, [rdefs[0], rdefs[1]])
-            astree.add_expr_reachingdefs(ll_rhs1, [rdefs[0]])
-            astree.add_expr_reachingdefs(ll_rhs2, [rdefs[1]])
-            astree.add_expr_reachingdefs(hl_rhs, rdefs[2:])
-            astree.add_lval_defuses(hl_lhs, defuses[0])
-            astree.add_lval_defuses_high(hl_lhs, defuseshigh[0])
-
-            return ([hl_assign], [ll_assign])
-
-        else:
-            raise UF.CHBError(
-                "ARMArithmeticShiftRight: multiple lval/expressions in ast")
+        astree.add_instr_mapping(hl_assign, ll_assign)
+        astree.add_instr_address(hl_assign, [iaddr])
+        astree.add_expr_mapping(hl_rhs, ll_asr)
+        astree.add_lval_mapping(hl_lhs, ll_lhs)
+        astree.add_expr_reachingdefs(ll_asr, [rdefs[0], rdefs[1]])
+        astree.add_expr_reachingdefs(ll_rhs1, [rdefs[0]])
+        astree.add_expr_reachingdefs(ll_rhs2, [rdefs[1]])
+        astree.add_expr_reachingdefs(hl_rhs, rdefs[2:])
+        astree.add_lval_defuses(hl_lhs, defuses[0])
+        astree.add_lval_defuses_high(hl_lhs, defuseshigh[0])
+
+        return ([hl_assign], [ll_assign])

chb/arm/opcodes/ARMBitFieldInsert.py

@@ -4,7 +4,7 @@
 # ------------------------------------------------------------------------------
 # The MIT License (MIT)
 #
-# Copyright (c) 2021-2023  Aarno Labs LLC
+# Copyright (c) 2021-2024  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
@@ -133,6 +133,16 @@ def ast_prov(
 
         annotations: List[str] = [iaddr, "BFI"]
 
+        if self.width == 0:
+            nopinstr = astree.mk_nop_instruction(
+                "BFI (width = 0)",
+                iaddr=iaddr,
+                bytestring=bytestring,
+                annotations=annotations)
+            astree.add_instr_address(nopinstr, [iaddr])
+
+            return ([], [nopinstr])
+
         lhs = xdata.vars[0]
         rhs1 = xdata.xprs[0]
         rhs2 = xdata.xprs[1]
@@ -143,6 +153,7 @@ def ast_prov(
         (ll_lhs, _, _) = self.operands[0].ast_lvalue(astree)
         (ll_op1, _, _) = self.operands[0].ast_rvalue(astree)
         (ll_op2, _, _) = self.operands[0].ast_rvalue(astree)
+
         mask1 = int("1" * self.width, 2)
         mask1const = astree.mk_integer_constant(mask1)
         ll_rhs2 = astree.mk_binary_op("band", ll_op2, mask1const)

chb/arm/opcodes/ARMBitwiseBitClear.py

@@ -4,7 +4,7 @@
 # ------------------------------------------------------------------------------
 # The MIT License (MIT)
 #
-# Copyright (c) 2021-2022 Aarno Labs LLC
+# Copyright (c) 2021-2024 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
@@ -112,11 +112,7 @@ def ast_prov(
 
         annotations: List[str] = [iaddr, "BIC"]
 
-        lhs = xdata.vars[0]
-        rhs = xdata.xprs[3]
-        rdefs = xdata.reachingdefs
-        defuses = xdata.defuses
-        defuseshigh = xdata.defuseshigh
+        # low-level assignment
 
         (ll_lhs, _, _) = self.operands[0].ast_lvalue(astree)
         (ll_op1, _, _) = self.operands[0].ast_rvalue(astree)
@@ -131,27 +127,20 @@ def ast_prov(
             bytestring=bytestring,
             annotations=annotations)
 
-        lhsasts = XU.xvariable_to_ast_lvals(lhs, xdata, astree)
-        if len(lhsasts) == 0:
-            raise UF.CHBError("BitFieldInsert (BFI): no lval found")
-
-        if len(lhsasts) > 1:
-            raise UF.CHBError(
-                "BitFieldInsert (BFI): multiple lvals found: "
-                + ", ".join(str(v) for v in lhsasts))
+        rdefs = xdata.reachingdefs
 
-        hl_lhs = lhsasts[0]
+        astree.add_expr_reachingdefs(ll_op1, [rdefs[0]])
+        astree.add_expr_reachingdefs(ll_op2, [rdefs[1]])
 
-        rhsasts = XU.xxpr_to_ast_def_exprs(rhs, xdata, iaddr, astree)
-        if len(rhsasts) == 0:
-            raise UF.CHBError("BitwiseBitClear (BIC): no lval found")
+        # high-level assignment
 
-        if len(rhsasts) > 1:
-            raise UF.CHBError(
-                "BitwiseBitClear (BIC): multiple rhs values found: "
-                + ", ".join(str(v) for v in rhsasts))
+        lhs = xdata.vars[0]
+        rhs = xdata.xprs[3]
+        defuses = xdata.defuses
+        defuseshigh = xdata.defuseshigh
 
-        hl_rhs = rhsasts[0]
+        hl_lhs = XU.xvariable_to_ast_lval(lhs, xdata, iaddr, astree)
+        hl_rhs = XU.xxpr_to_ast_def_expr(rhs, xdata, iaddr, astree)
 
         hl_assign = astree.mk_assign(
             hl_lhs,
@@ -165,8 +154,6 @@ def ast_prov(
         astree.add_instr_address(hl_assign, [iaddr])
         astree.add_expr_mapping(hl_rhs, ll_rhs)
         astree.add_lval_mapping(hl_lhs, ll_lhs)
-        astree.add_expr_reachingdefs(ll_op1, [rdefs[0]])
-        astree.add_expr_reachingdefs(ll_op2, [rdefs[1]])
         astree.add_lval_defuses(hl_lhs, defuses[0])
         astree.add_lval_defuses_high(hl_lhs, defuseshigh[0])
 

chb/arm/opcodes/ARMBitwiseOr.py

@@ -4,7 +4,7 @@
 # ------------------------------------------------------------------------------
 # The MIT License (MIT)
 #
-# Copyright (c) 2021-2023  Aarno Labs LLC
+# Copyright (c) 2021-2024  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
@@ -123,50 +123,47 @@ def ast_prov(
 
         annotations: List[str] = [iaddr, "ORR"]
 
-        lhs = xdata.vars[0]
-        rhs1 = xdata.xprs[0]
-        rhs2 = xdata.xprs[1]
-        rhs3 = xdata.xprs[3]
-        rdefs = xdata.reachingdefs
-        defuses = xdata.defuses
-        defuseshigh = xdata.defuseshigh
+        # low-level assignment
 
         (ll_lhs, _, _) = self.opargs[0].ast_lvalue(astree)
         (ll_op1, _, _) = self.opargs[1].ast_rvalue(astree)
         (ll_op2, _, _) = self.opargs[2].ast_rvalue(astree)
         ll_rhs = astree.mk_binary_op("bor", ll_op1, ll_op2)
 
-        astree.add_expr_reachingdefs(ll_op1, [rdefs[0]])
-        astree.add_expr_reachingdefs(ll_op2, [rdefs[1]])
-
         ll_assign = astree.mk_assign(
             ll_lhs,
             ll_rhs,
             iaddr=iaddr,
             bytestring=bytestring,
             annotations=annotations)
 
-        lhsasts = XU.xvariable_to_ast_lvals(lhs, xdata, astree)
-        if len(lhsasts) == 0:
-            raise UF.CHBError("BitwiseOr (ORR): no lval found")
+        rdefs = xdata.reachingdefs
 
-        if len(lhsasts) > 1:
-            raise UF.CHBError(
-                "BitwiseOr (ORR): multiple lvals found: "
-                + ", ".join(str(v) for v in lhsasts))
+        astree.add_expr_reachingdefs(ll_op1, [rdefs[0]])
+        astree.add_expr_reachingdefs(ll_op2, [rdefs[1]])
 
-        hl_lhs = lhsasts[0]
+        # high-level assignment
 
-        rhsasts = XU.xxpr_to_ast_def_exprs(rhs3, xdata, iaddr, astree)
-        if len(rhsasts) == 0:
-            raise UF.CHBError("BitwiseOr (ORR): no lval found")
+        lhs = xdata.vars[0]
+        rhs1 = xdata.xprs[0]
+        rhs2 = xdata.xprs[1]
+        rhs3 = xdata.xprs[3]
 
-        if len(rhsasts) > 1:
-            raise UF.CHBError(
-                "BitwiseOr (ORR): multiple rhs values found: "
-                + ", ".join(str(v) for v in rhsasts))
+        defuses = xdata.defuses
+        defuseshigh = xdata.defuseshigh
 
-        hl_rhs = rhsasts[0]
+        astree.add_expr_reachingdefs(ll_op1, [rdefs[0]])
+        astree.add_expr_reachingdefs(ll_op2, [rdefs[1]])
+
+        ll_assign = astree.mk_assign(
+            ll_lhs,
+            ll_rhs,
+            iaddr=iaddr,
+            bytestring=bytestring,
+            annotations=annotations)
+
+        hl_lhs = XU.xvariable_to_ast_lval(lhs, xdata, iaddr, astree)
+        hl_rhs = XU.xxpr_to_ast_def_expr(rhs3, xdata, iaddr, astree)
 
         hl_assign = astree.mk_assign(
             hl_lhs,
@@ -175,14 +172,11 @@ def ast_prov(
             bytestring=bytestring,
             annotations=annotations)
 
-        astree.add_reg_definition(iaddr, hl_lhs, hl_rhs)
         astree.add_instr_mapping(hl_assign, ll_assign)
         astree.add_instr_address(hl_assign, [iaddr])
         astree.add_expr_mapping(hl_rhs, ll_rhs)
         astree.add_lval_mapping(hl_lhs, ll_lhs)
-        astree.add_expr_reachingdefs(ll_rhs, [rdefs[0], rdefs[1]])
-        astree.add_expr_reachingdefs(ll_op1, [rdefs[0]])
-        astree.add_expr_reachingdefs(ll_op2, [rdefs[1]])
+        astree.add_expr_reachingdefs(ll_rhs, rdefs[:2])
         astree.add_expr_reachingdefs(hl_rhs, rdefs[2:])
         astree.add_lval_defuses(hl_lhs, defuses[0])
         astree.add_lval_defuses_high(hl_lhs, defuseshigh[0])

chb/arm/opcodes/ARMBranchExchange.py

@@ -4,7 +4,7 @@
 # ------------------------------------------------------------------------------
 # The MIT License (MIT)
 #
-# Copyright (c) 2021-2023 Aarno Labs LLC
+# Copyright (c) 2021-2024 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
@@ -29,6 +29,7 @@
 
 from chb.app.InstrXData import InstrXData
 
+from chb.arm.ARMCallOpcode import ARMCallOpcode
 from chb.arm.ARMDictionaryRecord import armregistry
 from chb.arm.ARMOpcode import ARMOpcode, simplify_result
 from chb.arm.ARMOperand import ARMOperand
@@ -43,11 +44,12 @@
 from chb.util.IndexedTable import IndexedTableValue
 
 if TYPE_CHECKING:
+    from chb.api.CallTarget import CallTarget, AppTarget, StaticStubTarget
     import chb.arm.ARMDictionary
 
 
 @armregistry.register_tag("BX", ARMOpcode)
-class ARMBranchExchange(ARMOpcode):
+class ARMBranchExchange(ARMCallOpcode):
     """Branch to an address and instruction set specified by a register.
 
     tags[1]: <c>
@@ -84,17 +86,36 @@ def return_value(self, xdata: InstrXData) -> Optional[XXpr]:
         else:
             return None
 
+    def is_call(self, xdata: InstrXData) -> bool:
+        return len(xdata.tags) >= 2 and xdata.tags[1] == "call"
+
+    def is_call_instruction(self, xdata: InstrXData) -> bool:
+        return xdata.has_call_target()
+
+    def call_target(self, xdata: InstrXData) -> "CallTarget":
+        if self.is_call_instruction(xdata):
+            return xdata.call_target(self.ixd)
+        else:
+            raise UF.CHBError("Instruction is not a call: " + str(self))
+
+    def arguments(self, xdata: InstrXData) -> Sequence[XXpr]:
+        return xdata.xprs
+
     def annotation(self, xdata: InstrXData) -> str:
         """xdata format: a:x .
 
         xprs[0]: target operand
         """
+        if self.is_call_instruction(xdata):
+            tgt = xdata.call_target(self.ixd)
+            args = ", ".join(str(x) for x in self.arguments(xdata))
+            return "call " + str(tgt) + "(" + args + ")"
 
-        tgt = str(xdata.xprs[0])
-        if tgt == "LR":
+        tgtop = str(xdata.xprs[0])
+        if tgtop == "LR":
             return "return"
         else:
-            return "goto " + tgt
+            return "goto " + tgtop
 
     def assembly_ast(
             self,
@@ -115,8 +136,24 @@ def ast_prov(
 
         annotations: List[str] = [iaddr, "BX"]
 
-        nopinstr = astree.mk_nop_instruction(
-            "BX", iaddr=iaddr, bytestring=bytestring, annotations=annotations)
-        astree.add_instr_address(nopinstr, [iaddr])
+        if self.is_call_instruction(xdata) and xdata.has_call_target():
+            return self.ast_call_prov(
+                astree, iaddr, bytestring, "BranchExchange", xdata)
+        else:
+            nopinstr = astree.mk_nop_instruction(
+                "BX", iaddr=iaddr, bytestring=bytestring, annotations=annotations)
+            astree.add_instr_address(nopinstr, [iaddr])
+
+            return ([], [nopinstr])
+
+    def ast_call_prov(
+            self,
+            astree: ASTInterface,
+            iaddr: str,
+            bytestring: str,
+            name: str,
+            xdata: InstrXData) -> Tuple[
+                List[AST.ASTInstruction], List[AST.ASTInstruction]]:
 
-        return ([], [nopinstr])
+        return ARMCallOpcode.ast_call_prov(
+            self, astree, iaddr, bytestring, "BranchExchange (BX)", xdata)