various fixes in IDEExtendedTaintAnalysis

Martin Mory · vulder · commit 42f91ce7b068 · 2021-12-24T14:31:12.000+01:00
diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/AbstractMemoryLocation.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/AbstractMemoryLocation.h
@@ -214,13 +214,12 @@ namespace llvm {
 
 template <> struct DenseMapInfo<psr::AbstractMemoryLocation> {
   static inline psr::AbstractMemoryLocation getEmptyKey() {
-    return psr::AbstractMemoryLocation(
-        DenseMapInfo<psr::detail::AbstractMemoryLocationImpl *>::getEmptyKey());
+    return {
+        DenseMapInfo<psr::detail::AbstractMemoryLocationImpl *>::getEmptyKey()};
   }
   static inline psr::AbstractMemoryLocation getTombstoneKey() {
-    return psr::AbstractMemoryLocation(
-        DenseMapInfo<
-            psr::detail::AbstractMemoryLocationImpl *>::getTombstoneKey());
+    return {DenseMapInfo<
+        psr::detail::AbstractMemoryLocationImpl *>::getTombstoneKey()};
   }
   static unsigned getHashValue(psr::AbstractMemoryLocation Val) {
     return hash_value(Val);
diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/AbstractMemoryLocationFactory.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/AbstractMemoryLocationFactory.h
@@ -95,7 +95,7 @@ class AbstractMemoryLocationFactoryBase {
   const detail::AbstractMemoryLocationImpl *
   getOrCreateImpl(const llvm::Value *V, unsigned BOUND);
 
-  const AbstractMemoryLocationImpl *CreateImpl(const llvm::Value *V,
+  const AbstractMemoryLocationImpl *createImpl(const llvm::Value *V,
                                                unsigned BOUND);
   const AbstractMemoryLocationImpl *GetOrCreateZeroImpl() const;
   const AbstractMemoryLocationImpl *
@@ -141,7 +141,7 @@ class AbstractMemoryLocationFactory<AbstractMemoryLocation>
     : public detail::AbstractMemoryLocationFactoryBase {
 
   AbstractMemoryLocation limit(const AbstractMemoryLocation &AML) {
-    return AbstractMemoryLocation(limitImpl(AML.operator->()));
+    return {limitImpl(AML.operator->())};
   }
 
 public:
@@ -156,12 +156,12 @@ class AbstractMemoryLocationFactory<AbstractMemoryLocation>
   AbstractMemoryLocationFactory &
   operator=(const AbstractMemoryLocationFactory &) = delete;
 
-  [[nodiscard]] AbstractMemoryLocation Create(const llvm::Value *V,
+  [[nodiscard]] AbstractMemoryLocation create(const llvm::Value *V,
                                               unsigned BOUND) {
-    return AbstractMemoryLocation(CreateImpl(V, BOUND));
+    return {createImpl(V, BOUND)};
   }
-  [[nodiscard]] AbstractMemoryLocation GetOrCreateZero() const {
-    return AbstractMemoryLocation(GetOrCreateZeroImpl());
+  [[nodiscard]] AbstractMemoryLocation getOrCreateZero() const {
+    return {getOrCreateZeroImpl()};
   }
 
   /// Creates a decendant AbstractMemoryLocation by adding an indirection
@@ -170,19 +170,19 @@ class AbstractMemoryLocationFactory<AbstractMemoryLocation>
   [[nodiscard]] AbstractMemoryLocation
   withIndirectionOf(const AbstractMemoryLocation &AML,
                     llvm::ArrayRef<ptrdiff_t> Ind) {
-    return AbstractMemoryLocation(withIndirectionOfImpl(AML.operator->(), Ind));
+    return {withIndirectionOfImpl(AML.operator->(), Ind)};
   }
 
   [[nodiscard]] AbstractMemoryLocation
   withOffset(const AbstractMemoryLocation &AML,
              const llvm::GetElementPtrInst *Gep) {
-    return AbstractMemoryLocation(withOffsetImpl(AML.operator->(), Gep));
+    return {withOffsetImpl(AML.operator->(), Gep)};
   }
 
   [[nodiscard]] AbstractMemoryLocation
   withOffsets(const AbstractMemoryLocation &AML,
               llvm::ArrayRef<ptrdiff_t> Offs) {
-    return AbstractMemoryLocation(withOffsetsImpl(AML.operator->(), Offs));
+    return {withOffsetsImpl(AML.operator->(), Offs)};
   }
 
   /// Transfers the taint from AML (source at the callsite) seen as From to To
@@ -191,8 +191,7 @@ class AbstractMemoryLocationFactory<AbstractMemoryLocation>
   [[nodiscard]] AbstractMemoryLocation
   withTransferTo(const AbstractMemoryLocation &AML,
                  const AbstractMemoryLocation &From, const llvm::Value *To) {
-    return AbstractMemoryLocation(
-        withTransferToImpl(AML.operator->(), From.operator->(), To));
+    return {withTransferToImpl(AML.operator->(), From.operator->(), To)};
   }
 
   /// Transfers the taint from AML (source at the return-site) to To(at the
@@ -201,8 +200,7 @@ class AbstractMemoryLocationFactory<AbstractMemoryLocation>
   [[nodiscard]] AbstractMemoryLocation
   withTransferFrom(const AbstractMemoryLocation &AML,
                    const AbstractMemoryLocation &To) {
-    return AbstractMemoryLocation(
-        withTransferFromImpl(AML.operator->(), To.operator->()));
+    return {withTransferFromImpl(AML.operator->(), To.operator->())};
   }
 };
 
diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/ComposeEdgeFunction.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/ComposeEdgeFunction.h
@@ -29,7 +29,7 @@ class ComposeEdgeFunction : public EdgeFunctionBase {
   llvm::hash_code getHashCode() const override;
 
   static inline bool classof(const EdgeFunctionBase *EF) {
-    return EF->getKind() == Kind::Compose;
+    return EF->getKind() == EFKind::Compose;
   }
 };
 } // namespace psr::XTaint
diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/GenEdgeFunction.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/GenEdgeFunction.h
@@ -36,7 +36,7 @@ class GenEdgeFunction : public EdgeFunctionBase {
   inline const llvm::Instruction *getSanitizer() const { return Sani; }
 
   static inline bool classof(const EdgeFunctionBase *EF) {
-    return EF->getKind() == Kind::Gen;
+    return EF->getKind() == EFKind::Gen;
   }
 
   llvm::hash_code getHashCode() const override;
diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/Helpers.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/Helpers.h
@@ -54,12 +54,12 @@ EdgeFunction<EdgeDomain>::EdgeFunctionPtrType getAllSanitized();
 /// Have an own function for creating a flow/edge-function instance to allow
 /// fast migration to memory-management schemes other than std::shared_ptr
 template <typename FlowFunctionTy, typename... Args>
-inline std::shared_ptr<FlowFunctionTy> makeFF(Args &&...args) {
-  return std::make_shared<FlowFunctionTy>(std::forward<Args>(args)...);
+inline std::shared_ptr<FlowFunctionTy> makeFF(Args &&...Arguments) {
+  return std::make_shared<FlowFunctionTy>(std::forward<Args>(Arguments)...);
 }
 template <typename EdgeFunctionTy, typename... Args>
-inline std::shared_ptr<EdgeFunctionTy> makeEF(Args &&...args) {
-  return std::make_shared<EdgeFunctionTy>(std::forward<Args>(args)...);
+inline std::shared_ptr<EdgeFunctionTy> makeEF(Args &&...Arguments) {
+  return std::make_shared<EdgeFunctionTy>(std::forward<Args>(Arguments)...);
 }
 
 } // namespace psr::XTaint
diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/JoinConstEdgeFunction.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/JoinConstEdgeFunction.h
@@ -36,7 +36,7 @@ class JoinConstEdgeFunction : public EdgeFunctionBase {
   llvm::hash_code getHashCode() const override;
 
   inline static bool classof(const EdgeFunctionBase *EF) {
-    return EF->getKind() == Kind::JoinConst;
+    return EF->getKind() == EFKind::JoinConst;
   }
 };
 } // namespace psr::XTaint
diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/JoinEdgeFunction.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/JoinEdgeFunction.h
@@ -88,7 +88,7 @@ class JoinEdgeFunction : public EdgeFunctionBase {
   llvm::hash_code getHashCode() const override;
 
   static inline bool classof(const EdgeFunctionBase *EF) {
-    return EF->getKind() == Kind::Join;
+    return EF->getKind() == EFKind::Join;
   }
 };
 } // namespace psr::XTaint
diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/KillIfSanitizedEdgeFunction.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/KillIfSanitizedEdgeFunction.h
@@ -33,7 +33,7 @@ class KillIfSanitizedEdgeFunction : public EdgeFunctionBase {
   llvm::hash_code getHashCode() const override;
 
   inline static bool classof(const EdgeFunctionBase *EF) {
-    return EF->getKind() == Kind::KillIfSani;
+    return EF->getKind() == EFKind::KillIfSani;
   }
 };
 
diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/XTaintEdgeFunctionBase.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/XTaintEdgeFunctionBase.h
@@ -25,25 +25,25 @@ namespace psr::XTaint {
 class EdgeFunctionBase : public EdgeFunction<EdgeDomain>,
                          public std::enable_shared_from_this<EdgeFunctionBase> {
 public:
-  enum class Kind { Gen, Join, JoinConst, Compose, KillIfSani, Transfer };
+  enum class EFKind { Gen, Join, JoinConst, Compose, KillIfSani, Transfer };
 
 protected:
   BasicBlockOrdering &BBO;
 
 private:
-  const Kind kind;
+  const EFKind Kind;
 
 public:
   using l_t = EdgeDomain;
 
-  EdgeFunctionBase(Kind Kind, BasicBlockOrdering &BBO);
+  EdgeFunctionBase(EFKind Kind, BasicBlockOrdering &BBO);
   ~EdgeFunctionBase() override = default;
 
   EdgeFunctionPtrType composeWith(EdgeFunctionPtrType SecondFunction) override;
   EdgeFunctionPtrType joinWith(EdgeFunctionPtrType OtherFunction) override;
 
   /// The actualy kind of this edge function. Can be used in a type-switch.
-  [[nodiscard]] inline Kind getKind() const { return kind; }
+  [[nodiscard]] inline EFKind getKind() const { return Kind; }
 
   virtual llvm::hash_code getHashCode() const = 0;
 };
diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEExtendedTaintAnalysis.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEExtendedTaintAnalysis.h
@@ -199,7 +199,7 @@ class IDEExtendedTaintAnalysis
         DL((*IRDB->getAllModules().begin())->getDataLayout()), Bound(Bound),
         PostProcessed(DisableStrongUpdates),
         DisableStrongUpdates(DisableStrongUpdates) {
-    base_t::ZeroValue = createZeroValue();
+    base_t::ZeroValue = IDEExtendedTaintAnalysis::createZeroValue();
 
     FactFactory.setDataLayout(DL);
 
diff --git a/include/phasar/Utils/Utilities.h b/include/phasar/Utils/Utilities.h
@@ -182,10 +182,10 @@ template <typename Fn> class scope_exit {
 template <typename Fn> scope_exit(Fn) -> scope_exit<Fn>;
 
 // Copied from "https://en.cppreference.com/w/cpp/utility/variant/visit"
-template <class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
+template <class... Ts> struct Overloaded : Ts... { using Ts::operator()...; };
 
 // explicit deduction guide (not needed as of C++20)
-template <class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
+template <class... Ts> Overloaded(Ts...) -> Overloaded<Ts...>;
 
 /// Based on the reference implementation of std::remove_if
 /// "https://en.cppreference.com/w/cpp/algorithm/remove" and optimized for the
diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/AbstractMemoryLocationFactory.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/AbstractMemoryLocationFactory.cpp
@@ -118,7 +118,7 @@ AbstractMemoryLocationFactoryBase::Allocator::create(
 
 AbstractMemoryLocationFactoryBase::AbstractMemoryLocationFactoryBase(
     size_t InitialCapacity)
-    : Owner(InitialCapacity), DL(nullptr) {
+    : Owner(InitialCapacity) {
 
   Pool.reserve(InitialCapacity);
   Cache.reserve(InitialCapacity);
@@ -166,7 +166,7 @@ AbstractMemoryLocationFactoryBase::getOrCreateImpl(const llvm::Value *V,
 }
 
 const AbstractMemoryLocationImpl *
-AbstractMemoryLocationFactoryBase::CreateImpl(const llvm::Value *V,
+AbstractMemoryLocationFactoryBase::createImpl(const llvm::Value *V,
                                               unsigned BOUND) {
   assert(DL);
   if (auto It = Cache.find(V); It != Cache.end()) {
@@ -222,13 +222,14 @@ AbstractMemoryLocationFactoryBase::CreateImpl(const llvm::Value *V,
   auto Lifetime = BOUND - std::min(Ver, BOUND);
 
   // assert(ver >= offs.size());
-
+#ifdef XTAINT_DIAGNOSTICS
   bool IsOverApproximating = false;
-
+#endif
   if (Offs.size() > BOUND) {
     assert(Lifetime == 0);
-
+#ifdef XTAINT_DIAGNOSTICS
     IsOverApproximating = true;
+#endif
     Offs.resize(BOUND);
   }
 
@@ -279,16 +280,19 @@ AbstractMemoryLocationFactoryBase::withIndirectionOfImpl(
 
   llvm::SmallVector<ptrdiff_t, 8> Offs(AML->offsets().begin(),
                                        AML->offsets().end());
-
+#ifdef XTAINT_DIAGNOSTICS
   bool IsOverApproximating = false;
+#endif
 
   if (Ind.empty()) {
     Offs.push_back(0);
     NwLifeTime--;
   } else {
     if (NwLifeTime < Ind.size()) {
       Ind = Ind.slice(0, NwLifeTime);
+#ifdef XTAINT_DIAGNOSTICS
       IsOverApproximating = true;
+#endif
     }
     Offs.append(Ind.begin(), Ind.end());
 
@@ -394,12 +398,17 @@ AbstractMemoryLocationFactoryBase::withTransferToImpl(
 
           if (!From->offsets().empty()) {
             return std::next(AML->offsets().begin(),
-                             From->offsets().size() - 1);
+                             From->offsets().size() -
+                                 1); // FIXME @Fabian clang-tidy complains about
+                                     // narrowing conversion
           }
           return AML->offsets().begin();
         }
         if (!AML->offsets().empty()) {
-          return std::next(From->offsets().begin(), AML->offsets().size() - 1);
+          return std::next(From->offsets().begin(),
+                           AML->offsets().size() -
+                               1); // FIXME @Fabian clang-tidy complains about
+                                   // narrowing conversion
         }
         return From->offsets().begin();
       }(),
@@ -443,11 +452,14 @@ AbstractMemoryLocationFactoryBase::withTransferFromImpl(
   auto MaximumSize = std::min(AML->offsets().size() + AML->lifetime(),
                               To->offsets().size() + NwLifetime);
 
+#ifdef XTAINT_DIAGNOSTICS
   bool IsOverApproximating = false;
+#endif
   if (Offs.size() > MaximumSize) {
     Offs.resize(MaximumSize);
-    NwLifetime = 0;
+#ifdef XTAINT_DIAGNOSTICS
     IsOverApproximating = true;
+#endif
   }
 
   const auto *Ret =
diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/ComposeEdgeFunction.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/ComposeEdgeFunction.cpp
@@ -18,7 +18,7 @@ namespace psr::XTaint {
 ComposeEdgeFunction::ComposeEdgeFunction(BasicBlockOrdering &BBO,
                                          EdgeFunctionPtrType F,
                                          EdgeFunctionPtrType G)
-    : EdgeFunctionBase(Kind::Compose, BBO), F(std::move(F)), G(std::move(G)) {}
+    : EdgeFunctionBase(EFKind::Compose, BBO), F(std::move(F)), G(std::move(G)) {}
 
 auto ComposeEdgeFunction::computeTarget(l_t Source) -> l_t {
   return G->computeTarget(F->computeTarget(Source));
diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/GenEdgeFunction.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/GenEdgeFunction.cpp
@@ -21,7 +21,7 @@ namespace psr::XTaint {
 
 GenEdgeFunction::GenEdgeFunction(BasicBlockOrdering &BBO,
                                  const llvm::Instruction *Sani)
-    : EdgeFunctionBase(Kind::Gen, BBO), Sani(Sani) {}
+    : EdgeFunctionBase(EFKind::Gen, BBO), Sani(Sani) {}
 
 GenEdgeFunction::l_t
 GenEdgeFunction::computeTarget([[maybe_unused]] l_t Source) {
diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/JoinConstEdgeFunction.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/JoinConstEdgeFunction.cpp
@@ -20,7 +20,7 @@ namespace psr::XTaint {
 JoinConstEdgeFunction::JoinConstEdgeFunction(
     BasicBlockOrdering &BBO, EdgeFunctionPtrType OtherFn,
     const llvm::Instruction *OtherConst)
-    : EdgeFunctionBase(Kind::JoinConst, BBO), OtherFn(std::move(OtherFn)),
+    : EdgeFunctionBase(EFKind::JoinConst, BBO), OtherFn(std::move(OtherFn)),
       OtherConst(OtherConst) {
   assert(OtherConst);
 }
diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/JoinEdgeFunction.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/JoinEdgeFunction.cpp
@@ -23,11 +23,11 @@ namespace psr::XTaint {
 JoinEdgeFunction::JoinEdgeFunction(BasicBlockOrdering &BBO,
                                    SubEdgeFuctionsTy &&SubEF,
                                    const EdgeDomain &Seed)
-    : EdgeFunctionBase(Kind::Join, BBO), SubEF(std::move(SubEF)), Seed(Seed) {}
+    : EdgeFunctionBase(EFKind::Join, BBO), SubEF(std::move(SubEF)), Seed(Seed) {}
 JoinEdgeFunction::JoinEdgeFunction(
     BasicBlockOrdering &BBO, std::initializer_list<EdgeFunctionPtrType> SubEF,
     const EdgeDomain &Seed)
-    : EdgeFunctionBase(Kind::Join, BBO), SubEF(SubEF), Seed(Seed) {}
+    : EdgeFunctionBase(EFKind::Join, BBO), SubEF(SubEF), Seed(Seed) {}
 
 auto JoinEdgeFunction::create(BasicBlockOrdering &BBO,
                               EdgeFunctionPtrType First,
diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/KillIfSanitizedEdgeFunction.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/KillIfSanitizedEdgeFunction.cpp
@@ -19,7 +19,7 @@
 namespace psr::XTaint {
 KillIfSanitizedEdgeFunction::KillIfSanitizedEdgeFunction(
     BasicBlockOrdering &BBO, const llvm::Instruction *Load)
-    : EdgeFunctionBase(Kind::KillIfSani, BBO), Load(Load) {}
+    : EdgeFunctionBase(EFKind::KillIfSani, BBO), Load(Load) {}
 
 KillIfSanitizedEdgeFunction::l_t
 KillIfSanitizedEdgeFunction::computeTarget(l_t Source) {
diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/TransferEdgeFunction.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/TransferEdgeFunction.cpp
@@ -20,7 +20,7 @@ namespace psr::XTaint {
 TransferEdgeFunction::TransferEdgeFunction(BasicBlockOrdering &BBO,
                                            const llvm::Instruction *Load,
                                            const llvm::Instruction *To)
-    : EdgeFunctionBase(Kind::Transfer, BBO), Load(Load), To(To) {}
+    : EdgeFunctionBase(EFKind::Transfer, BBO), Load(Load), To(To) {}
 
 auto TransferEdgeFunction::computeTarget(l_t Source) -> l_t {
 
diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/XTaintEdgeFunctionBase.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/XTaintEdgeFunctionBase.cpp
@@ -15,8 +15,8 @@
 #include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/JoinEdgeFunction.h"
 
 namespace psr::XTaint {
-EdgeFunctionBase::EdgeFunctionBase(Kind Kind, BasicBlockOrdering &BBO)
-    : BBO(BBO), kind(Kind) {}
+EdgeFunctionBase::EdgeFunctionBase(EFKind Kind, BasicBlockOrdering &BBO)
+    : BBO(BBO), Kind(Kind) {}
 
 EdgeFunctionBase::EdgeFunctionPtrType
 EdgeFunctionBase::composeWith(EdgeFunctionPtrType SecondFunction) {
diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEExtendedTaintAnalysis.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEExtendedTaintAnalysis.cpp
@@ -72,7 +72,7 @@ IDEExtendedTaintAnalysis::initialSeeds() {
 }
 
 auto IDEExtendedTaintAnalysis::createZeroValue() const -> d_t {
-  return FactFactory.GetOrCreateZero();
+  return FactFactory.getOrCreateZero();
 }
 
 bool IDEExtendedTaintAnalysis::isZeroValue(d_t Fact) const {
@@ -822,7 +822,7 @@ auto IDEExtendedTaintAnalysis::join(l_t LHS, l_t RHS) -> l_t {
 // Helpers:
 
 auto IDEExtendedTaintAnalysis::makeFlowFact(const llvm::Value *V) -> d_t {
-  return FactFactory.Create(V, Bound);
+  return FactFactory.create(V, Bound);
 }
 
 void IDEExtendedTaintAnalysis::identity(std::set<d_t> &Ret, d_t Source,
diff --git a/unittests/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEExtendedTaintAnalysisTest.cpp b/unittests/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEExtendedTaintAnalysisTest.cpp

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ class ComposeEdgeFunction : public EdgeFunctionBase {`
`29`	`29`	`llvm::hash_code getHashCode() const override;`
`30`	`30`
`31`	`31`	`static inline bool classof(const EdgeFunctionBase *EF) {`
`32`		`- return EF->getKind() == Kind::Compose;`
	`32`	`+ return EF->getKind() == EFKind::Compose;`
`33`	`33`	`}`
`34`	`34`	`};`
`35`	`35`	`} // namespace psr::XTaint`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ class GenEdgeFunction : public EdgeFunctionBase {`
`36`	`36`	`inline const llvm::Instruction *getSanitizer() const { return Sani; }`
`37`	`37`
`38`	`38`	`static inline bool classof(const EdgeFunctionBase *EF) {`
`39`		`- return EF->getKind() == Kind::Gen;`
	`39`	`+ return EF->getKind() == EFKind::Gen;`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`llvm::hash_code getHashCode() const override;`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ class JoinConstEdgeFunction : public EdgeFunctionBase {`
`36`	`36`	`llvm::hash_code getHashCode() const override;`
`37`	`37`
`38`	`38`	`inline static bool classof(const EdgeFunctionBase *EF) {`
`39`		`- return EF->getKind() == Kind::JoinConst;`
	`39`	`+ return EF->getKind() == EFKind::JoinConst;`
`40`	`40`	`}`
`41`	`41`	`};`
`42`	`42`	`} // namespace psr::XTaint`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ class JoinEdgeFunction : public EdgeFunctionBase {`
`88`	`88`	`llvm::hash_code getHashCode() const override;`
`89`	`89`
`90`	`90`	`static inline bool classof(const EdgeFunctionBase *EF) {`
`91`		`- return EF->getKind() == Kind::Join;`
	`91`	`+ return EF->getKind() == EFKind::Join;`
`92`	`92`	`}`
`93`	`93`	`};`
`94`	`94`	`} // namespace psr::XTaint`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ class KillIfSanitizedEdgeFunction : public EdgeFunctionBase {`
`33`	`33`	`llvm::hash_code getHashCode() const override;`
`34`	`34`
`35`	`35`	`inline static bool classof(const EdgeFunctionBase *EF) {`
`36`		`- return EF->getKind() == Kind::KillIfSani;`
	`36`	`+ return EF->getKind() == EFKind::KillIfSani;`
`37`	`37`	`}`
`38`	`38`	`};`
`39`	`39`