LLVM  10.0.0svn
WebAssemblyLowerEmscriptenEHSjLj.cpp
Go to the documentation of this file.
1 //=== WebAssemblyLowerEmscriptenEHSjLj.cpp - Lower exceptions for Emscripten =//
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 /// \file
10 /// This file lowers exception-related instructions and setjmp/longjmp
11 /// function calls in order to use Emscripten's JavaScript try and catch
12 /// mechanism.
13 ///
14 /// To handle exceptions and setjmp/longjmps, this scheme relies on JavaScript's
15 /// try and catch syntax and relevant exception-related libraries implemented
16 /// in JavaScript glue code that will be produced by Emscripten. This is similar
17 /// to the current Emscripten asm.js exception handling in fastcomp. For
18 /// fastcomp's EH / SjLj scheme, see these files in fastcomp LLVM branch:
19 /// (Location: https://github.com/kripken/emscripten-fastcomp)
20 /// lib/Target/JSBackend/NaCl/LowerEmExceptionsPass.cpp
21 /// lib/Target/JSBackend/NaCl/LowerEmSetjmp.cpp
22 /// lib/Target/JSBackend/JSBackend.cpp
23 /// lib/Target/JSBackend/CallHandlers.h
24 ///
25 /// * Exception handling
26 /// This pass lowers invokes and landingpads into library functions in JS glue
27 /// code. Invokes are lowered into function wrappers called invoke wrappers that
28 /// exist in JS side, which wraps the original function call with JS try-catch.
29 /// If an exception occurred, cxa_throw() function in JS side sets some
30 /// variables (see below) so we can check whether an exception occurred from
31 /// wasm code and handle it appropriately.
32 ///
33 /// * Setjmp-longjmp handling
34 /// This pass lowers setjmp to a reasonably-performant approach for emscripten.
35 /// The idea is that each block with a setjmp is broken up into two parts: the
36 /// part containing setjmp and the part right after the setjmp. The latter part
37 /// is either reached from the setjmp, or later from a longjmp. To handle the
38 /// longjmp, all calls that might longjmp are also called using invoke wrappers
39 /// and thus JS / try-catch. JS longjmp() function also sets some variables so
40 /// we can check / whether a longjmp occurred from wasm code. Each block with a
41 /// function call that might longjmp is also split up after the longjmp call.
42 /// After the longjmp call, we check whether a longjmp occurred, and if it did,
43 /// which setjmp it corresponds to, and jump to the right post-setjmp block.
44 /// We assume setjmp-longjmp handling always run after EH handling, which means
45 /// we don't expect any exception-related instructions when SjLj runs.
46 /// FIXME Currently this scheme does not support indirect call of setjmp,
47 /// because of the limitation of the scheme itself. fastcomp does not support it
48 /// either.
49 ///
50 /// In detail, this pass does following things:
51 ///
52 /// 1) Assumes the existence of global variables: __THREW__, __threwValue
53 /// __THREW__ and __threwValue will be set in invoke wrappers
54 /// in JS glue code. For what invoke wrappers are, refer to 3). These
55 /// variables are used for both exceptions and setjmp/longjmps.
56 /// __THREW__ indicates whether an exception or a longjmp occurred or not. 0
57 /// means nothing occurred, 1 means an exception occurred, and other numbers
58 /// mean a longjmp occurred. In the case of longjmp, __threwValue variable
59 /// indicates the corresponding setjmp buffer the longjmp corresponds to.
60 ///
61 /// * Exception handling
62 ///
63 /// 2) We assume the existence of setThrew and setTempRet0/getTempRet0 functions
64 /// at link time.
65 /// The global variables in 1) will exist in wasm address space,
66 /// but their values should be set in JS code, so these functions
67 /// as interfaces to JS glue code. These functions are equivalent to the
68 /// following JS functions, which actually exist in asm.js version of JS
69 /// library.
70 ///
71 /// function setThrew(threw, value) {
72 /// if (__THREW__ == 0) {
73 /// __THREW__ = threw;
74 /// __threwValue = value;
75 /// }
76 /// }
77 //
78 /// setTempRet0 is called from __cxa_find_matching_catch() in JS glue code.
79 ///
80 /// In exception handling, getTempRet0 indicates the type of an exception
81 /// caught, and in setjmp/longjmp, it means the second argument to longjmp
82 /// function.
83 ///
84 /// 3) Lower
85 /// invoke @func(arg1, arg2) to label %invoke.cont unwind label %lpad
86 /// into
87 /// __THREW__ = 0;
88 /// call @__invoke_SIG(func, arg1, arg2)
89 /// %__THREW__.val = __THREW__;
90 /// __THREW__ = 0;
91 /// if (%__THREW__.val == 1)
92 /// goto %lpad
93 /// else
94 /// goto %invoke.cont
95 /// SIG is a mangled string generated based on the LLVM IR-level function
96 /// signature. After LLVM IR types are lowered to the target wasm types,
97 /// the names for these wrappers will change based on wasm types as well,
98 /// as in invoke_vi (function takes an int and returns void). The bodies of
99 /// these wrappers will be generated in JS glue code, and inside those
100 /// wrappers we use JS try-catch to generate actual exception effects. It
101 /// also calls the original callee function. An example wrapper in JS code
102 /// would look like this:
103 /// function invoke_vi(index,a1) {
104 /// try {
105 /// Module["dynCall_vi"](index,a1); // This calls original callee
106 /// } catch(e) {
107 /// if (typeof e !== 'number' && e !== 'longjmp') throw e;
108 /// asm["setThrew"](1, 0); // setThrew is called here
109 /// }
110 /// }
111 /// If an exception is thrown, __THREW__ will be set to true in a wrapper,
112 /// so we can jump to the right BB based on this value.
113 ///
114 /// 4) Lower
115 /// %val = landingpad catch c1 catch c2 catch c3 ...
116 /// ... use %val ...
117 /// into
118 /// %fmc = call @__cxa_find_matching_catch_N(c1, c2, c3, ...)
119 /// %val = {%fmc, getTempRet0()}
120 /// ... use %val ...
121 /// Here N is a number calculated based on the number of clauses.
122 /// setTempRet0 is called from __cxa_find_matching_catch() in JS glue code.
123 ///
124 /// 5) Lower
125 /// resume {%a, %b}
126 /// into
127 /// call @__resumeException(%a)
128 /// where __resumeException() is a function in JS glue code.
129 ///
130 /// 6) Lower
131 /// call @llvm.eh.typeid.for(type) (intrinsic)
132 /// into
133 /// call @llvm_eh_typeid_for(type)
134 /// llvm_eh_typeid_for function will be generated in JS glue code.
135 ///
136 /// * Setjmp / Longjmp handling
137 ///
138 /// In case calls to longjmp() exists
139 ///
140 /// 1) Lower
141 /// longjmp(buf, value)
142 /// into
143 /// emscripten_longjmp_jmpbuf(buf, value)
144 /// emscripten_longjmp_jmpbuf will be lowered to emscripten_longjmp later.
145 ///
146 /// In case calls to setjmp() exists
147 ///
148 /// 2) In the function entry that calls setjmp, initialize setjmpTable and
149 /// sejmpTableSize as follows:
150 /// setjmpTableSize = 4;
151 /// setjmpTable = (int *) malloc(40);
152 /// setjmpTable[0] = 0;
153 /// setjmpTable and setjmpTableSize are used in saveSetjmp() function in JS
154 /// code.
155 ///
156 /// 3) Lower
157 /// setjmp(buf)
158 /// into
159 /// setjmpTable = saveSetjmp(buf, label, setjmpTable, setjmpTableSize);
160 /// setjmpTableSize = getTempRet0();
161 /// For each dynamic setjmp call, setjmpTable stores its ID (a number which
162 /// is incrementally assigned from 0) and its label (a unique number that
163 /// represents each callsite of setjmp). When we need more entries in
164 /// setjmpTable, it is reallocated in saveSetjmp() in JS code and it will
165 /// return the new table address, and assign the new table size in
166 /// setTempRet0(). saveSetjmp also stores the setjmp's ID into the buffer
167 /// buf. A BB with setjmp is split into two after setjmp call in order to
168 /// make the post-setjmp BB the possible destination of longjmp BB.
169 ///
170 ///
171 /// 4) Lower every call that might longjmp into
172 /// __THREW__ = 0;
173 /// call @__invoke_SIG(func, arg1, arg2)
174 /// %__THREW__.val = __THREW__;
175 /// __THREW__ = 0;
176 /// if (%__THREW__.val != 0 & __threwValue != 0) {
177 /// %label = testSetjmp(mem[%__THREW__.val], setjmpTable,
178 /// setjmpTableSize);
179 /// if (%label == 0)
180 /// emscripten_longjmp(%__THREW__.val, __threwValue);
181 /// setTempRet0(__threwValue);
182 /// } else {
183 /// %label = -1;
184 /// }
185 /// longjmp_result = getTempRet0();
186 /// switch label {
187 /// label 1: goto post-setjmp BB 1
188 /// label 2: goto post-setjmp BB 2
189 /// ...
190 /// default: goto splitted next BB
191 /// }
192 /// testSetjmp examines setjmpTable to see if there is a matching setjmp
193 /// call. After calling an invoke wrapper, if a longjmp occurred, __THREW__
194 /// will be the address of matching jmp_buf buffer and __threwValue be the
195 /// second argument to longjmp. mem[__THREW__.val] is a setjmp ID that is
196 /// stored in saveSetjmp. testSetjmp returns a setjmp label, a unique ID to
197 /// each setjmp callsite. Label 0 means this longjmp buffer does not
198 /// correspond to one of the setjmp callsites in this function, so in this
199 /// case we just chain the longjmp to the caller. (Here we call
200 /// emscripten_longjmp, which is different from emscripten_longjmp_jmpbuf.
201 /// emscripten_longjmp_jmpbuf takes jmp_buf as its first argument, while
202 /// emscripten_longjmp takes an int. Both of them will eventually be lowered
203 /// to emscripten_longjmp in s2wasm, but here we need two signatures - we
204 /// can't translate an int value to a jmp_buf.)
205 /// Label -1 means no longjmp occurred. Otherwise we jump to the right
206 /// post-setjmp BB based on the label.
207 ///
208 ///===----------------------------------------------------------------------===//
209 
210 #include "WebAssembly.h"
211 #include "llvm/IR/CallSite.h"
212 #include "llvm/IR/Dominators.h"
213 #include "llvm/IR/IRBuilder.h"
216 
217 using namespace llvm;
218 
219 #define DEBUG_TYPE "wasm-lower-em-ehsjlj"
220 
222  EHWhitelist("emscripten-cxx-exceptions-whitelist",
223  cl::desc("The list of function names in which Emscripten-style "
224  "exception handling is enabled (see emscripten "
225  "EMSCRIPTEN_CATCHING_WHITELIST options)"),
227 
228 namespace {
229 class WebAssemblyLowerEmscriptenEHSjLj final : public ModulePass {
230  bool EnableEH; // Enable exception handling
231  bool EnableSjLj; // Enable setjmp/longjmp handling
232 
233  GlobalVariable *ThrewGV = nullptr;
234  GlobalVariable *ThrewValueGV = nullptr;
235  Function *GetTempRet0Func = nullptr;
236  Function *SetTempRet0Func = nullptr;
237  Function *ResumeF = nullptr;
238  Function *EHTypeIDF = nullptr;
239  Function *EmLongjmpF = nullptr;
240  Function *EmLongjmpJmpbufF = nullptr;
241  Function *SaveSetjmpF = nullptr;
242  Function *TestSetjmpF = nullptr;
243 
244  // __cxa_find_matching_catch_N functions.
245  // Indexed by the number of clauses in an original landingpad instruction.
246  DenseMap<int, Function *> FindMatchingCatches;
247  // Map of <function signature string, invoke_ wrappers>
248  StringMap<Function *> InvokeWrappers;
249  // Set of whitelisted function names for exception handling
250  std::set<std::string> EHWhitelistSet;
251 
252  StringRef getPassName() const override {
253  return "WebAssembly Lower Emscripten Exceptions";
254  }
255 
256  bool runEHOnFunction(Function &F);
257  bool runSjLjOnFunction(Function &F);
258  Function *getFindMatchingCatch(Module &M, unsigned NumClauses);
259 
260  template <typename CallOrInvoke> Value *wrapInvoke(CallOrInvoke *CI);
261  void wrapTestSetjmp(BasicBlock *BB, Instruction *InsertPt, Value *Threw,
262  Value *SetjmpTable, Value *SetjmpTableSize, Value *&Label,
263  Value *&LongjmpResult, BasicBlock *&EndBB);
264  template <typename CallOrInvoke> Function *getInvokeWrapper(CallOrInvoke *CI);
265 
266  bool areAllExceptionsAllowed() const { return EHWhitelistSet.empty(); }
267  bool canLongjmp(Module &M, const Value *Callee) const;
268  bool isEmAsmCall(Module &M, const Value *Callee) const;
269 
270  void rebuildSSA(Function &F);
271 
272 public:
273  static char ID;
274 
275  WebAssemblyLowerEmscriptenEHSjLj(bool EnableEH = true, bool EnableSjLj = true)
276  : ModulePass(ID), EnableEH(EnableEH), EnableSjLj(EnableSjLj) {
277  EHWhitelistSet.insert(EHWhitelist.begin(), EHWhitelist.end());
278  }
279  bool runOnModule(Module &M) override;
280 
281  void getAnalysisUsage(AnalysisUsage &AU) const override {
283  }
284 };
285 } // End anonymous namespace
286 
288 INITIALIZE_PASS(WebAssemblyLowerEmscriptenEHSjLj, DEBUG_TYPE,
289  "WebAssembly Lower Emscripten Exceptions / Setjmp / Longjmp",
290  false, false)
291 
293  bool EnableSjLj) {
294  return new WebAssemblyLowerEmscriptenEHSjLj(EnableEH, EnableSjLj);
295 }
296 
297 static bool canThrow(const Value *V) {
298  if (const auto *F = dyn_cast<const Function>(V)) {
299  // Intrinsics cannot throw
300  if (F->isIntrinsic())
301  return false;
302  StringRef Name = F->getName();
303  // leave setjmp and longjmp (mostly) alone, we process them properly later
304  if (Name == "setjmp" || Name == "longjmp")
305  return false;
306  return !F->doesNotThrow();
307  }
308  // not a function, so an indirect call - can throw, we can't tell
309  return true;
310 }
311 
312 // Get a global variable with the given name. If it doesn't exist declare it,
313 // which will generate an import and asssumes that it will exist at link time.
315  const char *Name) {
316 
317  auto *GV =
319  if (!GV)
320  report_fatal_error(Twine("unable to create global: ") + Name);
321 
322  return GV;
323 }
324 
325 // Simple function name mangler.
326 // This function simply takes LLVM's string representation of parameter types
327 // and concatenate them with '_'. There are non-alphanumeric characters but llc
328 // is ok with it, and we need to postprocess these names after the lowering
329 // phase anyway.
330 static std::string getSignature(FunctionType *FTy) {
331  std::string Sig;
332  raw_string_ostream OS(Sig);
333  OS << *FTy->getReturnType();
334  for (Type *ParamTy : FTy->params())
335  OS << "_" << *ParamTy;
336  if (FTy->isVarArg())
337  OS << "_...";
338  Sig = OS.str();
339  Sig.erase(remove_if(Sig, isspace), Sig.end());
340  // When s2wasm parses .s file, a comma means the end of an argument. So a
341  // mangled function name can contain any character but a comma.
342  std::replace(Sig.begin(), Sig.end(), ',', '.');
343  return Sig;
344 }
345 
346 // Returns __cxa_find_matching_catch_N function, where N = NumClauses + 2.
347 // This is because a landingpad instruction contains two more arguments, a
348 // personality function and a cleanup bit, and __cxa_find_matching_catch_N
349 // functions are named after the number of arguments in the original landingpad
350 // instruction.
351 Function *
352 WebAssemblyLowerEmscriptenEHSjLj::getFindMatchingCatch(Module &M,
353  unsigned NumClauses) {
354  if (FindMatchingCatches.count(NumClauses))
355  return FindMatchingCatches[NumClauses];
356  PointerType *Int8PtrTy = Type::getInt8PtrTy(M.getContext());
357  SmallVector<Type *, 16> Args(NumClauses, Int8PtrTy);
358  FunctionType *FTy = FunctionType::get(Int8PtrTy, Args, false);
361  "__cxa_find_matching_catch_" + Twine(NumClauses + 2), &M);
362  FindMatchingCatches[NumClauses] = F;
363  return F;
364 }
365 
366 // Generate invoke wrapper seqence with preamble and postamble
367 // Preamble:
368 // __THREW__ = 0;
369 // Postamble:
370 // %__THREW__.val = __THREW__; __THREW__ = 0;
371 // Returns %__THREW__.val, which indicates whether an exception is thrown (or
372 // whether longjmp occurred), for future use.
373 template <typename CallOrInvoke>
374 Value *WebAssemblyLowerEmscriptenEHSjLj::wrapInvoke(CallOrInvoke *CI) {
375  LLVMContext &C = CI->getModule()->getContext();
376 
377  // If we are calling a function that is noreturn, we must remove that
378  // attribute. The code we insert here does expect it to return, after we
379  // catch the exception.
380  if (CI->doesNotReturn()) {
381  if (auto *F = dyn_cast<Function>(CI->getCalledValue()))
382  F->removeFnAttr(Attribute::NoReturn);
383  CI->removeAttribute(AttributeList::FunctionIndex, Attribute::NoReturn);
384  }
385 
386  IRBuilder<> IRB(C);
387  IRB.SetInsertPoint(CI);
388 
389  // Pre-invoke
390  // __THREW__ = 0;
391  IRB.CreateStore(IRB.getInt32(0), ThrewGV);
392 
393  // Invoke function wrapper in JavaScript
395  // Put the pointer to the callee as first argument, so it can be called
396  // within the invoke wrapper later
397  Args.push_back(CI->getCalledValue());
398  Args.append(CI->arg_begin(), CI->arg_end());
399  CallInst *NewCall = IRB.CreateCall(getInvokeWrapper(CI), Args);
400  NewCall->takeName(CI);
402  NewCall->setDebugLoc(CI->getDebugLoc());
403 
404  // Because we added the pointer to the callee as first argument, all
405  // argument attribute indices have to be incremented by one.
406  SmallVector<AttributeSet, 8> ArgAttributes;
407  const AttributeList &InvokeAL = CI->getAttributes();
408 
409  // No attributes for the callee pointer.
410  ArgAttributes.push_back(AttributeSet());
411  // Copy the argument attributes from the original
412  for (unsigned I = 0, E = CI->getNumArgOperands(); I < E; ++I)
413  ArgAttributes.push_back(InvokeAL.getParamAttributes(I));
414 
415  AttrBuilder FnAttrs(InvokeAL.getFnAttributes());
416  if (FnAttrs.contains(Attribute::AllocSize)) {
417  // The allocsize attribute (if any) referes to parameters by index and needs
418  // to be adjusted.
419  unsigned SizeArg;
420  Optional<unsigned> NEltArg;
421  std::tie(SizeArg, NEltArg) = FnAttrs.getAllocSizeArgs();
422  SizeArg += 1;
423  if (NEltArg.hasValue())
424  NEltArg = NEltArg.getValue() + 1;
425  FnAttrs.addAllocSizeAttr(SizeArg, NEltArg);
426  }
427 
428  // Reconstruct the AttributesList based on the vector we constructed.
429  AttributeList NewCallAL =
430  AttributeList::get(C, AttributeSet::get(C, FnAttrs),
431  InvokeAL.getRetAttributes(), ArgAttributes);
432  NewCall->setAttributes(NewCallAL);
433 
434  CI->replaceAllUsesWith(NewCall);
435 
436  // Post-invoke
437  // %__THREW__.val = __THREW__; __THREW__ = 0;
438  Value *Threw =
439  IRB.CreateLoad(IRB.getInt32Ty(), ThrewGV, ThrewGV->getName() + ".val");
440  IRB.CreateStore(IRB.getInt32(0), ThrewGV);
441  return Threw;
442 }
443 
444 // Get matching invoke wrapper based on callee signature
445 template <typename CallOrInvoke>
446 Function *WebAssemblyLowerEmscriptenEHSjLj::getInvokeWrapper(CallOrInvoke *CI) {
447  Module *M = CI->getModule();
449  Value *Callee = CI->getCalledValue();
450  FunctionType *CalleeFTy;
451  if (auto *F = dyn_cast<Function>(Callee))
452  CalleeFTy = F->getFunctionType();
453  else {
454  auto *CalleeTy = cast<PointerType>(Callee->getType())->getElementType();
455  CalleeFTy = dyn_cast<FunctionType>(CalleeTy);
456  }
457 
458  std::string Sig = getSignature(CalleeFTy);
459  if (InvokeWrappers.find(Sig) != InvokeWrappers.end())
460  return InvokeWrappers[Sig];
461 
462  // Put the pointer to the callee as first argument
463  ArgTys.push_back(PointerType::getUnqual(CalleeFTy));
464  // Add argument types
465  ArgTys.append(CalleeFTy->param_begin(), CalleeFTy->param_end());
466 
467  FunctionType *FTy = FunctionType::get(CalleeFTy->getReturnType(), ArgTys,
468  CalleeFTy->isVarArg());
469  Function *F =
470  Function::Create(FTy, GlobalValue::ExternalLinkage, "__invoke_" + Sig, M);
471  InvokeWrappers[Sig] = F;
472  return F;
473 }
474 
475 bool WebAssemblyLowerEmscriptenEHSjLj::canLongjmp(Module &M,
476  const Value *Callee) const {
477  if (auto *CalleeF = dyn_cast<Function>(Callee))
478  if (CalleeF->isIntrinsic())
479  return false;
480 
481  // Attempting to transform inline assembly will result in something like:
482  // call void @__invoke_void(void ()* asm ...)
483  // which is invalid because inline assembly blocks do not have addresses
484  // and can't be passed by pointer. The result is a crash with illegal IR.
485  if (isa<InlineAsm>(Callee))
486  return false;
487  StringRef CalleeName = Callee->getName();
488 
489  // The reason we include malloc/free here is to exclude the malloc/free
490  // calls generated in setjmp prep / cleanup routines.
491  if (CalleeName == "setjmp" || CalleeName == "malloc" || CalleeName == "free")
492  return false;
493 
494  // There are functions in JS glue code
495  if (CalleeName == "__resumeException" || CalleeName == "llvm_eh_typeid_for" ||
496  CalleeName == "saveSetjmp" || CalleeName == "testSetjmp" ||
497  CalleeName == "getTempRet0" || CalleeName == "setTempRet0")
498  return false;
499 
500  // __cxa_find_matching_catch_N functions cannot longjmp
501  if (Callee->getName().startswith("__cxa_find_matching_catch_"))
502  return false;
503 
504  // Exception-catching related functions
505  if (CalleeName == "__cxa_begin_catch" || CalleeName == "__cxa_end_catch" ||
506  CalleeName == "__cxa_allocate_exception" || CalleeName == "__cxa_throw" ||
507  CalleeName == "__clang_call_terminate")
508  return false;
509 
510  // Otherwise we don't know
511  return true;
512 }
513 
514 bool WebAssemblyLowerEmscriptenEHSjLj::isEmAsmCall(Module &M,
515  const Value *Callee) const {
516  StringRef CalleeName = Callee->getName();
517  // This is an exhaustive list from Emscripten's <emscripten/em_asm.h>.
518  return CalleeName == "emscripten_asm_const_int" ||
519  CalleeName == "emscripten_asm_const_double" ||
520  CalleeName == "emscripten_asm_const_int_sync_on_main_thread" ||
521  CalleeName == "emscripten_asm_const_double_sync_on_main_thread" ||
522  CalleeName == "emscripten_asm_const_async_on_main_thread";
523 }
524 
525 // Generate testSetjmp function call seqence with preamble and postamble.
526 // The code this generates is equivalent to the following JavaScript code:
527 // if (%__THREW__.val != 0 & threwValue != 0) {
528 // %label = _testSetjmp(mem[%__THREW__.val], setjmpTable, setjmpTableSize);
529 // if (%label == 0)
530 // emscripten_longjmp(%__THREW__.val, threwValue);
531 // setTempRet0(threwValue);
532 // } else {
533 // %label = -1;
534 // }
535 // %longjmp_result = getTempRet0();
536 //
537 // As output parameters. returns %label, %longjmp_result, and the BB the last
538 // instruction (%longjmp_result = ...) is in.
539 void WebAssemblyLowerEmscriptenEHSjLj::wrapTestSetjmp(
540  BasicBlock *BB, Instruction *InsertPt, Value *Threw, Value *SetjmpTable,
541  Value *SetjmpTableSize, Value *&Label, Value *&LongjmpResult,
542  BasicBlock *&EndBB) {
543  Function *F = BB->getParent();
544  LLVMContext &C = BB->getModule()->getContext();
545  IRBuilder<> IRB(C);
546  IRB.SetInsertPoint(InsertPt);
547 
548  // if (%__THREW__.val != 0 & threwValue != 0)
549  IRB.SetInsertPoint(BB);
550  BasicBlock *ThenBB1 = BasicBlock::Create(C, "if.then1", F);
551  BasicBlock *ElseBB1 = BasicBlock::Create(C, "if.else1", F);
552  BasicBlock *EndBB1 = BasicBlock::Create(C, "if.end", F);
553  Value *ThrewCmp = IRB.CreateICmpNE(Threw, IRB.getInt32(0));
554  Value *ThrewValue = IRB.CreateLoad(IRB.getInt32Ty(), ThrewValueGV,
555  ThrewValueGV->getName() + ".val");
556  Value *ThrewValueCmp = IRB.CreateICmpNE(ThrewValue, IRB.getInt32(0));
557  Value *Cmp1 = IRB.CreateAnd(ThrewCmp, ThrewValueCmp, "cmp1");
558  IRB.CreateCondBr(Cmp1, ThenBB1, ElseBB1);
559 
560  // %label = _testSetjmp(mem[%__THREW__.val], _setjmpTable, _setjmpTableSize);
561  // if (%label == 0)
562  IRB.SetInsertPoint(ThenBB1);
563  BasicBlock *ThenBB2 = BasicBlock::Create(C, "if.then2", F);
564  BasicBlock *EndBB2 = BasicBlock::Create(C, "if.end2", F);
565  Value *ThrewInt = IRB.CreateIntToPtr(Threw, Type::getInt32PtrTy(C),
566  Threw->getName() + ".i32p");
567  Value *LoadedThrew = IRB.CreateLoad(IRB.getInt32Ty(), ThrewInt,
568  ThrewInt->getName() + ".loaded");
569  Value *ThenLabel = IRB.CreateCall(
570  TestSetjmpF, {LoadedThrew, SetjmpTable, SetjmpTableSize}, "label");
571  Value *Cmp2 = IRB.CreateICmpEQ(ThenLabel, IRB.getInt32(0));
572  IRB.CreateCondBr(Cmp2, ThenBB2, EndBB2);
573 
574  // emscripten_longjmp(%__THREW__.val, threwValue);
575  IRB.SetInsertPoint(ThenBB2);
576  IRB.CreateCall(EmLongjmpF, {Threw, ThrewValue});
577  IRB.CreateUnreachable();
578 
579  // setTempRet0(threwValue);
580  IRB.SetInsertPoint(EndBB2);
581  IRB.CreateCall(SetTempRet0Func, ThrewValue);
582  IRB.CreateBr(EndBB1);
583 
584  IRB.SetInsertPoint(ElseBB1);
585  IRB.CreateBr(EndBB1);
586 
587  // longjmp_result = getTempRet0();
588  IRB.SetInsertPoint(EndBB1);
589  PHINode *LabelPHI = IRB.CreatePHI(IRB.getInt32Ty(), 2, "label");
590  LabelPHI->addIncoming(ThenLabel, EndBB2);
591 
592  LabelPHI->addIncoming(IRB.getInt32(-1), ElseBB1);
593 
594  // Output parameter assignment
595  Label = LabelPHI;
596  EndBB = EndBB1;
597  LongjmpResult = IRB.CreateCall(GetTempRet0Func, None, "longjmp_result");
598 }
599 
600 void WebAssemblyLowerEmscriptenEHSjLj::rebuildSSA(Function &F) {
601  DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
602  DT.recalculate(F); // CFG has been changed
603  SSAUpdater SSA;
604  for (BasicBlock &BB : F) {
605  for (Instruction &I : BB) {
606  SSA.Initialize(I.getType(), I.getName());
607  SSA.AddAvailableValue(&BB, &I);
608  for (auto UI = I.use_begin(), UE = I.use_end(); UI != UE;) {
609  Use &U = *UI;
610  ++UI;
611  auto *User = cast<Instruction>(U.getUser());
612  if (auto *UserPN = dyn_cast<PHINode>(User))
613  if (UserPN->getIncomingBlock(U) == &BB)
614  continue;
615 
616  if (DT.dominates(&I, User))
617  continue;
619  }
620  }
621  }
622 }
623 
624 bool WebAssemblyLowerEmscriptenEHSjLj::runOnModule(Module &M) {
625  LLVM_DEBUG(dbgs() << "********** Lower Emscripten EH & SjLj **********\n");
626 
627  LLVMContext &C = M.getContext();
628  IRBuilder<> IRB(C);
629 
630  Function *SetjmpF = M.getFunction("setjmp");
631  Function *LongjmpF = M.getFunction("longjmp");
632  bool SetjmpUsed = SetjmpF && !SetjmpF->use_empty();
633  bool LongjmpUsed = LongjmpF && !LongjmpF->use_empty();
634  bool DoSjLj = EnableSjLj && (SetjmpUsed || LongjmpUsed);
635 
636  // Declare (or get) global variables __THREW__, __threwValue, and
637  // getTempRet0/setTempRet0 function which are used in common for both
638  // exception handling and setjmp/longjmp handling
639  ThrewGV = getGlobalVariableI32(M, IRB, "__THREW__");
640  ThrewValueGV = getGlobalVariableI32(M, IRB, "__threwValue");
641  GetTempRet0Func =
643  GlobalValue::ExternalLinkage, "getTempRet0", &M);
644  SetTempRet0Func = Function::Create(
645  FunctionType::get(IRB.getVoidTy(), IRB.getInt32Ty(), false),
646  GlobalValue::ExternalLinkage, "setTempRet0", &M);
647  GetTempRet0Func->setDoesNotThrow();
648  SetTempRet0Func->setDoesNotThrow();
649 
650  bool Changed = false;
651 
652  // Exception handling
653  if (EnableEH) {
654  // Register __resumeException function
655  FunctionType *ResumeFTy =
656  FunctionType::get(IRB.getVoidTy(), IRB.getInt8PtrTy(), false);
657  ResumeF = Function::Create(ResumeFTy, GlobalValue::ExternalLinkage,
658  "__resumeException", &M);
659 
660  // Register llvm_eh_typeid_for function
661  FunctionType *EHTypeIDTy =
662  FunctionType::get(IRB.getInt32Ty(), IRB.getInt8PtrTy(), false);
663  EHTypeIDF = Function::Create(EHTypeIDTy, GlobalValue::ExternalLinkage,
664  "llvm_eh_typeid_for", &M);
665 
666  for (Function &F : M) {
667  if (F.isDeclaration())
668  continue;
669  Changed |= runEHOnFunction(F);
670  }
671  }
672 
673  // Setjmp/longjmp handling
674  if (DoSjLj) {
675  Changed = true; // We have setjmp or longjmp somewhere
676 
677  if (LongjmpF) {
678  // Replace all uses of longjmp with emscripten_longjmp_jmpbuf, which is
679  // defined in JS code
680  EmLongjmpJmpbufF = Function::Create(LongjmpF->getFunctionType(),
682  "emscripten_longjmp_jmpbuf", &M);
683 
684  LongjmpF->replaceAllUsesWith(EmLongjmpJmpbufF);
685  }
686 
687  if (SetjmpF) {
688  // Register saveSetjmp function
689  FunctionType *SetjmpFTy = SetjmpF->getFunctionType();
690  SmallVector<Type *, 4> Params = {SetjmpFTy->getParamType(0),
692  IRB.getInt32Ty()};
693  FunctionType *FTy =
694  FunctionType::get(Type::getInt32PtrTy(C), Params, false);
695  SaveSetjmpF =
696  Function::Create(FTy, GlobalValue::ExternalLinkage, "saveSetjmp", &M);
697 
698  // Register testSetjmp function
699  Params = {IRB.getInt32Ty(), Type::getInt32PtrTy(C), IRB.getInt32Ty()};
700  FTy = FunctionType::get(IRB.getInt32Ty(), Params, false);
701  TestSetjmpF =
702  Function::Create(FTy, GlobalValue::ExternalLinkage, "testSetjmp", &M);
703 
704  FTy = FunctionType::get(IRB.getVoidTy(),
705  {IRB.getInt32Ty(), IRB.getInt32Ty()}, false);
707  "emscripten_longjmp", &M);
708 
709  // Only traverse functions that uses setjmp in order not to insert
710  // unnecessary prep / cleanup code in every function
711  SmallPtrSet<Function *, 8> SetjmpUsers;
712  for (User *U : SetjmpF->users()) {
713  auto *UI = cast<Instruction>(U);
714  SetjmpUsers.insert(UI->getFunction());
715  }
716  for (Function *F : SetjmpUsers)
717  runSjLjOnFunction(*F);
718  }
719  }
720 
721  if (!Changed) {
722  // Delete unused global variables and functions
723  if (ResumeF)
724  ResumeF->eraseFromParent();
725  if (EHTypeIDF)
726  EHTypeIDF->eraseFromParent();
727  if (EmLongjmpF)
728  EmLongjmpF->eraseFromParent();
729  if (SaveSetjmpF)
730  SaveSetjmpF->eraseFromParent();
731  if (TestSetjmpF)
732  TestSetjmpF->eraseFromParent();
733  return false;
734  }
735 
736  return true;
737 }
738 
739 bool WebAssemblyLowerEmscriptenEHSjLj::runEHOnFunction(Function &F) {
740  Module &M = *F.getParent();
741  LLVMContext &C = F.getContext();
742  IRBuilder<> IRB(C);
743  bool Changed = false;
746  bool AllowExceptions =
747  areAllExceptionsAllowed() || EHWhitelistSet.count(F.getName());
748 
749  for (BasicBlock &BB : F) {
750  auto *II = dyn_cast<InvokeInst>(BB.getTerminator());
751  if (!II)
752  continue;
753  Changed = true;
754  LandingPads.insert(II->getLandingPadInst());
755  IRB.SetInsertPoint(II);
756 
757  bool NeedInvoke = AllowExceptions && canThrow(II->getCalledValue());
758  if (NeedInvoke) {
759  // Wrap invoke with invoke wrapper and generate preamble/postamble
760  Value *Threw = wrapInvoke(II);
761  ToErase.push_back(II);
762 
763  // Insert a branch based on __THREW__ variable
764  Value *Cmp = IRB.CreateICmpEQ(Threw, IRB.getInt32(1), "cmp");
765  IRB.CreateCondBr(Cmp, II->getUnwindDest(), II->getNormalDest());
766 
767  } else {
768  // This can't throw, and we don't need this invoke, just replace it with a
769  // call+branch
770  SmallVector<Value *, 16> Args(II->arg_begin(), II->arg_end());
771  CallInst *NewCall =
772  IRB.CreateCall(II->getFunctionType(), II->getCalledValue(), Args);
773  NewCall->takeName(II);
774  NewCall->setCallingConv(II->getCallingConv());
775  NewCall->setDebugLoc(II->getDebugLoc());
776  NewCall->setAttributes(II->getAttributes());
777  II->replaceAllUsesWith(NewCall);
778  ToErase.push_back(II);
779 
780  IRB.CreateBr(II->getNormalDest());
781 
782  // Remove any PHI node entries from the exception destination
783  II->getUnwindDest()->removePredecessor(&BB);
784  }
785  }
786 
787  // Process resume instructions
788  for (BasicBlock &BB : F) {
789  // Scan the body of the basic block for resumes
790  for (Instruction &I : BB) {
791  auto *RI = dyn_cast<ResumeInst>(&I);
792  if (!RI)
793  continue;
794 
795  // Split the input into legal values
796  Value *Input = RI->getValue();
797  IRB.SetInsertPoint(RI);
798  Value *Low = IRB.CreateExtractValue(Input, 0, "low");
799  // Create a call to __resumeException function
800  IRB.CreateCall(ResumeF, {Low});
801  // Add a terminator to the block
802  IRB.CreateUnreachable();
803  ToErase.push_back(RI);
804  }
805  }
806 
807  // Process llvm.eh.typeid.for intrinsics
808  for (BasicBlock &BB : F) {
809  for (Instruction &I : BB) {
810  auto *CI = dyn_cast<CallInst>(&I);
811  if (!CI)
812  continue;
813  const Function *Callee = CI->getCalledFunction();
814  if (!Callee)
815  continue;
816  if (Callee->getIntrinsicID() != Intrinsic::eh_typeid_for)
817  continue;
818 
819  IRB.SetInsertPoint(CI);
820  CallInst *NewCI =
821  IRB.CreateCall(EHTypeIDF, CI->getArgOperand(0), "typeid");
822  CI->replaceAllUsesWith(NewCI);
823  ToErase.push_back(CI);
824  }
825  }
826 
827  // Look for orphan landingpads, can occur in blocks with no predecessors
828  for (BasicBlock &BB : F) {
829  Instruction *I = BB.getFirstNonPHI();
830  if (auto *LPI = dyn_cast<LandingPadInst>(I))
831  LandingPads.insert(LPI);
832  }
833 
834  // Handle all the landingpad for this function together, as multiple invokes
835  // may share a single lp
836  for (LandingPadInst *LPI : LandingPads) {
837  IRB.SetInsertPoint(LPI);
838  SmallVector<Value *, 16> FMCArgs;
839  for (unsigned I = 0, E = LPI->getNumClauses(); I < E; ++I) {
840  Constant *Clause = LPI->getClause(I);
841  // As a temporary workaround for the lack of aggregate varargs support
842  // in the interface between JS and wasm, break out filter operands into
843  // their component elements.
844  if (LPI->isFilter(I)) {
845  auto *ATy = cast<ArrayType>(Clause->getType());
846  for (unsigned J = 0, E = ATy->getNumElements(); J < E; ++J) {
847  Value *EV = IRB.CreateExtractValue(Clause, makeArrayRef(J), "filter");
848  FMCArgs.push_back(EV);
849  }
850  } else
851  FMCArgs.push_back(Clause);
852  }
853 
854  // Create a call to __cxa_find_matching_catch_N function
855  Function *FMCF = getFindMatchingCatch(M, FMCArgs.size());
856  CallInst *FMCI = IRB.CreateCall(FMCF, FMCArgs, "fmc");
857  Value *Undef = UndefValue::get(LPI->getType());
858  Value *Pair0 = IRB.CreateInsertValue(Undef, FMCI, 0, "pair0");
859  Value *TempRet0 = IRB.CreateCall(GetTempRet0Func, None, "tempret0");
860  Value *Pair1 = IRB.CreateInsertValue(Pair0, TempRet0, 1, "pair1");
861 
862  LPI->replaceAllUsesWith(Pair1);
863  ToErase.push_back(LPI);
864  }
865 
866  // Erase everything we no longer need in this function
867  for (Instruction *I : ToErase)
868  I->eraseFromParent();
869 
870  return Changed;
871 }
872 
873 bool WebAssemblyLowerEmscriptenEHSjLj::runSjLjOnFunction(Function &F) {
874  Module &M = *F.getParent();
875  LLVMContext &C = F.getContext();
876  IRBuilder<> IRB(C);
878  // Vector of %setjmpTable values
879  std::vector<Instruction *> SetjmpTableInsts;
880  // Vector of %setjmpTableSize values
881  std::vector<Instruction *> SetjmpTableSizeInsts;
882 
883  // Setjmp preparation
884 
885  // This instruction effectively means %setjmpTableSize = 4.
886  // We create this as an instruction intentionally, and we don't want to fold
887  // this instruction to a constant 4, because this value will be used in
888  // SSAUpdater.AddAvailableValue(...) later.
889  BasicBlock &EntryBB = F.getEntryBlock();
890  BinaryOperator *SetjmpTableSize = BinaryOperator::Create(
891  Instruction::Add, IRB.getInt32(4), IRB.getInt32(0), "setjmpTableSize",
892  &*EntryBB.getFirstInsertionPt());
893  // setjmpTable = (int *) malloc(40);
894  Instruction *SetjmpTable = CallInst::CreateMalloc(
895  SetjmpTableSize, IRB.getInt32Ty(), IRB.getInt32Ty(), IRB.getInt32(40),
896  nullptr, nullptr, "setjmpTable");
897  // setjmpTable[0] = 0;
898  IRB.SetInsertPoint(SetjmpTableSize);
899  IRB.CreateStore(IRB.getInt32(0), SetjmpTable);
900  SetjmpTableInsts.push_back(SetjmpTable);
901  SetjmpTableSizeInsts.push_back(SetjmpTableSize);
902 
903  // Setjmp transformation
904  std::vector<PHINode *> SetjmpRetPHIs;
905  Function *SetjmpF = M.getFunction("setjmp");
906  for (User *U : SetjmpF->users()) {
907  auto *CI = dyn_cast<CallInst>(U);
908  if (!CI)
909  report_fatal_error("Does not support indirect calls to setjmp");
910 
911  BasicBlock *BB = CI->getParent();
912  if (BB->getParent() != &F) // in other function
913  continue;
914 
915  // The tail is everything right after the call, and will be reached once
916  // when setjmp is called, and later when longjmp returns to the setjmp
917  BasicBlock *Tail = SplitBlock(BB, CI->getNextNode());
918  // Add a phi to the tail, which will be the output of setjmp, which
919  // indicates if this is the first call or a longjmp back. The phi directly
920  // uses the right value based on where we arrive from
921  IRB.SetInsertPoint(Tail->getFirstNonPHI());
922  PHINode *SetjmpRet = IRB.CreatePHI(IRB.getInt32Ty(), 2, "setjmp.ret");
923 
924  // setjmp initial call returns 0
925  SetjmpRet->addIncoming(IRB.getInt32(0), BB);
926  // The proper output is now this, not the setjmp call itself
927  CI->replaceAllUsesWith(SetjmpRet);
928  // longjmp returns to the setjmp will add themselves to this phi
929  SetjmpRetPHIs.push_back(SetjmpRet);
930 
931  // Fix call target
932  // Our index in the function is our place in the array + 1 to avoid index
933  // 0, because index 0 means the longjmp is not ours to handle.
934  IRB.SetInsertPoint(CI);
935  Value *Args[] = {CI->getArgOperand(0), IRB.getInt32(SetjmpRetPHIs.size()),
936  SetjmpTable, SetjmpTableSize};
937  Instruction *NewSetjmpTable =
938  IRB.CreateCall(SaveSetjmpF, Args, "setjmpTable");
939  Instruction *NewSetjmpTableSize =
940  IRB.CreateCall(GetTempRet0Func, None, "setjmpTableSize");
941  SetjmpTableInsts.push_back(NewSetjmpTable);
942  SetjmpTableSizeInsts.push_back(NewSetjmpTableSize);
943  ToErase.push_back(CI);
944  }
945 
946  // Update each call that can longjmp so it can return to a setjmp where
947  // relevant.
948 
949  // Because we are creating new BBs while processing and don't want to make
950  // all these newly created BBs candidates again for longjmp processing, we
951  // first make the vector of candidate BBs.
952  std::vector<BasicBlock *> BBs;
953  for (BasicBlock &BB : F)
954  BBs.push_back(&BB);
955 
956  // BBs.size() will change within the loop, so we query it every time
957  for (unsigned I = 0; I < BBs.size(); I++) {
958  BasicBlock *BB = BBs[I];
959  for (Instruction &I : *BB) {
960  assert(!isa<InvokeInst>(&I));
961  auto *CI = dyn_cast<CallInst>(&I);
962  if (!CI)
963  continue;
964 
965  const Value *Callee = CI->getCalledValue();
966  if (!canLongjmp(M, Callee))
967  continue;
968  if (isEmAsmCall(M, Callee))
969  report_fatal_error("Cannot use EM_ASM* alongside setjmp/longjmp in " +
970  F.getName() +
971  ". Please consider using EM_JS, or move the "
972  "EM_ASM into another function.",
973  false);
974 
975  Value *Threw = nullptr;
976  BasicBlock *Tail;
977  if (Callee->getName().startswith("__invoke_")) {
978  // If invoke wrapper has already been generated for this call in
979  // previous EH phase, search for the load instruction
980  // %__THREW__.val = __THREW__;
981  // in postamble after the invoke wrapper call
982  LoadInst *ThrewLI = nullptr;
983  StoreInst *ThrewResetSI = nullptr;
984  for (auto I = std::next(BasicBlock::iterator(CI)), IE = BB->end();
985  I != IE; ++I) {
986  if (auto *LI = dyn_cast<LoadInst>(I))
987  if (auto *GV = dyn_cast<GlobalVariable>(LI->getPointerOperand()))
988  if (GV == ThrewGV) {
989  Threw = ThrewLI = LI;
990  break;
991  }
992  }
993  // Search for the store instruction after the load above
994  // __THREW__ = 0;
995  for (auto I = std::next(BasicBlock::iterator(ThrewLI)), IE = BB->end();
996  I != IE; ++I) {
997  if (auto *SI = dyn_cast<StoreInst>(I))
998  if (auto *GV = dyn_cast<GlobalVariable>(SI->getPointerOperand()))
999  if (GV == ThrewGV && SI->getValueOperand() == IRB.getInt32(0)) {
1000  ThrewResetSI = SI;
1001  break;
1002  }
1003  }
1004  assert(Threw && ThrewLI && "Cannot find __THREW__ load after invoke");
1005  assert(ThrewResetSI && "Cannot find __THREW__ store after invoke");
1006  Tail = SplitBlock(BB, ThrewResetSI->getNextNode());
1007 
1008  } else {
1009  // Wrap call with invoke wrapper and generate preamble/postamble
1010  Threw = wrapInvoke(CI);
1011  ToErase.push_back(CI);
1012  Tail = SplitBlock(BB, CI->getNextNode());
1013  }
1014 
1015  // We need to replace the terminator in Tail - SplitBlock makes BB go
1016  // straight to Tail, we need to check if a longjmp occurred, and go to the
1017  // right setjmp-tail if so
1018  ToErase.push_back(BB->getTerminator());
1019 
1020  // Generate a function call to testSetjmp function and preamble/postamble
1021  // code to figure out (1) whether longjmp occurred (2) if longjmp
1022  // occurred, which setjmp it corresponds to
1023  Value *Label = nullptr;
1024  Value *LongjmpResult = nullptr;
1025  BasicBlock *EndBB = nullptr;
1026  wrapTestSetjmp(BB, CI, Threw, SetjmpTable, SetjmpTableSize, Label,
1027  LongjmpResult, EndBB);
1028  assert(Label && LongjmpResult && EndBB);
1029 
1030  // Create switch instruction
1031  IRB.SetInsertPoint(EndBB);
1032  SwitchInst *SI = IRB.CreateSwitch(Label, Tail, SetjmpRetPHIs.size());
1033  // -1 means no longjmp happened, continue normally (will hit the default
1034  // switch case). 0 means a longjmp that is not ours to handle, needs a
1035  // rethrow. Otherwise the index is the same as the index in P+1 (to avoid
1036  // 0).
1037  for (unsigned I = 0; I < SetjmpRetPHIs.size(); I++) {
1038  SI->addCase(IRB.getInt32(I + 1), SetjmpRetPHIs[I]->getParent());
1039  SetjmpRetPHIs[I]->addIncoming(LongjmpResult, EndBB);
1040  }
1041 
1042  // We are splitting the block here, and must continue to find other calls
1043  // in the block - which is now split. so continue to traverse in the Tail
1044  BBs.push_back(Tail);
1045  }
1046  }
1047 
1048  // Erase everything we no longer need in this function
1049  for (Instruction *I : ToErase)
1050  I->eraseFromParent();
1051 
1052  // Free setjmpTable buffer before each return instruction
1053  for (BasicBlock &BB : F) {
1054  Instruction *TI = BB.getTerminator();
1055  if (isa<ReturnInst>(TI))
1056  CallInst::CreateFree(SetjmpTable, TI);
1057  }
1058 
1059  // Every call to saveSetjmp can change setjmpTable and setjmpTableSize
1060  // (when buffer reallocation occurs)
1061  // entry:
1062  // setjmpTableSize = 4;
1063  // setjmpTable = (int *) malloc(40);
1064  // setjmpTable[0] = 0;
1065  // ...
1066  // somebb:
1067  // setjmpTable = saveSetjmp(buf, label, setjmpTable, setjmpTableSize);
1068  // setjmpTableSize = getTempRet0();
1069  // So we need to make sure the SSA for these variables is valid so that every
1070  // saveSetjmp and testSetjmp calls have the correct arguments.
1071  SSAUpdater SetjmpTableSSA;
1072  SSAUpdater SetjmpTableSizeSSA;
1073  SetjmpTableSSA.Initialize(Type::getInt32PtrTy(C), "setjmpTable");
1074  SetjmpTableSizeSSA.Initialize(Type::getInt32Ty(C), "setjmpTableSize");
1075  for (Instruction *I : SetjmpTableInsts)
1076  SetjmpTableSSA.AddAvailableValue(I->getParent(), I);
1077  for (Instruction *I : SetjmpTableSizeInsts)
1078  SetjmpTableSizeSSA.AddAvailableValue(I->getParent(), I);
1079 
1080  for (auto UI = SetjmpTable->use_begin(), UE = SetjmpTable->use_end();
1081  UI != UE;) {
1082  // Grab the use before incrementing the iterator.
1083  Use &U = *UI;
1084  // Increment the iterator before removing the use from the list.
1085  ++UI;
1086  if (auto *I = dyn_cast<Instruction>(U.getUser()))
1087  if (I->getParent() != &EntryBB)
1088  SetjmpTableSSA.RewriteUse(U);
1089  }
1090  for (auto UI = SetjmpTableSize->use_begin(), UE = SetjmpTableSize->use_end();
1091  UI != UE;) {
1092  Use &U = *UI;
1093  ++UI;
1094  if (auto *I = dyn_cast<Instruction>(U.getUser()))
1095  if (I->getParent() != &EntryBB)
1096  SetjmpTableSizeSSA.RewriteUse(U);
1097  }
1098 
1099  // Finally, our modifications to the cfg can break dominance of SSA variables.
1100  // For example, in this code,
1101  // if (x()) { .. setjmp() .. }
1102  // if (y()) { .. longjmp() .. }
1103  // We must split the longjmp block, and it can jump into the block splitted
1104  // from setjmp one. But that means that when we split the setjmp block, it's
1105  // first part no longer dominates its second part - there is a theoretically
1106  // possible control flow path where x() is false, then y() is true and we
1107  // reach the second part of the setjmp block, without ever reaching the first
1108  // part. So, we rebuild SSA form here.
1109  rebuildSSA(F);
1110  return true;
1111 }
uint64_t CallInst * C
use_iterator use_end()
Definition: Value.h:367
BranchInst * CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False, MDNode *BranchWeights=nullptr, MDNode *Unpredictable=nullptr)
Create a conditional &#39;br Cond, TrueDest, FalseDest&#39; instruction.
Definition: IRBuilder.h:890
Helper class for SSA formation on a set of values defined in multiple blocks.
Definition: SSAUpdater.h:38
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
ModulePass * createWebAssemblyLowerEmscriptenEHSjLj(bool DoEH, bool DoSjLj)
Value * CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2104
NodeTy * getNextNode()
Get the next node, or nullptr for the list tail.
Definition: ilist_node.h:288
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:139
This class represents lattice values for constants.
Definition: AllocatorList.h:23
static GlobalVariable * getGlobalVariableI32(Module &M, IRBuilder<> &IRB, const char *Name)
Type * getParamType(unsigned i) const
Parameter type accessors.
Definition: DerivedTypes.h:140
void Initialize(Type *Ty, StringRef Name)
Reset this object to get ready for a new set of SSA updates with type &#39;Ty&#39;.
Definition: SSAUpdater.cpp:53
LoadInst * CreateLoad(Type *Ty, Value *Ptr, const char *Name)
Provided to resolve &#39;CreateLoad(Ty, Ptr, "...")&#39; correctly, instead of converting the string to &#39;bool...
Definition: IRBuilder.h:1574
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
LLVM_NODISCARD bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:270
void AddAvailableValue(BasicBlock *BB, Value *V)
Indicate that a rewritten value is available in the specified block with the specified value...
Definition: SSAUpdater.cpp:71
void addCase(ConstantInt *OnVal, BasicBlock *Dest)
Add an entry to the switch instruction.
void recalculate(ParentType &Func)
recalculate - compute a dominator tree for the given function
This class represents a function call, abstracting a target machine&#39;s calling convention.
static PointerType * getInt32PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:232
iterator find(StringRef Key)
Definition: StringMap.h:355
Externally visible function.
Definition: GlobalValue.h:48
F(f)
param_iterator param_end() const
Definition: DerivedTypes.h:134
An instruction for reading from memory.
Definition: Instructions.h:169
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:144
static Instruction * CreateFree(Value *Source, Instruction *InsertBefore)
Generate the IR for a call to the builtin free function.
BasicBlock * SplitBlock(BasicBlock *Old, Instruction *SplitPt, DominatorTree *DT=nullptr, LoopInfo *LI=nullptr, MemorySSAUpdater *MSSAU=nullptr, const Twine &BBName="")
Split the specified block at the specified instruction - everything before SplitPt stays in Old and e...
This file contains the entry points for global functions defined in the LLVM WebAssembly back-end...
static bool canThrow(const Value *V)
void setDoesNotThrow()
Definition: Function.h:536
IntegerType * getInt32Ty()
Fetch the type representing a 32-bit integer.
Definition: IRBuilder.h:383
AnalysisUsage & addRequired()
const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr if the function does no...
Definition: BasicBlock.cpp:140
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:450
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:244
A Use represents the edge between a Value definition and its users.
Definition: Use.h:55
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:779
AttributeSet getRetAttributes() const
The attributes for the ret value are returned.
Type * getVoidTy()
Fetch the type representing void.
Definition: IRBuilder.h:416
StoreInst * CreateStore(Value *Val, Value *Ptr, bool isVolatile=false)
Definition: IRBuilder.h:1603
Value * CreateIntToPtr(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1957
User * getUser() const LLVM_READONLY
Returns the User that contains this Use.
Definition: Use.cpp:40
Class to represent function types.
Definition: DerivedTypes.h:108
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:246
const T & getValue() const LLVM_LVALUE_FUNCTION
Definition: Optional.h:255
AttributeSet getParamAttributes(unsigned ArgNo) const
The attributes for the argument or parameter at the given index are returned.
bool isVarArg() const
Definition: DerivedTypes.h:128
Memory SSA
Definition: MemorySSA.cpp:65
An instruction for storing to memory.
Definition: Instructions.h:325
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:429
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:291
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:144
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block...
Definition: IRBuilder.h:132
Class to represent pointers.
Definition: DerivedTypes.h:575
Calling convention for emscripten __invoke_* functions.
Definition: CallingConv.h:236
AttributeSet getAttributes(unsigned Index) const
The attributes for the specified index are returned.
const BasicBlock & getEntryBlock() const
Definition: Function.h:664
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:135
The landingpad instruction holds all of the information necessary to generate correct exception handl...
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: BasicBlock.cpp:196
static AttributeSet get(LLVMContext &C, const AttrBuilder &B)
Definition: Attributes.cpp:589
const_iterator getFirstInsertionPt() const
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
Definition: BasicBlock.cpp:223
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:328
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:64
void RewriteUseAfterInsertions(Use &U)
Rewrite a use like RewriteUse but handling in-block definitions.
Definition: SSAUpdater.cpp:206
UnreachableInst * CreateUnreachable()
Definition: IRBuilder.h:1050
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:41
Resume the propagation of an exception.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:370
size_t size() const
Definition: BasicBlock.h:283
ArrayRef< Type * > params() const
Definition: DerivedTypes.h:135
param_iterator param_begin() const
Definition: DerivedTypes.h:133
Represent the analysis usage information of a pass.
static void replace(Module &M, GlobalVariable *Old, GlobalVariable *New)
void setCallingConv(CallingConv::ID CC)
Definition: InstrTypes.h:1348
static FunctionType * get(Type *Result, ArrayRef< Type *> Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:301
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:99
Value * CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:2100
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:381
auto remove_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range))
Provide wrappers to std::remove_if which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1205
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:205
static UndefValue * get(Type *T)
Static factory methods - Return an &#39;undef&#39; object of the specified type.
Definition: Constants.cpp:1446
Value * CreateExtractValue(Value *Agg, ArrayRef< unsigned > Idxs, const Twine &Name="")
Definition: IRBuilder.h:2350
size_t size() const
Definition: SmallVector.h:52
PointerType * getInt8PtrTy(unsigned AddrSpace=0)
Fetch the type representing a pointer to an 8-bit integer value.
Definition: IRBuilder.h:421
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:224
std::string & str()
Flushes the stream contents to the target string and returns the string&#39;s reference.
Definition: raw_ostream.h:519
PHINode * CreatePHI(Type *Ty, unsigned NumReservedValues, const Twine &Name="")
Definition: IRBuilder.h:2230
Iterator for intrusive lists based on ilist_node.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:417
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the generic address space (address sp...
Definition: DerivedTypes.h:590
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
bool dominates(const Instruction *Def, const Use &U) const
Return true if Def dominates a use in User.
Definition: Dominators.cpp:248
Type * getReturnType() const
Definition: DerivedTypes.h:129
ConstantInt * getInt32(uint32_t C)
Get a constant 32-bit value.
Definition: IRBuilder.h:343
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:193
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
Function * getFunction(StringRef Name) const
Look up the specified function in the module symbol table.
Definition: Module.cpp:174
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:163
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:242
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:55
amdgpu Simplify well known AMD library false FunctionCallee Callee
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), Instruction *InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
iterator_range< user_iterator > users()
Definition: Value.h:420
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:387
static Instruction * CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy, Type *AllocTy, Value *AllocSize, Value *ArraySize=nullptr, Function *MallocF=nullptr, const Twine &Name="")
Generate the IR for a call to malloc:
SwitchInst * CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases=10, MDNode *BranchWeights=nullptr, MDNode *Unpredictable=nullptr)
Create a switch instruction with the specified value, default dest, and with a hint for the number of...
Definition: IRBuilder.h:913
use_iterator use_begin()
Definition: Value.h:359
bool hasValue() const
Definition: Optional.h:259
Constant * getOrInsertGlobal(StringRef Name, Type *Ty, function_ref< GlobalVariable *()> CreateGlobalCallback)
Look up the specified global in the module symbol table.
Definition: Module.cpp:204
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:180
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:214
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:106
#define I(x, y, z)
Definition: MD5.cpp:58
Tail - This calling convention attemps to make calls as fast as possible while guaranteeing that tail...
Definition: CallingConv.h:81
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:224
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
Definition: InstrTypes.h:1370
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:332
CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value *> Args=None, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2238
void eraseFromParent()
eraseFromParent - This method unlinks &#39;this&#39; from the containing module and deletes it...
Definition: Function.cpp:226
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:145
Value * CreateAnd(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1268
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:231
Multiway switch.
INITIALIZE_PASS(WebAssemblyLowerEmscriptenEHSjLj, DEBUG_TYPE, "WebAssembly Lower Emscripten Exceptions / Setjmp / Longjmp", false, false) ModulePass *llvm
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:503
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:575
LLVM Value Representation.
Definition: Value.h:74
static cl::list< std::string > EHWhitelist("emscripten-cxx-exceptions-whitelist", cl::desc("The list of function names in which Emscripten-style " "exception handling is enabled (see emscripten " "EMSCRIPTEN_CATCHING_WHITELIST options)"), cl::CommaSeparated)
BranchInst * CreateBr(BasicBlock *Dest)
Create an unconditional &#39;br label X&#39; instruction.
Definition: IRBuilder.h:884
AttributeSet getFnAttributes() const
The function attributes are returned.
Invoke instruction.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:259
Value * CreateInsertValue(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &Name="")
Definition: IRBuilder.h:2358
#define LLVM_DEBUG(X)
Definition: Debug.h:122
void RewriteUse(Use &U)
Rewrite a use of the symbolic value.
Definition: SSAUpdater.cpp:189
static std::string getSignature(FunctionType *FTy)
bool use_empty() const
Definition: Value.h:343
iterator end()
Definition: StringMap.h:340
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
static AttributeList get(LLVMContext &C, ArrayRef< std::pair< unsigned, Attribute >> Attrs)
Create an AttributeList with the specified parameters in it.
Definition: Attributes.cpp:970