GCC Compatibility (#787)

* Make phasar compile with gcc (g++-11) and uncover (and fix) two bugs related to json ser/de with LLVMAliasSet and LLVMBasedICFG that were not detected untio now, because of nlohmann's implicit conversions feature

* Address review comments

* Simplify isLLVMZeroValue according to the discussion in #787

Author: fabianbs96

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);