GCC Compatibility

CMakeLists.txt

@@ -82,6 +82,11 @@ option(PHASAR_BUILD_MODULES "Build C++20 modules for phasar" OFF)
 
 include(CheckCXXCompilerFlag)
 
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  # Match clang's behavior, when handling naming collisions, such as "using l_t = l_t;"
+  string(APPEND CMAKE_CXX_FLAGS " -fpermissive")
+endif()
+
 # Handle memory issues with linking
 if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
   string(APPEND CMAKE_CXX_FLAGS_DEBUG " -gsplit-dwarf")

include/phasar/ControlFlow/CallGraphBase.h

@@ -37,7 +37,7 @@ template <typename Derived> class CallGraphBase : public CRTPBase<Derived> {
   /// NOTE: This function is typically called in a hot part of the analysis and
   /// should therefore be very fast
   [[nodiscard]] decltype(auto) getCalleesOfCallAt(ByConstRef<n_t> Inst) const
-      noexcept(noexcept(self().getCalleesOfCallAtImpl(Inst))) {
+      noexcept(noexcept(this->self().getCalleesOfCallAtImpl(Inst))) {
     static_assert(
         is_iterable_over_v<decltype(self().getCalleesOfCallAtImpl(Inst)), f_t>);
     return self().getCalleesOfCallAtImpl(Inst);
@@ -47,7 +47,7 @@ template <typename Derived> class CallGraphBase : public CRTPBase<Derived> {
   /// call the given function induced by the used call-graph.
   [[nodiscard]] decltype(auto) getCallersOf(ByConstRef<f_t> Fun) const {
     static_assert(
-        is_iterable_over_v<decltype(self().getCallersOfImpl(Fun)), n_t>);
+        is_iterable_over_v<decltype(this->self().getCallersOfImpl(Fun)), n_t>);
     return self().getCallersOfImpl(Fun);
   }
 };

include/phasar/DataFlow/IfdsIde/EdgeFunction.h

@@ -442,21 +442,32 @@ class [[clang::trivial_abi]] EdgeFunction final : EdgeFunctionBase {
             typename = std::enable_if_t<
                 !std::is_same_v<EdgeFunction, std::decay_t<ConcreteEF>> &&
                 IsEdgeFunction<ConcreteEF>>>
-  [[nodiscard]] friend bool operator==(EdgeFunctionRef<ConcreteEF> LHS,
-                                       const EdgeFunction &RHS) noexcept {
-    if (!RHS.template isa<ConcreteEF>()) {
+  [[nodiscard]] bool equals(EdgeFunctionRef<ConcreteEF> Other) const noexcept {
+    // NOTE: Workaround issue in g++ that does not allow transitive friends: If
+    // putting this code in the operator== below, we cannot access
+    // Other.Instance, although it is friended...
+    if (!isa<ConcreteEF>()) {
       return false;
     }
-    if (LHS.Instance == RHS.EF) {
+    if (Other.Instance == EF) {
       return true;
     }
     if constexpr (IsEqualityComparable<ConcreteEF>) {
-      return *LHS == *getPtr<ConcreteEF>(RHS.EF);
+      return *Other == *getPtr<ConcreteEF>(EF);
     } else {
       return true;
     }
   }
 
+  template <typename ConcreteEF,
+            typename = std::enable_if_t<
+                !std::is_same_v<EdgeFunction, std::decay_t<ConcreteEF>> &&
+                IsEdgeFunction<ConcreteEF>>>
+  [[nodiscard]] friend bool operator==(EdgeFunctionRef<ConcreteEF> LHS,
+                                       const EdgeFunction &RHS) noexcept {
+    return RHS.equals(LHS);
+  }
+
   template <typename ConcreteEF,
             typename = std::enable_if_t<
                 !std::is_same_v<EdgeFunction, std::decay_t<ConcreteEF>> &&

include/phasar/DataFlow/IfdsIde/FlowFunctions.h

@@ -73,7 +73,7 @@ template <typename D, typename Container = std::set<D>> class FlowFunction {
 template <typename FF> struct IsFlowFunction {
   template <typename D, typename Container>
   static std::true_type test(const FlowFunction<D, Container> &);
-  static std::false_type test(...) {}
+  static std::false_type test(...);
 
   static constexpr bool value = // NOLINT
       std::is_same_v<std::true_type,

include/phasar/PhasarLLVM/ControlFlow/LLVMBasedBackwardICFG.h

@@ -52,6 +52,9 @@ class LLVMBasedBackwardICFG : public LLVMBasedBackwardCFG,
   LLVMBasedBackwardICFG(LLVMBasedICFG *ForwardICFG);
 
 private:
+  using typename ICFGBase::f_t;
+  using typename ICFGBase::n_t;
+
   [[nodiscard]] FunctionRange getAllFunctionsImpl() const;
   [[nodiscard]] f_t getFunctionImpl(llvm::StringRef Fun) const;
 

include/phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h

@@ -48,6 +48,9 @@ class LLVMBasedICFG : public LLVMBasedCFG, public ICFGBase<LLVMBasedICFG> {
   friend ICFGBase;
 
 public:
+  using typename ICFGBase::f_t;
+  using typename ICFGBase::n_t;
+
   // For backward compatibility
   static constexpr llvm::StringLiteral GlobalCRuntimeModelName =
       GlobalCtorsDtorsModel::ModelName;

include/phasar/PhasarLLVM/ControlFlow/SparseLLVMBasedCFG.h

@@ -30,6 +30,8 @@ class SparseLLVMBasedCFG : public LLVMBasedCFG,
   friend struct SVFGCache;
   friend SparseCFGBase<SparseLLVMBasedCFG>;
 
+  using typename LLVMBasedCFG::n_t;
+
 public:
   using vgraph_t =
       llvm::SmallDenseMap<const llvm::Instruction *, const llvm::Instruction *>;

include/phasar/PhasarLLVM/ControlFlow/SparseLLVMBasedICFG.h

@@ -33,6 +33,9 @@ class SparseLLVMBasedICFG
   friend SparseLLVMBasedCFGProvider<SparseLLVMBasedICFG>;
 
 public:
+  using typename LLVMBasedICFG::f_t;
+  using typename LLVMBasedICFG::n_t;
+
   /// Constructor that delegates all arguments to the ctor of LLVMBasedICFG
   explicit SparseLLVMBasedICFG(LLVMProjectIRDB *IRDB,
                                CallGraphAnalysisType CGType,
@@ -47,7 +50,7 @@ class SparseLLVMBasedICFG
                                LLVMAliasInfoRef PT);
 
   explicit SparseLLVMBasedICFG(LLVMProjectIRDB *IRDB,
-                               const nlohmann::json &SerializedCG,
+                               const CallGraphData &SerializedCG,
                                LLVMAliasInfoRef PT);
 
   ~SparseLLVMBasedICFG();

include/phasar/PhasarLLVM/ControlFlow/SparseLLVMBasedICFGView.h

@@ -45,6 +45,9 @@ class SparseLLVMBasedICFGView
   friend SparseLLVMBasedCFGProvider<SparseLLVMBasedICFGView>;
 
 public:
+  using typename LLVMBasedCFG::f_t;
+  using typename LLVMBasedCFG::n_t;
+
   explicit SparseLLVMBasedICFGView(const LLVMBasedICFG *ICF,
                                    LLVMAliasInfoRef PT);
 

include/phasar/PhasarLLVM/DataFlow/IfdsIde/DefaultAliasAwareIDEProblem.h

@@ -65,6 +65,10 @@ class DefaultAliasAwareIDEProblem
       protected detail::IDEAliasAwareDefaultFlowFunctionsImpl {
 public:
   using typename IDETabulationProblem<AnalysisDomainTy>::db_t;
+  using typename IDETabulationProblem<AnalysisDomainTy>::n_t;
+  using typename IDETabulationProblem<AnalysisDomainTy>::f_t;
+  using typename IDETabulationProblem<AnalysisDomainTy>::d_t;
+  using typename IDETabulationProblem<AnalysisDomainTy>::FlowFunctionPtrType;
 
   using detail::IDEAliasAwareDefaultFlowFunctionsImpl::getAliasInfo;
 
@@ -110,6 +114,11 @@ class DefaultAliasAwareIFDSProblem
     : public IFDSTabulationProblem<LLVMAnalysisDomainDefault>,
       protected detail::IDEAliasAwareDefaultFlowFunctionsImpl {
 public:
+  using typename IFDSTabulationProblem::d_t;
+  using typename IFDSTabulationProblem::f_t;
+  using typename IFDSTabulationProblem::FlowFunctionPtrType;
+  using typename IFDSTabulationProblem::n_t;
+
   /// Constructs an IFDSTabulationProblem with the usual arguments + alias
   /// information.
   ///

include/phasar/PhasarLLVM/DataFlow/IfdsIde/DefaultNoAliasIDEProblem.h

@@ -59,6 +59,10 @@ class DefaultNoAliasIDEProblem
 public:
   using IDETabulationProblem<AnalysisDomainTy>::IDETabulationProblem;
 
+  using typename IDETabulationProblem<AnalysisDomainTy>::f_t;
+  using typename IDETabulationProblem<AnalysisDomainTy>::FlowFunctionPtrType;
+  using typename IDETabulationProblem<AnalysisDomainTy>::n_t;
+
   [[nodiscard]] FlowFunctionPtrType getNormalFlowFunction(n_t Curr,
                                                           n_t Succ) override {
     return getNormalFlowFunctionImpl(Curr, Succ);
@@ -89,6 +93,12 @@ class DefaultNoAliasIFDSProblem
 public:
   using IFDSTabulationProblem::IFDSTabulationProblem;
 
+  using typename IFDSTabulationProblem::d_t;
+  using typename IFDSTabulationProblem::f_t;
+  using typename IFDSTabulationProblem::FlowFunctionPtrType;
+  using typename IFDSTabulationProblem::l_t;
+  using typename IFDSTabulationProblem::n_t;
+
   [[nodiscard]] FlowFunctionPtrType getNormalFlowFunction(n_t Curr,
                                                           n_t Succ) override {
     return getNormalFlowFunctionImpl(Curr, Succ);

include/phasar/PhasarLLVM/DataFlow/IfdsIde/DefaultReachableAllocationSitesIDEProblem.h

@@ -66,6 +66,10 @@ class DefaultReachableAllocationSitesIDEProblem
       protected detail::IDEReachableAllocationSitesDefaultFlowFunctionsImpl {
 public:
   using typename IDETabulationProblem<AnalysisDomainTy>::db_t;
+  using typename IDETabulationProblem<AnalysisDomainTy>::d_t;
+  using typename IDETabulationProblem<AnalysisDomainTy>::f_t;
+  using typename IDETabulationProblem<AnalysisDomainTy>::n_t;
+  using typename IDETabulationProblem<AnalysisDomainTy>::FlowFunctionPtrType;
 
   /// Constructs an IDETabulationProblem with the usual arguments + alias
   /// information.
@@ -109,6 +113,12 @@ class DefaultReachableAllocationSitesIFDSProblem
     : public IFDSTabulationProblem<LLVMIFDSAnalysisDomainDefault>,
       protected detail::IDEReachableAllocationSitesDefaultFlowFunctionsImpl {
 public:
+  using typename IFDSTabulationProblem::d_t;
+  using typename IFDSTabulationProblem::db_t;
+  using typename IFDSTabulationProblem::f_t;
+  using typename IFDSTabulationProblem::FlowFunctionPtrType;
+  using typename IFDSTabulationProblem::n_t;
+
   /// Constructs an IFDSTabulationProblem with the usual arguments + alias
   /// information.
   ///

include/phasar/PhasarLLVM/DataFlow/IfdsIde/LLVMZeroValue.h

@@ -36,6 +36,10 @@ class LLVMZeroValue : public llvm::GlobalVariable {
   LLVMZeroValue(llvm::Module &Mod);
 
   static constexpr llvm::StringLiteral LLVMZeroValueInternalName = "zero_value";
+  static bool isZeroValueHelper(const llvm::Value *V) noexcept {
+    // Need this helper function to make gcc happy
+    return V == getInstance();
+  }
 
 public:
   LLVMZeroValue(const LLVMZeroValue &Z) = delete;
@@ -53,7 +57,7 @@ class LLVMZeroValue : public llvm::GlobalVariable {
 
   // NOLINTNEXTLINE(readability-identifier-naming)
   static constexpr auto isLLVMZeroValue = [](const llvm::Value *V) noexcept {
-    return V == getInstance();
+    return isZeroValueHelper(V);
   };
 };
 } // namespace psr

include/phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IDEInstInteractionAnalysis.h

@@ -942,6 +942,14 @@ class IDEInstInteractionAnalysisT
 
   inline l_t join(l_t Lhs, l_t Rhs) override { return joinImpl(Lhs, Rhs); }
 
+  struct IIAAKillOrReplaceEF;
+  struct IIAAAddLabelsEF;
+  // These friend declarations are needed to make gcc happy
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                                       const IIAAKillOrReplaceEF &EF);
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                                       const IIAAAddLabelsEF &EF);
+
   // Provide some handy helper edge functions to improve reuse.
 
   // Edge function that kills all labels in a set (and may replaces them with

include/phasar/PhasarLLVM/DataFlow/IfdsIde/Problems/IDETypeStateAnalysis.h

@@ -195,8 +195,7 @@ class IDETypeStateAnalysis
     }
 
     [[no_unique_address]] std::conditional_t<HasJoinLatticeTraits<l_t>,
-                                             EmptyType, l_t>
-        BotElement{};
+                                             EmptyType, l_t> BotElement{};
 
     static EdgeFunction<l_t> join(EdgeFunctionRef<TSEdgeFunctionComposer> This,
                                   const EdgeFunction<l_t> &OtherFunction) {

include/phasar/PhasarLLVM/HelperAnalyses.h

@@ -11,13 +11,12 @@
 #define PHASAR_PHASARLLVM_HELPERANALYSES_H
 
 #include "phasar/ControlFlow/CallGraphAnalysisType.h"
+#include "phasar/ControlFlow/CallGraphData.h"
 #include "phasar/PhasarLLVM/HelperAnalysisConfig.h"
-
-#include "nlohmann/json.hpp"
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasSetData.h"
 
 #include <memory>
 #include <optional>
-#include <set>
 #include <vector>
 
 namespace llvm {
@@ -34,10 +33,10 @@ class LLVMAliasSet;
 class HelperAnalyses { // NOLINT(cppcoreguidelines-special-member-functions)
 public:
   explicit HelperAnalyses(std::string IRFile,
-                          std::optional<nlohmann::json> PrecomputedPTS,
+                          std::optional<LLVMAliasSetData> PrecomputedPTS,
                           AliasAnalysisType PTATy, bool AllowLazyPTS,
                           std::vector<std::string> EntryPoints,
-                          std::optional<nlohmann::json> PrecomputedCG,
+                          std::optional<CallGraphData> PrecomputedCG,
                           CallGraphAnalysisType CGTy, Soundness SoundnessLevel,
                           bool AutoGlobalSupport) noexcept;
 
@@ -75,12 +74,12 @@ class HelperAnalyses { // NOLINT(cppcoreguidelines-special-member-functions)
   std::string IRFile;
 
   // PTS
-  std::optional<nlohmann::json> PrecomputedPTS;
+  std::optional<LLVMAliasSetData> PrecomputedPTS;
   AliasAnalysisType PTATy{};
   bool AllowLazyPTS{};
 
   // ICF
-  std::optional<nlohmann::json> PrecomputedCG;
+  std::optional<CallGraphData> PrecomputedCG;
   std::vector<std::string> EntryPoints;
   CallGraphAnalysisType CGTy{};
   Soundness SoundnessLevel{};

include/phasar/PhasarLLVM/HelperAnalysisConfig.h

@@ -11,17 +11,17 @@
 #define PHASAR_PHASARLLVM_HELPERANALYSISCONFIG_H
 
 #include "phasar/ControlFlow/CallGraphAnalysisType.h"
+#include "phasar/ControlFlow/CallGraphData.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasSetData.h"
 #include "phasar/Pointer/AliasAnalysisType.h"
 #include "phasar/Utils/Soundness.h"
 
-#include "nlohmann/json.hpp"
-
 #include <optional>
 
 namespace psr {
 struct HelperAnalysisConfig {
-  std::optional<nlohmann::json> PrecomputedPTS = std::nullopt;
-  std::optional<nlohmann::json> PrecomputedCG = std::nullopt;
+  std::optional<LLVMAliasSetData> PrecomputedPTS = std::nullopt;
+  std::optional<CallGraphData> PrecomputedCG = std::nullopt;
   AliasAnalysisType PTATy = AliasAnalysisType::CFLAnders;
   CallGraphAnalysisType CGTy = CallGraphAnalysisType::OTF;
   Soundness SoundnessLevel = Soundness::Soundy;
@@ -31,7 +31,7 @@ struct HelperAnalysisConfig {
   /// existing llvm::Module
   bool PreprocessExistingModule = true;
 
-  HelperAnalysisConfig &&withCGType(CallGraphAnalysisType CGTy) &&noexcept {
+  HelperAnalysisConfig &&withCGType(CallGraphAnalysisType CGTy) && noexcept {
     this->CGTy = CGTy;
     return std::move(*this);
   }

include/phasar/PhasarLLVM/Pointer/LLVMAliasSet.h

@@ -63,7 +63,7 @@ class LLVMAliasSet : public AnalysisPropertiesMixin<LLVMAliasSet>,
 
   /// Loads alias sets from JSON
   explicit LLVMAliasSet(LLVMProjectIRDB *IRDB,
-                        const nlohmann::json &SerializedPTS);
+                        const LLVMAliasSetData &SerializedPTS);
 
   [[nodiscard]] inline bool isInterProcedural() const noexcept {
     return false;

lib/AnalysisStrategy/Strategies.cpp

@@ -10,6 +10,7 @@
 #include "phasar/AnalysisStrategy/Strategies.h"
 
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace psr {
@@ -24,6 +25,7 @@ std::string toString(const AnalysisStrategy &S) {
   case AnalysisStrategy::None:
     return "None";
   }
+  llvm_unreachable("All alternatives should be handled by the switch above");
 }
 
 AnalysisStrategy toAnalysisStrategy(llvm::StringRef S) {

lib/ControlFlow/CallGraphAnalysisType.cpp

@@ -21,6 +21,7 @@ std::string psr::toString(CallGraphAnalysisType CGA) {
   case CallGraphAnalysisType::Invalid:
     return "Invalid";
   }
+  llvm_unreachable("All alternatives should be handled by the switch above");
 }
 
 psr::CallGraphAnalysisType psr::toCallGraphAnalysisType(llvm::StringRef S) {

lib/PhasarLLVM/ControlFlow/SparseLLVMBasedICFG.cpp

@@ -1,5 +1,6 @@
 #include "phasar/PhasarLLVM/ControlFlow/SparseLLVMBasedICFG.h"
 
+#include "phasar/ControlFlow/CallGraphData.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
 
 #include "SVFGCache.h"
@@ -32,7 +33,7 @@ SparseLLVMBasedICFG::SparseLLVMBasedICFG(CallGraph<n_t, f_t> CG,
       AliasAnalysis(PT) {}
 
 SparseLLVMBasedICFG::SparseLLVMBasedICFG(LLVMProjectIRDB *IRDB,
-                                         const nlohmann::json &SerializedCG,
+                                         const CallGraphData &SerializedCG,
                                          LLVMAliasInfoRef PT)
     : LLVMBasedICFG(IRDB, SerializedCG), SparseCFGCache(new SVFGCache{}),
       AliasAnalysis(PT) {}

lib/PhasarLLVM/DataFlow/IfdsIde/Problems/IDEFeatureTaintAnalysis.cpp

@@ -357,11 +357,11 @@ struct IDEFeatureTaintAnalysis::GenerateEF {
     llvm::report_fatal_error("Implemented in 'combine'");
   }
 
-  constexpr friend bool operator==(const GenerateEF &L, const GenerateEF &R) {
+  friend bool operator==(const GenerateEF &L, const GenerateEF &R) {
     return L.Facts == R.Facts;
   }
 
-  constexpr friend llvm::hash_code hash_value(const GenerateEF &EF) {
+  friend llvm::hash_code hash_value(const GenerateEF &EF) {
     return hash_value(EF.Facts);
   }
 };