Union-Find Alias Analyses

.github/workflows/ci.yml

@@ -51,7 +51,7 @@ jobs:
       - name: ccache  # This should always come after the actions/checkout step.
         uses: hendrikmuhs/ccache-action@v1.2
         with:
-          key: ${{ github.job }}-${{ matrix.os }}-${{ matrix.build }}
+          key: ${{ github.job }}-${{ matrix.os }}-llvm${{ matrix.llvm-version }}-${{ matrix.build }}
 
       - name: Install Phasar Dependencies
         shell: bash

.github/workflows/deploy-docs.yml

@@ -8,6 +8,7 @@ permissions:
   contents: write
 jobs:
   build-and-deploy:
+    if: github.repository == 'secure-software-engineering/phasar'
     runs-on: ubuntu-24.04
     strategy:
       fail-fast: true

BreakingChanges.md

@@ -2,6 +2,8 @@
 
 ## development HEAD
 
+- The function `HelperAnalyses::getAliasInfo()` no longer returns a `LLVMAliasSet &`, but a `LLVMAliasInfoRef`.
+- The location of the library summary `FunctionDataFlowFacts` and `LLVMFunctionDataFlowFacts` has moved to `phasar/Utils/` and `phasar/PhasarLLVM/Utils`, respectively.
 - `IDESolver::initialize()` does no longer return a `bool`. Now, you are always allowed to call `next()` at least once.
 - `IntraMonoProblem` and `InterMonoProblem`, and all reference-implementations of these problems do not receive a TypeHierarchy-pointer anymore in the ctor.
 - Requiring C++20 instead of C++17

CMakeLists.txt

@@ -410,7 +410,7 @@ if (PHASAR_ENABLE_WARNINGS)
   if (MSVC)
     string(APPEND CMAKE_CXX_FLAGS " /W4")
   else()
-    string(APPEND CMAKE_CXX_FLAGS " -Wall -Wextra -Wno-unused-parameter")
+    string(APPEND CMAKE_CXX_FLAGS " -Wall -Wextra -Wno-unused-parameter -Werror=return-type")
   endif()
 endif (PHASAR_ENABLE_WARNINGS)
 

include/phasar/ControlFlow/CallGraphBase.h

@@ -12,8 +12,14 @@
 
 #include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/CRTPUtils.h"
+#include "phasar/Utils/Compressor.h"
+#include "phasar/Utils/GraphTraits.h"
+#include "phasar/Utils/IotaIterator.h"
+#include "phasar/Utils/NonNullPtr.h"
 #include "phasar/Utils/TypeTraits.h"
 
+#include "llvm/ADT/STLExtras.h"
+
 #include <concepts>
 #include <type_traits>
 
@@ -127,6 +133,92 @@ template <typename Derived> class CallGraphBase : public CRTPBase<Derived> {
 
   [[nodiscard]] constexpr bool empty() const noexcept { return size() == 0; }
 };
+
+/// A view over a call-graph that implements psr::GraphTraits on the
+/// getCallersOf() relation.
+/// Useful to compute CG-SCCs.
+template <typename CallGraphTy, typename DB> class ReverseCGGraph {
+  static constexpr bool NeedsMapping = !IdType<typename CallGraphTy::f_t>;
+
+  enum class FunctionIdImpl : uint32_t {};
+
+public:
+  using FunctionId = std::conditional_t<NeedsMapping, FunctionIdImpl,
+                                        typename CallGraphTy::f_t>;
+
+  constexpr ReverseCGGraph(
+      NonNullPtr<const CallGraphTy> CGView, NonNullPtr<const DB> IRDB,
+      Compressor<typename CallGraphTy::f_t, FunctionId> FC) noexcept
+    requires(NeedsMapping)
+      : CGView(CGView), IRDB(IRDB), FC(std::move(FC)) {}
+
+  constexpr ReverseCGGraph(NonNullPtr<const CallGraphTy> CGView,
+                           NonNullPtr<const DB> IRDB) noexcept
+      : CGView(CGView), IRDB(IRDB) {
+    FC.reserve(CGView->getNumVertexFunctions());
+    for (const auto &Fun : CGView->getAllVertexFunctions()) {
+      FC.insert(Fun);
+    }
+  }
+
+  NonNullPtr<const CallGraphTy> CGView;
+  NonNullPtr<const DB> IRDB;
+  [[no_unique_address]] std::conditional_t<
+      NeedsMapping, Compressor<typename CallGraphTy::f_t, FunctionId>,
+      NoneCompressor> FC{};
+};
+
+template <typename CallGraphTy, typename DB>
+ReverseCGGraph(NonNullPtr<const CallGraphTy>, NonNullPtr<const DB>)
+    -> ReverseCGGraph<CallGraphTy, DB>;
+template <typename CallGraphTy, typename DB>
+ReverseCGGraph(const CallGraphTy *, const DB *)
+    -> ReverseCGGraph<CallGraphTy, DB>;
+
+template <typename CallGraphTy, typename DB>
+struct GraphTraits<ReverseCGGraph<CallGraphTy, DB>> {
+  using graph_type = ReverseCGGraph<CallGraphTy, DB>;
+  using value_type = typename CallGraphTy::f_t;
+  using vertex_t = typename graph_type::FunctionId;
+  using edge_t = vertex_t;
+
+  static constexpr vertex_t Invalid = vertex_t(UINT32_MAX);
+
+  static constexpr auto mapToFunction(const graph_type &G) {
+    return [&G](ByConstRef<typename CallGraphTy::n_t> Inst) {
+      const auto &Fun = G.IRDB->getFunctionOf(Inst);
+      return G.FC.getOrNull(Fun).value();
+    };
+  }
+
+  static constexpr auto outEdges(const graph_type &G, vertex_t Vtx) {
+    return llvm::map_range(G.CGView->getCallersOf(G.FC[Vtx]), mapToFunction(G));
+  }
+
+  static constexpr decltype(auto) nodes(const graph_type &G) {
+    return G.CGView->getAllVertexFunctions();
+  }
+
+  // TODO: Roots
+
+  static constexpr auto vertices(const graph_type &G) {
+    return iota<vertex_t>(G.CGView->getNumVertexFunctions());
+  }
+
+  static constexpr decltype(auto) node(const graph_type &G, vertex_t Vtx) {
+    return G.FC[Vtx];
+  }
+
+  static constexpr size_t size(const graph_type &G) {
+    return G.CGView->getNumVertexFunctions();
+  }
+
+  static constexpr vertex_t target(edge_t Edge) { return Edge; }
+  static constexpr vertex_t withEdgeTarget(edge_t /*Edge*/, vertex_t Vtx) {
+    return Vtx;
+  }
+};
+
 } // namespace psr
 
 #endif // PHASAR_CONTROLFLOW_CALLGRAPHBASE_H

include/phasar/DB/ProjectIRDBBase.h

@@ -10,6 +10,7 @@
 #ifndef PHASAR_DB_PROJECTIRDBBASE_H
 #define PHASAR_DB_PROJECTIRDBBASE_H
 
+#include "phasar/Utils/ByRef.h"
 #include "phasar/Utils/Nullable.h"
 #include "phasar/Utils/TypeTraits.h"
 
@@ -84,6 +85,13 @@ class LLVM_DEPRECATED(
     return self().hasFunctionImpl(FunctionName);
   }
 
+  /// Returns the function that contains the given instruction Inst.
+  /// Each instruction must be part of a function.
+  [[nodiscard]] f_t getFunctionOf(ByConstRef<n_t> Inst) const {
+    assert(isValid());
+    return self().getFunctionOfImpl(Inst);
+  }
+
   /// Returns the global variable if available, nullptr/nullopt
   /// otherwise.
   [[nodiscard]] Nullable<g_t>

include/phasar/DataFlow/IfdsIde/Solver/Compressor.h

@@ -9,27 +9,6 @@
 
 namespace psr {
 
-struct NoneCompressor final {
-  constexpr NoneCompressor() noexcept = default;
-
-  template <typename T>
-    requires(!std::is_same_v<NoneCompressor, T>)
-  constexpr NoneCompressor(const T & /*unused*/) noexcept {}
-
-  template <typename T>
-  [[nodiscard]] decltype(auto) getOrInsert(T &&Val) const noexcept {
-    return std::forward<T>(Val);
-  }
-  template <typename T>
-  [[nodiscard]] decltype(auto) operator[](T &&Val) const noexcept {
-    return std::forward<T>(Val);
-  }
-  void reserve(size_t /*unused*/) const noexcept {}
-
-  [[nodiscard]] size_t size() const noexcept { return 0; }
-  [[nodiscard]] size_t capacity() const noexcept { return 0; }
-};
-
 class LLVMProjectIRDB;
 
 /// Once we have fast instruction IDs (as we already have in IntelliSecPhasar),

include/phasar/PhasarLLVM/ControlFlow/VTA/TypePropagator.h

@@ -11,6 +11,7 @@
 #define PHASAR_PHASARLLVM_CONTROLFLOW_TYPEPROPAGATOR_H
 
 #include "phasar/PhasarLLVM/ControlFlow/VTA/TypeAssignmentGraph.h"
+#include "phasar/Utils/SCCId.h"
 #include "phasar/Utils/TypedVector.h"
 
 #include "llvm/ADT/DenseSet.h"
@@ -22,7 +23,6 @@ class Value;
 } // namespace llvm
 
 namespace psr {
-template <typename GraphNodeId> struct SCCId;
 template <typename GraphNodeId> struct SCCHolder;
 template <typename GraphNodeId> struct SCCDependencyGraph;
 template <typename GraphNodeId> struct SCCOrder;

include/phasar/PhasarLLVM/DB/LLVMProjectIRDB.h

@@ -189,6 +189,11 @@ class LLVMProjectIRDB : public ProjectIRDBBase<LLVMProjectIRDB> {
   hasFunctionImpl(llvm::StringRef FunctionName) const noexcept {
     return Mod->getFunction(FunctionName) != nullptr;
   }
+  [[nodiscard]] f_t getFunctionOfImpl(n_t Inst) const {
+    assert(Inst != nullptr);
+    return Inst->getFunction();
+  }
+
   [[nodiscard]] g_t
   getGlobalVariableImpl(llvm::StringRef GlobalVariableName) const;
   [[nodiscard]] g_t

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

@@ -13,9 +13,9 @@
 #include "phasar/DataFlow/IfdsIde/IFDSTabulationProblem.h"
 #include "phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h"
 #include "phasar/PhasarLLVM/DB/LLVMProjectIRDB.h"
-#include "phasar/PhasarLLVM/DataFlow/IfdsIde/LLVMFunctionDataFlowFacts.h"
 #include "phasar/PhasarLLVM/Domain/LLVMAnalysisDomain.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
+#include "phasar/PhasarLLVM/Utils/LLVMFunctionDataFlowFacts.h"
 
 #include <map>
 #include <set>

include/phasar/PhasarLLVM/HelperAnalyses.h

@@ -13,7 +13,9 @@
 #include "phasar/ControlFlow/CallGraphAnalysisType.h"
 #include "phasar/ControlFlow/CallGraphData.h"
 #include "phasar/PhasarLLVM/HelperAnalysisConfig.h"
+#include "phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSetData.h"
+#include "phasar/Pointer/UnionFindAliasAnalysisType.h"
 
 #include "llvm/ADT/Twine.h"
 
@@ -60,14 +62,14 @@ class HelperAnalyses { // NOLINT(cppcoreguidelines-special-member-functions)
   ~HelperAnalyses() noexcept;
 
   [[nodiscard]] LLVMProjectIRDB &getProjectIRDB();
-  [[nodiscard]] LLVMAliasSet &getAliasInfo();
+  [[nodiscard]] LLVMAliasInfoRef getAliasInfo();
   [[nodiscard]] DIBasedTypeHierarchy &getTypeHierarchy();
   [[nodiscard]] LLVMBasedICFG &getICFG();
   [[nodiscard]] LLVMBasedCFG &getCFG();
 
 private:
   std::unique_ptr<LLVMProjectIRDB> IRDB;
-  std::unique_ptr<LLVMAliasSet> PT;
+  LLVMAliasInfo PT{};
   std::unique_ptr<DIBasedTypeHierarchy> TH;
   std::unique_ptr<LLVMBasedICFG> ICF;
   std::unique_ptr<LLVMBasedCFG> CFG;
@@ -78,6 +80,7 @@ class HelperAnalyses { // NOLINT(cppcoreguidelines-special-member-functions)
   // PTS
   std::optional<LLVMAliasSetData> PrecomputedPTS;
   AliasAnalysisType PTATy{};
+  UnionFindAliasAnalysisType UFAATy{};
   bool AllowLazyPTS{};
 
   // ICF

include/phasar/PhasarLLVM/HelperAnalysisConfig.h

@@ -14,6 +14,7 @@
 #include "phasar/ControlFlow/CallGraphData.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMAliasSetData.h"
 #include "phasar/Pointer/AliasAnalysisType.h"
+#include "phasar/Pointer/UnionFindAliasAnalysisType.h"
 #include "phasar/Utils/Soundness.h"
 
 #include <optional>
@@ -23,6 +24,7 @@ struct HelperAnalysisConfig {
   std::optional<LLVMAliasSetData> PrecomputedPTS = std::nullopt;
   std::optional<CallGraphData> PrecomputedCG = std::nullopt;
   AliasAnalysisType PTATy = AliasAnalysisType::CFLAnders;
+  UnionFindAliasAnalysisType UFAATy = UnionFindAliasAnalysisType::CtxIndSens;
   CallGraphAnalysisType CGTy = CallGraphAnalysisType::OTF;
   Soundness SoundnessLevel = Soundness::Soundy;
   bool AutoGlobalSupport = true;

include/phasar/PhasarLLVM/Pointer/LLVMAliasInfo.h

@@ -24,6 +24,11 @@ namespace psr {
 using LLVMAliasIteratorRef =
     AliasIteratorRef<const llvm::Value *, const llvm::Instruction *>;
 
+template <typename T>
+concept IsLLVMAliasIterator =
+    detail::IsAliasIteratorFor<T, const llvm::Value *,
+                               const llvm::Instruction *>;
+
 using LLVMAliasInfoRef =
     AliasInfoRef<const llvm::Value *, const llvm::Instruction *>;