AST: add support for BX-call

Author: sipma

chb/app/AppAccess.py

@@ -410,7 +410,8 @@ def callgraph(self) -> Callgraph:
                             cbttgts = cbtable.tagged_fields_at_offset(cbtgt.offset)
                             for (tag, cbfaddr) in cbttgts.items():
                                 if self.has_function_name(cbfaddr):
-                                    cbfname = tag + ":" + self.function_name(cbfaddr)
+                                    cbfname = (
+                                        tag + ":" + self.function_name(cbfaddr))
                                 else:
                                     cbfname = tag + ":" + cbfaddr
                                 apptgtnode = mk_tagged_app_callgraph_node(

chb/app/CallbackTables.py

@@ -78,11 +78,11 @@ def tag_offset(self) -> int:
         return (-1)
 
     @property
-    def tag(self) -> str:
+    def tag(self) -> Optional[str]:
         if self.tag_offset >= 0:
             return self.fields[self.tag_offset][1]
         else:
-            return "?"
+            return None
 
     def value_at_offset(self, offset: int) -> str:
         if offset in self.fields:
@@ -131,8 +131,8 @@ def tagged_fields_at_offset(self, offset: int) -> Dict[str, str]:
         for r in self.records:
             counter += 1
             tag = r.tag
-            if tag == "?":
-                tag = "unknown_" + str(counter)
+            if tag is None:
+                tag = str(counter)
             result[tag] = r.value_at_offset(offset)
         return result
 

chb/app/InstrXData.py

@@ -308,6 +308,10 @@ def has_call_target(self) -> bool:
         else:
             return False
 
+    @property
+    def is_bx_call(self) -> bool:
+        return "bx-call" in self.tags
+
     def call_target_argument_count(self) -> Optional[int]:
         if len(self.tags) >= 3:
             if self.tags[1] == "call":

chb/arm/ARMCallOpcode.py

@@ -195,23 +195,28 @@ def ast_call_prov(
         finfo = xdata.function.finfo
         if finfo.has_call_target_info(iaddr):
             ctinfo = finfo.call_target_info(iaddr)
-            fname = ctinfo.target_interface.name
             ftype = ctinfo.target_interface.bctype
             if ftype is not None:
                 astfntype = ftype.convert(astree.typconverter)
-            if astree.globalsymboltable.has_symbol(fname):
-                tgtvinfo = astree.globalsymboltable.get_symbol(fname)
-                hl_tgt = astree.mk_vinfo_lval_expression(tgtvinfo)
+
+            if xdata.is_bx_call:
+                # indirect call
+                hl_tgt = XU.xxpr_to_ast_def_expr(xprs[-1], xdata, iaddr, astree)
             else:
-                gaddr: int = 0
-                if fname.startswith("sub_"):
-                    gaddr = int("0x" + fname[4:], 16)
+                fname = ctinfo.target_interface.name
+                if astree.globalsymboltable.has_symbol(fname):
+                    tgtvinfo = astree.globalsymboltable.get_symbol(fname)
+                    hl_tgt = astree.mk_vinfo_lval_expression(tgtvinfo)
                 else:
-                    if tgt.is_absolute:
-                        tgtaddr = cast(ARMAbsoluteOp, tgt.opkind)
-                        gaddr = int(tgtaddr.address.get_hex(), 16)
-                hl_tgt = astree.mk_global_variable_expr(
-                    fname, globaladdress=gaddr, vtype=astfntype)
+                    gaddr: int = 0
+                    if fname.startswith("sub_"):
+                        gaddr = int("0x" + fname[4:], 16)
+                    else:
+                        if tgt.is_absolute:
+                            tgtaddr = cast(ARMAbsoluteOp, tgt.opkind)
+                            gaddr = int(tgtaddr.address.get_hex(), 16)
+                    hl_tgt = astree.mk_global_variable_expr(
+                        fname, globaladdress=gaddr, vtype=astfntype)
 
             if ftype is not None and ftype.is_function:
                 ftype = cast("BCTypFun", ftype)

chb/arm/ARMInstruction.py

@@ -236,8 +236,9 @@ def annotation(self) -> str:
             aggaddr = self.xdata.subsumed_by()
             return f"subsumed by {aggaddr}"
         elif self.subsumes:
+            ann = self.opcode.annotation(self.xdata)
             dependents = self.xdata.subsumes()
-            return "subsumes [" + ", ".join(dependents) + "]"
+            return ann + " (subsumes [" + ", ".join(dependents) + "])"
         else:
             return self.opcode.annotation(self.xdata)
 

chb/arm/opcodes/ARMBranchExchange.py

@@ -39,7 +39,9 @@
 
 from chb.invariants.XXpr import XXpr
 
+
 import chb.util.fileutil as UF
+from chb.util.loggingutil import chklogger
 
 from chb.util.IndexedTable import IndexedTableValue
 
@@ -98,8 +100,19 @@ def call_target(self, xdata: InstrXData) -> "CallTarget":
         else:
             raise UF.CHBError("Instruction is not a call: " + str(self))
 
+    def argument_count(self, xdata: InstrXData) -> int:
+        if self.is_call_instruction(xdata):
+            argcount = xdata.call_target_argument_count()
+            if argcount is not None:
+                return argcount
+            chklogger.logger.warning(
+                "Call instruction does not have argument count")
+            return 0
+        else:
+            raise UF.CHBError("Instruction is not a call: " + str(self))
+
     def arguments(self, xdata: InstrXData) -> Sequence[XXpr]:
-        return xdata.xprs
+        return xdata.xprs[:self.argument_count(xdata)]
 
     def annotation(self, xdata: InstrXData) -> str:
         """xdata format: a:x .

chb/graphics/DotCallgraph.py

@@ -103,6 +103,8 @@ def to_dotgraph(self) -> DotGraph:
                             ('[' in name or ']' in name or '?' in name)
                             and not name.startswith('"')):
                         name = '"' + name + '"'
+                    if ":" in name:
+                        continue
                     if len(name) == 0:
                         continue
                     sameranknodes.append(name)