Merge branch 'f-ClangTidyFixIDETSA' into f-ClangTidyFixIDEMiscAnalyses

Martin Mory · Martin Mory · commit c6625c49265e · 2021-12-24T01:29:54.000+01:00
diff --git a/include/phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h b/include/phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h
@@ -321,13 +321,13 @@ class LLVMBasedICFG
 
   template <typename Fn> void forEachGlobalCtor(Fn &&F) const {
     for (auto [Prio, Fun] : GlobalCtors) {
-      F(static_cast<const llvm::Function *>(Fun));
+      std::invoke(F, static_cast<const llvm::Function *>(Fun));
     }
   }
 
   template <typename Fn> void forEachGlobalDtor(Fn &&F) const {
     for (auto [Prio, Fun] : GlobalDtors) {
-      F(static_cast<const llvm::Function *>(Fun));
+      std::invoke(F, static_cast<const llvm::Function *>(Fun));
     }
   }
 
diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/FlowFunctions.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/FlowFunctions.h
@@ -185,7 +185,7 @@ class GenIf : public FlowFunction<D, Container> {
       : GenValues({GenValue}), Predicate(std::move(Predicate)) {}
 
   GenIf(container_type GenValues, std::function<bool(D)> Predicate)
-      : GenValues(std::move(GenValues)), Predicate(Predicate) {}
+      : GenValues(std::move(GenValues)), Predicate(std::move(Predicate)) {}
 
   ~GenIf() override = default;
 
@@ -274,7 +274,7 @@ class KillMultiple : public FlowFunction<D, Container> {
   KillMultiple(std::set<D> KillValues) : KillValues(std::move(KillValues)) {}
   ~KillMultiple() override = default;
   container_type computeTargets(D Source) override {
-    if (KillValues.find(Source) != KillValues.end()) {
+    if (KillValues.count(Source)) {
       return {};
     }
     return {Source};
diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/IFDSFieldSensTaintAnalysis/FlowFunctions/MapTaintedValuesToCaller.h b/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;
diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/IFDSFieldSensTaintAnalysis/Utils/Log.h b/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
diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/LLVMZeroValue.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/LLVMZeroValue.h
@@ -68,13 +68,8 @@ class LLVMZeroValue : public llvm::GlobalVariable {
     return LLVMZeroValueInternalName;
   }
 
-  bool isLLVMZeroValue(const llvm::Value *V) const {
-    if (V && V->hasName()) {
-      // checks if V's name start with "zero_value"
-      return V->getName().find(LLVMZeroValueInternalName) !=
-             llvm::StringRef::npos;
-    }
-    return false;
+  static bool isLLVMZeroValue(const llvm::Value *V) {
+    return V == getInstance();
   }
 
   // Do not specify a destructor (at all)!
diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.h b/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;
   }
diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/Mono/Contexts/CallStringCTX.h b/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
diff --git a/lib/PhasarLLVM/ControlFlow/LLVMBasedICFG.cpp b/lib/PhasarLLVM/ControlFlow/LLVMBasedICFG.cpp
@@ -444,15 +444,13 @@ const llvm::Function *LLVMBasedICFG::getFunction(const string &Fun) const {
 }
 
 const llvm::Function *LLVMBasedICFG::getFirstGlobalCtorOrNull() const {
-  auto It = GlobalCtors.begin();
-  if (It != GlobalCtors.end()) {
+  if (auto It = GlobalCtors.begin(); It != GlobalCtors.end()) {
     return It->second;
   }
   return nullptr;
 }
 const llvm::Function *LLVMBasedICFG::getLastGlobalDtorOrNull() const {
-  auto It = GlobalDtors.rbegin();
-  if (It != GlobalDtors.rend()) {
+  if (auto It = GlobalDtors.rbegin(); It != GlobalDtors.rend()) {
     return It->second;
   }
   return nullptr;
@@ -1273,8 +1271,8 @@ unsigned LLVMBasedICFG::getNumOfEdges() const {
 
 const llvm::Function *
 LLVMBasedICFG::getRegisteredDtorsCallerOrNull(const llvm::Module *Mod) {
-  auto It = GlobalRegisteredDtorsCaller.find(Mod);
-  if (It != GlobalRegisteredDtorsCaller.end()) {
+  if (auto It = GlobalRegisteredDtorsCaller.find(Mod);
+      It != GlobalRegisteredDtorsCaller.end()) {
     return It->second;
   }
 
diff --git a/lib/PhasarLLVM/ControlFlow/Resolver/Resolver.cpp b/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") {
diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/ComposeEdgeFunction.cpp b/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));
diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/ExtendedTaintAnalysis/JoinEdgeFunction.cpp b/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)
diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/EdgeValue.cpp
diff --git a/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/GenConstant.cpp b/lib/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEGeneralizedLCA/GenConstant.cpp
diff --git a/lib/PhasarLLVM/Plugins/IDETabulationProblemTestPlugin.h b/lib/PhasarLLVM/Plugins/IDETabulationProblemTestPlugin.h
diff --git a/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFGGlobCtorDtorTest.cpp b/unittests/PhasarLLVM/ControlFlow/LLVMBasedICFGGlobCtorDtorTest.cpp
diff --git a/unittests/PhasarLLVM/DataFlowSolver/IfdsIde/EdgeFunctionSingletonFactoryTest.cpp b/unittests/PhasarLLVM/DataFlowSolver/IfdsIde/EdgeFunctionSingletonFactoryTest.cpp

Original file line number	Diff line number	Diff line change
`@@ -321,13 +321,13 @@ class LLVMBasedICFG`
`321`	`321`
`322`	`322`	`template <typename Fn> void forEachGlobalCtor(Fn &&F) const {`
`323`	`323`	`for (auto [Prio, Fun] : GlobalCtors) {`
`324`		`- F(static_cast<const llvm::Function *>(Fun));`
	`324`	`+ std::invoke(F, static_cast<const llvm::Function *>(Fun));`
`325`	`325`	`}`
`326`	`326`	`}`
`327`	`327`
`328`	`328`	`template <typename Fn> void forEachGlobalDtor(Fn &&F) const {`
`329`	`329`	`for (auto [Prio, Fun] : GlobalDtors) {`
`330`		`- F(static_cast<const llvm::Function *>(Fun));`
	`330`	`+ std::invoke(F, static_cast<const llvm::Function *>(Fun));`
`331`	`331`	`}`
`332`	`332`	`}`
`333`	`333`
Original file line number	Diff line number	Diff line change
`@@ -68,13 +68,8 @@ class LLVMZeroValue : public llvm::GlobalVariable {`
`68`	`68`	`return LLVMZeroValueInternalName;`
`69`	`69`	`}`
`70`	`70`
`71`		`- bool isLLVMZeroValue(const llvm::Value *V) const {`
`72`		`- if (V && V->hasName()) {`
`73`		`- // checks if V's name start with "zero_value"`
`74`		`- return V->getName().find(LLVMZeroValueInternalName) !=`
`75`		`- llvm::StringRef::npos;`
`76`		`- }`
`77`		`- return false;`
	`71`	`+ static bool isLLVMZeroValue(const llvm::Value *V) {`
	`72`	`+ return V == getInstance();`
`78`	`73`	`}`
`79`	`74`
`80`	`75`	`// Do not specify a destructor (at all)!`
Original file line number	Diff line number	Diff line change
`@@ -99,4 +99,4 @@ template <typename N, unsigned K> struct hash<psr::CallStringCTX<N, K>> {`
`99`	`99`
`100`	`100`	`} // namespace std`
`101`	`101`
`102`		`-#endif`
	`102`	`+#endif`
Original file line number	Diff line number	Diff line change
`@@ -444,15 +444,13 @@ const llvm::Function *LLVMBasedICFG::getFunction(const string &Fun) const {`
`444`	`444`	`}`
`445`	`445`
`446`	`446`	`const llvm::Function *LLVMBasedICFG::getFirstGlobalCtorOrNull() const {`
`447`		`- auto It = GlobalCtors.begin();`
`448`		`- if (It != GlobalCtors.end()) {`
	`447`	`+ if (auto It = GlobalCtors.begin(); It != GlobalCtors.end()) {`
`449`	`448`	`return It->second;`
`450`	`449`	`}`
`451`	`450`	`return nullptr;`
`452`	`451`	`}`
`453`	`452`	`const llvm::Function *LLVMBasedICFG::getLastGlobalDtorOrNull() const {`
`454`		`- auto It = GlobalDtors.rbegin();`
`455`		`- if (It != GlobalDtors.rend()) {`
	`453`	`+ if (auto It = GlobalDtors.rbegin(); It != GlobalDtors.rend()) {`
`456`	`454`	`return It->second;`
`457`	`455`	`}`
`458`	`456`	`return nullptr;`
`@@ -1273,8 +1271,8 @@ unsigned LLVMBasedICFG::getNumOfEdges() const {`
`1273`	`1271`
`1274`	`1272`	`const llvm::Function *`
`1275`	`1273`	`LLVMBasedICFG::getRegisteredDtorsCallerOrNull(const llvm::Module *Mod) {`
`1276`		`- auto It = GlobalRegisteredDtorsCaller.find(Mod);`
`1277`		`- if (It != GlobalRegisteredDtorsCaller.end()) {`
	`1274`	`+ if (auto It = GlobalRegisteredDtorsCaller.find(Mod);`
	`1275`	`+ It != GlobalRegisteredDtorsCaller.end()) {`
`1278`	`1276`	`return It->second;`
`1279`	`1277`	`}`
`1280`	`1278`