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 <[email protected]> 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 <[email protected]> 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 <[email protected]> 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 <[email protected]> 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(); } _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
