REP: move the computation of the buffer size and spare instruction back to the reportcmds

And pass them in to the to_json_result method. Instead of passing in an
AppAccess object. Per Henny's code review, doing all that work inside of
the LibraryCallSideEffect class creates undesirable dependencies.

Author: waskyo

chb/buffer/LibraryCallCallsites.py

@@ -40,13 +40,10 @@
     from chb.api.CallTarget import StubTarget
     from chb.api.FunctionStub import SOFunction
     from chb.app.Instruction import Instruction
-    from chb.app.AppAccess import AppAccess
-    from chb.app.Function import Function
     from chb.models.BTerm import BTerm, BTermArithmetic
     from chb.models.FunctionSummary import FunctionSummary
     from chb.models.FunctionPrecondition import (
         FunctionPrecondition, PreDerefWrite)
-    from chb.mips.MIPSInstruction import MIPSInstruction
 
 
 class LibraryCallSideeffect:
@@ -236,56 +233,16 @@ def lentype(self) -> str:
             else:
                 return lenterm
 
-    @property
-    def dstoffset(self) -> Optional[int]:
-        """Returns the stack offset for our destination buffer"""
-        if self.dstarg is None:
-            return None
-        return self.dstarg.stack_address_offset()
-
-    def find_spare_instruction(self,
-                               app: 'AppAccess',
-                               fn: 'Function',
-                              ) -> Optional[str]:
-        if app.is_mips:
-            block = fn.block(self.baddr)
-            found = None
-            for (addr, instr) in block.instructions.items():
-                instr = cast("MIPSInstruction", instr)
-                if instr.iaddr > self.instr.iaddr:
-                    break
-                if instr.is_load_instruction:
-                    if str(instr.operands[0]) == "t9":
-                        found = instr.iaddr
-            return found
-        return None
-
-    def to_json_result(self, app: 'AppAccess') -> JSONResult:
+    def to_json_result(self,
+                       dstoffset: int,
+                       buffersize: int,
+                       spare: Optional[str],
+                      ) -> JSONResult:
         if self.dstarg is None:
             chklogger.logger.warning(
                 "No expression found for destination argument: %s", self)
             return JSONResult("librarycallsideeffect", {}, "fail",
                               "No expression found for destination argument")
-        dstoffset = self.dstoffset
-        if dstoffset is None:
-            chklogger.logger.warning(
-                "No value found for destination stack offset : %s", self)
-            return JSONResult("librarycallsideeffect", {}, "fail",
-                              "No value found for destination stack offset")
-
-        fn = app.function(self.faddr)
-        stackframe = fn.stackframe
-        stackbuffer = stackframe.get_stack_buffer(dstoffset)
-        if stackbuffer is None:
-            chklogger.logger.warning(
-                "No stackbuffer found for %s at offset %s", self.instr, dstoffset)
-            return JSONResult("librarycallsideeffect", {}, "fail",
-                              "No stackbuffer found for %s at offset %s" %
-                              (self.instr, dstoffset))
-
-        buffersize = stackbuffer.size
-        spare = self.find_spare_instruction(app, fn)
-
         content: Dict[str, Any] = {}
         content["annotation"] = self.instr.annotation
         content["faddr"] = self.faddr

chb/cmdline/reportcmds.py

@@ -1065,7 +1065,7 @@ def report_buffer_bounds(args: argparse.Namespace) -> NoReturn:
         if libcallsresult.is_ok:
             content["bounds"] = libcallsresult.content
         else:
-            write_json_result(xoutput, libcallsresult,"bufferboundsassessment" )
+            write_json_result(xoutput, libcallsresult, "bufferboundsassessment" )
 
         write_json_result(xoutput, JSONResult(
             "libcboundsanalysis", content, "ok"), "bufferboundsassessment")
@@ -1156,6 +1156,20 @@ def report_patch_candidates(args: argparse.Namespace) -> NoReturn:
     xinfo = XI.XInfo()
     xinfo.load(path, xfile)
 
+    def find_spare_instruction(
+            block: "BasicBlock", iaddr: str) -> Optional[str]:
+        if xinfo.is_mips:
+            found = None
+            for (addr, instr) in block.instructions.items():
+                instr = cast("MIPSInstruction", instr)
+                if instr.iaddr > iaddr:
+                    break
+                if instr.is_load_instruction:
+                    if str(instr.operands[0]) == "t9":
+                        found = instr.iaddr
+            return found
+        return None
+
     app = UC.get_app(path, xfile, xinfo)
 
     n_calls: int = 0
@@ -1191,7 +1205,27 @@ def include_target(target: 'CallTarget') -> bool:
     patch_records = []
 
     for pc in sorted(patchcallsites, key=lambda pc:pc.faddr):
-        jresult = pc.to_json_result(app)
+        instr = pc.instr
+        dstarg = pc.dstarg
+        if dstarg is None:
+            chklogger.logger.warning(
+                "No expression found for destination argument: %s",
+                str(instr))
+            continue
+        dstoffset = dstarg.stack_address_offset()
+        fn = app.function(pc.faddr)
+        stackframe = fn.stackframe
+        stackbuffer = stackframe.get_stack_buffer(dstoffset)
+        if stackbuffer is None:
+            chklogger.logger.warning(
+                "No stackbuffer found for %s at offset %s",
+                str(instr), str(dstoffset))
+            continue
+        buffersize = stackbuffer.size
+        basicblock = fn.block(pc.baddr)
+        spare = find_spare_instruction(basicblock, instr.iaddr)
+
+        jresult = pc.to_json_result(dstoffset, buffersize, spare)
         if not jresult.is_ok:
             chklogger.logger.warning("Couldn't process patch callsite %s", pc)
             continue