[llvm-branch-commits] [llvm] [WebAssembly] Port WebAssemblyMCLowerPrePass (PR #210440)
Aiden Grossman via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Thu Jul 23 06:59:46 PDT 2026
https://github.com/boomanaiden154 updated https://github.com/llvm/llvm-project/pull/210440
>From 44cbe4e4126daf0a36cbc1352e5a6e7f2259b361 Mon Sep 17 00:00:00 2001
From: Aiden Grossman <aidengrossman at google.com>
Date: Fri, 17 Jul 2026 21:26:30 +0000
Subject: [PATCH 1/4] =?UTF-8?q?[=F0=9D=98=80=F0=9D=97=BD=F0=9D=97=BF]=20ch?=
=?UTF-8?q?anges=20to=20main=20this=20commit=20is=20based=20on?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Created using spr 1.3.7
[skip ci]
---
llvm/lib/Target/WebAssembly/WebAssembly.h | 163 +++++++++++++++---
.../Target/WebAssembly/WebAssemblyCFGSort.cpp | 46 +++--
.../WebAssembly/WebAssemblyCFGStackify.cpp | 151 ++++++++--------
.../WebAssemblyCodeGenPassBuilder.cpp | 39 ++---
.../WebAssembly/WebAssemblyDebugFixup.cpp | 29 +++-
.../WebAssembly/WebAssemblyExceptionInfo.cpp | 66 +++++--
.../WebAssembly/WebAssemblyExceptionInfo.h | 51 +++++-
.../WebAssembly/WebAssemblyExplicitLocals.cpp | 30 +++-
.../WebAssembly/WebAssemblyLateEHPrepare.cpp | 67 ++++---
.../WebAssembly/WebAssemblyLowerBrUnless.cpp | 29 +++-
.../WebAssemblyMemIntrinsicResults.cpp | 108 ++++++++----
.../WebAssemblyOptimizeLiveIntervals.cpp | 39 ++++-
.../WebAssembly/WebAssemblyPassRegistry.def | 20 +++
.../WebAssembly/WebAssemblyPeephole.cpp | 57 ++++--
.../WebAssembly/WebAssemblyRegColoring.cpp | 48 ++++--
.../WebAssembly/WebAssemblyRegNumbering.cpp | 29 +++-
.../WebAssembly/WebAssemblyRegStackify.cpp | 57 ++++--
.../WebAssemblyReplacePhysRegs.cpp | 36 ++--
.../WebAssembly/WebAssemblyTargetMachine.cpp | 54 +++---
19 files changed, 809 insertions(+), 310 deletions(-)
diff --git a/llvm/lib/Target/WebAssembly/WebAssembly.h b/llvm/lib/Target/WebAssembly/WebAssembly.h
index cf90353f963b9..3e6602693bb4a 100644
--- a/llvm/lib/Target/WebAssembly/WebAssembly.h
+++ b/llvm/lib/Target/WebAssembly/WebAssembly.h
@@ -152,7 +152,14 @@ class WebAssemblyCleanCodeAfterTrapPass
FunctionPass *createWebAssemblyCleanCodeAfterTrapLegacyPass();
// Late passes.
-FunctionPass *createWebAssemblyReplacePhysRegs();
+class WebAssemblyReplacePhysRegsPass
+ : public RequiredPassInfoMixin<WebAssemblyReplacePhysRegsPass> {
+public:
+ PreservedAnalyses run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM);
+};
+
+FunctionPass *createWebAssemblyReplacePhysRegsLegacyPass();
class WebAssemblyNullifyDebugValueListsPass
: public RequiredPassInfoMixin<WebAssemblyNullifyDebugValueListsPass> {
@@ -162,10 +169,47 @@ class WebAssemblyNullifyDebugValueListsPass
};
FunctionPass *createWebAssemblyNullifyDebugValueListsLegacyPass();
-FunctionPass *createWebAssemblyOptimizeLiveIntervals();
-FunctionPass *createWebAssemblyMemIntrinsicResults();
-FunctionPass *createWebAssemblyRegStackify(CodeGenOptLevel OptLevel);
-FunctionPass *createWebAssemblyRegColoring();
+
+class WebAssemblyOptimizeLiveIntervalsPass
+ : public RequiredPassInfoMixin<WebAssemblyOptimizeLiveIntervalsPass> {
+public:
+ PreservedAnalyses run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM);
+};
+
+FunctionPass *createWebAssemblyOptimizeLiveIntervalsLegacyPass();
+
+class WebAssemblyMemIntrinsicResultsPass
+ : public RequiredPassInfoMixin<WebAssemblyMemIntrinsicResultsPass> {
+public:
+ PreservedAnalyses run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM);
+};
+
+FunctionPass *createWebAssemblyMemIntrinsicResultsLegacyPass();
+
+class WebAssemblyRegStackifyPass
+ : public RequiredPassInfoMixin<WebAssemblyRegStackifyPass> {
+private:
+ bool Optimize = false;
+
+public:
+ WebAssemblyRegStackifyPass(CodeGenOptLevel OptLevel)
+ : Optimize(OptLevel != CodeGenOptLevel::None) {}
+ PreservedAnalyses run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM);
+};
+
+FunctionPass *createWebAssemblyRegStackifyLegacyPass(CodeGenOptLevel OptLevel);
+
+class WebAssemblyRegColoringPass
+ : public RequiredPassInfoMixin<WebAssemblyRegColoringPass> {
+public:
+ PreservedAnalyses run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM);
+};
+
+FunctionPass *createWebAssemblyRegColoringLegacyPass();
class WebAssemblyFixBrTableDefaultsPass
: public RequiredPassInfoMixin<WebAssemblyFixBrTableDefaultsPass> {
@@ -184,15 +228,78 @@ class WebAssemblyFixIrreducibleControlFlowPass
};
FunctionPass *createWebAssemblyFixIrreducibleControlFlowLegacyPass();
-FunctionPass *createWebAssemblyLateEHPrepare();
-FunctionPass *createWebAssemblyCFGSort();
-FunctionPass *createWebAssemblyCFGStackify();
-FunctionPass *createWebAssemblyExplicitLocals();
-FunctionPass *createWebAssemblyLowerBrUnless();
-FunctionPass *createWebAssemblyRegNumbering();
-FunctionPass *createWebAssemblyVecReduce();
-FunctionPass *createWebAssemblyDebugFixup();
-FunctionPass *createWebAssemblyPeephole();
+
+class WebAssemblyLateEHPreparePass
+ : public RequiredPassInfoMixin<WebAssemblyLateEHPreparePass> {
+public:
+ PreservedAnalyses run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM);
+};
+
+FunctionPass *createWebAssemblyLateEHPrepareLegacyPass();
+
+class WebAssemblyCFGSortPass
+ : public RequiredPassInfoMixin<WebAssemblyCFGSortPass> {
+public:
+ PreservedAnalyses run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM);
+};
+
+FunctionPass *createWebAssemblyCFGSortLegacyPass();
+
+class WebAssemblyCFGStackifyPass
+ : public RequiredPassInfoMixin<WebAssemblyCFGStackifyPass> {
+public:
+ PreservedAnalyses run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM);
+};
+
+FunctionPass *createWebAssemblyCFGStackifyLegacyPass();
+
+class WebAssemblyExplicitLocalsPass
+ : public RequiredPassInfoMixin<WebAssemblyExplicitLocalsPass> {
+public:
+ PreservedAnalyses run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM);
+};
+
+FunctionPass *createWebAssemblyExplicitLocalsLegacyPass();
+
+class WebAssemblyLowerBrUnlessPass
+ : public RequiredPassInfoMixin<WebAssemblyLowerBrUnlessPass> {
+public:
+ PreservedAnalyses run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM);
+};
+
+FunctionPass *createWebAssemblyLowerBrUnlessLegacyPass();
+
+class WebAssemblyRegNumberingPass
+ : public RequiredPassInfoMixin<WebAssemblyRegNumberingPass> {
+public:
+ PreservedAnalyses run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM);
+};
+
+FunctionPass *createWebAssemblyRegNumberingLegacyPass();
+
+class WebAssemblyDebugFixupPass
+ : public RequiredPassInfoMixin<WebAssemblyDebugFixupPass> {
+public:
+ PreservedAnalyses run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM);
+};
+
+FunctionPass *createWebAssemblyDebugFixupLegacyPass();
+
+class WebAssemblyPeepholePass
+ : public RequiredPassInfoMixin<WebAssemblyPeepholePass> {
+public:
+ PreservedAnalyses run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM);
+};
+
+FunctionPass *createWebAssemblyPeepholeLegacyPass();
ModulePass *createWebAssemblyMCLowerPrePass();
// PassRegistry initialization declarations.
@@ -202,27 +309,27 @@ void initializeWebAssemblyAddMissingPrototypesLegacyPass(PassRegistry &);
void initializeWebAssemblyArgumentMoveLegacyPass(PassRegistry &);
void initializeWebAssemblyAsmPrinterPass(PassRegistry &);
void initializeWebAssemblyCleanCodeAfterTrapLegacyPass(PassRegistry &);
-void initializeWebAssemblyCFGSortPass(PassRegistry &);
-void initializeWebAssemblyCFGStackifyPass(PassRegistry &);
+void initializeWebAssemblyCFGSortLegacyPass(PassRegistry &);
+void initializeWebAssemblyCFGStackifyLegacyPass(PassRegistry &);
void initializeWebAssemblyDAGToDAGISelLegacyPass(PassRegistry &);
-void initializeWebAssemblyDebugFixupPass(PassRegistry &);
-void initializeWebAssemblyExceptionInfoPass(PassRegistry &);
-void initializeWebAssemblyExplicitLocalsPass(PassRegistry &);
+void initializeWebAssemblyDebugFixupLegacyPass(PassRegistry &);
+void initializeWebAssemblyExceptionInfoWrapperPassPass(PassRegistry &);
+void initializeWebAssemblyExplicitLocalsLegacyPass(PassRegistry &);
void initializeWebAssemblyFixBrTableDefaultsLegacyPass(PassRegistry &);
void initializeWebAssemblyFixFunctionBitcastsLegacyPass(PassRegistry &);
void initializeWebAssemblyFixIrreducibleControlFlowLegacyPass(PassRegistry &);
-void initializeWebAssemblyLateEHPreparePass(PassRegistry &);
-void initializeWebAssemblyLowerBrUnlessPass(PassRegistry &);
+void initializeWebAssemblyLateEHPrepareLegacyPass(PassRegistry &);
+void initializeWebAssemblyLowerBrUnlessLegacyPass(PassRegistry &);
void initializeWebAssemblyLowerEmscriptenEHSjLjLegacyPass(PassRegistry &);
void initializeWebAssemblyMCLowerPrePassPass(PassRegistry &);
-void initializeWebAssemblyMemIntrinsicResultsPass(PassRegistry &);
+void initializeWebAssemblyMemIntrinsicResultsLegacyPass(PassRegistry &);
void initializeWebAssemblyNullifyDebugValueListsLegacyPass(PassRegistry &);
-void initializeWebAssemblyOptimizeLiveIntervalsPass(PassRegistry &);
-void initializeWebAssemblyPeepholePass(PassRegistry &);
-void initializeWebAssemblyRegColoringPass(PassRegistry &);
-void initializeWebAssemblyRegNumberingPass(PassRegistry &);
-void initializeWebAssemblyRegStackifyPass(PassRegistry &);
-void initializeWebAssemblyReplacePhysRegsPass(PassRegistry &);
+void initializeWebAssemblyOptimizeLiveIntervalsLegacyPass(PassRegistry &);
+void initializeWebAssemblyPeepholeLegacyPass(PassRegistry &);
+void initializeWebAssemblyRegColoringLegacyPass(PassRegistry &);
+void initializeWebAssemblyRegNumberingLegacyPass(PassRegistry &);
+void initializeWebAssemblyRegStackifyLegacyPass(PassRegistry &);
+void initializeWebAssemblyReplacePhysRegsLegacyPass(PassRegistry &);
void initializeWebAssemblySetP2AlignOperandsLegacyPass(PassRegistry &);
void initializeWebAssemblyCoalesceFeaturesAndStripAtomicsLegacyPass(
PassRegistry &);
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyCFGSort.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyCFGSort.cpp
index 78a34f20e335d..810190b956485 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyCFGSort.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyCFGSort.cpp
@@ -23,9 +23,12 @@
#include "llvm/ADT/PriorityQueue.h"
#include "llvm/CodeGen/MachineDominators.h"
#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
#include "llvm/CodeGen/MachineLoopInfo.h"
+#include "llvm/CodeGen/MachinePassManager.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/Passes.h"
+#include "llvm/IR/Analysis.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
@@ -44,7 +47,7 @@ static cl::opt<bool> WasmDisableEHPadSort(
namespace {
-class WebAssemblyCFGSort final : public MachineFunctionPass {
+class WebAssemblyCFGSortLegacy final : public MachineFunctionPass {
StringRef getPassName() const override { return "WebAssembly CFG Sort"; }
void getAnalysisUsage(AnalysisUsage &AU) const override {
@@ -53,8 +56,8 @@ class WebAssemblyCFGSort final : public MachineFunctionPass {
AU.addPreserved<MachineDominatorTreeWrapperPass>();
AU.addRequired<MachineLoopInfoWrapperPass>();
AU.addPreserved<MachineLoopInfoWrapperPass>();
- AU.addRequired<WebAssemblyExceptionInfo>();
- AU.addPreserved<WebAssemblyExceptionInfo>();
+ AU.addRequired<WebAssemblyExceptionInfoWrapperPass>();
+ AU.addPreserved<WebAssemblyExceptionInfoWrapperPass>();
MachineFunctionPass::getAnalysisUsage(AU);
}
@@ -62,16 +65,16 @@ class WebAssemblyCFGSort final : public MachineFunctionPass {
public:
static char ID; // Pass identification, replacement for typeid
- WebAssemblyCFGSort() : MachineFunctionPass(ID) {}
+ WebAssemblyCFGSortLegacy() : MachineFunctionPass(ID) {}
};
} // end anonymous namespace
-char WebAssemblyCFGSort::ID = 0;
-INITIALIZE_PASS(WebAssemblyCFGSort, DEBUG_TYPE,
+char WebAssemblyCFGSortLegacy::ID = 0;
+INITIALIZE_PASS(WebAssemblyCFGSortLegacy, DEBUG_TYPE,
"Reorders blocks in topological order", false, false)
-FunctionPass *llvm::createWebAssemblyCFGSort() {
- return new WebAssemblyCFGSort();
+FunctionPass *llvm::createWebAssemblyCFGSortLegacyPass() {
+ return new WebAssemblyCFGSortLegacy();
}
static void maybeUpdateTerminator(MachineBasicBlock *MBB) {
@@ -379,14 +382,12 @@ static void sortBlocks(MachineFunction &MF, const MachineLoopInfo &MLI,
#endif
}
-bool WebAssemblyCFGSort::runOnMachineFunction(MachineFunction &MF) {
+static bool sortCFG(MachineFunction &MF, MachineLoopInfo &MLI,
+ WebAssemblyExceptionInfo &WEI, MachineDominatorTree &MDT) {
LLVM_DEBUG(dbgs() << "********** CFG Sorting **********\n"
"********** Function: "
<< MF.getName() << '\n');
- const auto &MLI = getAnalysis<MachineLoopInfoWrapperPass>().getLI();
- const auto &WEI = getAnalysis<WebAssemblyExceptionInfo>();
- auto &MDT = getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
// Liveness is not tracked for VALUE_STACK physreg.
MF.getRegInfo().invalidateLiveness();
@@ -395,3 +396,24 @@ bool WebAssemblyCFGSort::runOnMachineFunction(MachineFunction &MF) {
return true;
}
+
+bool WebAssemblyCFGSortLegacy::runOnMachineFunction(MachineFunction &MF) {
+ MachineLoopInfo &MLI = getAnalysis<MachineLoopInfoWrapperPass>().getLI();
+ WebAssemblyExceptionInfo &WEI =
+ getAnalysis<WebAssemblyExceptionInfoWrapperPass>().getWEI();
+ MachineDominatorTree &MDT =
+ getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
+ return sortCFG(MF, MLI, WEI, MDT);
+}
+
+PreservedAnalyses
+WebAssemblyCFGSortPass::run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ MachineLoopInfo &MLI = MFAM.getResult<MachineLoopAnalysis>(MF);
+ WebAssemblyExceptionInfo &WEI =
+ MFAM.getResult<WebAssemblyExceptionAnalysis>(MF);
+ MachineDominatorTree &MDT = MFAM.getResult<MachineDominatorTreeAnalysis>(MF);
+ return sortCFG(MF, MLI, WEI, MDT) ? getMachineFunctionPassPreservedAnalyses()
+ .preserveSet<CFGAnalyses>()
+ : PreservedAnalyses::all();
+}
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp
index 7e12b0861116e..b609f3e5b8e9f 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp
@@ -33,8 +33,12 @@
#include "llvm/ADT/Statistic.h"
#include "llvm/BinaryFormat/Wasm.h"
#include "llvm/CodeGen/MachineDominators.h"
+#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
+#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/MachineLoopInfo.h"
+#include "llvm/CodeGen/MachinePassManager.h"
+#include "llvm/IR/Analysis.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Target/TargetMachine.h"
using namespace llvm;
@@ -46,19 +50,10 @@ STATISTIC(NumCallUnwindMismatches, "Number of call unwind mismatches found");
STATISTIC(NumCatchUnwindMismatches, "Number of catch unwind mismatches found");
namespace {
-class WebAssemblyCFGStackify final : public MachineFunctionPass {
- MachineDominatorTree *MDT;
-
- StringRef getPassName() const override { return "WebAssembly CFG Stackify"; }
-
- void getAnalysisUsage(AnalysisUsage &AU) const override {
- AU.addRequired<MachineDominatorTreeWrapperPass>();
- AU.addRequired<MachineLoopInfoWrapperPass>();
- AU.addRequired<WebAssemblyExceptionInfo>();
- MachineFunctionPass::getAnalysisUsage(AU);
- }
-
- bool runOnMachineFunction(MachineFunction &MF) override;
+class WebAssemblyCFGStackifyImpl {
+ MachineDominatorTree &MDT;
+ MachineLoopInfo &MLI;
+ WebAssemblyExceptionInfo &WEI;
// For each block whose label represents the end of a scope, record the block
// which holds the beginning of the scope. This will allow us to quickly skip
@@ -169,21 +164,38 @@ class WebAssemblyCFGStackify final : public MachineFunctionPass {
void unregisterScope(MachineInstr *Begin);
public:
+ WebAssemblyCFGStackifyImpl(MachineDominatorTree &MDT, MachineLoopInfo &MLI,
+ WebAssemblyExceptionInfo &WEI)
+ : MDT(MDT), MLI(MLI), WEI(WEI) {}
+
+ bool runOnMachineFunction(MachineFunction &MF);
+};
+
+class WebAssemblyCFGStackifyLegacy : public MachineFunctionPass {
+ StringRef getPassName() const override { return "WebAssembly CFG Stackify"; }
+
+ void getAnalysisUsage(AnalysisUsage &AU) const override {
+ AU.addRequired<MachineDominatorTreeWrapperPass>();
+ AU.addRequired<MachineLoopInfoWrapperPass>();
+ AU.addRequired<WebAssemblyExceptionInfoWrapperPass>();
+ MachineFunctionPass::getAnalysisUsage(AU);
+ }
+
+public:
+ bool runOnMachineFunction(MachineFunction &MF) override;
static char ID; // Pass identification, replacement for typeid
- WebAssemblyCFGStackify() : MachineFunctionPass(ID) {}
- ~WebAssemblyCFGStackify() override { releaseMemory(); }
- void releaseMemory() override;
+ WebAssemblyCFGStackifyLegacy() : MachineFunctionPass(ID) {}
};
} // end anonymous namespace
-char WebAssemblyCFGStackify::ID = 0;
+char WebAssemblyCFGStackifyLegacy::ID = 0;
INITIALIZE_PASS(
- WebAssemblyCFGStackify, DEBUG_TYPE,
+ WebAssemblyCFGStackifyLegacy, DEBUG_TYPE,
"Insert BLOCK/LOOP/TRY/TRY_TABLE markers for WebAssembly scopes", false,
false)
-FunctionPass *llvm::createWebAssemblyCFGStackify() {
- return new WebAssemblyCFGStackify();
+FunctionPass *llvm::createWebAssemblyCFGStackifyLegacyPass() {
+ return new WebAssemblyCFGStackifyLegacy();
}
/// Test whether Pred has any terminators explicitly branching to MBB, as
@@ -248,22 +260,22 @@ getLatestInsertPos(MachineBasicBlock *MBB, const Container &BeforeSet,
return InsertPos;
}
-void WebAssemblyCFGStackify::registerScope(MachineInstr *Begin,
- MachineInstr *End) {
+void WebAssemblyCFGStackifyImpl::registerScope(MachineInstr *Begin,
+ MachineInstr *End) {
BeginToEnd[Begin] = End;
EndToBegin[End] = Begin;
}
// When 'End' is not an 'end_try' but a 'delegate', EHPad is nullptr.
-void WebAssemblyCFGStackify::registerTryScope(MachineInstr *Begin,
- MachineInstr *End,
- MachineBasicBlock *EHPad) {
+void WebAssemblyCFGStackifyImpl::registerTryScope(MachineInstr *Begin,
+ MachineInstr *End,
+ MachineBasicBlock *EHPad) {
registerScope(Begin, End);
TryToEHPad[Begin] = EHPad;
EHPadToTry[EHPad] = Begin;
}
-void WebAssemblyCFGStackify::unregisterScope(MachineInstr *Begin) {
+void WebAssemblyCFGStackifyImpl::unregisterScope(MachineInstr *Begin) {
assert(BeginToEnd.count(Begin));
MachineInstr *End = BeginToEnd[Begin];
assert(EndToBegin.count(End));
@@ -280,7 +292,7 @@ void WebAssemblyCFGStackify::unregisterScope(MachineInstr *Begin) {
/// Insert a BLOCK marker for branches to MBB (if needed).
// TODO Consider a more generalized way of handling block (and also loop and
// try) signatures when we implement the multi-value proposal later.
-void WebAssemblyCFGStackify::placeBlockMarker(MachineBasicBlock &MBB) {
+void WebAssemblyCFGStackifyImpl::placeBlockMarker(MachineBasicBlock &MBB) {
assert(!MBB.isEHPad());
MachineFunction &MF = *MBB.getParent();
const auto &TII = *MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
@@ -294,7 +306,7 @@ void WebAssemblyCFGStackify::placeBlockMarker(MachineBasicBlock &MBB) {
int MBBNumber = MBB.getNumber();
for (MachineBasicBlock *Pred : MBB.predecessors()) {
if (Pred->getNumber() < MBBNumber) {
- Header = Header ? MDT->findNearestCommonDominator(Header, Pred) : Pred;
+ Header = Header ? MDT.findNearestCommonDominator(Header, Pred) : Pred;
if (explicitlyBranchesTo(Pred, &MBB))
IsBranchedTo = true;
}
@@ -431,10 +443,8 @@ void WebAssemblyCFGStackify::placeBlockMarker(MachineBasicBlock &MBB) {
}
/// Insert a LOOP marker for a loop starting at MBB (if it's a loop header).
-void WebAssemblyCFGStackify::placeLoopMarker(MachineBasicBlock &MBB) {
+void WebAssemblyCFGStackifyImpl::placeLoopMarker(MachineBasicBlock &MBB) {
MachineFunction &MF = *MBB.getParent();
- const auto &MLI = getAnalysis<MachineLoopInfoWrapperPass>().getLI();
- const auto &WEI = getAnalysis<WebAssemblyExceptionInfo>();
SortRegionInfo SRI(MLI, WEI);
const auto &TII = *MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
@@ -498,13 +508,10 @@ void WebAssemblyCFGStackify::placeLoopMarker(MachineBasicBlock &MBB) {
updateScopeTops(&MBB, AfterLoop);
}
-void WebAssemblyCFGStackify::placeTryMarker(MachineBasicBlock &MBB) {
+void WebAssemblyCFGStackifyImpl::placeTryMarker(MachineBasicBlock &MBB) {
assert(MBB.isEHPad());
MachineFunction &MF = *MBB.getParent();
- auto &MDT = getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
const auto &TII = *MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
- const auto &MLI = getAnalysis<MachineLoopInfoWrapperPass>().getLI();
- const auto &WEI = getAnalysis<WebAssemblyExceptionInfo>();
SortRegionInfo SRI(MLI, WEI);
const auto &MFI = *MF.getInfo<WebAssemblyFunctionInfo>();
@@ -692,13 +699,10 @@ void WebAssemblyCFGStackify::placeTryMarker(MachineBasicBlock &MBB) {
updateScopeTops(Header, End);
}
-void WebAssemblyCFGStackify::placeTryTableMarker(MachineBasicBlock &MBB) {
+void WebAssemblyCFGStackifyImpl::placeTryTableMarker(MachineBasicBlock &MBB) {
assert(MBB.isEHPad());
MachineFunction &MF = *MBB.getParent();
- auto &MDT = getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
const auto &TII = *MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
- const auto &MLI = getAnalysis<MachineLoopInfoWrapperPass>().getLI();
- const auto &WEI = getAnalysis<WebAssemblyExceptionInfo>();
SortRegionInfo SRI(MLI, WEI);
const auto &MFI = *MF.getInfo<WebAssemblyFunctionInfo>();
@@ -989,7 +993,7 @@ void WebAssemblyCFGStackify::placeTryTableMarker(MachineBasicBlock &MBB) {
updateScopeTops(Header, End);
}
-void WebAssemblyCFGStackify::removeUnnecessaryInstrs(MachineFunction &MF) {
+void WebAssemblyCFGStackifyImpl::removeUnnecessaryInstrs(MachineFunction &MF) {
const auto &TII = *MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
// When there is an unconditional branch right before a catch instruction and
@@ -1171,7 +1175,7 @@ static void unstackifyVRegsUsedInSplitBB(MachineBasicBlock &MBB,
// Wrap the given range of instructions with a try-delegate that targets
// 'UnwindDest'. RangeBegin and RangeEnd are inclusive.
-void WebAssemblyCFGStackify::addNestedTryDelegate(
+void WebAssemblyCFGStackifyImpl::addNestedTryDelegate(
MachineInstr *RangeBegin, MachineInstr *RangeEnd,
MachineBasicBlock *UnwindDest) {
auto *BeginBB = RangeBegin->getParent();
@@ -1309,7 +1313,7 @@ void WebAssemblyCFGStackify::addNestedTryDelegate(
// throw_ref
// end_try_table
MachineBasicBlock *
-WebAssemblyCFGStackify::getTrampolineBlock(MachineBasicBlock *UnwindDest) {
+WebAssemblyCFGStackifyImpl::getTrampolineBlock(MachineBasicBlock *UnwindDest) {
// We need one trampoline BB per unwind destination, even though there are
// multiple try_tables target the same unwind destination. If we have already
// created one for the given UnwindDest, return it.
@@ -1380,9 +1384,9 @@ WebAssemblyCFGStackify::getTrampolineBlock(MachineBasicBlock *UnwindDest) {
// Wrap the given range of instructions with a try_table-end_try_table that
// targets 'UnwindDest'. RangeBegin and RangeEnd are inclusive.
-void WebAssemblyCFGStackify::addNestedTryTable(MachineInstr *RangeBegin,
- MachineInstr *RangeEnd,
- MachineBasicBlock *UnwindDest) {
+void WebAssemblyCFGStackifyImpl::addNestedTryTable(
+ MachineInstr *RangeBegin, MachineInstr *RangeEnd,
+ MachineBasicBlock *UnwindDest) {
auto *BeginBB = RangeBegin->getParent();
auto *EndBB = RangeEnd->getParent();
@@ -1589,7 +1593,7 @@ static void splitEndLoopBB(MachineBasicBlock *EndTryTableBB) {
return Name;
}
-bool WebAssemblyCFGStackify::fixCallUnwindMismatches(MachineFunction &MF) {
+bool WebAssemblyCFGStackifyImpl::fixCallUnwindMismatches(MachineFunction &MF) {
// This function is used for both the legacy EH and the standard (exnref) EH,
// and the reason we have unwind mismatches is the same for the both of them,
// but the code examples in the comments are going to be different. To make
@@ -2073,7 +2077,7 @@ bool WebAssemblyCFGStackify::fixCallUnwindMismatches(MachineFunction &MF) {
return true;
}
-bool WebAssemblyCFGStackify::fixCatchUnwindMismatches(MachineFunction &MF) {
+bool WebAssemblyCFGStackifyImpl::fixCatchUnwindMismatches(MachineFunction &MF) {
// This function is used for both the legacy EH and the standard (exnref) EH,
// and the reason we have unwind mismatches is the same for the both of them,
// but the code examples in the comments are going to be different. To make
@@ -2364,7 +2368,7 @@ bool WebAssemblyCFGStackify::fixCatchUnwindMismatches(MachineFunction &MF) {
return true;
}
-void WebAssemblyCFGStackify::recalculateScopeTops(MachineFunction &MF) {
+void WebAssemblyCFGStackifyImpl::recalculateScopeTops(MachineFunction &MF) {
// Renumber BBs and recalculate ScopeTop info because new BBs might have been
// created and inserted during fixing unwind mismatches.
MF.RenumberBlocks();
@@ -2398,7 +2402,7 @@ void WebAssemblyCFGStackify::recalculateScopeTops(MachineFunction &MF) {
/// that end at the function end need to have a return type signature that
/// matches the function signature, even though it's unreachable. This function
/// checks for such cases and fixes up the signatures.
-void WebAssemblyCFGStackify::fixEndsAtEndOfFunction(MachineFunction &MF) {
+void WebAssemblyCFGStackifyImpl::fixEndsAtEndOfFunction(MachineFunction &MF) {
const auto &MFI = *MF.getInfo<WebAssemblyFunctionInfo>();
if (MFI.getResults().empty())
@@ -2506,7 +2510,7 @@ static void addUnreachableAfterTryTables(MachineFunction &MF,
}
/// Insert BLOCK/LOOP/TRY/TRY_TABLE markers at appropriate places.
-void WebAssemblyCFGStackify::placeMarkers(MachineFunction &MF) {
+void WebAssemblyCFGStackifyImpl::placeMarkers(MachineFunction &MF) {
// We allocate one more than the number of blocks in the function to
// accommodate for the possible fake block we may insert at the end.
ScopeTops.resize(MF.getNumBlockIDs() + 1);
@@ -2548,7 +2552,7 @@ void WebAssemblyCFGStackify::placeMarkers(MachineFunction &MF) {
}
}
-unsigned WebAssemblyCFGStackify::getBranchDepth(
+unsigned WebAssemblyCFGStackifyImpl::getBranchDepth(
const SmallVectorImpl<EndMarkerInfo> &Stack, const MachineBasicBlock *MBB) {
unsigned Depth = 0;
for (auto X : reverse(Stack)) {
@@ -2560,7 +2564,7 @@ unsigned WebAssemblyCFGStackify::getBranchDepth(
return Depth;
}
-unsigned WebAssemblyCFGStackify::getDelegateDepth(
+unsigned WebAssemblyCFGStackifyImpl::getDelegateDepth(
const SmallVectorImpl<EndMarkerInfo> &Stack, const MachineBasicBlock *MBB) {
if (MBB == FakeCallerBB)
return Stack.size();
@@ -2595,7 +2599,7 @@ unsigned WebAssemblyCFGStackify::getDelegateDepth(
return Depth;
}
-unsigned WebAssemblyCFGStackify::getRethrowDepth(
+unsigned WebAssemblyCFGStackifyImpl::getRethrowDepth(
const SmallVectorImpl<EndMarkerInfo> &Stack,
const MachineBasicBlock *EHPadToRethrow) {
unsigned Depth = 0;
@@ -2612,7 +2616,7 @@ unsigned WebAssemblyCFGStackify::getRethrowDepth(
return Depth;
}
-void WebAssemblyCFGStackify::rewriteDepthImmediates(MachineFunction &MF) {
+void WebAssemblyCFGStackifyImpl::rewriteDepthImmediates(MachineFunction &MF) {
// Now rewrite references to basic blocks to be depth immediates.
SmallVector<EndMarkerInfo, 8> Stack;
@@ -2683,29 +2687,17 @@ void WebAssemblyCFGStackify::rewriteDepthImmediates(MachineFunction &MF) {
assert(Stack.empty() && "Control flow should be balanced");
}
-void WebAssemblyCFGStackify::cleanupFunctionData(MachineFunction &MF) {
+void WebAssemblyCFGStackifyImpl::cleanupFunctionData(MachineFunction &MF) {
if (FakeCallerBB)
MF.deleteMachineBasicBlock(FakeCallerBB);
AppendixBB = FakeCallerBB = CallerTrampolineBB = nullptr;
}
-void WebAssemblyCFGStackify::releaseMemory() {
- ScopeTops.clear();
- BeginToEnd.clear();
- EndToBegin.clear();
- TryToEHPad.clear();
- EHPadToTry.clear();
- UnwindDestToTrampoline.clear();
-}
-
-bool WebAssemblyCFGStackify::runOnMachineFunction(MachineFunction &MF) {
+bool WebAssemblyCFGStackifyImpl::runOnMachineFunction(MachineFunction &MF) {
LLVM_DEBUG(dbgs() << "********** CFG Stackifying **********\n"
"********** Function: "
<< MF.getName() << '\n');
const MCAsmInfo &MCAI = MF.getTarget().getMCAsmInfo();
- MDT = &getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
-
- releaseMemory();
// Liveness is not tracked for VALUE_STACK physreg.
MF.getRegInfo().invalidateLiveness();
@@ -2735,3 +2727,26 @@ bool WebAssemblyCFGStackify::runOnMachineFunction(MachineFunction &MF) {
MF.getInfo<WebAssemblyFunctionInfo>()->setCFGStackified();
return true;
}
+
+bool WebAssemblyCFGStackifyLegacy::runOnMachineFunction(MachineFunction &MF) {
+ MachineDominatorTree &MDT =
+ getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
+ MachineLoopInfo &MLI = getAnalysis<MachineLoopInfoWrapperPass>().getLI();
+ WebAssemblyExceptionInfo &WEI =
+ getAnalysis<WebAssemblyExceptionInfoWrapperPass>().getWEI();
+ WebAssemblyCFGStackifyImpl Impl(MDT, MLI, WEI);
+ return Impl.runOnMachineFunction(MF);
+}
+
+PreservedAnalyses
+WebAssemblyCFGStackifyPass::run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ MachineDominatorTree &MDT = MFAM.getResult<MachineDominatorTreeAnalysis>(MF);
+ MachineLoopInfo &MLI = MFAM.getResult<MachineLoopAnalysis>(MF);
+ WebAssemblyExceptionInfo &WEI =
+ MFAM.getResult<WebAssemblyExceptionAnalysis>(MF);
+ WebAssemblyCFGStackifyImpl Impl(MDT, MLI, WEI);
+ return Impl.runOnMachineFunction(MF)
+ ? getMachineFunctionPassPreservedAnalyses()
+ : PreservedAnalyses::all();
+}
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyCodeGenPassBuilder.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyCodeGenPassBuilder.cpp
index afd970ea8f577..488dcc19eca55 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyCodeGenPassBuilder.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyCodeGenPassBuilder.cpp
@@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "WebAssembly.h"
+#include "WebAssemblyExceptionInfo.h"
#include "WebAssemblyTargetMachine.h"
#include "llvm/CodeGen/AtomicExpand.h"
#include "llvm/CodeGen/IndirectBrExpand.h"
@@ -183,22 +184,21 @@ void WebAssemblyCodeGenPassBuilder::addPreEmitPass(
// Do various transformations for exception handling.
// Every CFG-changing optimizations should come before this.
- if (TM.Options.ExceptionModel == ExceptionHandling::Wasm) {
- // TODO(boomanaiden154): WebAssemblyLateEHPrepare
- }
+ if (TM.Options.ExceptionModel == ExceptionHandling::Wasm)
+ addMachineFunctionPass(WebAssemblyLateEHPreparePass(), PMW);
// Now that we have a prologue and epilogue and all frame indices are
// rewritten, eliminate SP and FP. This allows them to be stackified,
// colored, and numbered with the rest of the registers.
- // TODO(boomanaiden154): WebAssemblyReplacePhysRegs
+ addMachineFunctionPass(WebAssemblyReplacePhysRegsPass(), PMW);
// Preparations and optimizations related to register stackification.
if (getOptLevel() != CodeGenOptLevel::None) {
// Depend on LiveIntervals and perform some optimizations on it.
- // TODO(boomanaiden154): WebAssemblyOptimizeLiveIntervals
+ addMachineFunctionPass(WebAssemblyOptimizeLiveIntervalsPass(), PMW);
// Prepare memory intrinsic calls for register stackifying.
- // TODO(boomanaiden154): WebAssemblyMemIntrinsicResults
+ addMachineFunctionPass(WebAssemblyMemIntrinsicResultsPass(), PMW);
}
// Mark registers as representing wasm's value stack. This is a key
@@ -206,42 +206,39 @@ void WebAssemblyCodeGenPassBuilder::addPreEmitPass(
// MemIntrinsicResults above) very late, so that it sees as much code as
// possible, including code emitted by PEI and expanded by late tail
// duplication.
- // TODO(boomanaiden154): WebAssemblyRegStackify
+ addMachineFunctionPass(WebAssemblyRegStackifyPass(getOptLevel()), PMW);
if (getOptLevel() != CodeGenOptLevel::None) {
// Run the register coloring pass to reduce the total number of registers.
// This runs after stackification so that it doesn't consider registers
// that become stackified.
- // TODO(boomanaiden154): WebAssemblyRegColoring
+ addMachineFunctionPass(WebAssemblyRegColoringPass(), PMW);
}
// Sort the blocks of the CFG into topological order, a prerequisite for
// BLOCK and LOOP markers.
- // TODO(boomanaiden154): WebAssemblyCFGSort
+ addMachineFunctionPass(WebAssemblyCFGSortPass(), PMW);
// Insert BLOCK and LOOP markers.
- // TODO(boomanaiden154): WebAssemblyCFGStackify
+ addMachineFunctionPass(WebAssemblyCFGStackifyPass(), PMW);
// Insert explicit local.get and local.set operators.
- if (!WasmDisableExplicitLocals) {
- // TODO(boomanaiden154): WebAssemblyExplicitLocals
- }
+ if (!WasmDisableExplicitLocals)
+ addMachineFunctionPass(WebAssemblyExplicitLocalsPass(), PMW);
// Lower br_unless into br_if.
- // TODO(boomanaiden154): WebAssemblyLowerBrUnless
+ addMachineFunctionPass(WebAssemblyLowerBrUnlessPass(), PMW);
// Perform the very last peephole optimizations on the code.
- if (getOptLevel() != CodeGenOptLevel::None) {
- // TODO(boomanaiden154): WebAssemblyPeephole
- }
+ if (getOptLevel() != CodeGenOptLevel::None)
+ addMachineFunctionPass(WebAssemblyPeepholePass(), PMW);
// Create a mapping from LLVM CodeGen virtual registers to wasm registers.
- // TODO(boomanaiden154): WebAssemblyRegNumbering
+ addMachineFunctionPass(WebAssemblyRegNumberingPass(), PMW);
// Fix debug_values whose defs have been stackified.
- if (!WasmDisableExplicitLocals) {
- // TODO(boomanaiden154): WebAssemblyDebugFixup
- }
+ if (!WasmDisableExplicitLocals)
+ addMachineFunctionPass(WebAssemblyDebugFixupPass(), PMW);
// Collect information to prepare for MC lowering / asm printing.
// TODO(boomanaiden154): WebAssemblyMCLowerPrePass
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyDebugFixup.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyDebugFixup.cpp
index 2046c09d063ec..d6cfcc6451476 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyDebugFixup.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyDebugFixup.cpp
@@ -21,8 +21,11 @@
#include "WebAssemblyUtilities.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
+#include "llvm/CodeGen/MachinePassManager.h"
#include "llvm/CodeGen/Passes.h"
+#include "llvm/IR/Analysis.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
@@ -30,7 +33,7 @@ using namespace llvm;
#define DEBUG_TYPE "wasm-debug-fixup"
namespace {
-class WebAssemblyDebugFixup final : public MachineFunctionPass {
+class WebAssemblyDebugFixupLegacy final : public MachineFunctionPass {
StringRef getPassName() const override { return "WebAssembly Debug Fixup"; }
void getAnalysisUsage(AnalysisUsage &AU) const override {
@@ -42,18 +45,18 @@ class WebAssemblyDebugFixup final : public MachineFunctionPass {
public:
static char ID; // Pass identification, replacement for typeid
- WebAssemblyDebugFixup() : MachineFunctionPass(ID) {}
+ WebAssemblyDebugFixupLegacy() : MachineFunctionPass(ID) {}
};
} // end anonymous namespace
-char WebAssemblyDebugFixup::ID = 0;
+char WebAssemblyDebugFixupLegacy::ID = 0;
INITIALIZE_PASS(
- WebAssemblyDebugFixup, DEBUG_TYPE,
+ WebAssemblyDebugFixupLegacy, DEBUG_TYPE,
"Ensures debug_value's that have been stackified become stack relative",
false, false)
-FunctionPass *llvm::createWebAssemblyDebugFixup() {
- return new WebAssemblyDebugFixup();
+FunctionPass *llvm::createWebAssemblyDebugFixupLegacyPass() {
+ return new WebAssemblyDebugFixupLegacy();
}
// At this very end of the compilation pipeline, if any DBG_VALUEs with
@@ -74,7 +77,7 @@ static void setDanglingDebugValuesUndef(MachineBasicBlock &MBB,
}
}
-bool WebAssemblyDebugFixup::runOnMachineFunction(MachineFunction &MF) {
+static bool debugFixup(MachineFunction &MF) {
LLVM_DEBUG(dbgs() << "********** Debug Fixup **********\n"
"********** Function: "
<< MF.getName() << '\n');
@@ -156,3 +159,15 @@ bool WebAssemblyDebugFixup::runOnMachineFunction(MachineFunction &MF) {
return true;
}
+
+bool WebAssemblyDebugFixupLegacy::runOnMachineFunction(MachineFunction &MF) {
+ return debugFixup(MF);
+}
+
+PreservedAnalyses
+WebAssemblyDebugFixupPass::run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ return debugFixup(MF) ? getMachineFunctionPassPreservedAnalyses()
+ .preserveSet<CFGAnalyses>()
+ : PreservedAnalyses::all();
+}
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp
index ae6a7fb79aead..0596fdad12821 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp
@@ -16,6 +16,8 @@
#include "llvm/ADT/PostOrderIterator.h"
#include "llvm/CodeGen/MachineDominanceFrontier.h"
#include "llvm/CodeGen/MachineDominators.h"
+#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
+#include "llvm/IR/Analysis.h"
#include "llvm/IR/Function.h"
#include "llvm/InitializePasses.h"
#include "llvm/MC/MCAsmInfo.h"
@@ -25,31 +27,61 @@ using namespace llvm;
#define DEBUG_TYPE "wasm-exception-info"
-char WebAssemblyExceptionInfo::ID = 0;
+char WebAssemblyExceptionInfoWrapperPass::ID = 0;
-INITIALIZE_PASS_BEGIN(WebAssemblyExceptionInfo, DEBUG_TYPE,
+INITIALIZE_PASS_BEGIN(WebAssemblyExceptionInfoWrapperPass, DEBUG_TYPE,
"WebAssembly Exception Information", true, true)
INITIALIZE_PASS_DEPENDENCY(MachineDominatorTreeWrapperPass)
INITIALIZE_PASS_DEPENDENCY(MachineDominanceFrontierWrapperPass)
-INITIALIZE_PASS_END(WebAssemblyExceptionInfo, DEBUG_TYPE,
+INITIALIZE_PASS_END(WebAssemblyExceptionInfoWrapperPass, DEBUG_TYPE,
"WebAssembly Exception Information", true, true)
-bool WebAssemblyExceptionInfo::runOnMachineFunction(MachineFunction &MF) {
+static void computeWEI(WebAssemblyExceptionInfo &WEI, MachineFunction &MF,
+ function_ref<MachineDominatorTree &()> GetMDT,
+ function_ref<MachineDominanceFrontier &()> GetMDF) {
LLVM_DEBUG(dbgs() << "********** Exception Info Calculation **********\n"
"********** Function: "
<< MF.getName() << '\n');
- releaseMemory();
if (MF.getTarget().getMCAsmInfo().getExceptionHandlingType() !=
ExceptionHandling::Wasm ||
!MF.getFunction().hasPersonalityFn())
- return false;
- auto &MDT = getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
- auto &MDF = getAnalysis<MachineDominanceFrontierWrapperPass>().getMDF();
- recalculate(MF, MDT, MDF);
- LLVM_DEBUG(dump());
+ return;
+ MachineDominatorTree &MDT = GetMDT();
+ MachineDominanceFrontier &MDF = GetMDF();
+ WEI.recalculate(MF, MDT, MDF);
+}
+
+bool WebAssemblyExceptionInfoWrapperPass::runOnMachineFunction(
+ MachineFunction &MF) {
+ releaseMemory();
+ computeWEI(
+ WasmExceptionInfo, MF,
+ [&]() -> MachineDominatorTree & {
+ return getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
+ },
+ [&]() -> MachineDominanceFrontier & {
+ return getAnalysis<MachineDominanceFrontierWrapperPass>().getMDF();
+ });
return false;
}
+WebAssemblyExceptionAnalysis::Result
+WebAssemblyExceptionAnalysis::run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ WebAssemblyExceptionInfo WEI;
+ computeWEI(
+ WEI, MF,
+ [&]() -> MachineDominatorTree & {
+ return MFAM.getResult<MachineDominatorTreeAnalysis>(MF);
+ },
+ [&]() -> MachineDominanceFrontier & {
+ return MFAM.getResult<MachineDominanceFrontierAnalysis>(MF);
+ });
+ return WEI;
+}
+
+AnalysisKey WebAssemblyExceptionAnalysis::Key;
+
void WebAssemblyExceptionInfo::recalculate(
MachineFunction &MF, MachineDominatorTree &MDT,
const MachineDominanceFrontier &MDF) {
@@ -107,7 +139,8 @@ void WebAssemblyExceptionInfo::releaseMemory() {
TopLevelExceptions.clear();
}
-void WebAssemblyExceptionInfo::getAnalysisUsage(AnalysisUsage &AU) const {
+void WebAssemblyExceptionInfoWrapperPass::getAnalysisUsage(
+ AnalysisUsage &AU) const {
AU.setPreservesAll();
AU.addRequired<MachineDominatorTreeWrapperPass>();
AU.addRequired<MachineDominanceFrontierWrapperPass>();
@@ -205,3 +238,14 @@ void WebAssemblyExceptionInfo::print(raw_ostream &OS, const Module *) const {
for (auto &WE : TopLevelExceptions)
WE->print(OS);
}
+
+bool WebAssemblyExceptionInfo::invalidate(
+ MachineFunction &MF, const PreservedAnalyses &PA,
+ MachineFunctionAnalysisManager::Invalidator &) {
+ // Check whether the analysis, all analyses on machine functions, or the
+ // machine function's CFG have been preserved.
+ auto PAC = PA.getChecker<MachineBlockFrequencyAnalysis>();
+ return !PAC.preserved() &&
+ !PAC.preservedSet<AllAnalysesOn<MachineFunction>>() &&
+ !PAC.preservedSet<CFGAnalyses>();
+}
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyExceptionInfo.h b/llvm/lib/Target/WebAssembly/WebAssemblyExceptionInfo.h
index 1bfc61f0ab611..823f86eae9afa 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyExceptionInfo.h
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyExceptionInfo.h
@@ -16,7 +16,11 @@
#include "WebAssembly.h"
#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/IR/Analysis.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/Pass.h"
namespace llvm {
@@ -120,7 +124,7 @@ class WebAssemblyException {
raw_ostream &operator<<(raw_ostream &OS, const WebAssemblyException &WE);
-class WebAssemblyExceptionInfo final : public MachineFunctionPass {
+class WebAssemblyExceptionInfo {
// Mapping of basic blocks to the innermost exception they occur in
DenseMap<const MachineBasicBlock *, WebAssemblyException *> BBMap;
std::vector<std::unique_ptr<WebAssemblyException>> TopLevelExceptions;
@@ -131,18 +135,16 @@ class WebAssemblyExceptionInfo final : public MachineFunctionPass {
WebAssemblyException *getOutermostException(MachineBasicBlock *MBB) const;
public:
- static char ID;
- WebAssemblyExceptionInfo() : MachineFunctionPass(ID) {}
- ~WebAssemblyExceptionInfo() override { releaseMemory(); }
+ WebAssemblyExceptionInfo() {}
+ ~WebAssemblyExceptionInfo() { releaseMemory(); }
WebAssemblyExceptionInfo(const WebAssemblyExceptionInfo &) = delete;
+ WebAssemblyExceptionInfo(WebAssemblyExceptionInfo &&) = default;
WebAssemblyExceptionInfo &
operator=(const WebAssemblyExceptionInfo &) = delete;
- bool runOnMachineFunction(MachineFunction &) override;
- void releaseMemory() override;
+ void releaseMemory();
void recalculate(MachineFunction &MF, MachineDominatorTree &MDT,
const MachineDominanceFrontier &MDF);
- void getAnalysisUsage(AnalysisUsage &AU) const override;
bool empty() const { return TopLevelExceptions.empty(); }
@@ -166,7 +168,40 @@ class WebAssemblyExceptionInfo final : public MachineFunctionPass {
TopLevelExceptions.push_back(std::move(WE));
}
- void print(raw_ostream &OS, const Module *M = nullptr) const override;
+ void print(raw_ostream &OS, const Module *M) const;
+
+ bool invalidate(MachineFunction &MF, const PreservedAnalyses &PA,
+ MachineFunctionAnalysisManager::Invalidator &);
+};
+
+class WebAssemblyExceptionInfoWrapperPass : public MachineFunctionPass {
+ WebAssemblyExceptionInfo WasmExceptionInfo;
+
+public:
+ static char ID;
+ WebAssemblyExceptionInfoWrapperPass() : MachineFunctionPass(ID) {}
+
+ void getAnalysisUsage(AnalysisUsage &AU) const override;
+ bool runOnMachineFunction(MachineFunction &MF) override;
+ void print(raw_ostream &OS, const Module *M = nullptr) const override {
+ WasmExceptionInfo.print(OS, M);
+ }
+ void releaseMemory() override { WasmExceptionInfo.releaseMemory(); }
+
+ WebAssemblyExceptionInfo &getWEI() { return WasmExceptionInfo; }
+ const WebAssemblyExceptionInfo &getWEI() const { return WasmExceptionInfo; }
+};
+
+class WebAssemblyExceptionAnalysis
+ : public AnalysisInfoMixin<WebAssemblyExceptionAnalysis> {
+ friend AnalysisInfoMixin<WebAssemblyExceptionAnalysis>;
+ static AnalysisKey Key;
+
+public:
+ using Result = WebAssemblyExceptionInfo;
+
+ LLVM_ABI Result run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM);
};
} // end namespace llvm
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyExplicitLocals.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyExplicitLocals.cpp
index e05b23d255894..55bb28c1d6483 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyExplicitLocals.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyExplicitLocals.cpp
@@ -22,9 +22,12 @@
#include "WebAssemblySubtarget.h"
#include "WebAssemblyUtilities.h"
#include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
+#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
+#include "llvm/CodeGen/MachinePassManager.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/Passes.h"
+#include "llvm/IR/Analysis.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
@@ -32,7 +35,7 @@ using namespace llvm;
#define DEBUG_TYPE "wasm-explicit-locals"
namespace {
-class WebAssemblyExplicitLocals final : public MachineFunctionPass {
+class WebAssemblyExplicitLocalsLegacy final : public MachineFunctionPass {
StringRef getPassName() const override {
return "WebAssembly Explicit Locals";
}
@@ -47,16 +50,16 @@ class WebAssemblyExplicitLocals final : public MachineFunctionPass {
public:
static char ID; // Pass identification, replacement for typeid
- WebAssemblyExplicitLocals() : MachineFunctionPass(ID) {}
+ WebAssemblyExplicitLocalsLegacy() : MachineFunctionPass(ID) {}
};
} // end anonymous namespace
-char WebAssemblyExplicitLocals::ID = 0;
-INITIALIZE_PASS(WebAssemblyExplicitLocals, DEBUG_TYPE,
+char WebAssemblyExplicitLocalsLegacy::ID = 0;
+INITIALIZE_PASS(WebAssemblyExplicitLocalsLegacy, DEBUG_TYPE,
"Convert registers to WebAssembly locals", false, false)
-FunctionPass *llvm::createWebAssemblyExplicitLocals() {
- return new WebAssemblyExplicitLocals();
+FunctionPass *llvm::createWebAssemblyExplicitLocalsLegacyPass() {
+ return new WebAssemblyExplicitLocalsLegacy();
}
static void checkFrameBase(WebAssemblyFunctionInfo &MFI, unsigned Local,
@@ -228,7 +231,7 @@ static void removeFakeUses(MachineFunction &MF) {
MI->eraseFromParent();
}
-bool WebAssemblyExplicitLocals::runOnMachineFunction(MachineFunction &MF) {
+static bool explicitLocals(MachineFunction &MF) {
LLVM_DEBUG(dbgs() << "********** Make Locals Explicit **********\n"
"********** Function: "
<< MF.getName() << '\n');
@@ -500,3 +503,16 @@ bool WebAssemblyExplicitLocals::runOnMachineFunction(MachineFunction &MF) {
return Changed;
}
+
+bool WebAssemblyExplicitLocalsLegacy::runOnMachineFunction(
+ MachineFunction &MF) {
+ return explicitLocals(MF);
+}
+
+PreservedAnalyses
+WebAssemblyExplicitLocalsPass::run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ return explicitLocals(MF) ? getMachineFunctionPassPreservedAnalyses()
+ .preserveSet<CFGAnalyses>()
+ : PreservedAnalyses::all();
+}
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp
index 56f74dce630df..01f9975225aa2 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp
@@ -17,8 +17,11 @@
#include "WebAssemblyUtilities.h"
#include "llvm/ADT/MapVector.h"
#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
+#include "llvm/CodeGen/MachinePassManager.h"
+#include "llvm/IR/Analysis.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/Support/Debug.h"
#include "llvm/Target/TargetMachine.h"
@@ -27,12 +30,7 @@ using namespace llvm;
#define DEBUG_TYPE "wasm-late-eh-prepare"
namespace {
-class WebAssemblyLateEHPrepare final : public MachineFunctionPass {
- StringRef getPassName() const override {
- return "WebAssembly Late Prepare Exception";
- }
-
- bool runOnMachineFunction(MachineFunction &MF) override;
+class WebAssemblyLateEHPrepareImpl {
bool removeUnreachableEHPads(MachineFunction &MF);
void recordCatchRetBBs(MachineFunction &MF);
bool hoistCatches(MachineFunction &MF);
@@ -45,18 +43,29 @@ class WebAssemblyLateEHPrepare final : public MachineFunctionPass {
MachineBasicBlock *getMatchingEHPad(MachineInstr *MI);
SmallPtrSet<MachineBasicBlock *, 8> CatchRetBBs;
+public:
+ bool runOnMachineFunction(MachineFunction &MF);
+};
+
+class WebAssemblyLateEHPrepareLegacy final : public MachineFunctionPass {
+ StringRef getPassName() const override {
+ return "WebAssembly Late Prepare Exception";
+ }
+
+ bool runOnMachineFunction(MachineFunction &MF) override;
+
public:
static char ID; // Pass identification, replacement for typeid
- WebAssemblyLateEHPrepare() : MachineFunctionPass(ID) {}
+ WebAssemblyLateEHPrepareLegacy() : MachineFunctionPass(ID) {}
};
} // end anonymous namespace
-char WebAssemblyLateEHPrepare::ID = 0;
-INITIALIZE_PASS(WebAssemblyLateEHPrepare, DEBUG_TYPE,
+char WebAssemblyLateEHPrepareLegacy::ID = 0;
+INITIALIZE_PASS(WebAssemblyLateEHPrepareLegacy, DEBUG_TYPE,
"WebAssembly Late Exception Preparation", false, false)
-FunctionPass *llvm::createWebAssemblyLateEHPrepare() {
- return new WebAssemblyLateEHPrepare();
+FunctionPass *llvm::createWebAssemblyLateEHPrepareLegacyPass() {
+ return new WebAssemblyLateEHPrepareLegacy();
}
// Returns the nearest EH pad that dominates this instruction. This does not use
@@ -66,7 +75,7 @@ FunctionPass *llvm::createWebAssemblyLateEHPrepare() {
// Returns nullptr in case it does not find any EH pad in the search, or finds
// multiple different EH pads.
MachineBasicBlock *
-WebAssemblyLateEHPrepare::getMatchingEHPad(MachineInstr *MI) {
+WebAssemblyLateEHPrepareImpl::getMatchingEHPad(MachineInstr *MI) {
MachineFunction *MF = MI->getParent()->getParent();
SmallVector<MachineBasicBlock *, 2> WL;
SmallPtrSet<MachineBasicBlock *, 2> Visited;
@@ -112,7 +121,7 @@ static void eraseDeadBBsAndChildren(const Container &MBBs) {
}
}
-bool WebAssemblyLateEHPrepare::runOnMachineFunction(MachineFunction &MF) {
+bool WebAssemblyLateEHPrepareImpl::runOnMachineFunction(MachineFunction &MF) {
LLVM_DEBUG(dbgs() << "********** Late EH Prepare **********\n"
"********** Function: "
<< MF.getName() << '\n');
@@ -139,7 +148,8 @@ bool WebAssemblyLateEHPrepare::runOnMachineFunction(MachineFunction &MF) {
// Remove unreachable EH pads and its children. If they remain, CFG
// stackification can be tricky.
-bool WebAssemblyLateEHPrepare::removeUnreachableEHPads(MachineFunction &MF) {
+bool WebAssemblyLateEHPrepareImpl::removeUnreachableEHPads(
+ MachineFunction &MF) {
SmallVector<MachineBasicBlock *, 4> ToDelete;
for (auto &MBB : MF)
if (MBB.isEHPad() && MBB.pred_empty())
@@ -151,7 +161,7 @@ bool WebAssemblyLateEHPrepare::removeUnreachableEHPads(MachineFunction &MF) {
// Record which BB ends with catchret instruction, because this will be replaced
// with 'br's later. This set of catchret BBs is necessary in 'getMatchingEHPad'
// function.
-void WebAssemblyLateEHPrepare::recordCatchRetBBs(MachineFunction &MF) {
+void WebAssemblyLateEHPrepareImpl::recordCatchRetBBs(MachineFunction &MF) {
CatchRetBBs.clear();
for (auto &MBB : MF) {
auto Pos = MBB.getFirstTerminator();
@@ -175,7 +185,7 @@ void WebAssemblyLateEHPrepare::recordCatchRetBBs(MachineFunction &MF) {
// br bb0
// bb0:
// %exn = catch 0
-bool WebAssemblyLateEHPrepare::hoistCatches(MachineFunction &MF) {
+bool WebAssemblyLateEHPrepareImpl::hoistCatches(MachineFunction &MF) {
bool Changed = false;
SmallVector<MachineInstr *, 16> Catches;
for (auto &MBB : MF)
@@ -201,7 +211,7 @@ bool WebAssemblyLateEHPrepare::hoistCatches(MachineFunction &MF) {
}
// Add catch_all to beginning of cleanup pads.
-bool WebAssemblyLateEHPrepare::addCatchAlls(MachineFunction &MF) {
+bool WebAssemblyLateEHPrepareImpl::addCatchAlls(MachineFunction &MF) {
bool Changed = false;
const auto &TII = *MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
@@ -230,7 +240,7 @@ bool WebAssemblyLateEHPrepare::addCatchAlls(MachineFunction &MF) {
// Replace pseudo-instructions catchret and cleanupret with br and rethrow
// respectively.
-bool WebAssemblyLateEHPrepare::replaceFuncletReturns(MachineFunction &MF) {
+bool WebAssemblyLateEHPrepareImpl::replaceFuncletReturns(MachineFunction &MF) {
bool Changed = false;
const auto &TII = *MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
@@ -295,7 +305,8 @@ bool WebAssemblyLateEHPrepare::replaceFuncletReturns(MachineFunction &MF) {
// Add CATCH_REF and CATCH_ALL_REF pseudo instructions to EH pads, and convert
// RETHROWs to THROW_REFs.
-bool WebAssemblyLateEHPrepare::addCatchRefsAndThrowRefs(MachineFunction &MF) {
+bool WebAssemblyLateEHPrepareImpl::addCatchRefsAndThrowRefs(
+ MachineFunction &MF) {
const auto &TII = *MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
auto &MRI = MF.getRegInfo();
MapVector<MachineBasicBlock *, SmallVector<MachineInstr *, 2>>
@@ -351,7 +362,7 @@ bool WebAssemblyLateEHPrepare::addCatchRefsAndThrowRefs(MachineFunction &MF) {
}
// Remove unnecessary unreachables after a throw/rethrow/throw_ref.
-bool WebAssemblyLateEHPrepare::removeUnnecessaryUnreachables(
+bool WebAssemblyLateEHPrepareImpl::removeUnnecessaryUnreachables(
MachineFunction &MF) {
bool Changed = false;
for (auto &MBB : MF) {
@@ -381,7 +392,7 @@ bool WebAssemblyLateEHPrepare::removeUnnecessaryUnreachables(
// After the stack is unwound due to a thrown exception, the __stack_pointer
// global/__wasm_get_stack_pointer() can point to an invalid address. This
// inserts instructions that restore the stack pointer state.
-bool WebAssemblyLateEHPrepare::restoreStackPointer(MachineFunction &MF) {
+bool WebAssemblyLateEHPrepareImpl::restoreStackPointer(MachineFunction &MF) {
const auto *FrameLowering = static_cast<const WebAssemblyFrameLowering *>(
MF.getSubtarget().getFrameLowering());
if (!FrameLowering->needsPrologForEH(MF))
@@ -412,3 +423,17 @@ bool WebAssemblyLateEHPrepare::restoreStackPointer(MachineFunction &MF) {
}
return Changed;
}
+
+bool WebAssemblyLateEHPrepareLegacy::runOnMachineFunction(MachineFunction &MF) {
+ WebAssemblyLateEHPrepareImpl Impl;
+ return Impl.runOnMachineFunction(MF);
+}
+
+PreservedAnalyses
+WebAssemblyLateEHPreparePass::run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ WebAssemblyLateEHPrepareImpl Impl;
+ return Impl.runOnMachineFunction(MF)
+ ? getMachineFunctionPassPreservedAnalyses()
+ : PreservedAnalyses::all();
+}
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyLowerBrUnless.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyLowerBrUnless.cpp
index 52226206eb325..3d154bcbd2d0b 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyLowerBrUnless.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyLowerBrUnless.cpp
@@ -18,8 +18,11 @@
#include "WebAssembly.h"
#include "WebAssemblyMachineFunctionInfo.h"
#include "WebAssemblySubtarget.h"
+#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
+#include "llvm/CodeGen/MachinePassManager.h"
+#include "llvm/IR/Analysis.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
@@ -27,7 +30,7 @@ using namespace llvm;
#define DEBUG_TYPE "wasm-lower-br_unless"
namespace {
-class WebAssemblyLowerBrUnless final : public MachineFunctionPass {
+class WebAssemblyLowerBrUnlessLegacy final : public MachineFunctionPass {
StringRef getPassName() const override {
return "WebAssembly Lower br_unless";
}
@@ -41,19 +44,19 @@ class WebAssemblyLowerBrUnless final : public MachineFunctionPass {
public:
static char ID; // Pass identification, replacement for typeid
- WebAssemblyLowerBrUnless() : MachineFunctionPass(ID) {}
+ WebAssemblyLowerBrUnlessLegacy() : MachineFunctionPass(ID) {}
};
} // end anonymous namespace
-char WebAssemblyLowerBrUnless::ID = 0;
-INITIALIZE_PASS(WebAssemblyLowerBrUnless, DEBUG_TYPE,
+char WebAssemblyLowerBrUnlessLegacy::ID = 0;
+INITIALIZE_PASS(WebAssemblyLowerBrUnlessLegacy, DEBUG_TYPE,
"Lowers br_unless into inverted br_if", false, false)
-FunctionPass *llvm::createWebAssemblyLowerBrUnless() {
- return new WebAssemblyLowerBrUnless();
+FunctionPass *llvm::createWebAssemblyLowerBrUnlessLegacyPass() {
+ return new WebAssemblyLowerBrUnlessLegacy();
}
-bool WebAssemblyLowerBrUnless::runOnMachineFunction(MachineFunction &MF) {
+static bool lowerBrUnless(MachineFunction &MF) {
LLVM_DEBUG(dbgs() << "********** Lowering br_unless **********\n"
"********** Function: "
<< MF.getName() << '\n');
@@ -207,3 +210,15 @@ bool WebAssemblyLowerBrUnless::runOnMachineFunction(MachineFunction &MF) {
return true;
}
+
+bool WebAssemblyLowerBrUnlessLegacy::runOnMachineFunction(MachineFunction &MF) {
+ return lowerBrUnless(MF);
+}
+
+PreservedAnalyses
+WebAssemblyLowerBrUnlessPass::run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ return lowerBrUnless(MF) ? getMachineFunctionPassPreservedAnalyses()
+ .preserveSet<CFGAnalyses>()
+ : PreservedAnalyses::all();
+}
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyMemIntrinsicResults.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyMemIntrinsicResults.cpp
index 74bba7339cab0..8b4285af4bb00 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyMemIntrinsicResults.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyMemIntrinsicResults.cpp
@@ -31,11 +31,17 @@
#include "WebAssemblyMachineFunctionInfo.h"
#include "WebAssemblySubtarget.h"
#include "llvm/Analysis/TargetLibraryInfo.h"
+#include "llvm/CodeGen/LibcallLoweringInfo.h"
#include "llvm/CodeGen/LiveIntervals.h"
#include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
#include "llvm/CodeGen/MachineDominators.h"
+#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
+#include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/CodeGen/MachinePassManager.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/Passes.h"
+#include "llvm/CodeGen/SlotIndexes.h"
+#include "llvm/IR/Analysis.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
@@ -43,10 +49,31 @@ using namespace llvm;
#define DEBUG_TYPE "wasm-mem-intrinsic-results"
namespace {
-class WebAssemblyMemIntrinsicResults final : public MachineFunctionPass {
+class WebAssemblyMemIntrinsicResultsImpl {
+public:
+ WebAssemblyMemIntrinsicResultsImpl(MachineDominatorTree *MDT,
+ LiveIntervals *LIS,
+ const TargetLibraryInfo *LibInfo,
+ const LibcallLoweringInfo &LibCalls)
+ : MDT(MDT), LIS(LIS), LibInfo(LibInfo), LibCalls(LibCalls) {}
+ bool runOnMachineFunction(MachineFunction &MF);
+
+private:
+ MachineDominatorTree *MDT;
+ LiveIntervals *LIS;
+ const TargetLibraryInfo *LibInfo;
+ const LibcallLoweringInfo &LibCalls;
+
+ StringRef MemcpyName, MemmoveName, MemsetName;
+
+ bool optimizeCall(MachineBasicBlock &MBB, MachineInstr &MI,
+ const MachineRegisterInfo &MRI) const;
+};
+
+class WebAssemblyMemIntrinsicResultsLegacy final : public MachineFunctionPass {
public:
static char ID; // Pass identification, replacement for typeid
- WebAssemblyMemIntrinsicResults() : MachineFunctionPass(ID) {}
+ WebAssemblyMemIntrinsicResultsLegacy() : MachineFunctionPass(ID) {}
StringRef getPassName() const override {
return "WebAssembly Memory Intrinsic Results";
@@ -67,26 +94,16 @@ class WebAssemblyMemIntrinsicResults final : public MachineFunctionPass {
}
bool runOnMachineFunction(MachineFunction &MF) override;
-
-private:
- MachineDominatorTree *MDT;
- LiveIntervals *LIS;
- const TargetLibraryInfo *LibInfo;
-
- StringRef MemcpyName, MemmoveName, MemsetName;
-
- bool optimizeCall(MachineBasicBlock &MBB, MachineInstr &MI,
- const MachineRegisterInfo &MRI) const;
};
} // end anonymous namespace
-char WebAssemblyMemIntrinsicResults::ID = 0;
-INITIALIZE_PASS(WebAssemblyMemIntrinsicResults, DEBUG_TYPE,
+char WebAssemblyMemIntrinsicResultsLegacy::ID = 0;
+INITIALIZE_PASS(WebAssemblyMemIntrinsicResultsLegacy, DEBUG_TYPE,
"Optimize memory intrinsic result values for WebAssembly",
false, false)
-FunctionPass *llvm::createWebAssemblyMemIntrinsicResults() {
- return new WebAssemblyMemIntrinsicResults();
+FunctionPass *llvm::createWebAssemblyMemIntrinsicResultsLegacyPass() {
+ return new WebAssemblyMemIntrinsicResultsLegacy();
}
// Replace uses of FromReg with ToReg if they are dominated by MI.
@@ -154,7 +171,7 @@ static bool replaceDominatedUses(MachineBasicBlock &MBB, MachineInstr &MI,
return Changed;
}
-bool WebAssemblyMemIntrinsicResults::optimizeCall(
+bool WebAssemblyMemIntrinsicResultsImpl::optimizeCall(
MachineBasicBlock &MBB, MachineInstr &MI,
const MachineRegisterInfo &MRI) const {
MachineOperand &Op1 = MI.getOperand(1);
@@ -182,29 +199,21 @@ bool WebAssemblyMemIntrinsicResults::optimizeCall(
return replaceDominatedUses(MBB, MI, FromReg, ToReg, MRI, *MDT, *LIS);
}
-bool WebAssemblyMemIntrinsicResults::runOnMachineFunction(MachineFunction &MF) {
+bool WebAssemblyMemIntrinsicResultsImpl::runOnMachineFunction(
+ MachineFunction &MF) {
LLVM_DEBUG({
dbgs() << "********** Memory Intrinsic Results **********\n"
<< "********** Function: " << MF.getName() << '\n';
});
MachineRegisterInfo &MRI = MF.getRegInfo();
- LIS = &getAnalysis<LiveIntervalsWrapperPass>().getLIS();
- MDT = &getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
- const WebAssemblySubtarget &Subtarget =
- MF.getSubtarget<WebAssemblySubtarget>();
- LibInfo =
- &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(MF.getFunction());
- const LibcallLoweringInfo &Libcalls =
- getAnalysis<LibcallLoweringInfoWrapper>().getLibcallLowering(
- *MF.getFunction().getParent(), Subtarget);
MemcpyName = RTLIB::RuntimeLibcallsInfo::getLibcallImplName(
- Libcalls.getLibcallImpl(RTLIB::MEMCPY));
+ LibCalls.getLibcallImpl(RTLIB::MEMCPY));
MemmoveName = RTLIB::RuntimeLibcallsInfo::getLibcallImplName(
- Libcalls.getLibcallImpl(RTLIB::MEMMOVE));
+ LibCalls.getLibcallImpl(RTLIB::MEMMOVE));
MemsetName = RTLIB::RuntimeLibcallsInfo::getLibcallImplName(
- Libcalls.getLibcallImpl(RTLIB::MEMSET));
+ LibCalls.getLibcallImpl(RTLIB::MEMSET));
bool Changed = false;
@@ -228,3 +237,42 @@ bool WebAssemblyMemIntrinsicResults::runOnMachineFunction(MachineFunction &MF) {
return Changed;
}
+
+bool WebAssemblyMemIntrinsicResultsLegacy::runOnMachineFunction(
+ MachineFunction &MF) {
+ MachineDominatorTree *MDT =
+ &getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
+ LiveIntervals *LIS = &getAnalysis<LiveIntervalsWrapperPass>().getLIS();
+ const TargetLibraryInfo *LibInfo =
+ &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(MF.getFunction());
+ const WebAssemblySubtarget &Subtarget =
+ MF.getSubtarget<WebAssemblySubtarget>();
+ const LibcallLoweringInfo &LibCalls =
+ getAnalysis<LibcallLoweringInfoWrapper>().getLibcallLowering(
+ *MF.getFunction().getParent(), Subtarget);
+ WebAssemblyMemIntrinsicResultsImpl Impl(MDT, LIS, LibInfo, LibCalls);
+ return Impl.runOnMachineFunction(MF);
+}
+
+PreservedAnalyses
+WebAssemblyMemIntrinsicResultsPass::run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ MachineDominatorTree *MDT = &MFAM.getResult<MachineDominatorTreeAnalysis>(MF);
+ LiveIntervals *LIS = &MFAM.getResult<LiveIntervalsAnalysis>(MF);
+ const TargetLibraryInfo *LibInfo = &MFAM.getResult<TargetLibraryAnalysis>(MF);
+ const WebAssemblySubtarget &Subtarget =
+ MF.getSubtarget<WebAssemblySubtarget>();
+ const LibcallLoweringInfo &LibCalls =
+ MFAM.getResult<ModuleAnalysisManagerMachineFunctionProxy>(MF)
+ .getCachedResult<LibcallLoweringModuleAnalysis>(
+ *MF.getFunction().getParent())
+ ->getLibcallLowering(Subtarget);
+ WebAssemblyMemIntrinsicResultsImpl Impl(MDT, LIS, LibInfo, LibCalls);
+ bool Changed = Impl.runOnMachineFunction(MF);
+ if (!Changed)
+ return PreservedAnalyses::all();
+ return getMachineFunctionPassPreservedAnalyses()
+ .preserveSet<CFGAnalyses>()
+ .preserve<LiveIntervalsAnalysis>()
+ .preserve<SlotIndexesAnalysis>();
+}
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyOptimizeLiveIntervals.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyOptimizeLiveIntervals.cpp
index 0c561622e634e..324a42b2e3e53 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyOptimizeLiveIntervals.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyOptimizeLiveIntervals.cpp
@@ -24,8 +24,12 @@
#include "WebAssemblySubtarget.h"
#include "llvm/CodeGen/LiveIntervals.h"
#include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
+#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
+#include "llvm/CodeGen/MachinePassManager.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/Passes.h"
+#include "llvm/CodeGen/SlotIndexes.h"
+#include "llvm/IR/Analysis.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
@@ -33,7 +37,8 @@ using namespace llvm;
#define DEBUG_TYPE "wasm-optimize-live-intervals"
namespace {
-class WebAssemblyOptimizeLiveIntervals final : public MachineFunctionPass {
+class WebAssemblyOptimizeLiveIntervalsLegacy final
+ : public MachineFunctionPass {
StringRef getPassName() const override {
return "WebAssembly Optimize Live Intervals";
}
@@ -57,26 +62,24 @@ class WebAssemblyOptimizeLiveIntervals final : public MachineFunctionPass {
public:
static char ID; // Pass identification, replacement for typeid
- WebAssemblyOptimizeLiveIntervals() : MachineFunctionPass(ID) {}
+ WebAssemblyOptimizeLiveIntervalsLegacy() : MachineFunctionPass(ID) {}
};
} // end anonymous namespace
-char WebAssemblyOptimizeLiveIntervals::ID = 0;
-INITIALIZE_PASS(WebAssemblyOptimizeLiveIntervals, DEBUG_TYPE,
+char WebAssemblyOptimizeLiveIntervalsLegacy::ID = 0;
+INITIALIZE_PASS(WebAssemblyOptimizeLiveIntervalsLegacy, DEBUG_TYPE,
"Optimize LiveIntervals for WebAssembly", false, false)
-FunctionPass *llvm::createWebAssemblyOptimizeLiveIntervals() {
- return new WebAssemblyOptimizeLiveIntervals();
+FunctionPass *llvm::createWebAssemblyOptimizeLiveIntervalsLegacyPass() {
+ return new WebAssemblyOptimizeLiveIntervalsLegacy();
}
-bool WebAssemblyOptimizeLiveIntervals::runOnMachineFunction(
- MachineFunction &MF) {
+static bool optimizeLiveIntervals(MachineFunction &MF, LiveIntervals &LIS) {
LLVM_DEBUG(dbgs() << "********** Optimize LiveIntervals **********\n"
"********** Function: "
<< MF.getName() << '\n');
MachineRegisterInfo &MRI = MF.getRegInfo();
- auto &LIS = getAnalysis<LiveIntervalsWrapperPass>().getLIS();
// We don't preserve SSA form.
MRI.leaveSSA();
@@ -121,3 +124,21 @@ bool WebAssemblyOptimizeLiveIntervals::runOnMachineFunction(
return true;
}
+
+bool WebAssemblyOptimizeLiveIntervalsLegacy::runOnMachineFunction(
+ MachineFunction &MF) {
+ return optimizeLiveIntervals(
+ MF, getAnalysis<LiveIntervalsWrapperPass>().getLIS());
+}
+
+PreservedAnalyses WebAssemblyOptimizeLiveIntervalsPass::run(
+ MachineFunction &MF, MachineFunctionAnalysisManager &MFAM) {
+ bool Changed =
+ optimizeLiveIntervals(MF, MFAM.getResult<LiveIntervalsAnalysis>(MF));
+ if (!Changed)
+ return PreservedAnalyses::all();
+ return getMachineFunctionPassPreservedAnalyses()
+ .preserveSet<CFGAnalyses>()
+ .preserve<LiveIntervalsAnalysis>()
+ .preserve<SlotIndexesAnalysis>();
+}
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyPassRegistry.def b/llvm/lib/Target/WebAssembly/WebAssemblyPassRegistry.def
index caf32fae60470..8ed934639e30f 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyPassRegistry.def
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyPassRegistry.def
@@ -29,19 +29,39 @@ FUNCTION_PASS("wasm-reduce-to-any-all-true", WebAssemblyReduceToAnyAllTruePass(*
FUNCTION_PASS("wasm-ref-type-mem2local", WebAssemblyRefTypeMem2LocalPass())
#undef FUNCTION_PASS
+#ifndef MACHINE_FUNCTION_ANALYSIS
+#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS)
+#endif
+MACHINE_FUNCTION_ANALYSIS("wasm-exception-info", WebAssemblyExceptionAnalysis())
+#undef MACHINE_FUNCTION_ANALYSIS
+
#ifndef MACHINE_FUNCTION_PASS
#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS)
#endif
MACHINE_FUNCTION_PASS("wasm-argument-move", WebAssemblyArgumentMovePass())
+MACHINE_FUNCTION_PASS("wasm-cfg-sort", WebAssemblyCFGSortPass())
+MACHINE_FUNCTION_PASS("wasm-cfg-stackify", WebAssemblyCFGStackifyPass())
MACHINE_FUNCTION_PASS("wasm-clean-code-after-trap",
WebAssemblyCleanCodeAfterTrapPass())
+MACHINE_FUNCTION_PASS("wasm-debug-fixup", WebAssemblyDebugFixupPass())
+MACHINE_FUNCTION_PASS("wasm-explicit-locals", WebAssemblyExplicitLocalsPass())
MACHINE_FUNCTION_PASS("wasm-isel", WebAssemblyISelDAGToDAGPass(*this, getOptLevel()))
MACHINE_FUNCTION_PASS("wasm-fix-br-table-defaults",
WebAssemblyFixBrTableDefaultsPass())
MACHINE_FUNCTION_PASS("wasm-fix-irreducible-control-flow",
WebAssemblyFixIrreducibleControlFlowPass())
+MACHINE_FUNCTION_PASS("wasm-late-eh-prepare", WebAssemblyLateEHPreparePass())
+MACHINE_FUNCTION_PASS("wasm-lower-br-unless", WebAssemblyLowerBrUnlessPass())
+MACHINE_FUNCTION_PASS("wasm-mem-intrinsic-results", WebAssemblyMemIntrinsicResultsPass())
MACHINE_FUNCTION_PASS("wasm-nullify-dbg-value-lists",
WebAssemblyNullifyDebugValueListsPass())
+MACHINE_FUNCTION_PASS("wasm-optimize-live-intervals",
+ WebAssemblyOptimizeLiveIntervalsPass())
+MACHINE_FUNCTION_PASS("wasm-peephole", WebAssemblyPeepholePass())
+MACHINE_FUNCTION_PASS("wasm-reg-coloring", WebAssemblyRegColoringPass())
+MACHINE_FUNCTION_PASS("wasm-reg-numbering", WebAssemblyRegNumberingPass())
+MACHINE_FUNCTION_PASS("wasm-reg-stackify", WebAssemblyRegStackifyPass(getOptLevel()))
+MACHINE_FUNCTION_PASS("wasm-replace-phys-regs", WebAssemblyReplacePhysRegsPass())
MACHINE_FUNCTION_PASS("wasm-set-p2align-operands",
WebAssemblySetP2AlignOperandsPass())
#undef MACHINE_FUNCTION_PASS
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyPeephole.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyPeephole.cpp
index d7ae32b061e67..992283e9cc3d6 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyPeephole.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyPeephole.cpp
@@ -17,9 +17,14 @@
#include "WebAssemblySubtarget.h"
#include "WebAssemblyUtilities.h"
#include "llvm/Analysis/TargetLibraryInfo.h"
+#include "llvm/CodeGen/LibcallLoweringInfo.h"
+#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
+#include "llvm/CodeGen/MachinePassManager.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/IR/Analysis.h"
+#include "llvm/Support/ErrorHandling.h"
using namespace llvm;
#define DEBUG_TYPE "wasm-peephole"
@@ -30,7 +35,7 @@ static cl::opt<bool> DisableWebAssemblyFallthroughReturnOpt(
cl::init(false));
namespace {
-class WebAssemblyPeephole final : public MachineFunctionPass {
+class WebAssemblyPeepholeLegacy final : public MachineFunctionPass {
StringRef getPassName() const override {
return "WebAssembly late peephole optimizer";
}
@@ -46,16 +51,16 @@ class WebAssemblyPeephole final : public MachineFunctionPass {
public:
static char ID;
- WebAssemblyPeephole() : MachineFunctionPass(ID) {}
+ WebAssemblyPeepholeLegacy() : MachineFunctionPass(ID) {}
};
} // end anonymous namespace
-char WebAssemblyPeephole::ID = 0;
-INITIALIZE_PASS(WebAssemblyPeephole, DEBUG_TYPE,
+char WebAssemblyPeepholeLegacy::ID = 0;
+INITIALIZE_PASS(WebAssemblyPeepholeLegacy, DEBUG_TYPE,
"WebAssembly peephole optimizations", false, false)
-FunctionPass *llvm::createWebAssemblyPeephole() {
- return new WebAssemblyPeephole();
+FunctionPass *llvm::createWebAssemblyPeepholeLegacyPass() {
+ return new WebAssemblyPeepholeLegacy();
}
/// If desirable, rewrite NewReg to a drop register.
@@ -110,7 +115,8 @@ static bool maybeRewriteToFallthrough(MachineInstr &MI, MachineBasicBlock &MBB,
return true;
}
-bool WebAssemblyPeephole::runOnMachineFunction(MachineFunction &MF) {
+static bool peephole(MachineFunction &MF, TargetLibraryInfo &LibInfo,
+ const LibcallLoweringInfo &LibcallLowering) {
LLVM_DEBUG({
dbgs() << "********** Peephole **********\n"
<< "********** Function: " << MF.getName() << '\n';
@@ -121,12 +127,6 @@ bool WebAssemblyPeephole::runOnMachineFunction(MachineFunction &MF) {
const WebAssemblySubtarget &Subtarget =
MF.getSubtarget<WebAssemblySubtarget>();
const auto &TII = *Subtarget.getInstrInfo();
- auto &LibInfo =
- getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(MF.getFunction());
-
- const LibcallLoweringInfo &LibcallLowering =
- getAnalysis<LibcallLoweringInfoWrapper>().getLibcallLowering(
- *MF.getFunction().getParent(), Subtarget);
RTLIB::LibcallImpl MemcpyImpl = LibcallLowering.getLibcallImpl(RTLIB::MEMCPY);
RTLIB::LibcallImpl MemmoveImpl =
@@ -179,3 +179,34 @@ bool WebAssemblyPeephole::runOnMachineFunction(MachineFunction &MF) {
return Changed;
}
+
+bool WebAssemblyPeepholeLegacy::runOnMachineFunction(MachineFunction &MF) {
+ TargetLibraryInfo &LibInfo =
+ getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(MF.getFunction());
+ const WebAssemblySubtarget &Subtarget =
+ MF.getSubtarget<WebAssemblySubtarget>();
+ const LibcallLoweringInfo &LibcallLowering =
+ getAnalysis<LibcallLoweringInfoWrapper>().getLibcallLowering(
+ *MF.getFunction().getParent(), Subtarget);
+ return peephole(MF, LibInfo, LibcallLowering);
+}
+
+PreservedAnalyses
+WebAssemblyPeepholePass::run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ TargetLibraryInfo &LibInfo =
+ MFAM.getResult<FunctionAnalysisManagerMachineFunctionProxy>(MF)
+ .getManager()
+ .getResult<TargetLibraryAnalysis>(MF.getFunction());
+ const WebAssemblySubtarget &Subtarget =
+ MF.getSubtarget<WebAssemblySubtarget>();
+ const LibcallLoweringInfo &LibcallLowering =
+ MFAM.getResult<ModuleAnalysisManagerMachineFunctionProxy>(MF)
+ .getCachedResult<LibcallLoweringModuleAnalysis>(
+ *MF.getFunction().getParent())
+ ->getLibcallLowering(Subtarget);
+ return peephole(MF, LibInfo, LibcallLowering)
+ ? getMachineFunctionPassPreservedAnalyses()
+ .preserveSet<CFGAnalyses>()
+ : PreservedAnalyses::all();
+}
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyRegColoring.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyRegColoring.cpp
index 6efe09d775c4b..a1c4b02fb290d 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyRegColoring.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyRegColoring.cpp
@@ -20,8 +20,12 @@
#include "WebAssemblyMachineFunctionInfo.h"
#include "llvm/CodeGen/LiveIntervals.h"
#include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
+#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
+#include "llvm/CodeGen/MachinePassManager.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/Passes.h"
+#include "llvm/CodeGen/SlotIndexes.h"
+#include "llvm/IR/Analysis.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
@@ -29,10 +33,10 @@ using namespace llvm;
#define DEBUG_TYPE "wasm-reg-coloring"
namespace {
-class WebAssemblyRegColoring final : public MachineFunctionPass {
+class WebAssemblyRegColoringLegacy final : public MachineFunctionPass {
public:
static char ID; // Pass identification, replacement for typeid
- WebAssemblyRegColoring() : MachineFunctionPass(ID) {}
+ WebAssemblyRegColoringLegacy() : MachineFunctionPass(ID) {}
StringRef getPassName() const override {
return "WebAssembly Register Coloring";
@@ -48,17 +52,15 @@ class WebAssemblyRegColoring final : public MachineFunctionPass {
}
bool runOnMachineFunction(MachineFunction &MF) override;
-
-private:
};
} // end anonymous namespace
-char WebAssemblyRegColoring::ID = 0;
-INITIALIZE_PASS(WebAssemblyRegColoring, DEBUG_TYPE,
+char WebAssemblyRegColoringLegacy::ID = 0;
+INITIALIZE_PASS(WebAssemblyRegColoringLegacy, DEBUG_TYPE,
"Minimize number of registers used", false, false)
-FunctionPass *llvm::createWebAssemblyRegColoring() {
- return new WebAssemblyRegColoring();
+FunctionPass *llvm::createWebAssemblyRegColoringLegacyPass() {
+ return new WebAssemblyRegColoringLegacy();
}
// Compute the total spill weight for VReg.
@@ -217,7 +219,8 @@ static void undefInvalidDbgValues(
}
}
-bool WebAssemblyRegColoring::runOnMachineFunction(MachineFunction &MF) {
+static bool regColoring(MachineFunction &MF, LiveIntervals *Liveness,
+ const MachineBlockFrequencyInfo *MBFI) {
LLVM_DEBUG({
dbgs() << "********** Register Coloring **********\n"
<< "********** Function: " << MF.getName() << '\n';
@@ -231,9 +234,6 @@ bool WebAssemblyRegColoring::runOnMachineFunction(MachineFunction &MF) {
return false;
MachineRegisterInfo *MRI = &MF.getRegInfo();
- LiveIntervals *Liveness = &getAnalysis<LiveIntervalsWrapperPass>().getLIS();
- const MachineBlockFrequencyInfo *MBFI =
- &getAnalysis<MachineBlockFrequencyInfoWrapperPass>().getMBFI();
WebAssemblyFunctionInfo &MFI = *MF.getInfo<WebAssemblyFunctionInfo>();
// We don't preserve SSA form.
@@ -329,3 +329,27 @@ bool WebAssemblyRegColoring::runOnMachineFunction(MachineFunction &MF) {
}
return true;
}
+
+bool WebAssemblyRegColoringLegacy::runOnMachineFunction(MachineFunction &MF) {
+ LiveIntervals *Liveness = &getAnalysis<LiveIntervalsWrapperPass>().getLIS();
+ const MachineBlockFrequencyInfo *MBFI =
+ &getAnalysis<MachineBlockFrequencyInfoWrapperPass>().getMBFI();
+ return regColoring(MF, Liveness, MBFI);
+}
+
+PreservedAnalyses
+WebAssemblyRegColoringPass::run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ // TODO(boomanaiden154): We duplicate this check from above to avoid computing
+ // analyses if we do not need to. We should remove it when remove support for
+ // the LegacyPM and are able to simplify things.
+ if (MF.exposesReturnsTwice())
+ return PreservedAnalyses::all();
+ LiveIntervals *Liveness = &MFAM.getResult<LiveIntervalsAnalysis>(MF);
+ const MachineBlockFrequencyInfo *MBFI =
+ &MFAM.getResult<MachineBlockFrequencyAnalysis>(MF);
+ return regColoring(MF, Liveness, MBFI)
+ ? getMachineFunctionPassPreservedAnalyses()
+ .preserveSet<CFGAnalyses>()
+ : PreservedAnalyses::all();
+}
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyRegNumbering.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyRegNumbering.cpp
index 17a914408a886..e3f4aedcbe6a8 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyRegNumbering.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyRegNumbering.cpp
@@ -18,8 +18,11 @@
#include "WebAssemblyUtilities.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
+#include "llvm/CodeGen/MachinePassManager.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/Passes.h"
+#include "llvm/IR/Analysis.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
@@ -27,7 +30,7 @@ using namespace llvm;
#define DEBUG_TYPE "wasm-reg-numbering"
namespace {
-class WebAssemblyRegNumbering final : public MachineFunctionPass {
+class WebAssemblyRegNumberingLegacy final : public MachineFunctionPass {
StringRef getPassName() const override {
return "WebAssembly Register Numbering";
}
@@ -41,20 +44,20 @@ class WebAssemblyRegNumbering final : public MachineFunctionPass {
public:
static char ID; // Pass identification, replacement for typeid
- WebAssemblyRegNumbering() : MachineFunctionPass(ID) {}
+ WebAssemblyRegNumberingLegacy() : MachineFunctionPass(ID) {}
};
} // end anonymous namespace
-char WebAssemblyRegNumbering::ID = 0;
-INITIALIZE_PASS(WebAssemblyRegNumbering, DEBUG_TYPE,
+char WebAssemblyRegNumberingLegacy::ID = 0;
+INITIALIZE_PASS(WebAssemblyRegNumberingLegacy, DEBUG_TYPE,
"Assigns WebAssembly register numbers for virtual registers",
false, false)
-FunctionPass *llvm::createWebAssemblyRegNumbering() {
- return new WebAssemblyRegNumbering();
+FunctionPass *llvm::createWebAssemblyRegNumberingLegacyPass() {
+ return new WebAssemblyRegNumberingLegacy();
}
-bool WebAssemblyRegNumbering::runOnMachineFunction(MachineFunction &MF) {
+static bool regNumbering(MachineFunction &MF) {
LLVM_DEBUG(dbgs() << "********** Register Numbering **********\n"
"********** Function: "
<< MF.getName() << '\n');
@@ -105,3 +108,15 @@ bool WebAssemblyRegNumbering::runOnMachineFunction(MachineFunction &MF) {
return true;
}
+
+bool WebAssemblyRegNumberingLegacy::runOnMachineFunction(MachineFunction &MF) {
+ return regNumbering(MF);
+}
+
+PreservedAnalyses
+WebAssemblyRegNumberingPass::run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ return regNumbering(MF) ? getMachineFunctionPassPreservedAnalyses()
+ .preserveSet<CFGAnalyses>()
+ : PreservedAnalyses::all();
+}
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyRegStackify.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyRegStackify.cpp
index 2b34e2cf5ca6b..0b10f68ccbca0 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyRegStackify.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyRegStackify.cpp
@@ -28,9 +28,13 @@
#include "llvm/CodeGen/LiveIntervals.h"
#include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
#include "llvm/CodeGen/MachineDominators.h"
+#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
+#include "llvm/CodeGen/MachinePassManager.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/Passes.h"
+#include "llvm/CodeGen/SlotIndexes.h"
+#include "llvm/IR/Analysis.h"
#include "llvm/IR/GlobalAlias.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
@@ -40,7 +44,7 @@ using namespace llvm;
#define DEBUG_TYPE "wasm-reg-stackify"
namespace {
-class WebAssemblyRegStackify final : public MachineFunctionPass {
+class WebAssemblyRegStackifyLegacy final : public MachineFunctionPass {
bool Optimize;
StringRef getPassName() const override {
@@ -65,19 +69,21 @@ class WebAssemblyRegStackify final : public MachineFunctionPass {
public:
static char ID; // Pass identification, replacement for typeid
- WebAssemblyRegStackify(CodeGenOptLevel OptLevel)
+ WebAssemblyRegStackifyLegacy(CodeGenOptLevel OptLevel)
: MachineFunctionPass(ID), Optimize(OptLevel != CodeGenOptLevel::None) {}
- WebAssemblyRegStackify() : WebAssemblyRegStackify(CodeGenOptLevel::Default) {}
+ WebAssemblyRegStackifyLegacy()
+ : WebAssemblyRegStackifyLegacy(CodeGenOptLevel::Default) {}
};
} // end anonymous namespace
-char WebAssemblyRegStackify::ID = 0;
-INITIALIZE_PASS(WebAssemblyRegStackify, DEBUG_TYPE,
+char WebAssemblyRegStackifyLegacy::ID = 0;
+INITIALIZE_PASS(WebAssemblyRegStackifyLegacy, DEBUG_TYPE,
"Reorder instructions to use the WebAssembly value stack",
false, false)
-FunctionPass *llvm::createWebAssemblyRegStackify(CodeGenOptLevel OptLevel) {
- return new WebAssemblyRegStackify(OptLevel);
+FunctionPass *
+llvm::createWebAssemblyRegStackifyLegacyPass(CodeGenOptLevel OptLevel) {
+ return new WebAssemblyRegStackifyLegacy(OptLevel);
}
// Decorate the given instruction with implicit operands that enforce the
@@ -826,7 +832,8 @@ class CommutingState {
};
} // end anonymous namespace
-bool WebAssemblyRegStackify::runOnMachineFunction(MachineFunction &MF) {
+static bool regStackify(MachineFunction &MF, bool Optimize,
+ MachineDominatorTree *MDT, LiveIntervals *LIS) {
LLVM_DEBUG(dbgs() << "********** Register Stackifying **********\n"
"********** Function: "
<< MF.getName() << '\n');
@@ -835,11 +842,9 @@ bool WebAssemblyRegStackify::runOnMachineFunction(MachineFunction &MF) {
MachineRegisterInfo &MRI = MF.getRegInfo();
WebAssemblyFunctionInfo &MFI = *MF.getInfo<WebAssemblyFunctionInfo>();
const auto *TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
- MachineDominatorTree *MDT = nullptr;
- LiveIntervals *LIS = nullptr;
if (Optimize) {
- MDT = &getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
- LIS = &getAnalysis<LiveIntervalsWrapperPass>().getLIS();
+ assert(MDT && "expected MDT to be available");
+ assert(LIS && "expected LIS to be available");
}
// Walk the instructions from the bottom up. Currently we don't look past
@@ -1021,3 +1026,31 @@ bool WebAssemblyRegStackify::runOnMachineFunction(MachineFunction &MF) {
return Changed;
}
+
+bool WebAssemblyRegStackifyLegacy::runOnMachineFunction(MachineFunction &MF) {
+ MachineDominatorTree *MDT = nullptr;
+ LiveIntervals *LIS = nullptr;
+ if (Optimize) {
+ MDT = &getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
+ LIS = &getAnalysis<LiveIntervalsWrapperPass>().getLIS();
+ }
+ return regStackify(MF, Optimize, MDT, LIS);
+}
+
+PreservedAnalyses
+WebAssemblyRegStackifyPass::run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ MachineDominatorTree *MDT = nullptr;
+ LiveIntervals *LIS = nullptr;
+ if (Optimize) {
+ MDT = &MFAM.getResult<MachineDominatorTreeAnalysis>(MF);
+ LIS = &MFAM.getResult<LiveIntervalsAnalysis>(MF);
+ }
+ bool Changed = regStackify(MF, Optimize, MDT, LIS);
+ if (!Changed)
+ return PreservedAnalyses::all();
+ return getMachineFunctionPassPreservedAnalyses()
+ .preserveSet<CFGAnalyses>()
+ .preserve<LiveIntervalsAnalysis>()
+ .preserve<SlotIndexesAnalysis>();
+}
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyReplacePhysRegs.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyReplacePhysRegs.cpp
index cb152f500436a..f2d3fc12b6af9 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyReplacePhysRegs.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyReplacePhysRegs.cpp
@@ -22,9 +22,12 @@
#include "WebAssembly.h"
#include "WebAssemblyMachineFunctionInfo.h"
#include "WebAssemblySubtarget.h"
+#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/CodeGen/MachinePassManager.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/Passes.h"
+#include "llvm/IR/Analysis.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
@@ -32,10 +35,10 @@ using namespace llvm;
#define DEBUG_TYPE "wasm-replace-phys-regs"
namespace {
-class WebAssemblyReplacePhysRegs final : public MachineFunctionPass {
+class WebAssemblyReplacePhysRegsLegacy final : public MachineFunctionPass {
public:
static char ID; // Pass identification, replacement for typeid
- WebAssemblyReplacePhysRegs() : MachineFunctionPass(ID) {}
+ WebAssemblyReplacePhysRegsLegacy() : MachineFunctionPass(ID) {}
private:
StringRef getPassName() const override {
@@ -51,16 +54,16 @@ class WebAssemblyReplacePhysRegs final : public MachineFunctionPass {
};
} // end anonymous namespace
-char WebAssemblyReplacePhysRegs::ID = 0;
-INITIALIZE_PASS(WebAssemblyReplacePhysRegs, DEBUG_TYPE,
+char WebAssemblyReplacePhysRegsLegacy::ID = 0;
+INITIALIZE_PASS(WebAssemblyReplacePhysRegsLegacy, DEBUG_TYPE,
"Replace physical registers with virtual registers", false,
false)
-FunctionPass *llvm::createWebAssemblyReplacePhysRegs() {
- return new WebAssemblyReplacePhysRegs();
+FunctionPass *llvm::createWebAssemblyReplacePhysRegsLegacyPass() {
+ return new WebAssemblyReplacePhysRegsLegacy();
}
-bool WebAssemblyReplacePhysRegs::runOnMachineFunction(MachineFunction &MF) {
+static bool replacePhysRegs(MachineFunction &MF) {
LLVM_DEBUG({
dbgs() << "********** Replace Physical Registers **********\n"
<< "********** Function: " << MF.getName() << '\n';
@@ -70,9 +73,6 @@ bool WebAssemblyReplacePhysRegs::runOnMachineFunction(MachineFunction &MF) {
auto &TRI = *MF.getSubtarget<WebAssemblySubtarget>().getRegisterInfo();
bool Changed = false;
- assert(!mustPreserveAnalysisID(LiveIntervalsID) &&
- "LiveIntervals shouldn't be active yet!");
-
for (unsigned PReg = WebAssembly::NoRegister + 1;
PReg < WebAssembly::NUM_TARGET_REGS; ++PReg) {
// Skip fake registers that are never used explicitly.
@@ -105,3 +105,19 @@ bool WebAssemblyReplacePhysRegs::runOnMachineFunction(MachineFunction &MF) {
return Changed;
}
+
+bool WebAssemblyReplacePhysRegsLegacy::runOnMachineFunction(
+ MachineFunction &MF) {
+ assert(!mustPreserveAnalysisID(LiveIntervalsID) &&
+ "LiveIntervals shouldn't be active yet!");
+
+ return replacePhysRegs(MF);
+}
+
+PreservedAnalyses
+WebAssemblyReplacePhysRegsPass::run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ return replacePhysRegs(MF) ? getMachineFunctionPassPreservedAnalyses()
+ .preserveSet<CFGAnalyses>()
+ : PreservedAnalyses::all();
+}
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp
index ac44dcc2be674..343be643fd7c3 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp
@@ -102,22 +102,22 @@ LLVMInitializeWebAssemblyTarget() {
initializeWebAssemblyArgumentMoveLegacyPass(PR);
initializeWebAssemblyAsmPrinterPass(PR);
initializeWebAssemblySetP2AlignOperandsLegacyPass(PR);
- initializeWebAssemblyReplacePhysRegsPass(PR);
- initializeWebAssemblyOptimizeLiveIntervalsPass(PR);
- initializeWebAssemblyMemIntrinsicResultsPass(PR);
- initializeWebAssemblyRegStackifyPass(PR);
- initializeWebAssemblyRegColoringPass(PR);
+ initializeWebAssemblyReplacePhysRegsLegacyPass(PR);
+ initializeWebAssemblyOptimizeLiveIntervalsLegacyPass(PR);
+ initializeWebAssemblyMemIntrinsicResultsLegacyPass(PR);
+ initializeWebAssemblyRegStackifyLegacyPass(PR);
+ initializeWebAssemblyRegColoringLegacyPass(PR);
initializeWebAssemblyNullifyDebugValueListsLegacyPass(PR);
initializeWebAssemblyFixIrreducibleControlFlowLegacyPass(PR);
- initializeWebAssemblyLateEHPreparePass(PR);
- initializeWebAssemblyExceptionInfoPass(PR);
- initializeWebAssemblyCFGSortPass(PR);
- initializeWebAssemblyCFGStackifyPass(PR);
- initializeWebAssemblyExplicitLocalsPass(PR);
- initializeWebAssemblyLowerBrUnlessPass(PR);
- initializeWebAssemblyRegNumberingPass(PR);
- initializeWebAssemblyDebugFixupPass(PR);
- initializeWebAssemblyPeepholePass(PR);
+ initializeWebAssemblyLateEHPrepareLegacyPass(PR);
+ initializeWebAssemblyExceptionInfoWrapperPassPass(PR);
+ initializeWebAssemblyCFGSortLegacyPass(PR);
+ initializeWebAssemblyCFGStackifyLegacyPass(PR);
+ initializeWebAssemblyExplicitLocalsLegacyPass(PR);
+ initializeWebAssemblyLowerBrUnlessLegacyPass(PR);
+ initializeWebAssemblyRegNumberingLegacyPass(PR);
+ initializeWebAssemblyDebugFixupLegacyPass(PR);
+ initializeWebAssemblyPeepholeLegacyPass(PR);
initializeWebAssemblyMCLowerPrePassPass(PR);
initializeWebAssemblyFixBrTableDefaultsLegacyPass(PR);
initializeWebAssemblyDAGToDAGISelLegacyPass(PR);
@@ -451,20 +451,20 @@ void WebAssemblyPassConfig::addPreEmitPass() {
// Do various transformations for exception handling.
// Every CFG-changing optimizations should come before this.
if (TM->Options.ExceptionModel == ExceptionHandling::Wasm)
- addPass(createWebAssemblyLateEHPrepare());
+ addPass(createWebAssemblyLateEHPrepareLegacyPass());
// Now that we have a prologue and epilogue and all frame indices are
// rewritten, eliminate SP and FP. This allows them to be stackified,
// colored, and numbered with the rest of the registers.
- addPass(createWebAssemblyReplacePhysRegs());
+ addPass(createWebAssemblyReplacePhysRegsLegacyPass());
// Preparations and optimizations related to register stackification.
if (getOptLevel() != CodeGenOptLevel::None) {
// Depend on LiveIntervals and perform some optimizations on it.
- addPass(createWebAssemblyOptimizeLiveIntervals());
+ addPass(createWebAssemblyOptimizeLiveIntervalsLegacyPass());
// Prepare memory intrinsic calls for register stackifying.
- addPass(createWebAssemblyMemIntrinsicResults());
+ addPass(createWebAssemblyMemIntrinsicResultsLegacyPass());
}
// Mark registers as representing wasm's value stack. This is a key
@@ -472,39 +472,39 @@ void WebAssemblyPassConfig::addPreEmitPass() {
// MemIntrinsicResults above) very late, so that it sees as much code as
// possible, including code emitted by PEI and expanded by late tail
// duplication.
- addPass(createWebAssemblyRegStackify(getOptLevel()));
+ addPass(createWebAssemblyRegStackifyLegacyPass(getOptLevel()));
if (getOptLevel() != CodeGenOptLevel::None) {
// Run the register coloring pass to reduce the total number of registers.
// This runs after stackification so that it doesn't consider registers
// that become stackified.
- addPass(createWebAssemblyRegColoring());
+ addPass(createWebAssemblyRegColoringLegacyPass());
}
// Sort the blocks of the CFG into topological order, a prerequisite for
// BLOCK and LOOP markers.
- addPass(createWebAssemblyCFGSort());
+ addPass(createWebAssemblyCFGSortLegacyPass());
// Insert BLOCK and LOOP markers.
- addPass(createWebAssemblyCFGStackify());
+ addPass(createWebAssemblyCFGStackifyLegacyPass());
// Insert explicit local.get and local.set operators.
if (!WasmDisableExplicitLocals)
- addPass(createWebAssemblyExplicitLocals());
+ addPass(createWebAssemblyExplicitLocalsLegacyPass());
// Lower br_unless into br_if.
- addPass(createWebAssemblyLowerBrUnless());
+ addPass(createWebAssemblyLowerBrUnlessLegacyPass());
// Perform the very last peephole optimizations on the code.
if (getOptLevel() != CodeGenOptLevel::None)
- addPass(createWebAssemblyPeephole());
+ addPass(createWebAssemblyPeepholeLegacyPass());
// Create a mapping from LLVM CodeGen virtual registers to wasm registers.
- addPass(createWebAssemblyRegNumbering());
+ addPass(createWebAssemblyRegNumberingLegacyPass());
// Fix debug_values whose defs have been stackified.
if (!WasmDisableExplicitLocals)
- addPass(createWebAssemblyDebugFixup());
+ addPass(createWebAssemblyDebugFixupLegacyPass());
// Collect information to prepare for MC lowering / asm printing.
addPass(createWebAssemblyMCLowerPrePass());
>From 8b441f995ef1ad38949a7fc73c7e093b50f9f2a5 Mon Sep 17 00:00:00 2001
From: Aiden Grossman <aidengrossman at google.com>
Date: Fri, 17 Jul 2026 21:28:27 +0000
Subject: [PATCH 2/4] fix
Created using spr 1.3.7
---
llvm/lib/Target/WebAssembly/WebAssembly.h | 4 ++--
llvm/lib/Target/WebAssembly/WebAssemblyCodeGenPassBuilder.cpp | 2 +-
llvm/lib/Target/WebAssembly/WebAssemblyMCLowerPrePass.cpp | 4 ++--
3 files changed, 5 insertions(+), 5 deletions(-)
diff --git a/llvm/lib/Target/WebAssembly/WebAssembly.h b/llvm/lib/Target/WebAssembly/WebAssembly.h
index aa15f112eca26..fc28aff21aa42 100644
--- a/llvm/lib/Target/WebAssembly/WebAssembly.h
+++ b/llvm/lib/Target/WebAssembly/WebAssembly.h
@@ -301,8 +301,8 @@ class WebAssemblyPeepholePass
FunctionPass *createWebAssemblyPeepholeLegacyPass();
-class WebAssemblyMCLowerPass
- : public RequiredPassInfoMixin<WebAssemblyMCLowerPass> {
+class WebAssemblyMCLowerPrePass
+ : public RequiredPassInfoMixin<WebAssemblyMCLowerPrePass> {
public:
PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
};
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyCodeGenPassBuilder.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyCodeGenPassBuilder.cpp
index 14540e4288781..239d2473c9088 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyCodeGenPassBuilder.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyCodeGenPassBuilder.cpp
@@ -242,7 +242,7 @@ void WebAssemblyCodeGenPassBuilder::addPreEmitPass(
// Collect information to prepare for MC lowering / asm printing.
flushFPMsToMPM(PMW);
- addModulePass(WebAssemblyMCLowerPass(), PMW);
+ addModulePass(WebAssemblyMCLowerPrePass(), PMW);
}
} // namespace
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyMCLowerPrePass.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyMCLowerPrePass.cpp
index 318b2dd13f79e..7aa5b6570edee 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyMCLowerPrePass.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyMCLowerPrePass.cpp
@@ -100,8 +100,8 @@ bool WebAssemblyMCLowerPreLegacy::runOnModule(Module &M) {
return mcLower(M, MMI);
}
-PreservedAnalyses WebAssemblyMCLowerPass::run(Module &M,
- ModuleAnalysisManager &MAM) {
+PreservedAnalyses WebAssemblyMCLowerPrePass::run(Module &M,
+ ModuleAnalysisManager &MAM) {
MachineModuleInfo &MMI = MAM.getResult<MachineModuleAnalysis>(M).getMMI();
return mcLower(M, MMI) ? PreservedAnalyses::none().preserveSet<CFGAnalyses>()
: PreservedAnalyses::all();
>From e7da919ac05899ea7d6e7b2624ead78fa6ebd19a Mon Sep 17 00:00:00 2001
From: Aiden Grossman <aidengrossman at google.com>
Date: Fri, 17 Jul 2026 22:19:14 +0000
Subject: [PATCH 3/4] =?UTF-8?q?[=F0=9D=98=80=F0=9D=97=BD=F0=9D=97=BF]=20ch?=
=?UTF-8?q?anges=20introduced=20through=20rebase?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Created using spr 1.3.7
[skip ci]
---
llvm/lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp | 1 +
1 file changed, 1 insertion(+)
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp
index 0596fdad12821..92b1dc9502d4b 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp
@@ -14,6 +14,7 @@
#include "WebAssemblyExceptionInfo.h"
#include "WebAssemblyUtilities.h"
#include "llvm/ADT/PostOrderIterator.h"
+#include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
#include "llvm/CodeGen/MachineDominanceFrontier.h"
#include "llvm/CodeGen/MachineDominators.h"
#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
>From c6257d628a0b9f77ac4996876c2482120494443b Mon Sep 17 00:00:00 2001
From: Aiden Grossman <aidengrossman at google.com>
Date: Wed, 22 Jul 2026 15:39:39 +0000
Subject: [PATCH 4/4] fix
Created using spr 1.3.7
---
.../WebAssembly/WebAssemblyMCLowerPrePass.cpp | 19 +++++++++++++++----
1 file changed, 15 insertions(+), 4 deletions(-)
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyMCLowerPrePass.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyMCLowerPrePass.cpp
index 3659a33bb3cce..dce9838698e55 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyMCLowerPrePass.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyMCLowerPrePass.cpp
@@ -17,8 +17,10 @@
#include "WebAssemblyUtilities.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineFunctionAnalysis.h"
#include "llvm/CodeGen/MachineModuleInfo.h"
#include "llvm/CodeGen/MachineModuleInfoImpls.h"
+#include "llvm/CodeGen/MachinePassManager.h"
#include "llvm/CodeGen/Passes.h"
#include "llvm/IR/Analysis.h"
#include "llvm/IR/Module.h"
@@ -64,11 +66,12 @@ ModulePass *llvm::createWebAssemblyMCLowerPreLegacyPass() {
//
// The information stored here is essential for emitExternalDecls in the Wasm
// AsmPrinter
-static void mcLower(Module &M, MachineModuleInfo &MMI) {
+static void mcLower(Module &M, MachineModuleInfo &MMI,
+ llvm::function_ref<MachineFunction *(Function *)> GetMF) {
MachineModuleInfoWasm &MMIW = MMI.getObjFileInfo<MachineModuleInfoWasm>();
for (Function &F : M) {
- MachineFunction *MF = MMI.getMachineFunction(F);
+ MachineFunction *MF = GetMF(&F);
if (!MF)
continue;
@@ -96,13 +99,21 @@ bool WebAssemblyMCLowerPreLegacy::runOnModule(Module &M) {
if (!MMIWP)
return false;
MachineModuleInfo &MMI = MMIWP->getMMI();
- mcLower(M, MMI);
+ mcLower(M, MMI, [MMIWP](Function *F) {
+ return MMIWP->getMMI().getMachineFunction(*F);
+ });
return false;
}
PreservedAnalyses WebAssemblyMCLowerPrePass::run(Module &M,
ModuleAnalysisManager &MAM) {
MachineModuleInfo &MMI = MAM.getResult<MachineModuleAnalysis>(M).getMMI();
- mcLower(M, MMI);
+ mcLower(M, MMI, [&](Function *F) {
+ MachineFunctionAnalysis::Result *MFA =
+ MAM.getResult<FunctionAnalysisManagerModuleProxy>(M)
+ .getManager()
+ .getCachedResult<MachineFunctionAnalysis>(*F);
+ return MFA ? &MFA->getMF() : nullptr;
+ });
return PreservedAnalyses::all();
}
More information about the llvm-branch-commits
mailing list