Merge pull request #420 from secure-software-engineering/f-InsertBackwardRets

insert dummy return instructions in each function in the backward ICFG to get consistency w.r.t. forward ICFG

Author: pdschubert

include/phasar/PhasarLLVM/ControlFlow/LLVMBasedBackwardICFG.h

@@ -18,6 +18,8 @@
 #include <unordered_set>
 #include <vector>
 
+#include "llvm/IR/LLVMContext.h"
+
 #include "phasar/PhasarLLVM/ControlFlow/ICFG.h"
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedBackwardCFG.h"
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h"
@@ -42,17 +44,28 @@ class LLVMBasedBackwardsICFG
     : public ICFG<const llvm::Instruction *, const llvm::Function *>,
       public virtual LLVMBasedBackwardCFG {
 private:
-  LLVMBasedICFG ForwardICFG;
+  LLVMBasedICFG &ForwardICFG;
+  static inline const std::unique_ptr<llvm::LLVMContext> LLVMBackwardRetCTX =
+      std::make_unique<llvm::LLVMContext>();
+
+  class LLVMBackwardRet {
+  private:
+    const llvm::ReturnInst *Instance;
+
+  public:
+    LLVMBackwardRet()
+        : Instance(llvm::ReturnInst::Create(*LLVMBackwardRetCTX)){};
+    [[nodiscard]] const llvm::ReturnInst *getInstance() const {
+      return Instance;
+    }
+  };
+  std::unordered_map<const llvm::Function *, LLVMBackwardRet> BackwardRets;
+  llvm::DenseMap<const llvm::Instruction *, const llvm::Function *>
+      BackwardRetToFunction;
 
 public:
   LLVMBasedBackwardsICFG(LLVMBasedICFG &ICFG);
 
-  LLVMBasedBackwardsICFG(ProjectIRDB &IRDB, CallGraphAnalysisType CGType,
-                         const std::set<std::string> &EntryPoints = {},
-                         LLVMTypeHierarchy *TH = nullptr,
-                         LLVMPointsToInfo *PT = nullptr,
-                         Soundness S = Soundness::Soundy);
-
   ~LLVMBasedBackwardsICFG() override = default;
 
   std::set<const llvm::Function *> getAllFunctions() const override;
@@ -77,6 +90,20 @@ class LLVMBasedBackwardsICFG
 
   std::set<const llvm::Instruction *> allNonCallStartNodes() const override;
 
+  [[nodiscard]] const llvm::Function *
+  getFunctionOf(const llvm::Instruction *Stmt) const override;
+
+  [[nodiscard]] std::vector<const llvm::Instruction *>
+  getPredsOf(const llvm::Instruction *Stmt) const override;
+
+  [[nodiscard]] std::vector<const llvm::Instruction *>
+  getSuccsOf(const llvm::Instruction *Stmt) const override;
+
+  [[nodiscard]] std::set<const llvm::Instruction *>
+  getExitPointsOf(const llvm::Function *Fun) const override;
+
+  [[nodiscard]] bool isExitInst(const llvm::Instruction *Stmt) const override;
+
   void mergeWith(const LLVMBasedBackwardsICFG &other);
 
   using LLVMBasedBackwardCFG::print; // tell the compiler we wish to have both
@@ -95,6 +122,9 @@ class LLVMBasedBackwardsICFG
 
   std::vector<const llvm::Function *> getDependencyOrderedFunctions();
 
+private:
+  void createBackwardRets();
+
 protected:
   void collectGlobalCtors() override;
 

lib/PhasarLLVM/ControlFlow/LLVMBasedBackwardICFG.cpp

@@ -38,15 +38,13 @@ LLVMBasedBackwardsICFG::LLVMBasedBackwardsICFG(LLVMBasedICFG &ICFG)
     : ForwardICFG(ICFG) {
   auto CgCopy = ForwardICFG.CallGraph;
   boost::copy_graph(boost::make_reverse_graph(CgCopy), ForwardICFG.CallGraph);
+  createBackwardRets();
 }
 
-LLVMBasedBackwardsICFG::LLVMBasedBackwardsICFG(
-    ProjectIRDB &IRDB, CallGraphAnalysisType CGType,
-    const std::set<std::string> &EntryPoints, LLVMTypeHierarchy *TH,
-    LLVMPointsToInfo *PT, Soundness S)
-    : ForwardICFG(IRDB, CGType, EntryPoints, TH, PT, S) {
-  auto CgCopy = ForwardICFG.CallGraph;
-  boost::copy_graph(boost::make_reverse_graph(CgCopy), ForwardICFG.CallGraph);
+void LLVMBasedBackwardsICFG::createBackwardRets() {
+  for (const auto *Function : getAllFunctions()) {
+    BackwardRetToFunction[BackwardRets[Function].getInstance()] = Function;
+  }
 }
 
 bool LLVMBasedBackwardsICFG::isIndirectFunctionCall(
@@ -88,15 +86,11 @@ std::set<const llvm::Instruction *>
 LLVMBasedBackwardsICFG::getReturnSitesOfCallAt(
     const llvm::Instruction *N) const {
   std::set<const llvm::Instruction *> ReturnSites;
-  if (const auto *Call = llvm::dyn_cast<llvm::CallInst>(N)) {
+  if (const auto *Call = llvm::dyn_cast<llvm::CallBase>(N)) {
     for (const auto *Succ : this->getSuccsOf(Call)) {
       ReturnSites.insert(Succ);
     }
   }
-  if (const auto *Invoke = llvm::dyn_cast<llvm::InvokeInst>(N)) {
-    ReturnSites.insert(&Invoke->getNormalDest()->back());
-    ReturnSites.insert(&Invoke->getUnwindDest()->back());
-  }
   return ReturnSites;
 }
 
@@ -105,6 +99,51 @@ LLVMBasedBackwardsICFG::allNonCallStartNodes() const {
   return ForwardICFG.allNonCallStartNodes();
 }
 
+const llvm::Function *
+LLVMBasedBackwardsICFG::getFunctionOf(const llvm::Instruction *Stmt) const {
+  auto BackwardRetIt = BackwardRetToFunction.find(Stmt);
+  if (BackwardRetIt != BackwardRetToFunction.end()) {
+    return BackwardRetIt->second;
+  }
+  return Stmt->getFunction();
+}
+
+std::vector<const llvm::Instruction *>
+LLVMBasedBackwardsICFG::getPredsOf(const llvm::Instruction *Stmt) const {
+  auto BackwardRetIt = BackwardRetToFunction.find(Stmt);
+  if (BackwardRetIt == BackwardRetToFunction.end()) {
+    return LLVMBasedBackwardCFG::getPredsOf(Stmt);
+  }
+  auto ExitPoints =
+      LLVMBasedBackwardCFG::getExitPointsOf(BackwardRetIt->second);
+  return {ExitPoints.begin(), ExitPoints.end()};
+}
+
+std::vector<const llvm::Instruction *>
+LLVMBasedBackwardsICFG::getSuccsOf(const llvm::Instruction *Stmt) const {
+  if (isExitInst(Stmt)) {
+    return {};
+  }
+  std::vector<const llvm::Instruction *> Succs =
+      LLVMBasedBackwardCFG::getSuccsOf(Stmt);
+  if (Succs.size() == 0) {
+    assert(Stmt->getParent()->getParent() && "Could not find parent of stmt's parent ");
+    Succs.push_back(
+        BackwardRets.at(Stmt->getParent()->getParent()).getInstance());
+  }
+  return Succs;
+}
+
+bool LLVMBasedBackwardsICFG::isExitInst(const llvm::Instruction *Stmt) const {
+  return (Stmt->getParent() == nullptr &&
+          BackwardRetToFunction.count(Stmt) > 0);
+}
+
+std::set<const llvm::Instruction *>
+LLVMBasedBackwardsICFG::getExitPointsOf(const llvm::Function *Fun) const {
+  return {BackwardRets.at(Fun).getInstance()};
+}
+
 void LLVMBasedBackwardsICFG::mergeWith(const LLVMBasedBackwardsICFG &Other) {
   ForwardICFG.mergeWith(Other.ForwardICFG);
 }