Merge branch 'f-ClangTidyFixIDEGeneralizedLCA' into f-ClangTidyFixIDELCA

Author: Martin Mory

include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/IFDSFieldSensTaintAnalysis/FlowFunctions/MapTaintedValuesToCaller.h

@@ -20,8 +20,7 @@ class MapTaintedValuesToCaller : public FlowFunction<ExtendedValue> {
   MapTaintedValuesToCaller(const llvm::CallInst *CallInst,
                            const llvm::ReturnInst *RetInst,
                            TraceStats &TraceStats, const ExtendedValue &ZV)
-      : CallInst(CallInst), RetInst(RetInst), TraceStats(TraceStats),
-        ZV(ZV) {}
+      : CallInst(CallInst), RetInst(RetInst), TraceStats(TraceStats), ZV(ZV) {}
   ~MapTaintedValuesToCaller() override = default;
 
   std::set<ExtendedValue> computeTargets(ExtendedValue Fact) override;

include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/IFDSFieldSensTaintAnalysis/Utils/Log.h

@@ -10,9 +10,8 @@
 #define LOG_INFO(x)                                                            \
   do {                                                                         \
     llvm::outs() << "[ENV_TRACE] " << x << "\n"; /*NOLINT*/                    \
-    \
-    llvm::outs()                                                               \
-        .flush();                                                              \
+                                                                               \
+    llvm::outs().flush();                                                      \
   } while (0)
 
 #ifdef DEBUG_BUILD

include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.h

@@ -29,7 +29,7 @@ class EdgeValue {
   enum Type { Top, Integer, String, FloatingPoint };
 
 private:
-  std::variant<llvm::APInt, llvm::APFloat, std::string, std::nullptr_t>
+  std::variant<llvm::APInt, llvm::APFloat, std::string, std::nullptr_t>
       ValVariant = nullptr;
   Type VariantType;
 
@@ -56,7 +56,7 @@ class EdgeValue {
   [[nodiscard]] Type getKind() const;
   // std::unique_ptr<ObjectLLVM> asObjLLVM(llvm::LLVMContext &ctx) const;
   [[nodiscard]] bool sqSubsetEq(const EdgeValue &Other) const;
-  [[nodiscard]] EdgeValue performBinOp(llvm::BinaryOperator::BinaryOps Op,
+  [[nodiscard]] EdgeValue performBinOp(llvm::BinaryOperator::BinaryOps Op,
                                        const EdgeValue &Other) const;
   [[nodiscard]] EdgeValue typecast(Type Dest, unsigned Bits) const;
   EdgeValue &operator=(const EdgeValue &EV);
@@ -89,7 +89,7 @@ using ev_t = EdgeValueSet;
 ev_t performBinOp(llvm::BinaryOperator::BinaryOps Op, const ev_t &Lhs,
                   const ev_t &Rhs, size_t MaxSize);
 ev_t performTypecast(const ev_t &Ev, EdgeValue::Type Dest, unsigned Bits);
-Ordering compare(const ev_t &Lhs, const ev_t &Rhs);
+Ordering compare(const ev_t &Lhs, const ev_t &Rhs);
 ev_t join(const ev_t &Lhs, const ev_t &Rhs, size_t MaxSize);
 /// \brief implements square subset equal
 bool operator<(const ev_t &Lhs, const ev_t &Rhs);
@@ -108,13 +108,13 @@ template <> struct hash<psr::EdgeValue> {
     double AsFloat;
     string AsString;
     if (Val.tryGetInt(AsInt)) {
-      return hash<uint64_t>()(AsInt) * 31 + Hash;
-    }
+      return hash<uint64_t>()(AsInt) * 31 + Hash;
+    }
     if (Val.tryGetFP(AsFloat)) {
-      return hash<double>()(round(AsFloat)) * 31 + Hash;
-    }
-    if (Val.tryGetString(AsString)) {
-      return hash<string>()(AsString) * 31 + Hash;
+      return hash<double>()(round(AsFloat)) * 31 + Hash;
+    }
+    if (Val.tryGetString(AsString)) {
+      return hash<string>()(AsString) * 31 + Hash;
     }
     return Hash;
   }

include/phasar/PhasarLLVM/DataFlowSolver/Mono/Contexts/CallStringCTX.h

@@ -99,4 +99,4 @@ template <typename N, unsigned K> struct hash<psr::CallStringCTX<N, K>> {
 
 } // namespace std
 
-#endif
+#endif

lib/PhasarLLVM/ControlFlow/Resolver/Resolver.cpp

@@ -77,7 +77,7 @@ Resolver::Resolver(ProjectIRDB &IRDB, LLVMTypeHierarchy &TH)
 
 const llvm::Function *
 Resolver::getNonPureVirtualVFTEntry(const llvm::StructType *T, unsigned Idx,
-                                    const llvm::CallBase */*CallSite*/) {
+                                    const llvm::CallBase * /*CallSite*/) {
   if (TH && TH->hasVFTable(T)) {
     const auto *Target = TH->getVFTable(T)->getFunction(Idx);
     if (Target && Target->getName() != "__cxa_pure_virtual") {

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

@@ -18,7 +18,8 @@ namespace psr::XTaint {
 ComposeEdgeFunction::ComposeEdgeFunction(BasicBlockOrdering &BBO,
                                          EdgeFunctionPtrType F,
                                          EdgeFunctionPtrType G)
-    : EdgeFunctionBase(EFKind::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));

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

@@ -23,7 +23,8 @@ namespace psr::XTaint {
 JoinEdgeFunction::JoinEdgeFunction(BasicBlockOrdering &BBO,
                                    SubEdgeFuctionsTy &&SubEF,
                                    const EdgeDomain &Seed)
-    : EdgeFunctionBase(EFKind::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)