1 //=== WebAssemblyLateEHPrepare.cpp - WebAssembly Exception Preparation -===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
10 /// \brief Does various transformations for exception handling.
12 //===----------------------------------------------------------------------===//
14 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
15 #include "WebAssembly.h"
16 #include "WebAssemblySubtarget.h"
17 #include "WebAssemblyUtilities.h"
18 #include "llvm/ADT/SmallSet.h"
19 #include "llvm/CodeGen/MachineInstrBuilder.h"
20 #include "llvm/CodeGen/WasmEHFuncInfo.h"
21 #include "llvm/MC/MCAsmInfo.h"
22 #include "llvm/Support/Debug.h"
25 #define DEBUG_TYPE "wasm-late-eh-prepare"
28 class WebAssemblyLateEHPrepare final : public MachineFunctionPass {
29 StringRef getPassName() const override {
30 return "WebAssembly Late Prepare Exception";
33 bool runOnMachineFunction(MachineFunction &MF) override;
34 bool addCatches(MachineFunction &MF);
35 bool replaceFuncletReturns(MachineFunction &MF);
36 bool removeUnnecessaryUnreachables(MachineFunction &MF);
37 bool addExceptionExtraction(MachineFunction &MF);
38 bool restoreStackPointer(MachineFunction &MF);
41 static char ID; // Pass identification, replacement for typeid
42 WebAssemblyLateEHPrepare() : MachineFunctionPass(ID) {}
44 } // end anonymous namespace
46 char WebAssemblyLateEHPrepare::ID = 0;
47 INITIALIZE_PASS(WebAssemblyLateEHPrepare, DEBUG_TYPE,
48 "WebAssembly Late Exception Preparation", false, false)
50 FunctionPass *llvm::createWebAssemblyLateEHPrepare() {
51 return new WebAssemblyLateEHPrepare();
54 // Returns the nearest EH pad that dominates this instruction. This does not use
55 // dominator analysis; it just does BFS on its predecessors until arriving at an
56 // EH pad. This assumes valid EH scopes so the first EH pad it arrives in all
57 // possible search paths should be the same.
58 // Returns nullptr in case it does not find any EH pad in the search, or finds
59 // multiple different EH pads.
60 static MachineBasicBlock *getMatchingEHPad(MachineInstr *MI) {
61 MachineFunction *MF = MI->getParent()->getParent();
62 SmallVector<MachineBasicBlock *, 2> WL;
63 SmallPtrSet<MachineBasicBlock *, 2> Visited;
64 WL.push_back(MI->getParent());
65 MachineBasicBlock *EHPad = nullptr;
67 MachineBasicBlock *MBB = WL.pop_back_val();
68 if (Visited.count(MBB))
72 if (EHPad && EHPad != MBB)
77 if (MBB == &MF->front())
79 WL.append(MBB->pred_begin(), MBB->pred_end());
84 // Erase the specified BBs if the BB does not have any remaining predecessors,
85 // and also all its dead children.
86 template <typename Container>
87 static void eraseDeadBBsAndChildren(const Container &MBBs) {
88 SmallVector<MachineBasicBlock *, 8> WL(MBBs.begin(), MBBs.end());
90 MachineBasicBlock *MBB = WL.pop_back_val();
91 if (!MBB->pred_empty())
93 SmallVector<MachineBasicBlock *, 4> Succs(MBB->succ_begin(),
95 WL.append(MBB->succ_begin(), MBB->succ_end());
96 for (auto *Succ : Succs)
97 MBB->removeSuccessor(Succ);
98 MBB->eraseFromParent();
102 bool WebAssemblyLateEHPrepare::runOnMachineFunction(MachineFunction &MF) {
103 LLVM_DEBUG(dbgs() << "********** Late EH Prepare **********\n"
104 "********** Function: "
105 << MF.getName() << '\n');
107 if (MF.getTarget().getMCAsmInfo()->getExceptionHandlingType() !=
108 ExceptionHandling::Wasm)
111 bool Changed = false;
112 if (MF.getFunction().hasPersonalityFn()) {
113 Changed |= addCatches(MF);
114 Changed |= replaceFuncletReturns(MF);
116 Changed |= removeUnnecessaryUnreachables(MF);
117 if (MF.getFunction().hasPersonalityFn()) {
118 Changed |= addExceptionExtraction(MF);
119 Changed |= restoreStackPointer(MF);
124 // Add catch instruction to beginning of catchpads and cleanuppads.
125 bool WebAssemblyLateEHPrepare::addCatches(MachineFunction &MF) {
126 bool Changed = false;
127 const auto &TII = *MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
128 MachineRegisterInfo &MRI = MF.getRegInfo();
129 for (auto &MBB : MF) {
132 auto InsertPos = MBB.begin();
133 if (InsertPos->isEHLabel()) // EH pad starts with an EH label
135 Register DstReg = MRI.createVirtualRegister(&WebAssembly::EXNREFRegClass);
136 BuildMI(MBB, InsertPos, MBB.begin()->getDebugLoc(),
137 TII.get(WebAssembly::CATCH), DstReg);
143 bool WebAssemblyLateEHPrepare::replaceFuncletReturns(MachineFunction &MF) {
144 bool Changed = false;
145 const auto &TII = *MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
147 for (auto &MBB : MF) {
148 auto Pos = MBB.getFirstTerminator();
149 if (Pos == MBB.end())
151 MachineInstr *TI = &*Pos;
153 switch (TI->getOpcode()) {
154 case WebAssembly::CATCHRET: {
155 // Replace a catchret with a branch
156 MachineBasicBlock *TBB = TI->getOperand(0).getMBB();
157 if (!MBB.isLayoutSuccessor(TBB))
158 BuildMI(MBB, TI, TI->getDebugLoc(), TII.get(WebAssembly::BR))
160 TI->eraseFromParent();
164 case WebAssembly::CLEANUPRET:
165 case WebAssembly::RETHROW_IN_CATCH: {
166 // Replace a cleanupret/rethrow_in_catch with a rethrow
167 auto *EHPad = getMatchingEHPad(TI);
168 auto CatchPos = EHPad->begin();
169 if (CatchPos->isEHLabel()) // EH pad starts with an EH label
171 MachineInstr *Catch = &*CatchPos;
172 Register ExnReg = Catch->getOperand(0).getReg();
173 BuildMI(MBB, TI, TI->getDebugLoc(), TII.get(WebAssembly::RETHROW))
175 TI->eraseFromParent();
184 bool WebAssemblyLateEHPrepare::removeUnnecessaryUnreachables(
185 MachineFunction &MF) {
186 bool Changed = false;
187 for (auto &MBB : MF) {
188 for (auto &MI : MBB) {
189 if (MI.getOpcode() != WebAssembly::THROW &&
190 MI.getOpcode() != WebAssembly::RETHROW)
194 // The instruction after the throw should be an unreachable or a branch to
195 // another BB that should eventually lead to an unreachable. Delete it
196 // because throw itself is a terminator, and also delete successors if
198 MBB.erase(std::next(MI.getIterator()), MBB.end());
199 SmallVector<MachineBasicBlock *, 8> Succs(MBB.succ_begin(),
201 for (auto *Succ : Succs)
202 if (!Succ->isEHPad())
203 MBB.removeSuccessor(Succ);
204 eraseDeadBBsAndChildren(Succs);
211 // Wasm uses 'br_on_exn' instruction to check the tag of an exception. It takes
212 // exnref type object returned by 'catch', and branches to the destination if it
213 // matches a given tag. We currently use __cpp_exception symbol to represent the
214 // tag for all C++ exceptions.
216 // block $l (result i32)
218 // ;; exnref $e is on the stack at this point
219 // br_on_exn $l $e ;; branch to $l with $e's arguments
222 // ;; Here we expect the extracted values are on top of the wasm value stack
223 // ... Handle exception using values ...
225 // br_on_exn takes an exnref object and branches if it matches the given tag.
226 // There can be multiple br_on_exn instructions if we want to match for another
227 // tag, but for now we only test for __cpp_exception tag, and if it does not
228 // match, i.e., it is a foreign exception, we rethrow it.
230 // In the destination BB that's the target of br_on_exn, extracted exception
231 // values (in C++'s case a single i32, which represents an exception pointer)
232 // are placed on top of the wasm stack. Because we can't model wasm stack in
233 // LLVM instruction, we use 'extract_exception' pseudo instruction to retrieve
234 // it. The pseudo instruction will be deleted later.
235 bool WebAssemblyLateEHPrepare::addExceptionExtraction(MachineFunction &MF) {
236 const auto &TII = *MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
237 MachineRegisterInfo &MRI = MF.getRegInfo();
238 auto *EHInfo = MF.getWasmEHFuncInfo();
239 SmallVector<MachineInstr *, 16> ExtractInstrs;
240 SmallVector<MachineInstr *, 8> ToDelete;
241 for (auto &MBB : MF) {
242 for (auto &MI : MBB) {
243 if (MI.getOpcode() == WebAssembly::EXTRACT_EXCEPTION_I32) {
244 if (MI.getOperand(0).isDead())
245 ToDelete.push_back(&MI);
247 ExtractInstrs.push_back(&MI);
251 bool Changed = !ToDelete.empty() || !ExtractInstrs.empty();
252 for (auto *MI : ToDelete)
253 MI->eraseFromParent();
254 if (ExtractInstrs.empty())
257 // Find terminate pads.
258 SmallSet<MachineBasicBlock *, 8> TerminatePads;
259 for (auto &MBB : MF) {
260 for (auto &MI : MBB) {
262 const MachineOperand &CalleeOp = MI.getOperand(0);
263 if (CalleeOp.isGlobal() && CalleeOp.getGlobal()->getName() ==
264 WebAssembly::ClangCallTerminateFn)
265 TerminatePads.insert(getMatchingEHPad(&MI));
270 for (auto *Extract : ExtractInstrs) {
271 MachineBasicBlock *EHPad = getMatchingEHPad(Extract);
272 assert(EHPad && "No matching EH pad for extract_exception");
273 auto CatchPos = EHPad->begin();
274 if (CatchPos->isEHLabel()) // EH pad starts with an EH label
276 MachineInstr *Catch = &*CatchPos;
278 if (Catch->getNextNode() != Extract)
279 EHPad->insert(Catch->getNextNode(), Extract->removeFromParent());
283 // %exnref:exnref = catch
284 // %exn:i32 = extract_exception
289 // %exnref:exnref = catch
290 // br_on_exn %thenbb, $__cpp_exception, %exnref
295 // %exn:i32 = extract_exception
297 Register ExnReg = Catch->getOperand(0).getReg();
298 auto *ThenMBB = MF.CreateMachineBasicBlock();
299 auto *ElseMBB = MF.CreateMachineBasicBlock();
300 MF.insert(std::next(MachineFunction::iterator(EHPad)), ElseMBB);
301 MF.insert(std::next(MachineFunction::iterator(ElseMBB)), ThenMBB);
302 ThenMBB->splice(ThenMBB->end(), EHPad, Extract, EHPad->end());
303 ThenMBB->transferSuccessors(EHPad);
304 EHPad->addSuccessor(ThenMBB);
305 EHPad->addSuccessor(ElseMBB);
307 DebugLoc DL = Extract->getDebugLoc();
308 const char *CPPExnSymbol = MF.createExternalSymbolName("__cpp_exception");
309 BuildMI(EHPad, DL, TII.get(WebAssembly::BR_ON_EXN))
311 .addExternalSymbol(CPPExnSymbol)
313 BuildMI(EHPad, DL, TII.get(WebAssembly::BR)).addMBB(ElseMBB);
315 // When this is a terminate pad with __clang_call_terminate() call, we don't
316 // rethrow it anymore and call __clang_call_terminate() with a nullptr
317 // argument, which will call std::terminate().
321 // %exnref:exnref = catch
322 // %exn:i32 = extract_exception
323 // call @__clang_call_terminate(%exn)
328 // %exnref:exnref = catch
329 // br_on_exn %thenbb, $__cpp_exception, %exnref
332 // call @__clang_call_terminate(0)
335 // %exn:i32 = extract_exception
336 // call @__clang_call_terminate(%exn)
338 if (TerminatePads.count(EHPad)) {
339 Function *ClangCallTerminateFn =
340 MF.getFunction().getParent()->getFunction(
341 WebAssembly::ClangCallTerminateFn);
342 assert(ClangCallTerminateFn &&
343 "There is no __clang_call_terminate() function");
344 Register Reg = MRI.createVirtualRegister(&WebAssembly::I32RegClass);
345 BuildMI(ElseMBB, DL, TII.get(WebAssembly::CONST_I32), Reg).addImm(0);
346 BuildMI(ElseMBB, DL, TII.get(WebAssembly::CALL_VOID))
347 .addGlobalAddress(ClangCallTerminateFn)
349 BuildMI(ElseMBB, DL, TII.get(WebAssembly::UNREACHABLE));
352 BuildMI(ElseMBB, DL, TII.get(WebAssembly::RETHROW)).addReg(ExnReg);
353 if (EHInfo->hasEHPadUnwindDest(EHPad))
354 ElseMBB->addSuccessor(EHInfo->getEHPadUnwindDest(EHPad));
361 // After the stack is unwound due to a thrown exception, the __stack_pointer
362 // global can point to an invalid address. This inserts instructions that
363 // restore __stack_pointer global.
364 bool WebAssemblyLateEHPrepare::restoreStackPointer(MachineFunction &MF) {
365 const auto *FrameLowering = static_cast<const WebAssemblyFrameLowering *>(
366 MF.getSubtarget().getFrameLowering());
367 if (!FrameLowering->needsPrologForEH(MF))
369 bool Changed = false;
371 for (auto &MBB : MF) {
376 // Insert __stack_pointer restoring instructions at the beginning of each EH
377 // pad, after the catch instruction. Here it is safe to assume that SP32
378 // holds the latest value of __stack_pointer, because the only exception for
379 // this case is when a function uses the red zone, but that only happens
380 // with leaf functions, and we don't restore __stack_pointer in leaf
382 auto InsertPos = MBB.begin();
383 if (InsertPos->isEHLabel()) // EH pad starts with an EH label
385 if (InsertPos->getOpcode() == WebAssembly::CATCH)
387 FrameLowering->writeSPToGlobal(WebAssembly::SP32, MF, MBB, InsertPos,
388 MBB.begin()->getDebugLoc());