[llvm-branch-commits] [llvm] cee0873 - Revert "[SandboxVectorizer] Use sbvec-passes flag to create a pipeline of Reg…"
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Wed Oct 9 10:44:22 PDT 2024
Author: Jorge Gorbe Moya
Date: 2024-10-09T10:44:19-07:00
New Revision: cee0873fc83beb441a27b1f0555da54e56aa0910
URL: https://github.com/llvm/llvm-project/commit/cee0873fc83beb441a27b1f0555da54e56aa0910
DIFF: https://github.com/llvm/llvm-project/commit/cee0873fc83beb441a27b1f0555da54e56aa0910.diff
LOG: Revert "[SandboxVectorizer] Use sbvec-passes flag to create a pipeline of Reg…"
This reverts commit 10ada4ae738b9d93174e516ca841e61a8f4fd612.
Added:
Modified:
llvm/include/llvm/SandboxIR/PassManager.h
llvm/include/llvm/Transforms/Vectorize/SandboxVectorizer/Passes/BottomUpVec.h
llvm/include/llvm/Transforms/Vectorize/SandboxVectorizer/SandboxVectorizer.h
llvm/lib/SandboxIR/PassManager.cpp
llvm/lib/Transforms/Vectorize/SandboxVectorizer/Passes/BottomUpVec.cpp
llvm/lib/Transforms/Vectorize/SandboxVectorizer/SandboxVectorizer.cpp
llvm/test/Transforms/SandboxVectorizer/default_pass_pipeline.ll
llvm/test/Transforms/SandboxVectorizer/user_pass_pipeline.ll
llvm/unittests/SandboxIR/PassTest.cpp
Removed:
llvm/include/llvm/Transforms/Vectorize/SandboxVectorizer/Passes/NullPass.h
llvm/lib/Transforms/Vectorize/SandboxVectorizer/Passes/PassRegistry.def
################################################################################
diff --git a/llvm/include/llvm/SandboxIR/PassManager.h b/llvm/include/llvm/SandboxIR/PassManager.h
index 247c43615f5766..54192c6bf1333b 100644
--- a/llvm/include/llvm/SandboxIR/PassManager.h
+++ b/llvm/include/llvm/SandboxIR/PassManager.h
@@ -18,8 +18,6 @@
#ifndef LLVM_SANDBOXIR_PASSMANAGER_H
#define LLVM_SANDBOXIR_PASSMANAGER_H
-#include <memory>
-
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/SandboxIR/Pass.h"
@@ -34,65 +32,25 @@ template <typename ParentPass, typename ContainedPass>
class PassManager : public ParentPass {
protected:
/// The list of passes that this pass manager will run.
- SmallVector<std::unique_ptr<ContainedPass>> Passes;
+ SmallVector<ContainedPass *> Passes;
PassManager(StringRef Name) : ParentPass(Name) {}
PassManager(const PassManager &) = delete;
- PassManager(PassManager &&) = default;
virtual ~PassManager() = default;
PassManager &operator=(const PassManager &) = delete;
public:
/// Adds \p Pass to the pass pipeline.
- void addPass(std::unique_ptr<ContainedPass> Pass) {
+ void addPass(ContainedPass *Pass) {
// TODO: Check that Pass's class type works with this PassManager type.
- Passes.push_back(std::move(Pass));
- }
-
- using CreatePassFunc =
- std::function<std::unique_ptr<ContainedPass>(StringRef)>;
-
- /// Parses \p Pipeline as a comma-separated sequence of pass names and sets
- /// the pass pipeline, using \p CreatePass to instantiate passes by name.
- ///
- /// After calling this function, the PassManager contains only the specified
- /// pipeline, any previously added passes are cleared.
- void setPassPipeline(StringRef Pipeline, CreatePassFunc CreatePass) {
- static constexpr const char EndToken = '\0';
- static constexpr const char PassDelimToken = ',';
-
- assert(Passes.empty() &&
- "setPassPipeline called on a non-empty sandboxir::PassManager");
- // Add EndToken to the end to ease parsing.
- std::string PipelineStr = std::string(Pipeline) + EndToken;
- int FlagBeginIdx = 0;
-
- for (auto [Idx, C] : enumerate(PipelineStr)) {
- // Keep moving Idx until we find the end of the pass name.
- bool FoundDelim = C == EndToken || C == PassDelimToken;
- if (!FoundDelim)
- continue;
- unsigned Sz = Idx - FlagBeginIdx;
- std::string PassName(&PipelineStr[FlagBeginIdx], Sz);
- FlagBeginIdx = Idx + 1;
-
- // Get the pass that corresponds to PassName and add it to the pass
- // manager.
- auto Pass = CreatePass(PassName);
- if (Pass == nullptr) {
- errs() << "Pass '" << PassName << "' not registered!\n";
- exit(1);
- }
- addPass(std::move(Pass));
- }
+ Passes.push_back(Pass);
}
-
#ifndef NDEBUG
void print(raw_ostream &OS) const override {
OS << this->getName();
OS << "(";
// TODO: This should call Pass->print(OS) because Pass may be a PM.
- interleave(Passes, OS, [&OS](auto &Pass) { OS << Pass->getName(); }, ",");
+ interleave(Passes, OS, [&OS](auto *Pass) { OS << Pass->getName(); }, ",");
OS << ")";
}
LLVM_DUMP_METHOD void dump() const override {
@@ -121,6 +79,38 @@ class RegionPassManager final : public PassManager<RegionPass, RegionPass> {
bool runOnRegion(Region &R) final;
};
+/// Owns the passes and provides an API to get a pass by its name.
+class PassRegistry {
+ SmallVector<std::unique_ptr<Pass>, 8> Passes;
+ DenseMap<StringRef, Pass *> NameToPassMap;
+
+public:
+ static constexpr const char PassDelimToken = ',';
+ PassRegistry() = default;
+ /// Registers \p PassPtr and takes ownership.
+ Pass ®isterPass(std::unique_ptr<Pass> &&PassPtr) {
+ auto &PassRef = *PassPtr.get();
+ NameToPassMap[PassRef.getName()] = &PassRef;
+ Passes.push_back(std::move(PassPtr));
+ return PassRef;
+ }
+ /// \Returns the pass with name \p Name, or null if not registered.
+ Pass *getPassByName(StringRef Name) const {
+ auto It = NameToPassMap.find(Name);
+ return It != NameToPassMap.end() ? It->second : nullptr;
+ }
+ /// Creates a pass pipeline and returns the first pass manager.
+ FunctionPassManager &parseAndCreatePassPipeline(StringRef Pipeline);
+
+#ifndef NDEBUG
+ void print(raw_ostream &OS) const {
+ for (const auto &PassPtr : Passes)
+ OS << PassPtr->getName() << "\n";
+ }
+ LLVM_DUMP_METHOD void dump() const;
+#endif
+};
+
} // namespace llvm::sandboxir
#endif // LLVM_SANDBOXIR_PASSMANAGER_H
diff --git a/llvm/include/llvm/Transforms/Vectorize/SandboxVectorizer/Passes/BottomUpVec.h b/llvm/include/llvm/Transforms/Vectorize/SandboxVectorizer/Passes/BottomUpVec.h
index 02abdf0a1ef0df..a2108f07c28e50 100644
--- a/llvm/include/llvm/Transforms/Vectorize/SandboxVectorizer/Passes/BottomUpVec.h
+++ b/llvm/include/llvm/Transforms/Vectorize/SandboxVectorizer/Passes/BottomUpVec.h
@@ -15,24 +15,18 @@
#include "llvm/ADT/ArrayRef.h"
#include "llvm/SandboxIR/Constant.h"
#include "llvm/SandboxIR/Pass.h"
-#include "llvm/SandboxIR/PassManager.h"
#include "llvm/Transforms/Vectorize/SandboxVectorizer/Legality.h"
namespace llvm::sandboxir {
-class RegionPassManager;
-
class BottomUpVec final : public FunctionPass {
bool Change = false;
LegalityAnalysis Legality;
void vectorizeRec(ArrayRef<Value *> Bndl);
void tryVectorize(ArrayRef<Value *> Seeds);
- // The PM containing the pipeline of region passes.
- RegionPassManager RPM;
-
public:
- BottomUpVec();
+ BottomUpVec() : FunctionPass("bottom-up-vec") {}
bool runOnFunction(Function &F) final;
};
diff --git a/llvm/include/llvm/Transforms/Vectorize/SandboxVectorizer/Passes/NullPass.h b/llvm/include/llvm/Transforms/Vectorize/SandboxVectorizer/Passes/NullPass.h
deleted file mode 100644
index 75b9f42520156c..00000000000000
--- a/llvm/include/llvm/Transforms/Vectorize/SandboxVectorizer/Passes/NullPass.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#ifndef LLVM_TRANSFORMS_VECTORIZE_SANDBOXVECTORIZER_PASSES_NULLPASS_H
-#define LLVM_TRANSFORMS_VECTORIZE_SANDBOXVECTORIZER_PASSES_NULLPASS_H
-
-#include "llvm/SandboxIR/Pass.h"
-
-namespace llvm::sandboxir {
-
-class Region;
-
-/// A Region pass that does nothing, for use as a placeholder in tests.
-class NullPass final : public RegionPass {
-public:
- NullPass() : RegionPass("null") {}
- bool runOnRegion(Region &R) final { return false; }
-};
-
-} // namespace llvm::sandboxir
-
-#endif // LLVM_TRANSFORMS_VECTORIZE_SANDBOXVECTORIZER_PASSES_NULLPASS_H
diff --git a/llvm/include/llvm/Transforms/Vectorize/SandboxVectorizer/SandboxVectorizer.h b/llvm/include/llvm/Transforms/Vectorize/SandboxVectorizer/SandboxVectorizer.h
index 1dcd976bf751c5..dd9f02d3272643 100644
--- a/llvm/include/llvm/Transforms/Vectorize/SandboxVectorizer/SandboxVectorizer.h
+++ b/llvm/include/llvm/Transforms/Vectorize/SandboxVectorizer/SandboxVectorizer.h
@@ -8,10 +8,7 @@
#ifndef LLVM_TRANSFORMS_VECTORIZE_SANDBOXVECTORIZER_SANDBOXVECTORIZER_H
#define LLVM_TRANSFORMS_VECTORIZE_SANDBOXVECTORIZER_SANDBOXVECTORIZER_H
-#include <memory>
-
#include "llvm/IR/PassManager.h"
-#include "llvm/Transforms/Vectorize/SandboxVectorizer/Passes/BottomUpVec.h"
namespace llvm {
@@ -20,13 +17,10 @@ class TargetTransformInfo;
class SandboxVectorizerPass : public PassInfoMixin<SandboxVectorizerPass> {
TargetTransformInfo *TTI = nullptr;
- // The main vectorizer pass.
- sandboxir::BottomUpVec BottomUpVecPass;
-
- bool runImpl(Function &F);
-
public:
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+ bool runImpl(Function &F);
};
} // namespace llvm
diff --git a/llvm/lib/SandboxIR/PassManager.cpp b/llvm/lib/SandboxIR/PassManager.cpp
index 3a1cfa1d367a2a..95bc5e56bb3ec9 100644
--- a/llvm/lib/SandboxIR/PassManager.cpp
+++ b/llvm/lib/SandboxIR/PassManager.cpp
@@ -8,11 +8,11 @@
#include "llvm/SandboxIR/PassManager.h"
-namespace llvm::sandboxir {
+using namespace llvm::sandboxir;
bool FunctionPassManager::runOnFunction(Function &F) {
bool Change = false;
- for (auto &Pass : Passes) {
+ for (FunctionPass *Pass : Passes) {
Change |= Pass->runOnFunction(F);
// TODO: run the verifier.
}
@@ -22,7 +22,7 @@ bool FunctionPassManager::runOnFunction(Function &F) {
bool RegionPassManager::runOnRegion(Region &R) {
bool Change = false;
- for (auto &Pass : Passes) {
+ for (RegionPass *Pass : Passes) {
Change |= Pass->runOnRegion(R);
// TODO: run the verifier.
}
@@ -30,4 +30,40 @@ bool RegionPassManager::runOnRegion(Region &R) {
return Change;
}
-} // namespace llvm::sandboxir
+FunctionPassManager &
+PassRegistry::parseAndCreatePassPipeline(StringRef Pipeline) {
+ static constexpr const char EndToken = '\0';
+ // Add EndToken to the end to ease parsing.
+ std::string PipelineStr = std::string(Pipeline) + EndToken;
+ int FlagBeginIdx = 0;
+ // Start with a FunctionPassManager.
+ auto &InitialPM = static_cast<FunctionPassManager &>(
+ registerPass(std::make_unique<FunctionPassManager>("init-fpm")));
+
+ for (auto [Idx, C] : enumerate(PipelineStr)) {
+ // Keep moving Idx until we find the end of the pass name.
+ bool FoundDelim = C == EndToken || C == PassDelimToken;
+ if (!FoundDelim)
+ continue;
+ unsigned Sz = Idx - FlagBeginIdx;
+ std::string PassName(&PipelineStr[FlagBeginIdx], Sz);
+ FlagBeginIdx = Idx + 1;
+
+ // Get the pass that corresponds to PassName and add it to the pass manager.
+ auto *Pass = getPassByName(PassName);
+ if (Pass == nullptr) {
+ errs() << "Pass '" << PassName << "' not registered!\n";
+ exit(1);
+ }
+ // TODO: This is safe for now, but would require proper upcasting once we
+ // add more Pass sub-classes.
+ InitialPM.addPass(static_cast<FunctionPass *>(Pass));
+ }
+ return InitialPM;
+}
+#ifndef NDEBUG
+void PassRegistry::dump() const {
+ print(dbgs());
+ dbgs() << "\n";
+}
+#endif // NDEBUG
diff --git a/llvm/lib/Transforms/Vectorize/SandboxVectorizer/Passes/BottomUpVec.cpp b/llvm/lib/Transforms/Vectorize/SandboxVectorizer/Passes/BottomUpVec.cpp
index 77198f932a3ec0..c59abd09d43629 100644
--- a/llvm/lib/Transforms/Vectorize/SandboxVectorizer/Passes/BottomUpVec.cpp
+++ b/llvm/lib/Transforms/Vectorize/SandboxVectorizer/Passes/BottomUpVec.cpp
@@ -10,41 +10,10 @@
#include "llvm/ADT/SmallVector.h"
#include "llvm/SandboxIR/Function.h"
#include "llvm/SandboxIR/Instruction.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Transforms/Vectorize/SandboxVectorizer/Passes/NullPass.h"
-namespace llvm::sandboxir {
-
-static cl::opt<bool>
- PrintPassPipeline("sbvec-print-pass-pipeline", cl::init(false), cl::Hidden,
- cl::desc("Prints the pass pipeline and returns."));
-
-/// A magic string for the default pass pipeline.
-static const char *DefaultPipelineMagicStr = "*";
-
-static cl::opt<std::string> UserDefinedPassPipeline(
- "sbvec-passes", cl::init(DefaultPipelineMagicStr), cl::Hidden,
- cl::desc("Comma-separated list of vectorizer passes. If not set "
- "we run the predefined pipeline."));
-
-static std::unique_ptr<RegionPass> createRegionPass(StringRef Name) {
-#define REGION_PASS(NAME, CREATE_PASS) \
- if (Name == NAME) \
- return std::make_unique<decltype(CREATE_PASS)>(CREATE_PASS);
-#include "PassRegistry.def"
- return nullptr;
-}
-
-BottomUpVec::BottomUpVec() : FunctionPass("bottom-up-vec"), RPM("rpm") {
- // Create a pipeline to be run on each Region created by BottomUpVec.
- if (UserDefinedPassPipeline == DefaultPipelineMagicStr) {
- // TODO: Add default passes to RPM.
- } else {
- // Create the user-defined pipeline.
- RPM.setPassPipeline(UserDefinedPassPipeline, createRegionPass);
- }
-}
+using namespace llvm::sandboxir;
+namespace llvm::sandboxir {
// TODO: This is a temporary function that returns some seeds.
// Replace this with SeedCollector's function when it lands.
static llvm::SmallVector<Value *, 4> collectSeeds(BasicBlock &BB) {
@@ -65,6 +34,8 @@ static SmallVector<Value *, 4> getOperand(ArrayRef<Value *> Bndl,
return Operands;
}
+} // namespace llvm::sandboxir
+
void BottomUpVec::vectorizeRec(ArrayRef<Value *> Bndl) {
auto LegalityRes = Legality.canVectorize(Bndl);
switch (LegalityRes.getSubclassID()) {
@@ -82,23 +53,14 @@ void BottomUpVec::vectorizeRec(ArrayRef<Value *> Bndl) {
void BottomUpVec::tryVectorize(ArrayRef<Value *> Bndl) { vectorizeRec(Bndl); }
bool BottomUpVec::runOnFunction(Function &F) {
- if (PrintPassPipeline) {
- RPM.printPipeline(outs());
- return false;
- }
-
Change = false;
// TODO: Start from innermost BBs first
for (auto &BB : F) {
// TODO: Replace with proper SeedCollector function.
auto Seeds = collectSeeds(BB);
// TODO: Slice Seeds into smaller chunks.
- // TODO: If vectorization succeeds, run the RegionPassManager on the
- // resulting region.
if (Seeds.size() >= 2)
tryVectorize(Seeds);
}
return Change;
}
-
-} // namespace llvm::sandboxir
diff --git a/llvm/lib/Transforms/Vectorize/SandboxVectorizer/Passes/PassRegistry.def b/llvm/lib/Transforms/Vectorize/SandboxVectorizer/Passes/PassRegistry.def
deleted file mode 100644
index bbb0dcba1ea516..00000000000000
--- a/llvm/lib/Transforms/Vectorize/SandboxVectorizer/Passes/PassRegistry.def
+++ /dev/null
@@ -1,22 +0,0 @@
-//===- PassRegistry.def - Registry of passes --------------------*- 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 file is used as the registry of sub-passes that are part of the
-// SandboxVectorizer pass.
-//
-//===----------------------------------------------------------------------===//
-
-// NOTE: NO INCLUDE GUARD DESIRED!
-
-#ifndef REGION_PASS
-#define REGION_PASS(NAME, CREATE_PASS)
-#endif
-
-REGION_PASS("null", NullPass())
-
-#undef REGION_PASS
diff --git a/llvm/lib/Transforms/Vectorize/SandboxVectorizer/SandboxVectorizer.cpp b/llvm/lib/Transforms/Vectorize/SandboxVectorizer/SandboxVectorizer.cpp
index cbaf2b6288d928..80afcb499a2c22 100644
--- a/llvm/lib/Transforms/Vectorize/SandboxVectorizer/SandboxVectorizer.cpp
+++ b/llvm/lib/Transforms/Vectorize/SandboxVectorizer/SandboxVectorizer.cpp
@@ -9,6 +9,8 @@
#include "llvm/Transforms/Vectorize/SandboxVectorizer/SandboxVectorizer.h"
#include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/SandboxIR/Constant.h"
+#include "llvm/SandboxIR/PassManager.h"
+#include "llvm/Support/CommandLine.h"
#include "llvm/Transforms/Vectorize/SandboxVectorizer/Passes/BottomUpVec.h"
using namespace llvm;
@@ -16,6 +18,18 @@ using namespace llvm;
#define SV_NAME "sandbox-vectorizer"
#define DEBUG_TYPE SV_NAME
+cl::opt<bool>
+ PrintPassPipeline("sbvec-print-pass-pipeline", cl::init(false), cl::Hidden,
+ cl::desc("Prints the pass pipeline and returns."));
+
+/// A magic string for the default pass pipeline.
+const char *DefaultPipelineMagicStr = "*";
+
+cl::opt<std::string> UserDefinedPassPipeline(
+ "sbvec-passes", cl::init(DefaultPipelineMagicStr), cl::Hidden,
+ cl::desc("Comma-separated list of vectorizer passes. If not set "
+ "we run the predefined pipeline."));
+
PreservedAnalyses SandboxVectorizerPass::run(Function &F,
FunctionAnalysisManager &AM) {
TTI = &AM.getResult<TargetIRAnalysis>(F);
@@ -42,8 +56,31 @@ bool SandboxVectorizerPass::runImpl(Function &LLVMF) {
return false;
}
- // Create SandboxIR for LLVMF and run BottomUpVec on it.
sandboxir::Context Ctx(LLVMF.getContext());
+ // Create SandboxIR for `LLVMF`.
sandboxir::Function &F = *Ctx.createFunction(&LLVMF);
- return BottomUpVecPass.runOnFunction(F);
+ // Create the passes and register them with the PassRegistry.
+ sandboxir::PassRegistry PR;
+ auto &BottomUpVecPass = static_cast<sandboxir::FunctionPass &>(
+ PR.registerPass(std::make_unique<sandboxir::BottomUpVec>()));
+
+ sandboxir::FunctionPassManager *PM = nullptr;
+ if (UserDefinedPassPipeline == DefaultPipelineMagicStr) {
+ // Create the default pass pipeline.
+ PM = &static_cast<sandboxir::FunctionPassManager &>(PR.registerPass(
+ std::make_unique<sandboxir::FunctionPassManager>("pm")));
+ PM->addPass(&BottomUpVecPass);
+ } else {
+ // Create the user-defined pipeline.
+ PM = &PR.parseAndCreatePassPipeline(UserDefinedPassPipeline);
+ }
+
+ if (PrintPassPipeline) {
+ PM->printPipeline(outs());
+ return false;
+ }
+
+ // Run the pass pipeline.
+ bool Change = PM->runOnFunction(F);
+ return Change;
}
diff --git a/llvm/test/Transforms/SandboxVectorizer/default_pass_pipeline.ll b/llvm/test/Transforms/SandboxVectorizer/default_pass_pipeline.ll
index 86bfbee6364788..5ccd64d9f487a3 100644
--- a/llvm/test/Transforms/SandboxVectorizer/default_pass_pipeline.ll
+++ b/llvm/test/Transforms/SandboxVectorizer/default_pass_pipeline.ll
@@ -4,7 +4,8 @@
; This checks the default pass pipeline for the sandbox vectorizer.
define void @pipeline() {
-; CHECK: rpm
+; CHECK: pm
+; CHECK: bottom-up-vec
; CHECK-EMPTY:
ret void
}
diff --git a/llvm/test/Transforms/SandboxVectorizer/user_pass_pipeline.ll b/llvm/test/Transforms/SandboxVectorizer/user_pass_pipeline.ll
index 2e6dab0aa29c74..2879fbba1b9c00 100644
--- a/llvm/test/Transforms/SandboxVectorizer/user_pass_pipeline.ll
+++ b/llvm/test/Transforms/SandboxVectorizer/user_pass_pipeline.ll
@@ -1,12 +1,12 @@
-; RUN: opt -passes=sandbox-vectorizer -sbvec-print-pass-pipeline -sbvec-passes=null,null %s -disable-output | FileCheck %s
+; RUN: opt -passes=sandbox-vectorizer -sbvec-print-pass-pipeline -sbvec-passes=bottom-up-vec,bottom-up-vec %s -disable-output | FileCheck %s
; !!!WARNING!!! This won't get updated by update_test_checks.py !
; This checks the user defined pass pipeline.
define void @pipeline() {
-; CHECK: rpm
-; CHECK: null
-; CHECK: null
+; CHECK: pm
+; CHECK: bottom-up-vec
+; CHECK: bottom-up-vec
; CHECK-EMPTY:
ret void
}
diff --git a/llvm/unittests/SandboxIR/PassTest.cpp b/llvm/unittests/SandboxIR/PassTest.cpp
index ae7284ecf2deb9..b380ae9fd475ab 100644
--- a/llvm/unittests/SandboxIR/PassTest.cpp
+++ b/llvm/unittests/SandboxIR/PassTest.cpp
@@ -180,10 +180,12 @@ define void @foo() {
};
unsigned BBCnt1 = 0;
unsigned BBCnt2 = 0;
+ TestPass1 TPass1(BBCnt1);
+ TestPass2 TPass2(BBCnt2);
FunctionPassManager FPM("test-fpm");
- FPM.addPass(std::make_unique<TestPass1>(BBCnt1));
- FPM.addPass(std::make_unique<TestPass2>(BBCnt2));
+ FPM.addPass(&TPass1);
+ FPM.addPass(&TPass2);
// Check runOnFunction().
FPM.runOnFunction(*F);
EXPECT_EQ(BBCnt1, 1u);
@@ -236,10 +238,12 @@ define i8 @foo(i8 %v0, i8 %v1) {
};
unsigned InstCount1 = 0;
unsigned InstCount2 = 0;
+ TestPass1 TPass1(InstCount1);
+ TestPass2 TPass2(InstCount2);
RegionPassManager RPM("test-rpm");
- RPM.addPass(std::make_unique<TestPass1>(InstCount1));
- RPM.addPass(std::make_unique<TestPass2>(InstCount2));
+ RPM.addPass(&TPass1);
+ RPM.addPass(&TPass2);
// Check runOnRegion().
llvm::SmallVector<std::unique_ptr<Region>> Regions =
Region::createRegionsFromMD(*F);
@@ -256,60 +260,62 @@ define i8 @foo(i8 %v0, i8 %v1) {
#endif // NDEBUG
}
-TEST_F(PassTest, SetPassPipeline) {
- auto *F = parseFunction(R"IR(
-define void @f() {
- ret void
-}
-)IR",
- "f");
- class FooPass final : public FunctionPass {
- std::string &Str;
-
+TEST_F(PassTest, PassRegistry) {
+ class TestPass1 final : public FunctionPass {
public:
- FooPass(std::string &Str) : FunctionPass("foo-pass"), Str(Str) {}
- bool runOnFunction(Function &F) final {
- Str += "foo";
- return false;
- }
+ TestPass1() : FunctionPass("test-pass1") {}
+ bool runOnFunction(Function &F) final { return false; }
};
- class BarPass final : public FunctionPass {
- std::string &Str;
-
+ class TestPass2 final : public FunctionPass {
public:
- BarPass(std::string &Str) : FunctionPass("bar-pass"), Str(Str) {}
- bool runOnFunction(Function &F) final {
- Str += "bar";
- return false;
- }
+ TestPass2() : FunctionPass("test-pass2") {}
+ bool runOnFunction(Function &F) final { return false; }
};
- std::string Str;
- auto CreatePass =
- [&Str](llvm::StringRef Name) -> std::unique_ptr<FunctionPass> {
- if (Name == "foo")
- return std::make_unique<FooPass>(Str);
- if (Name == "bar")
- return std::make_unique<BarPass>(Str);
- return nullptr;
+ PassRegistry Registry;
+ auto &TP1 = Registry.registerPass(std::make_unique<TestPass1>());
+ auto &TP2 = Registry.registerPass(std::make_unique<TestPass2>());
+
+ // Check getPassByName().
+ EXPECT_EQ(Registry.getPassByName("test-pass1"), &TP1);
+ EXPECT_EQ(Registry.getPassByName("test-pass2"), &TP2);
+
+#ifndef NDEBUG
+ // Check print().
+ std::string Buff;
+ llvm::raw_string_ostream SS(Buff);
+ Registry.print(SS);
+ EXPECT_EQ(Buff, "test-pass1\ntest-pass2\n");
+#endif // NDEBUG
+}
+
+TEST_F(PassTest, ParsePassPipeline) {
+ class TestPass1 final : public FunctionPass {
+ public:
+ TestPass1() : FunctionPass("test-pass1") {}
+ bool runOnFunction(Function &F) final { return false; }
+ };
+ class TestPass2 final : public FunctionPass {
+ public:
+ TestPass2() : FunctionPass("test-pass2") {}
+ bool runOnFunction(Function &F) final { return false; }
};
- FunctionPassManager FPM("test-fpm");
- FPM.setPassPipeline("foo,bar,foo", CreatePass);
- FPM.runOnFunction(*F);
- EXPECT_EQ(Str, "foobarfoo");
+ PassRegistry Registry;
+ Registry.registerPass(std::make_unique<TestPass1>());
+ Registry.registerPass(std::make_unique<TestPass2>());
- // A second call to setPassPipeline will trigger an assertion in debug mode.
+ [[maybe_unused]] auto &FPM =
+ Registry.parseAndCreatePassPipeline("test-pass1,test-pass2,test-pass1");
#ifndef NDEBUG
- EXPECT_DEATH(FPM.setPassPipeline("bar,bar,foo", CreatePass),
- "setPassPipeline called on a non-empty sandboxir::PassManager");
-#endif
+ std::string Buff;
+ llvm::raw_string_ostream SS(Buff);
+ FPM.print(SS);
+ EXPECT_EQ(Buff, "init-fpm(test-pass1,test-pass2,test-pass1)");
+#endif // NDEBUG
- // Fresh PM for the death tests so they die from bad pipeline strings, rather
- // than from multiple setPassPipeline calls.
- FunctionPassManager FPM2("test-fpm");
- EXPECT_DEATH(FPM2.setPassPipeline("bad-pass-name", CreatePass),
+ EXPECT_DEATH(Registry.parseAndCreatePassPipeline("bad-pass-name"),
".*not registered.*");
- EXPECT_DEATH(FPM2.setPassPipeline("", CreatePass), ".*not registered.*");
- EXPECT_DEATH(FPM2.setPassPipeline(",", CreatePass), ".*not registered.*");
+ EXPECT_DEATH(Registry.parseAndCreatePassPipeline(""), ".*not registered.*");
+ EXPECT_DEATH(Registry.parseAndCreatePassPipeline(","), ".*not registered.*");
}
More information about the llvm-branch-commits
mailing list