Reduce function-complexity warnings by clang-tidy

Author: fabianbs96

include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEExtendedTaintAnalysis.h

@@ -93,17 +93,18 @@ class IDEExtendedTaintAnalysis
 
   /// Add source to ret if it belongs to the same function as CurrInst. If
   /// addGlobals is true, also add llvm::GlobalValue.
-  void identity(std::set<d_t> &Ret, const d_t &Source,
-                const llvm::Instruction *CurrInst, bool AddGlobals = true);
-  std::set<d_t> identity(const d_t &Source, const llvm::Instruction *CurrInst,
-                         bool AddGlobals = true);
+  static void identity(std::set<d_t> &Ret, d_t Source,
+                       const llvm::Instruction *CurrInst,
+                       bool AddGlobals = true);
+  static std::set<d_t> identity(d_t Source, const llvm::Instruction *CurrInst,
+                                bool AddGlobals = true);
 
-  [[nodiscard]] static inline bool equivalent(const d_t &LHS, const d_t &RHS) {
+  [[nodiscard]] static inline bool equivalent(d_t LHS, d_t RHS) {
     return LHS->equivalent(RHS);
   }
 
-  [[nodiscard]] static inline bool
-  equivalentExceptPointerArithmetics(const d_t &LHS, const d_t &RHS) {
+  [[nodiscard]] static inline bool equivalentExceptPointerArithmetics(d_t LHS,
+                                                                      d_t RHS) {
     return LHS->equivalentExceptPointerArithmetics(RHS);
   }
 
@@ -121,6 +122,11 @@ class IDEExtendedTaintAnalysis
                                  const llvm::Value *ValueOp,
                                  const llvm::Instruction *Store,
                                  unsigned PALevel = 1);
+  std::set<d_t> propagateAtStore(PointsToInfo<v_t, n_t>::PointsToSetPtrTy PTS,
+                                 d_t Source, d_t Val, d_t Mem,
+                                 const llvm::Value *PointerOp,
+                                 const llvm::Value *ValueOp,
+                                 const llvm::Instruction *Store);
 
   template <typename CallBack, typename = std::enable_if_t<std::is_invocable_v<
                                    CallBack, const llvm::Value *>>>
@@ -143,6 +149,8 @@ class IDEExtendedTaintAnalysis
     }
   }
 
+  static const llvm::Value *getVAListTagOrNull(const llvm::Function *DestFun);
+
   void populateWithMayAliases(SourceConfigTy &Facts) const;
 
   bool isMustAlias(const SanitizerConfigTy &Facts, d_t CurrNod);

lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/AbstractMemoryLocation.cpp

@@ -71,9 +71,9 @@ auto AbstractMemoryLocationImpl::computeOffset(
 [[nodiscard]] auto AbstractMemoryLocationImpl::operator-(
     const AbstractMemoryLocationImpl &TV) const -> llvm::ArrayRef<ptrdiff_t> {
   if (NumOffsets > TV.offsets().size()) {
-    return offsets().slice(std::max(size_t(1), TV.offsets().size()) - 1);
+    return offsets().drop_front(std::max(size_t(1), TV.offsets().size()) - 1);
   }
-  return TV.offsets().slice(std::max(1U, NumOffsets) - 1);
+  return TV.offsets().drop_front(std::max(1U, NumOffsets) - 1);
 }
 
 bool AbstractMemoryLocationImpl::equivalentOffsets(
@@ -112,6 +112,7 @@ bool AbstractMemoryLocationImpl::mustAlias(
                 << llvmIRToShortString(TV.base()) << ") = " << std::boolalpha
                 << (PT.alias(base(), TV.base()) == AliasResult::MustAlias));
 
+  // NOLINTNEXTLINE(readability-identifier-naming)
   auto getFunctionOrNull = [](const llvm::Value *V) -> const llvm::Function * {
     if (const auto *Inst = llvm::dyn_cast<llvm::Instruction>(V)) {
       return Inst->getFunction();

lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/AbstractMemoryLocationFactory.cpp

@@ -12,6 +12,7 @@
 #include <new>
 
 #include "llvm/IR/Instructions.h"
+#include "llvm/Support/Compiler.h"
 
 #include "phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/AbstractMemoryLocationFactory.h"
 #include "phasar/Utils/Logger.h"
@@ -25,8 +26,8 @@ auto AbstractMemoryLocationFactoryBase::Allocator::Block::create(
     Block *Next, size_t NumPointerEntries) -> Block * {
   // Allocate one more pointer to store the next-block ptr
 
-  if (NumPointerEntries >
-      std::numeric_limits<size_t>::max() / sizeof(size_t) - 1) [[unlikely]] {
+  if (LLVM_UNLIKELY(NumPointerEntries >
+                    std::numeric_limits<size_t>::max() / sizeof(size_t) - 1)) {
 
     LOG_IF_ENABLE(BOOST_LOG_SEV(lg::get(), CRITICAL)
                   << "Cannot allocate " << NumPointerEntries

lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/JoinEdgeFunction.cpp

@@ -44,6 +44,7 @@ auto JoinEdgeFunction::create(BasicBlockOrdering &BBO,
   }
   // Helper-function to handle the case where exactly one of {First, Second} is
   // a JoinEdgeFunction
+  // NOLINTNEXTLINE(readability-identifier-naming)
   auto joinSingle =
       [&BBO](
           const EdgeFunctionPtrType &Single, const JoinEdgeFunction *Other,
@@ -64,49 +65,55 @@ auto JoinEdgeFunction::create(BasicBlockOrdering &BBO,
     return makeEF<JoinEdgeFunction>(BBO, std::move(Subs), Other->Seed);
   };
 
-  EdgeDomain Seed = psr::Top{};
+  /// Check for JoinConstEF:
 
-  if (auto *FirstJC = dynamic_cast<JoinConstEdgeFunction *>(&*First)) {
-    if (auto *SecondJC = dynamic_cast<JoinConstEdgeFunction *>(&*Second)) {
-      Seed = EdgeDomain(FirstJC->getConstant()).join(SecondJC->getConstant());
-      First = FirstJC->getFunction();
-      Second = SecondJC->getFunction();
-    } else {
-      Seed = FirstJC->getConstant();
-      First = FirstJC->getFunction();
-    }
-  } else if (auto *SecondJC = dynamic_cast<JoinConstEdgeFunction *>(&*Second)) {
+  EdgeDomain Seed = psr::Top{};
+  auto *FirstJC = dynamic_cast<JoinConstEdgeFunction *>(&*First);
+  auto *SecondJC = dynamic_cast<JoinConstEdgeFunction *>(&*Second);
+  if (FirstJC && SecondJC) {
+    Seed = EdgeDomain(FirstJC->getConstant()).join(SecondJC->getConstant());
+    First = FirstJC->getFunction();
+    Second = SecondJC->getFunction();
+  } else if (FirstJC) {
+    Seed = FirstJC->getConstant();
+    First = FirstJC->getFunction();
+  } else if (SecondJC) {
     Seed = SecondJC->getConstant();
     Second = SecondJC->getFunction();
   }
 
-  if (&*First == &*Second || First->equal_to(Second)) // Just to be sure...
+  if (&*First == &*Second || First->equal_to(Second)) {
+    // Just to be sure...
     return First;
+  }
+
+  /// Check for JoinEF:
 
-  if (auto *FirstEF = dynamic_cast<JoinEdgeFunction *>(&*First)) {
-    if (auto *SecondEF = dynamic_cast<JoinEdgeFunction *>(&*Second)) {
-      // Most difficult case: Both First and Second are JoinEdgeFunctions. Merge
-      // the subEF-sets by using set-union (deduplicating)
-
-      if (SecondEF->SubEF.size() < FirstEF->SubEF.size()) {
-        std::swap(FirstEF, SecondEF);
-      }
-      SubEdgeFuctionsTy Subs(SecondEF->SubEF);
-      for (const auto &Sub : FirstEF->SubEF) {
-        Subs.insert(Sub);
-      }
-
-      if (Subs.size() > SubEFThreshold) {
-        return getAllBot();
-      }
-
-      return makeEF<JoinEdgeFunction>(BBO, std::move(Subs),
-                                      FirstEF->Seed.join(SecondEF->Seed, &BBO));
+  auto *FirstEF = dynamic_cast<JoinEdgeFunction *>(&*First);
+  auto *SecondEF = dynamic_cast<JoinEdgeFunction *>(&*Second);
+  if (FirstEF && SecondEF) {
+    // Most difficult case: Both First and Second are JoinEdgeFunctions. Merge
+    // the subEF-sets by using set-union (deduplicating)
+
+    if (SecondEF->SubEF.size() < FirstEF->SubEF.size()) {
+      std::swap(FirstEF, SecondEF);
+    }
+    SubEdgeFuctionsTy Subs(SecondEF->SubEF);
+    for (const auto &Sub : FirstEF->SubEF) {
+      Subs.insert(Sub);
+    }
+
+    if (Subs.size() > SubEFThreshold) {
+      return getAllBot();
     }
 
+    return makeEF<JoinEdgeFunction>(BBO, std::move(Subs),
+                                    FirstEF->Seed.join(SecondEF->Seed, &BBO));
+  }
+  if (FirstEF) {
     return joinSingle(Second, FirstEF, First);
   }
-  if (auto *SecondEF = dynamic_cast<JoinEdgeFunction *>(&*Second)) {
+  if (SecondEF) {
     return joinSingle(First, SecondEF, Second);
   }