minor

Author: fabianbs96

external/json

@@ -10,27 +10,30 @@
 #ifndef PHASAR_PHASARLLVM_POINTER_POINTSTOSETOWNER_H_
 #define PHASAR_PHASARLLVM_POINTER_POINTSTOSETOWNER_H_
 
-#include "llvm/ADT/DenseMap.h"
 #include <memory>
 #include <vector>
 
+#include "llvm/ADT/DenseMap.h"
+
 namespace psr {
 template <typename PointsToSetTy> class PointsToSetOwner {
 public:
-  explicit PointsToSetOwner() = default;
-  explicit PointsToSetOwner(size_t InitialCapacity) {
-    OwnedPTS.reserve(InitialCapacity);
-  }
+  explicit PointsToSetOwner() noexcept = default;
 
   PointsToSetTy *acquire() {
     auto Ptr = std::make_unique<PointsToSetTy>();
     auto Ret = Ptr.get();
     OwnedPTS.try_emplace(Ret, std::move(Ptr));
     return Ret;
   }
-  void release(PointsToSetTy *PTS) { OwnedPTS.erase(PTS); }
+  void release(PointsToSetTy *PTS) noexcept { OwnedPTS.erase(PTS); }
+
+  void reserve(size_t Capacity) { OwnedPTS.reserve(Capacity); }
 
 private:
+  /// Note: Cannot use a set here, because llvm::DenseSet requires the key-type
+  /// to be copy-constructible and the STL containers do not support
+  /// heterogenous lookup as of C++17
   llvm::DenseMap<PointsToSetTy *, std::unique_ptr<PointsToSetTy>> OwnedPTS;
 };
 } // namespace psr

include/phasar/PhasarLLVM/Pointer/PointsToSetOwner.h

@@ -145,6 +145,8 @@ auto OTFResolver::resolveFunctionPointer(const llvm::CallBase *CallSite)
 
       llvm::SmallVector<const llvm::GlobalVariable *, 2> GlobalVariableWL;
       llvm::SmallVector<const llvm::ConstantAggregate *> ConstantAggregateWL;
+      llvm::SmallPtrSet<const llvm::ConstantAggregate *, 4>
+          VisitedConstantAggregates;
 
       for (const auto *P : *PTS) {
         if (!llvm::isa<llvm::Constant>(P)) {
@@ -163,16 +165,15 @@ auto OTFResolver::resolveFunctionPointer(const llvm::CallBase *CallSite)
           }
         }
 
-        if (const auto *CE = llvm::dyn_cast<llvm::ConstantExpr>(P)) {
+        if (const auto *GVP = llvm::dyn_cast<llvm::GlobalVariable>(P)) {
+          GlobalVariableWL.push_back(GVP);
+        } else if (const auto *CE = llvm::dyn_cast<llvm::ConstantExpr>(P)) {
           for (const auto &Op : CE->operands()) {
             if (const auto *GVOp = llvm::dyn_cast<llvm::GlobalVariable>(Op)) {
               GlobalVariableWL.push_back(GVOp);
             }
           }
         }
-        if (const auto *GVP = llvm::dyn_cast<llvm::GlobalVariable>(P)) {
-          GlobalVariableWL.push_back(GVP);
-        }
 
         if (GlobalVariableWL.empty()) {
           continue;
@@ -188,8 +189,8 @@ auto OTFResolver::resolveFunctionPointer(const llvm::CallBase *CallSite)
             ConstantAggregateWL.push_back(InitConstAggregate);
           }
         }
-        llvm::SmallPtrSet<const llvm::ConstantAggregate *, 4>
-            VisitedConstantAggregates;
+
+        VisitedConstantAggregates.clear();
 
         while (!ConstantAggregateWL.empty()) {
           const auto *ConstAggregateItem = ConstantAggregateWL.pop_back_val();
@@ -213,11 +214,9 @@ auto OTFResolver::resolveFunctionPointer(const llvm::CallBase *CallSite)
               if (matchesSignature(F, FTy, false)) {
                 Callees.insert(F);
               }
-            }
-            if (auto *CA = llvm::dyn_cast<llvm::ConstantAggregate>(Op)) {
+            } else if (auto *CA = llvm::dyn_cast<llvm::ConstantAggregate>(Op)) {
               ConstantAggregateWL.push_back(CA);
-            }
-            if (auto *GV = llvm::dyn_cast<llvm::GlobalVariable>(Op)) {
+            } else if (auto *GV = llvm::dyn_cast<llvm::GlobalVariable>(Op)) {
               if (!GV->hasInitializer()) {
                 continue;
               }

lib/PhasarLLVM/ControlFlow/Resolver/OTFResolver.cpp

@@ -45,15 +45,16 @@
 #include "phasar/Utils/Logger.h"
 
 using namespace std;
-using namespace psr;
 
 namespace psr {
 
 LLVMPointsToSet::LLVMPointsToSet(ProjectIRDB &IRDB, bool UseLazyEvaluation,
                                  PointerAnalysisType PATy)
-    : PTA(IRDB, UseLazyEvaluation, PATy), Owner(IRDB.getNumGlobals()) {
+    : PTA(IRDB, UseLazyEvaluation, PATy) {
 
-  PointsToSets.reserve(IRDB.getNumGlobals());
+  auto NumGlobals = IRDB.getNumGlobals();
+  PointsToSets.reserve(NumGlobals);
+  Owner.reserve(NumGlobals);
 
   for (llvm::Module *M : IRDB.getAllModules()) {
     // compute points-to information for all globals