1//===-- WasmEHPrepare - Prepare excepton handling for WebAssembly --------===//
2//
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
6//
7//===----------------------------------------------------------------------===//
8//
9// This transformation is designed for use by code generators which use
10// WebAssembly exception handling scheme. This currently supports C++
11// exceptions.
12//
13// WebAssembly exception handling uses Windows exception IR for the middle level
14// representation. This pass does the following transformation for every
15// catchpad block:
16// (In C-style pseudocode)
17//
18// - Before:
19// catchpad ...
20// exn = wasm.get.exception();
21// selector = wasm.get.selector();
22// ...
23//
24// - After:
25// catchpad ...
26// exn = wasm.catch(WebAssembly::CPP_EXCEPTION);
27// // Only add below in case it's not a single catch (...)
28// wasm.landingpad.index(index);
29// __wasm_lpad_context.lpad_index = index;
30// __wasm_lpad_context.lsda = wasm.lsda();
31// personality_fn(exn);
32// selector = __wasm_lpad_context.selector;
33// ...
34//
35//
36// * Background: Direct personality function call
37// In WebAssembly EH, the VM is responsible for unwinding the stack once an
38// exception is thrown. After the stack is unwound, the control flow is
39// transferred to WebAssembly 'catch' instruction.
40//
41// Unwinding the stack is not done by libunwind but the VM, so the personality
42// function (e.g. in libcxxabi) cannot be called from libunwind during the
43// unwinding process. So after a catch instruction, we insert a direct call to
44// the personality instead.
45//
46// In Itanium EH, if the personality function decides there is no matching catch
47// clause in a call frame and no cleanup action to perform, the unwinder doesn't
48// stop there and continues unwinding. But in Wasm EH, the unwinder stops at
49// every call frame with a catch instruction, after which the personality
50// function is called from the compiler-generated user code here.
51//
52// In libunwind, we have this struct that serves as a communication channel
53// between the compiler-generated user code and the personality function in
54// libcxxabi.
55//
56// struct _Unwind_LandingPadContext {
57// uintptr_t lpad_index;
58// uintptr_t lsda;
59// uintptr_t selector;
60// };
61// struct _Unwind_LandingPadContext __wasm_lpad_context = ...;
62//
63// We pass a landing pad index, and the address of LSDA for the current function
64// to the personality function, and we retrieve the selector after it returns.
65//
66//===----------------------------------------------------------------------===//
67
68#include "llvm/CodeGen/WasmEHPrepare.h"
69#include "llvm/CodeGen/MachineBasicBlock.h"
70#include "llvm/CodeGen/Passes.h"
71#include "llvm/CodeGen/WasmEHInfo.h"
72#include "llvm/IR/EHPersonalities.h"
73#include "llvm/IR/IRBuilder.h"
74#include "llvm/IR/IntrinsicsWebAssembly.h"
75#include "llvm/IR/Module.h"
76#include "llvm/IR/RuntimeLibcalls.h"
77#include "llvm/InitializePasses.h"
78#include "llvm/Transforms/Utils/BasicBlockUtils.h"
79
80using namespace llvm;
81
82#define DEBUG_TYPE "wasm-eh-prepare"
83
84namespace {
85class WasmEHPrepareImpl {
86 friend class WasmEHPrepare;
87
88 Type *LPadContextTy = nullptr; // type of 'struct _Unwind_LandingPadContext'
89 GlobalVariable *LPadContextGV = nullptr; // __wasm_lpad_context
90
91 // Field addresses of struct _Unwind_LandingPadContext
92 Value *LPadIndexField = nullptr; // lpad_index field
93 Value *LSDAField = nullptr; // lsda field
94 Value *SelectorField = nullptr; // selector
95
96 Function *ThrowF = nullptr; // wasm.throw() intrinsic
97 Function *LPadIndexF = nullptr; // wasm.landingpad.index() intrinsic
98 Function *LSDAF = nullptr; // wasm.lsda() intrinsic
99 Function *GetExnF = nullptr; // wasm.get.exception() intrinsic
100 Function *CatchF = nullptr; // wasm.catch() intrinsic
101 Function *GetSelectorF = nullptr; // wasm.get.ehselector() intrinsic
102 FunctionCallee PersonalityF = nullptr;
103
104 bool prepareThrows(Function &F);
105 bool prepareEHPads(Function &F);
106 void prepareEHPad(BasicBlock *BB, bool NeedPersonality, unsigned Index = 0);
107
108public:
109 WasmEHPrepareImpl() = default;
110 WasmEHPrepareImpl(Type *LPadContextTy_) : LPadContextTy(LPadContextTy_) {}
111 bool runOnFunction(Function &F);
112};
113
114class WasmEHPrepare : public FunctionPass {
115 WasmEHPrepareImpl P;
116
117public:
118 static char ID; // Pass identification, replacement for typeid
119
120 WasmEHPrepare() : FunctionPass(ID) {}
121 bool doInitialization(Module &M) override;
122 bool runOnFunction(Function &F) override { return P.runOnFunction(F); }
123
124 StringRef getPassName() const override {
125 return "WebAssembly Exception handling preparation";
126 }
127};
128
129} // end anonymous namespace
130
131PreservedAnalyses WasmEHPreparePass::run(Function &F,
132 FunctionAnalysisManager &) {
133 auto &Context = F.getContext();
134 auto *I32Ty = Type::getInt32Ty(C&: Context);
135 auto *PtrTy = PointerType::get(C&: Context, AddressSpace: 0);
136 auto *LPadContextTy =
137 StructType::get(elt1: I32Ty /*lpad_index*/, elts: PtrTy /*lsda*/, elts: I32Ty /*selector*/);
138 WasmEHPrepareImpl P(LPadContextTy);
139 bool Changed = P.runOnFunction(F);
140 return Changed ? PreservedAnalyses::none() : PreservedAnalyses ::all();
141}
142
143char WasmEHPrepare::ID = 0;
144INITIALIZE_PASS_BEGIN(WasmEHPrepare, DEBUG_TYPE,
145 "Prepare WebAssembly exceptions", false, false)
146INITIALIZE_PASS_END(WasmEHPrepare, DEBUG_TYPE, "Prepare WebAssembly exceptions",
147 false, false)
148
149FunctionPass *llvm::createWasmEHPass() { return new WasmEHPrepare(); }
150
151bool WasmEHPrepare::doInitialization(Module &M) {
152 IRBuilder<> IRB(M.getContext());
153 P.LPadContextTy = StructType::get(elt1: IRB.getInt32Ty(), // lpad_index
154 elts: IRB.getPtrTy(), // lsda
155 elts: IRB.getInt32Ty() // selector
156 );
157 return false;
158}
159
160// Erase the specified BBs if the BB does not have any remaining predecessors,
161// and also all its dead children.
162template <typename Container>
163static void eraseDeadBBsAndChildren(const Container &BBs) {
164 SmallVector<BasicBlock *, 8> WL(BBs.begin(), BBs.end());
165 while (!WL.empty()) {
166 auto *BB = WL.pop_back_val();
167 if (!pred_empty(BB))
168 continue;
169 WL.append(in_start: succ_begin(BB), in_end: succ_end(BB));
170 DeleteDeadBlock(BB);
171 }
172}
173
174bool WasmEHPrepareImpl::runOnFunction(Function &F) {
175 bool Changed = false;
176 Changed |= prepareThrows(F);
177 Changed |= prepareEHPads(F);
178 return Changed;
179}
180
181bool WasmEHPrepareImpl::prepareThrows(Function &F) {
182 Module &M = *F.getParent();
183 IRBuilder<> IRB(F.getContext());
184 bool Changed = false;
185
186 // wasm.throw() intinsic, which will be lowered to wasm 'throw' instruction.
187 ThrowF = Intrinsic::getOrInsertDeclaration(M: &M, id: Intrinsic::wasm_throw);
188 // Insert an unreachable instruction after a call to @llvm.wasm.throw and
189 // delete all following instructions within the BB, and delete all the dead
190 // children of the BB as well.
191 for (User *U : ThrowF->users()) {
192 auto *ThrowI = dyn_cast<CallInst>(Val: U);
193 if (!ThrowI || ThrowI->getFunction() != &F)
194 continue;
195 Changed = true;
196 auto *BB = ThrowI->getParent();
197 SmallVector<BasicBlock *, 4> Succs(successors(BB));
198 BB->erase(FromIt: std::next(x: BasicBlock::iterator(ThrowI)), ToIt: BB->end());
199 IRB.SetInsertPoint(BB);
200 IRB.CreateUnreachable();
201 eraseDeadBBsAndChildren(BBs: Succs);
202 }
203
204 return Changed;
205}
206
207bool WasmEHPrepareImpl::prepareEHPads(Function &F) {
208 Module &M = *F.getParent();
209 IRBuilder<> IRB(F.getContext());
210
211 SmallVector<BasicBlock *, 16> CatchPads;
212 SmallVector<BasicBlock *, 16> CleanupPads;
213 for (BasicBlock &BB : F) {
214 if (!BB.isEHPad())
215 continue;
216 BasicBlock::iterator Pad = BB.getFirstNonPHIIt();
217 if (isa<CatchPadInst>(Val: Pad))
218 CatchPads.push_back(Elt: &BB);
219 else if (isa<CleanupPadInst>(Val: Pad))
220 CleanupPads.push_back(Elt: &BB);
221 }
222 if (CatchPads.empty() && CleanupPads.empty())
223 return false;
224
225 if (!F.hasPersonalityFn())
226 return false;
227
228 auto Personality = classifyEHPersonality(Pers: F.getPersonalityFn());
229
230 if (!isScopedEHPersonality(Pers: Personality)) {
231 report_fatal_error(reason: "Function '" + F.getName() +
232 "' does not have a supported Wasm personality function");
233 }
234 assert(F.hasPersonalityFn() && "Personality function not found");
235
236 // __wasm_lpad_context global variable.
237 // This variable should be thread local. If the target does not support TLS,
238 // we depend on CoalesceFeaturesAndStripAtomics to downgrade it to
239 // non-thread-local ones, in which case we don't allow this object to be
240 // linked with other objects using shared memory.
241 LPadContextGV = M.getOrInsertGlobal(Name: "__wasm_lpad_context", Ty: LPadContextTy);
242 LPadContextGV->setThreadLocalMode(GlobalValue::GeneralDynamicTLSModel);
243
244 LPadIndexField = LPadContextGV;
245 LSDAField = IRB.CreateConstInBoundsGEP2_32(Ty: LPadContextTy, Ptr: LPadContextGV, Idx0: 0, Idx1: 1,
246 Name: "lsda_gep");
247 SelectorField = IRB.CreateConstInBoundsGEP2_32(Ty: LPadContextTy, Ptr: LPadContextGV,
248 Idx0: 0, Idx1: 2, Name: "selector_gep");
249
250 // wasm.landingpad.index() intrinsic, which is to specify landingpad index
251 LPadIndexF =
252 Intrinsic::getOrInsertDeclaration(M: &M, id: Intrinsic::wasm_landingpad_index);
253 // wasm.lsda() intrinsic. Returns the address of LSDA table for the current
254 // function.
255 LSDAF = Intrinsic::getOrInsertDeclaration(M: &M, id: Intrinsic::wasm_lsda);
256 // wasm.get.exception() and wasm.get.ehselector() intrinsics. Calls to these
257 // are generated in clang.
258 GetExnF =
259 Intrinsic::getOrInsertDeclaration(M: &M, id: Intrinsic::wasm_get_exception);
260 GetSelectorF =
261 Intrinsic::getOrInsertDeclaration(M: &M, id: Intrinsic::wasm_get_ehselector);
262
263 // wasm.catch() will be lowered down to wasm 'catch' instruction in
264 // instruction selection.
265 CatchF = Intrinsic::getOrInsertDeclaration(M: &M, id: Intrinsic::wasm_catch);
266
267 auto *PersPrototype =
268 FunctionType::get(Result: IRB.getInt32Ty(), Params: {IRB.getPtrTy()}, isVarArg: false);
269 PersonalityF =
270 M.getOrInsertFunction(Name: getEHPersonalityName(Pers: Personality), T: PersPrototype);
271
272 if (Function *F = dyn_cast<Function>(Val: PersonalityF.getCallee()))
273 F->setDoesNotThrow();
274
275 unsigned Index = 0;
276 for (auto *BB : CatchPads) {
277 auto *CPI = cast<CatchPadInst>(Val: BB->getFirstNonPHIIt());
278 // In case of a single catch (...), we don't need to emit a personalify
279 // function call
280 if (CPI->arg_size() == 1 &&
281 cast<Constant>(Val: CPI->getArgOperand(i: 0))->isNullValue())
282 prepareEHPad(BB, NeedPersonality: false);
283 else
284 prepareEHPad(BB, NeedPersonality: true, Index: Index++);
285 }
286
287 // Cleanup pads don't need a personality function call.
288 for (auto *BB : CleanupPads)
289 prepareEHPad(BB, NeedPersonality: false);
290
291 return true;
292}
293
294// Prepare an EH pad for Wasm EH handling. If NeedPersonality is false, Index is
295// ignored.
296void WasmEHPrepareImpl::prepareEHPad(BasicBlock *BB, bool NeedPersonality,
297 unsigned Index) {
298 assert(BB->isEHPad() && "BB is not an EHPad!");
299 IRBuilder<> IRB(BB->getContext());
300 IRB.SetInsertPoint(TheBB: BB, IP: BB->getFirstInsertionPt());
301
302 auto *FPI = cast<FuncletPadInst>(Val: BB->getFirstNonPHIIt());
303 Instruction *GetExnCI = nullptr, *GetSelectorCI = nullptr;
304 for (auto &U : FPI->uses()) {
305 if (auto *CI = dyn_cast<CallInst>(Val: U.getUser())) {
306 if (CI->getCalledOperand() == GetExnF)
307 GetExnCI = CI;
308 if (CI->getCalledOperand() == GetSelectorF)
309 GetSelectorCI = CI;
310 }
311 }
312
313 // Cleanup pads do not have any of wasm.get.exception() or
314 // wasm.get.ehselector() calls. We need to do nothing.
315 if (!GetExnCI) {
316 assert(!GetSelectorCI &&
317 "wasm.get.ehselector() cannot exist w/o wasm.get.exception()");
318 return;
319 }
320
321 // Replace wasm.get.exception intrinsic with wasm.catch intrinsic, which will
322 // be lowered to wasm 'catch' instruction. We do this mainly because
323 // instruction selection cannot handle wasm.get.exception intrinsic's token
324 // argument.
325 Instruction *CatchCI =
326 IRB.CreateCall(Callee: CatchF, Args: {IRB.getInt32(C: WebAssembly::CPP_EXCEPTION)}, Name: "exn");
327 GetExnCI->replaceAllUsesWith(V: CatchCI);
328 GetExnCI->eraseFromParent();
329
330 // In case it is a catchpad with single catch (...) or a cleanuppad, we don't
331 // need to call personality function because we don't need a selector.
332 if (!NeedPersonality) {
333 if (GetSelectorCI) {
334 assert(GetSelectorCI->use_empty() &&
335 "wasm.get.ehselector() still has uses!");
336 GetSelectorCI->eraseFromParent();
337 }
338 return;
339 }
340 IRB.SetInsertPoint(CatchCI->getNextNode());
341
342 // This is to create a map of <landingpad EH label, landingpad index> in
343 // SelectionDAGISel, which is to be used in EHStreamer to emit LSDA tables.
344 // Pseudocode: wasm.landingpad.index(Index);
345 IRB.CreateCall(Callee: LPadIndexF, Args: {FPI, IRB.getInt32(C: Index)});
346
347 // Pseudocode: __wasm_lpad_context.lpad_index = index;
348 IRB.CreateStore(Val: IRB.getInt32(C: Index), Ptr: LPadIndexField);
349
350 auto *CPI = cast<CatchPadInst>(Val: FPI);
351 // TODO Sometimes storing the LSDA address every time is not necessary, in
352 // case it is already set in a dominating EH pad and there is no function call
353 // between from that EH pad to here. Consider optimizing those cases.
354 // Pseudocode: __wasm_lpad_context.lsda = wasm.lsda();
355 IRB.CreateStore(Val: IRB.CreateCall(Callee: LSDAF), Ptr: LSDAField);
356
357 // Pseudocode: personality_fn(exn);
358 CallInst *PersCI =
359 IRB.CreateCall(Callee: PersonalityF, Args: CatchCI, OpBundles: OperandBundleDef("funclet", CPI));
360 PersCI->setDoesNotThrow();
361
362 // Pseudocode: int selector = __wasm_lpad_context.selector;
363 Instruction *Selector =
364 IRB.CreateLoad(Ty: IRB.getInt32Ty(), Ptr: SelectorField, Name: "selector");
365
366 // Replace the return value from wasm.get.ehselector() with the selector value
367 // loaded from __wasm_lpad_context.selector.
368 assert(GetSelectorCI && "wasm.get.ehselector() call does not exist");
369 GetSelectorCI->replaceAllUsesWith(V: Selector);
370 GetSelectorCI->eraseFromParent();
371}
372