[Analysis][EphemeralValuesCache] Adds an ephemeral values cache analysis pass

This analysis pass collects the ephemeral values of a function and caches them
for fast lookups. The collection of the ephemeral values is done lazily when
the user calls `EphemeralValuesCache::ephValues()`.

Author: Vasileios Porpodas

llvm/include/llvm/Analysis/EphemeralValuesCache.h

@@ -0,0 +1,59 @@
+//===- llvm/Analysis/EphemeralValuesCache.h ---------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass caches ephemeral values, i.e., values that are only used by
+// @llvm.assume intrinsics, for cheap access after the initial collection.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_EPHEMERALVALUESCACHE_H
+#define LLVM_ANALYSIS_EPHEMERALVALUESCACHE_H
+
+#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/Analysis/AssumptionCache.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class Function;
+
+/// A cache of ephemeral values within a function.
+class EphemeralValuesCache {
+  SmallPtrSet<const Value *, 32> EphValues;
+  Function &F;
+  AssumptionCache &AC;
+  bool Collected = false;
+
+  void collectEphemeralValues();
+
+public:
+  EphemeralValuesCache(Function &F, AssumptionCache &AC) : F(F), AC(AC) {}
+  void clear() {
+    EphValues.clear();
+    Collected = false;
+  }
+  const SmallPtrSetImpl<const Value *> &ephValues() {
+    if (!Collected)
+      collectEphemeralValues();
+    return EphValues;
+  }
+};
+
+class EphemeralValuesAnalysis
+    : public AnalysisInfoMixin<EphemeralValuesAnalysis> {
+  friend AnalysisInfoMixin<EphemeralValuesAnalysis>;
+  static AnalysisKey Key;
+
+public:
+  using Result = EphemeralValuesCache;
+  Result run(Function &F, FunctionAnalysisManager &FAM);
+};
+
+} // namespace llvm
+
+#endif // LLVM_ANALYSIS_EPHEMERALVALUESCACHE_H

llvm/lib/Analysis/CMakeLists.txt

@@ -62,6 +62,7 @@ add_llvm_component_library(LLVMAnalysis
   DominanceFrontier.cpp
   DXILResource.cpp
   DXILMetadataAnalysis.cpp
+  EphemeralValuesCache.cpp
   FunctionPropertiesAnalysis.cpp
   GlobalsModRef.cpp
   GuardUtils.cpp

llvm/lib/Analysis/EphemeralValuesCache.cpp

@@ -0,0 +1,28 @@
+//===- EphemeralValuesCache.cpp - Cache collecting ephemeral values -------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Analysis/EphemeralValuesCache.h"
+#include "llvm/Analysis/AssumptionCache.h"
+#include "llvm/Analysis/CodeMetrics.h"
+
+namespace llvm {
+
+void EphemeralValuesCache::collectEphemeralValues() {
+  CodeMetrics::collectEphemeralValues(&F, &AC, EphValues);
+  Collected = true;
+}
+
+AnalysisKey EphemeralValuesAnalysis::Key;
+
+EphemeralValuesCache
+EphemeralValuesAnalysis::run(Function &F, FunctionAnalysisManager &FAM) {
+  auto &AC = FAM.getResult<AssumptionAnalysis>(F);
+  return EphemeralValuesCache(F, AC);
+}
+
+} // namespace llvm

llvm/lib/Passes/PassBuilder.cpp

@@ -39,6 +39,7 @@
 #include "llvm/Analysis/DependenceAnalysis.h"
 #include "llvm/Analysis/DomPrinter.h"
 #include "llvm/Analysis/DominanceFrontier.h"
+#include "llvm/Analysis/EphemeralValuesCache.h"
 #include "llvm/Analysis/FunctionPropertiesAnalysis.h"
 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/IRSimilarityIdentifier.h"

llvm/lib/Passes/PassRegistry.def

@@ -290,6 +290,7 @@ FUNCTION_ANALYSIS("debug-ata", DebugAssignmentTrackingAnalysis())
 FUNCTION_ANALYSIS("demanded-bits", DemandedBitsAnalysis())
 FUNCTION_ANALYSIS("domfrontier", DominanceFrontierAnalysis())
 FUNCTION_ANALYSIS("domtree", DominatorTreeAnalysis())
+FUNCTION_ANALYSIS("ephemerals", EphemeralValuesAnalysis())
 FUNCTION_ANALYSIS("func-properties", FunctionPropertiesAnalysis())
 FUNCTION_ANALYSIS("machine-function-info", MachineFunctionAnalysis(TM))
 FUNCTION_ANALYSIS("gc-function", GCFunctionAnalysis())

llvm/unittests/Analysis/CMakeLists.txt

@@ -27,6 +27,7 @@ set(ANALYSIS_TEST_SOURCES
   DDGTest.cpp
   DomTreeUpdaterTest.cpp
   DXILResourceTest.cpp
+  EphemeralValuesCacheTest.cpp
   GraphWriterTest.cpp
   GlobalsModRefTest.cpp
   FunctionPropertiesAnalysisTest.cpp

llvm/unittests/Analysis/EphemeralValuesCacheTest.cpp

@@ -0,0 +1,74 @@
+//===--- EphemeralValuesCache.cpp -----------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Analysis/EphemeralValuesCache.h"
+#include "llvm/Analysis/AssumptionCache.h"
+#include "llvm/AsmParser/Parser.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/SourceMgr.h"
+#include "gmock/gmock-matchers.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+namespace {
+
+struct EphemeralValuesCacheTest : public testing::Test {
+  LLVMContext Ctx;
+  std::unique_ptr<Module> M;
+
+  void parseIR(const char *Assembly) {
+    SMDiagnostic Error;
+    M = parseAssemblyString(Assembly, Error, Ctx);
+    if (!M)
+      Error.print("EphemeralValuesCacheTest", errs());
+  }
+};
+
+TEST_F(EphemeralValuesCacheTest, basic) {
+  parseIR(R"IR(
+declare void @llvm.assume(i1)
+
+define void @foo(i8 %arg0, i8 %arg1) {
+  %c0 = icmp eq i8 %arg0, 0
+  call void @llvm.assume(i1 %c0)
+  call void @foo(i8 %arg0, i8 %arg1)
+  %c1 = icmp eq i8 %arg1, 0
+  call void @llvm.assume(i1 %c1)
+  ret void
+}
+)IR");
+  Function *F = M->getFunction("foo");
+  auto *BB = &*F->begin();
+  AssumptionCache AC(*F);
+  EphemeralValuesCache EVC(*F, AC);
+  auto It = BB->begin();
+  auto *C0 = &*It++;
+  auto *Assume0 = &*It++;
+  [[maybe_unused]] auto *NotEph = &*It++;
+  auto *C1 = &*It++;
+  auto *Assume1 = &*It++;
+  [[maybe_unused]] auto *Ret = &*It++;
+  // Check emphemeral values.
+  EXPECT_THAT(EVC.ephValues(),
+              testing::UnorderedElementsAre(C0, Assume0, C1, Assume1));
+  // Clear the cache and try again.
+  EVC.clear();
+  EXPECT_THAT(EVC.ephValues(),
+              testing::UnorderedElementsAre(C0, Assume0, C1, Assume1));
+  // Modify the IR, clear cache and recompute.
+  Assume1->eraseFromParent();
+  C1->eraseFromParent();
+  EXPECT_THAT(EVC.ephValues(),
+              testing::UnorderedElementsAre(C0, Assume0, C1, Assume1));
+  EVC.clear();
+  EXPECT_THAT(EVC.ephValues(), testing::UnorderedElementsAre(C0, Assume0));
+}
+
+} // namespace