LLVM  9.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  static const char *ResumeFName;
231  static const char *EHTypeIDFName;
232  static const char *EmLongjmpFName;
233  static const char *EmLongjmpJmpbufFName;
234  static const char *SaveSetjmpFName;
235  static const char *TestSetjmpFName;
236  static const char *FindMatchingCatchPrefix;
237  static const char *InvokePrefix;
238 
239  bool EnableEH; // Enable exception handling
240  bool EnableSjLj; // Enable setjmp/longjmp handling
241 
242  GlobalVariable *ThrewGV = nullptr;
243  GlobalVariable *ThrewValueGV = nullptr;
244  Function *GetTempRet0Func = nullptr;
245  Function *SetTempRet0Func = nullptr;
246  Function *ResumeF = nullptr;
247  Function *EHTypeIDF = nullptr;
248  Function *EmLongjmpF = nullptr;
249  Function *EmLongjmpJmpbufF = nullptr;
250  Function *SaveSetjmpF = nullptr;
251  Function *TestSetjmpF = nullptr;
252 
253  // __cxa_find_matching_catch_N functions.
254  // Indexed by the number of clauses in an original landingpad instruction.
255  DenseMap<int, Function *> FindMatchingCatches;
256  // Map of <function signature string, invoke_ wrappers>
257  StringMap<Function *> InvokeWrappers;
258  // Set of whitelisted function names for exception handling
259  std::set<std::string> EHWhitelistSet;
260 
261  StringRef getPassName() const override {
262  return "WebAssembly Lower Emscripten Exceptions";
263  }
264 
265  bool runEHOnFunction(Function &F);
266  bool runSjLjOnFunction(Function &F);
267  Function *getFindMatchingCatch(Module &M, unsigned NumClauses);
268 
269  template <typename CallOrInvoke> Value *wrapInvoke(CallOrInvoke *CI);
270  void wrapTestSetjmp(BasicBlock *BB, Instruction *InsertPt, Value *Threw,
271  Value *SetjmpTable, Value *SetjmpTableSize, Value *&Label,
272  Value *&LongjmpResult, BasicBlock *&EndBB);
273  template <typename CallOrInvoke> Function *getInvokeWrapper(CallOrInvoke *CI);
274 
275  bool areAllExceptionsAllowed() const { return EHWhitelistSet.empty(); }
276  bool canLongjmp(Module &M, const Value *Callee) const;
277 
278  void rebuildSSA(Function &F);
279 
280 public:
281  static char ID;
282 
283  WebAssemblyLowerEmscriptenEHSjLj(bool EnableEH = true, bool EnableSjLj = true)
284  : ModulePass(ID), EnableEH(EnableEH), EnableSjLj(EnableSjLj) {
285  EHWhitelistSet.insert(EHWhitelist.begin(), EHWhitelist.end());
286  }
287  bool runOnModule(Module &M) override;
288 
289  void getAnalysisUsage(AnalysisUsage &AU) const override {
291  }
292 };
293 } // End anonymous namespace
294 
295 const char *WebAssemblyLowerEmscriptenEHSjLj::ResumeFName = "__resumeException";
296 const char *WebAssemblyLowerEmscriptenEHSjLj::EHTypeIDFName =
297  "llvm_eh_typeid_for";
298 const char *WebAssemblyLowerEmscriptenEHSjLj::EmLongjmpFName =
299  "emscripten_longjmp";
300 const char *WebAssemblyLowerEmscriptenEHSjLj::EmLongjmpJmpbufFName =
301  "emscripten_longjmp_jmpbuf";
302 const char *WebAssemblyLowerEmscriptenEHSjLj::SaveSetjmpFName = "saveSetjmp";
303 const char *WebAssemblyLowerEmscriptenEHSjLj::TestSetjmpFName = "testSetjmp";
304 const char *WebAssemblyLowerEmscriptenEHSjLj::FindMatchingCatchPrefix =
305  "__cxa_find_matching_catch_";
306 const char *WebAssemblyLowerEmscriptenEHSjLj::InvokePrefix = "__invoke_";
307 
309 INITIALIZE_PASS(WebAssemblyLowerEmscriptenEHSjLj, DEBUG_TYPE,
310  "WebAssembly Lower Emscripten Exceptions / Setjmp / Longjmp",
311  false, false)
312 
314  bool EnableSjLj) {
315  return new WebAssemblyLowerEmscriptenEHSjLj(EnableEH, EnableSjLj);
316 }
317 
318 static bool canThrow(const Value *V) {
319  if (const auto *F = dyn_cast<const Function>(V)) {
320  // Intrinsics cannot throw
321  if (F->isIntrinsic())
322  return false;
323  StringRef Name = F->getName();
324  // leave setjmp and longjmp (mostly) alone, we process them properly later
325  if (Name == "setjmp" || Name == "longjmp")
326  return false;
327  return !F->doesNotThrow();
328  }
329  // not a function, so an indirect call - can throw, we can't tell
330  return true;
331 }
332 
333 // Get a global variable with the given name. If it doesn't exist declare it,
334 // which will generate an import and asssumes that it will exist at link time.
336  const char *Name) {
337  if (M.getNamedGlobal(Name))
338  report_fatal_error(Twine("variable name is reserved: ") + Name);
339 
340  return new GlobalVariable(M, IRB.getInt32Ty(), false,
342 }
343 
344 // Simple function name mangler.
345 // This function simply takes LLVM's string representation of parameter types
346 // and concatenate them with '_'. There are non-alphanumeric characters but llc
347 // is ok with it, and we need to postprocess these names after the lowering
348 // phase anyway.
349 static std::string getSignature(FunctionType *FTy) {
350  std::string Sig;
351  raw_string_ostream OS(Sig);
352  OS << *FTy->getReturnType();
353  for (Type *ParamTy : FTy->params())
354  OS << "_" << *ParamTy;
355  if (FTy->isVarArg())
356  OS << "_...";
357  Sig = OS.str();
358  Sig.erase(remove_if(Sig, isspace), Sig.end());
359  // When s2wasm parses .s file, a comma means the end of an argument. So a
360  // mangled function name can contain any character but a comma.
361  std::replace(Sig.begin(), Sig.end(), ',', '.');
362  return Sig;
363 }
364 
365 // Returns __cxa_find_matching_catch_N function, where N = NumClauses + 2.
366 // This is because a landingpad instruction contains two more arguments, a
367 // personality function and a cleanup bit, and __cxa_find_matching_catch_N
368 // functions are named after the number of arguments in the original landingpad
369 // instruction.
370 Function *
371 WebAssemblyLowerEmscriptenEHSjLj::getFindMatchingCatch(Module &M,
372  unsigned NumClauses) {
373  if (FindMatchingCatches.count(NumClauses))
374  return FindMatchingCatches[NumClauses];
375  PointerType *Int8PtrTy = Type::getInt8PtrTy(M.getContext());
376  SmallVector<Type *, 16> Args(NumClauses, Int8PtrTy);
377  FunctionType *FTy = FunctionType::get(Int8PtrTy, Args, false);
378  Function *F =
380  FindMatchingCatchPrefix + Twine(NumClauses + 2), &M);
381  FindMatchingCatches[NumClauses] = F;
382  return F;
383 }
384 
385 // Generate invoke wrapper seqence with preamble and postamble
386 // Preamble:
387 // __THREW__ = 0;
388 // Postamble:
389 // %__THREW__.val = __THREW__; __THREW__ = 0;
390 // Returns %__THREW__.val, which indicates whether an exception is thrown (or
391 // whether longjmp occurred), for future use.
392 template <typename CallOrInvoke>
393 Value *WebAssemblyLowerEmscriptenEHSjLj::wrapInvoke(CallOrInvoke *CI) {
394  LLVMContext &C = CI->getModule()->getContext();
395 
396  // If we are calling a function that is noreturn, we must remove that
397  // attribute. The code we insert here does expect it to return, after we
398  // catch the exception.
399  if (CI->doesNotReturn()) {
400  if (auto *F = dyn_cast<Function>(CI->getCalledValue()))
401  F->removeFnAttr(Attribute::NoReturn);
402  CI->removeAttribute(AttributeList::FunctionIndex, Attribute::NoReturn);
403  }
404 
405  IRBuilder<> IRB(C);
406  IRB.SetInsertPoint(CI);
407 
408  // Pre-invoke
409  // __THREW__ = 0;
410  IRB.CreateStore(IRB.getInt32(0), ThrewGV);
411 
412  // Invoke function wrapper in JavaScript
414  // Put the pointer to the callee as first argument, so it can be called
415  // within the invoke wrapper later
416  Args.push_back(CI->getCalledValue());
417  Args.append(CI->arg_begin(), CI->arg_end());
418  CallInst *NewCall = IRB.CreateCall(getInvokeWrapper(CI), Args);
419  NewCall->takeName(CI);
420  NewCall->setCallingConv(CI->getCallingConv());
421  NewCall->setDebugLoc(CI->getDebugLoc());
422 
423  // Because we added the pointer to the callee as first argument, all
424  // argument attribute indices have to be incremented by one.
425  SmallVector<AttributeSet, 8> ArgAttributes;
426  const AttributeList &InvokeAL = CI->getAttributes();
427 
428  // No attributes for the callee pointer.
429  ArgAttributes.push_back(AttributeSet());
430  // Copy the argument attributes from the original
431  for (unsigned I = 0, E = CI->getNumArgOperands(); I < E; ++I)
432  ArgAttributes.push_back(InvokeAL.getParamAttributes(I));
433 
434  // Reconstruct the AttributesList based on the vector we constructed.
435  AttributeList NewCallAL =
436  AttributeList::get(C, InvokeAL.getFnAttributes(),
437  InvokeAL.getRetAttributes(), ArgAttributes);
438  NewCall->setAttributes(NewCallAL);
439 
440  CI->replaceAllUsesWith(NewCall);
441 
442  // Post-invoke
443  // %__THREW__.val = __THREW__; __THREW__ = 0;
444  Value *Threw =
445  IRB.CreateLoad(IRB.getInt32Ty(), ThrewGV, ThrewGV->getName() + ".val");
446  IRB.CreateStore(IRB.getInt32(0), ThrewGV);
447  return Threw;
448 }
449 
450 // Get matching invoke wrapper based on callee signature
451 template <typename CallOrInvoke>
452 Function *WebAssemblyLowerEmscriptenEHSjLj::getInvokeWrapper(CallOrInvoke *CI) {
453  Module *M = CI->getModule();
455  Value *Callee = CI->getCalledValue();
456  FunctionType *CalleeFTy;
457  if (auto *F = dyn_cast<Function>(Callee))
458  CalleeFTy = F->getFunctionType();
459  else {
460  auto *CalleeTy = cast<PointerType>(Callee->getType())->getElementType();
461  CalleeFTy = dyn_cast<FunctionType>(CalleeTy);
462  }
463 
464  std::string Sig = getSignature(CalleeFTy);
465  if (InvokeWrappers.find(Sig) != InvokeWrappers.end())
466  return InvokeWrappers[Sig];
467 
468  // Put the pointer to the callee as first argument
469  ArgTys.push_back(PointerType::getUnqual(CalleeFTy));
470  // Add argument types
471  ArgTys.append(CalleeFTy->param_begin(), CalleeFTy->param_end());
472 
473  FunctionType *FTy = FunctionType::get(CalleeFTy->getReturnType(), ArgTys,
474  CalleeFTy->isVarArg());
476  InvokePrefix + Sig, M);
477  InvokeWrappers[Sig] = F;
478  return F;
479 }
480 
481 bool WebAssemblyLowerEmscriptenEHSjLj::canLongjmp(Module &M,
482  const Value *Callee) const {
483  if (auto *CalleeF = dyn_cast<Function>(Callee))
484  if (CalleeF->isIntrinsic())
485  return false;
486 
487  // The reason we include malloc/free here is to exclude the malloc/free
488  // calls generated in setjmp prep / cleanup routines.
489  Function *SetjmpF = M.getFunction("setjmp");
490  Function *MallocF = M.getFunction("malloc");
491  Function *FreeF = M.getFunction("free");
492  if (Callee == SetjmpF || Callee == MallocF || Callee == FreeF)
493  return false;
494 
495  // There are functions in JS glue code
496  if (Callee == ResumeF || Callee == EHTypeIDF || Callee == SaveSetjmpF ||
497  Callee == TestSetjmpF)
498  return false;
499 
500  // __cxa_find_matching_catch_N functions cannot longjmp
501  if (Callee->getName().startswith(FindMatchingCatchPrefix))
502  return false;
503 
504  // Exception-catching related functions
505  Function *BeginCatchF = M.getFunction("__cxa_begin_catch");
506  Function *EndCatchF = M.getFunction("__cxa_end_catch");
507  Function *AllocExceptionF = M.getFunction("__cxa_allocate_exception");
508  Function *ThrowF = M.getFunction("__cxa_throw");
509  Function *TerminateF = M.getFunction("__clang_call_terminate");
510  if (Callee == BeginCatchF || Callee == EndCatchF ||
511  Callee == AllocExceptionF || Callee == ThrowF || Callee == TerminateF ||
512  Callee == GetTempRet0Func || Callee == SetTempRet0Func)
513  return false;
514 
515  // Otherwise we don't know
516  return true;
517 }
518 
519 // Generate testSetjmp function call seqence with preamble and postamble.
520 // The code this generates is equivalent to the following JavaScript code:
521 // if (%__THREW__.val != 0 & threwValue != 0) {
522 // %label = _testSetjmp(mem[%__THREW__.val], setjmpTable, setjmpTableSize);
523 // if (%label == 0)
524 // emscripten_longjmp(%__THREW__.val, threwValue);
525 // setTempRet0(threwValue);
526 // } else {
527 // %label = -1;
528 // }
529 // %longjmp_result = getTempRet0();
530 //
531 // As output parameters. returns %label, %longjmp_result, and the BB the last
532 // instruction (%longjmp_result = ...) is in.
533 void WebAssemblyLowerEmscriptenEHSjLj::wrapTestSetjmp(
534  BasicBlock *BB, Instruction *InsertPt, Value *Threw, Value *SetjmpTable,
535  Value *SetjmpTableSize, Value *&Label, Value *&LongjmpResult,
536  BasicBlock *&EndBB) {
537  Function *F = BB->getParent();
538  LLVMContext &C = BB->getModule()->getContext();
539  IRBuilder<> IRB(C);
540  IRB.SetInsertPoint(InsertPt);
541 
542  // if (%__THREW__.val != 0 & threwValue != 0)
543  IRB.SetInsertPoint(BB);
544  BasicBlock *ThenBB1 = BasicBlock::Create(C, "if.then1", F);
545  BasicBlock *ElseBB1 = BasicBlock::Create(C, "if.else1", F);
546  BasicBlock *EndBB1 = BasicBlock::Create(C, "if.end", F);
547  Value *ThrewCmp = IRB.CreateICmpNE(Threw, IRB.getInt32(0));
548  Value *ThrewValue = IRB.CreateLoad(IRB.getInt32Ty(), ThrewValueGV,
549  ThrewValueGV->getName() + ".val");
550  Value *ThrewValueCmp = IRB.CreateICmpNE(ThrewValue, IRB.getInt32(0));
551  Value *Cmp1 = IRB.CreateAnd(ThrewCmp, ThrewValueCmp, "cmp1");
552  IRB.CreateCondBr(Cmp1, ThenBB1, ElseBB1);
553 
554  // %label = _testSetjmp(mem[%__THREW__.val], _setjmpTable, _setjmpTableSize);
555  // if (%label == 0)
556  IRB.SetInsertPoint(ThenBB1);
557  BasicBlock *ThenBB2 = BasicBlock::Create(C, "if.then2", F);
558  BasicBlock *EndBB2 = BasicBlock::Create(C, "if.end2", F);
559  Value *ThrewInt = IRB.CreateIntToPtr(Threw, Type::getInt32PtrTy(C),
560  Threw->getName() + ".i32p");
561  Value *LoadedThrew = IRB.CreateLoad(IRB.getInt32Ty(), ThrewInt,
562  ThrewInt->getName() + ".loaded");
563  Value *ThenLabel = IRB.CreateCall(
564  TestSetjmpF, {LoadedThrew, SetjmpTable, SetjmpTableSize}, "label");
565  Value *Cmp2 = IRB.CreateICmpEQ(ThenLabel, IRB.getInt32(0));
566  IRB.CreateCondBr(Cmp2, ThenBB2, EndBB2);
567 
568  // emscripten_longjmp(%__THREW__.val, threwValue);
569  IRB.SetInsertPoint(ThenBB2);
570  IRB.CreateCall(EmLongjmpF, {Threw, ThrewValue});
571  IRB.CreateUnreachable();
572 
573  // setTempRet0(threwValue);
574  IRB.SetInsertPoint(EndBB2);
575  IRB.CreateCall(SetTempRet0Func, ThrewValue);
576  IRB.CreateBr(EndBB1);
577 
578  IRB.SetInsertPoint(ElseBB1);
579  IRB.CreateBr(EndBB1);
580 
581  // longjmp_result = getTempRet0();
582  IRB.SetInsertPoint(EndBB1);
583  PHINode *LabelPHI = IRB.CreatePHI(IRB.getInt32Ty(), 2, "label");
584  LabelPHI->addIncoming(ThenLabel, EndBB2);
585 
586  LabelPHI->addIncoming(IRB.getInt32(-1), ElseBB1);
587 
588  // Output parameter assignment
589  Label = LabelPHI;
590  EndBB = EndBB1;
591  LongjmpResult = IRB.CreateCall(GetTempRet0Func, None, "longjmp_result");
592 }
593 
594 void WebAssemblyLowerEmscriptenEHSjLj::rebuildSSA(Function &F) {
595  DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
596  DT.recalculate(F); // CFG has been changed
597  SSAUpdater SSA;
598  for (BasicBlock &BB : F) {
599  for (Instruction &I : BB) {
600  for (auto UI = I.use_begin(), UE = I.use_end(); UI != UE;) {
601  Use &U = *UI;
602  ++UI;
603  SSA.Initialize(I.getType(), I.getName());
604  SSA.AddAvailableValue(&BB, &I);
605  auto *User = cast<Instruction>(U.getUser());
606  if (User->getParent() == &BB)
607  continue;
608 
609  if (auto *UserPN = dyn_cast<PHINode>(User))
610  if (UserPN->getIncomingBlock(U) == &BB)
611  continue;
612 
613  if (DT.dominates(&I, User))
614  continue;
616  }
617  }
618  }
619 }
620 
621 bool WebAssemblyLowerEmscriptenEHSjLj::runOnModule(Module &M) {
622  LLVM_DEBUG(dbgs() << "********** Lower Emscripten EH & SjLj **********\n");
623 
624  LLVMContext &C = M.getContext();
625  IRBuilder<> IRB(C);
626 
627  Function *SetjmpF = M.getFunction("setjmp");
628  Function *LongjmpF = M.getFunction("longjmp");
629  bool SetjmpUsed = SetjmpF && !SetjmpF->use_empty();
630  bool LongjmpUsed = LongjmpF && !LongjmpF->use_empty();
631  bool DoSjLj = EnableSjLj && (SetjmpUsed || LongjmpUsed);
632 
633  // Declare (or get) global variables __THREW__, __threwValue, and
634  // getTempRet0/setTempRet0 function which are used in common for both
635  // exception handling and setjmp/longjmp handling
636  ThrewGV = getGlobalVariableI32(M, IRB, "__THREW__");
637  ThrewValueGV = getGlobalVariableI32(M, IRB, "__threwValue");
638  GetTempRet0Func =
640  GlobalValue::ExternalLinkage, "getTempRet0", &M);
641  SetTempRet0Func = Function::Create(
642  FunctionType::get(IRB.getVoidTy(), IRB.getInt32Ty(), false),
643  GlobalValue::ExternalLinkage, "setTempRet0", &M);
644  GetTempRet0Func->setDoesNotThrow();
645  SetTempRet0Func->setDoesNotThrow();
646 
647  bool Changed = false;
648 
649  // Exception handling
650  if (EnableEH) {
651  // Register __resumeException function
652  FunctionType *ResumeFTy =
653  FunctionType::get(IRB.getVoidTy(), IRB.getInt8PtrTy(), false);
654  ResumeF = Function::Create(ResumeFTy, GlobalValue::ExternalLinkage,
655  ResumeFName, &M);
656 
657  // Register llvm_eh_typeid_for function
658  FunctionType *EHTypeIDTy =
659  FunctionType::get(IRB.getInt32Ty(), IRB.getInt8PtrTy(), false);
660  EHTypeIDF = Function::Create(EHTypeIDTy, GlobalValue::ExternalLinkage,
661  EHTypeIDFName, &M);
662 
663  for (Function &F : M) {
664  if (F.isDeclaration())
665  continue;
666  Changed |= runEHOnFunction(F);
667  }
668  }
669 
670  // Setjmp/longjmp handling
671  if (DoSjLj) {
672  Changed = true; // We have setjmp or longjmp somewhere
673 
674  if (LongjmpF) {
675  // Replace all uses of longjmp with emscripten_longjmp_jmpbuf, which is
676  // defined in JS code
677  EmLongjmpJmpbufF = Function::Create(LongjmpF->getFunctionType(),
679  EmLongjmpJmpbufFName, &M);
680 
681  LongjmpF->replaceAllUsesWith(EmLongjmpJmpbufF);
682  }
683 
684  if (SetjmpF) {
685  // Register saveSetjmp function
686  FunctionType *SetjmpFTy = SetjmpF->getFunctionType();
687  SmallVector<Type *, 4> Params = {SetjmpFTy->getParamType(0),
689  IRB.getInt32Ty()};
690  FunctionType *FTy =
691  FunctionType::get(Type::getInt32PtrTy(C), Params, false);
693  SaveSetjmpFName, &M);
694 
695  // Register testSetjmp function
696  Params = {IRB.getInt32Ty(), Type::getInt32PtrTy(C), IRB.getInt32Ty()};
697  FTy = FunctionType::get(IRB.getInt32Ty(), Params, false);
699  TestSetjmpFName, &M);
700 
701  FTy = FunctionType::get(IRB.getVoidTy(),
702  {IRB.getInt32Ty(), IRB.getInt32Ty()}, false);
704  EmLongjmpFName, &M);
705 
706  // Only traverse functions that uses setjmp in order not to insert
707  // unnecessary prep / cleanup code in every function
708  SmallPtrSet<Function *, 8> SetjmpUsers;
709  for (User *U : SetjmpF->users()) {
710  auto *UI = cast<Instruction>(U);
711  SetjmpUsers.insert(UI->getFunction());
712  }
713  for (Function *F : SetjmpUsers)
714  runSjLjOnFunction(*F);
715  }
716  }
717 
718  if (!Changed) {
719  // Delete unused global variables and functions
720  if (ResumeF)
721  ResumeF->eraseFromParent();
722  if (EHTypeIDF)
723  EHTypeIDF->eraseFromParent();
724  if (EmLongjmpF)
725  EmLongjmpF->eraseFromParent();
726  if (SaveSetjmpF)
727  SaveSetjmpF->eraseFromParent();
728  if (TestSetjmpF)
729  TestSetjmpF->eraseFromParent();
730  return false;
731  }
732 
733  return true;
734 }
735 
736 bool WebAssemblyLowerEmscriptenEHSjLj::runEHOnFunction(Function &F) {
737  Module &M = *F.getParent();
738  LLVMContext &C = F.getContext();
739  IRBuilder<> IRB(C);
740  bool Changed = false;
743  bool AllowExceptions =
744  areAllExceptionsAllowed() || EHWhitelistSet.count(F.getName());
745 
746  for (BasicBlock &BB : F) {
747  auto *II = dyn_cast<InvokeInst>(BB.getTerminator());
748  if (!II)
749  continue;
750  Changed = true;
751  LandingPads.insert(II->getLandingPadInst());
752  IRB.SetInsertPoint(II);
753 
754  bool NeedInvoke = AllowExceptions && canThrow(II->getCalledValue());
755  if (NeedInvoke) {
756  // Wrap invoke with invoke wrapper and generate preamble/postamble
757  Value *Threw = wrapInvoke(II);
758  ToErase.push_back(II);
759 
760  // Insert a branch based on __THREW__ variable
761  Value *Cmp = IRB.CreateICmpEQ(Threw, IRB.getInt32(1), "cmp");
762  IRB.CreateCondBr(Cmp, II->getUnwindDest(), II->getNormalDest());
763 
764  } else {
765  // This can't throw, and we don't need this invoke, just replace it with a
766  // call+branch
767  SmallVector<Value *, 16> Args(II->arg_begin(), II->arg_end());
768  CallInst *NewCall =
769  IRB.CreateCall(II->getFunctionType(), II->getCalledValue(), Args);
770  NewCall->takeName(II);
771  NewCall->setCallingConv(II->getCallingConv());
772  NewCall->setDebugLoc(II->getDebugLoc());
773  NewCall->setAttributes(II->getAttributes());
774  II->replaceAllUsesWith(NewCall);
775  ToErase.push_back(II);
776 
777  IRB.CreateBr(II->getNormalDest());
778 
779  // Remove any PHI node entries from the exception destination
780  II->getUnwindDest()->removePredecessor(&BB);
781  }
782  }
783 
784  // Process resume instructions
785  for (BasicBlock &BB : F) {
786  // Scan the body of the basic block for resumes
787  for (Instruction &I : BB) {
788  auto *RI = dyn_cast<ResumeInst>(&I);
789  if (!RI)
790  continue;
791 
792  // Split the input into legal values
793  Value *Input = RI->getValue();
794  IRB.SetInsertPoint(RI);
795  Value *Low = IRB.CreateExtractValue(Input, 0, "low");
796  // Create a call to __resumeException function
797  IRB.CreateCall(ResumeF, {Low});
798  // Add a terminator to the block
799  IRB.CreateUnreachable();
800  ToErase.push_back(RI);
801  }
802  }
803 
804  // Process llvm.eh.typeid.for intrinsics
805  for (BasicBlock &BB : F) {
806  for (Instruction &I : BB) {
807  auto *CI = dyn_cast<CallInst>(&I);
808  if (!CI)
809  continue;
810  const Function *Callee = CI->getCalledFunction();
811  if (!Callee)
812  continue;
813  if (Callee->getIntrinsicID() != Intrinsic::eh_typeid_for)
814  continue;
815 
816  IRB.SetInsertPoint(CI);
817  CallInst *NewCI =
818  IRB.CreateCall(EHTypeIDF, CI->getArgOperand(0), "typeid");
819  CI->replaceAllUsesWith(NewCI);
820  ToErase.push_back(CI);
821  }
822  }
823 
824  // Look for orphan landingpads, can occur in blocks with no predecessors
825  for (BasicBlock &BB : F) {
826  Instruction *I = BB.getFirstNonPHI();
827  if (auto *LPI = dyn_cast<LandingPadInst>(I))
828  LandingPads.insert(LPI);
829  }
830 
831  // Handle all the landingpad for this function together, as multiple invokes
832  // may share a single lp
833  for (LandingPadInst *LPI : LandingPads) {
834  IRB.SetInsertPoint(LPI);
835  SmallVector<Value *, 16> FMCArgs;
836  for (unsigned I = 0, E = LPI->getNumClauses(); I < E; ++I) {
837  Constant *Clause = LPI->getClause(I);
838  // As a temporary workaround for the lack of aggregate varargs support
839  // in the interface between JS and wasm, break out filter operands into
840  // their component elements.
841  if (LPI->isFilter(I)) {
842  auto *ATy = cast<ArrayType>(Clause->getType());
843  for (unsigned J = 0, E = ATy->getNumElements(); J < E; ++J) {
844  Value *EV = IRB.CreateExtractValue(Clause, makeArrayRef(J), "filter");
845  FMCArgs.push_back(EV);
846  }
847  } else
848  FMCArgs.push_back(Clause);
849  }
850 
851  // Create a call to __cxa_find_matching_catch_N function
852  Function *FMCF = getFindMatchingCatch(M, FMCArgs.size());
853  CallInst *FMCI = IRB.CreateCall(FMCF, FMCArgs, "fmc");
854  Value *Undef = UndefValue::get(LPI->getType());
855  Value *Pair0 = IRB.CreateInsertValue(Undef, FMCI, 0, "pair0");
856  Value *TempRet0 = IRB.CreateCall(GetTempRet0Func, None, "tempret0");
857  Value *Pair1 = IRB.CreateInsertValue(Pair0, TempRet0, 1, "pair1");
858 
859  LPI->replaceAllUsesWith(Pair1);
860  ToErase.push_back(LPI);
861  }
862 
863  // Erase everything we no longer need in this function
864  for (Instruction *I : ToErase)
865  I->eraseFromParent();
866 
867  return Changed;
868 }
869 
870 bool WebAssemblyLowerEmscriptenEHSjLj::runSjLjOnFunction(Function &F) {
871  Module &M = *F.getParent();
872  LLVMContext &C = F.getContext();
873  IRBuilder<> IRB(C);
875  // Vector of %setjmpTable values
876  std::vector<Instruction *> SetjmpTableInsts;
877  // Vector of %setjmpTableSize values
878  std::vector<Instruction *> SetjmpTableSizeInsts;
879 
880  // Setjmp preparation
881 
882  // This instruction effectively means %setjmpTableSize = 4.
883  // We create this as an instruction intentionally, and we don't want to fold
884  // this instruction to a constant 4, because this value will be used in
885  // SSAUpdater.AddAvailableValue(...) later.
886  BasicBlock &EntryBB = F.getEntryBlock();
887  BinaryOperator *SetjmpTableSize = BinaryOperator::Create(
888  Instruction::Add, IRB.getInt32(4), IRB.getInt32(0), "setjmpTableSize",
889  &*EntryBB.getFirstInsertionPt());
890  // setjmpTable = (int *) malloc(40);
891  Instruction *SetjmpTable = CallInst::CreateMalloc(
892  SetjmpTableSize, IRB.getInt32Ty(), IRB.getInt32Ty(), IRB.getInt32(40),
893  nullptr, nullptr, "setjmpTable");
894  // setjmpTable[0] = 0;
895  IRB.SetInsertPoint(SetjmpTableSize);
896  IRB.CreateStore(IRB.getInt32(0), SetjmpTable);
897  SetjmpTableInsts.push_back(SetjmpTable);
898  SetjmpTableSizeInsts.push_back(SetjmpTableSize);
899 
900  // Setjmp transformation
901  std::vector<PHINode *> SetjmpRetPHIs;
902  Function *SetjmpF = M.getFunction("setjmp");
903  for (User *U : SetjmpF->users()) {
904  auto *CI = dyn_cast<CallInst>(U);
905  if (!CI)
906  report_fatal_error("Does not support indirect calls to setjmp");
907 
908  BasicBlock *BB = CI->getParent();
909  if (BB->getParent() != &F) // in other function
910  continue;
911 
912  // The tail is everything right after the call, and will be reached once
913  // when setjmp is called, and later when longjmp returns to the setjmp
914  BasicBlock *Tail = SplitBlock(BB, CI->getNextNode());
915  // Add a phi to the tail, which will be the output of setjmp, which
916  // indicates if this is the first call or a longjmp back. The phi directly
917  // uses the right value based on where we arrive from
918  IRB.SetInsertPoint(Tail->getFirstNonPHI());
919  PHINode *SetjmpRet = IRB.CreatePHI(IRB.getInt32Ty(), 2, "setjmp.ret");
920 
921  // setjmp initial call returns 0
922  SetjmpRet->addIncoming(IRB.getInt32(0), BB);
923  // The proper output is now this, not the setjmp call itself
924  CI->replaceAllUsesWith(SetjmpRet);
925  // longjmp returns to the setjmp will add themselves to this phi
926  SetjmpRetPHIs.push_back(SetjmpRet);
927 
928  // Fix call target
929  // Our index in the function is our place in the array + 1 to avoid index
930  // 0, because index 0 means the longjmp is not ours to handle.
931  IRB.SetInsertPoint(CI);
932  Value *Args[] = {CI->getArgOperand(0), IRB.getInt32(SetjmpRetPHIs.size()),
933  SetjmpTable, SetjmpTableSize};
934  Instruction *NewSetjmpTable =
935  IRB.CreateCall(SaveSetjmpF, Args, "setjmpTable");
936  Instruction *NewSetjmpTableSize =
937  IRB.CreateCall(GetTempRet0Func, None, "setjmpTableSize");
938  SetjmpTableInsts.push_back(NewSetjmpTable);
939  SetjmpTableSizeInsts.push_back(NewSetjmpTableSize);
940  ToErase.push_back(CI);
941  }
942 
943  // Update each call that can longjmp so it can return to a setjmp where
944  // relevant.
945 
946  // Because we are creating new BBs while processing and don't want to make
947  // all these newly created BBs candidates again for longjmp processing, we
948  // first make the vector of candidate BBs.
949  std::vector<BasicBlock *> BBs;
950  for (BasicBlock &BB : F)
951  BBs.push_back(&BB);
952 
953  // BBs.size() will change within the loop, so we query it every time
954  for (unsigned I = 0; I < BBs.size(); I++) {
955  BasicBlock *BB = BBs[I];
956  for (Instruction &I : *BB) {
957  assert(!isa<InvokeInst>(&I));
958  auto *CI = dyn_cast<CallInst>(&I);
959  if (!CI)
960  continue;
961 
962  const Value *Callee = CI->getCalledValue();
963  if (!canLongjmp(M, Callee))
964  continue;
965 
966  Value *Threw = nullptr;
967  BasicBlock *Tail;
968  if (Callee->getName().startswith(InvokePrefix)) {
969  // If invoke wrapper has already been generated for this call in
970  // previous EH phase, search for the load instruction
971  // %__THREW__.val = __THREW__;
972  // in postamble after the invoke wrapper call
973  LoadInst *ThrewLI = nullptr;
974  StoreInst *ThrewResetSI = nullptr;
975  for (auto I = std::next(BasicBlock::iterator(CI)), IE = BB->end();
976  I != IE; ++I) {
977  if (auto *LI = dyn_cast<LoadInst>(I))
978  if (auto *GV = dyn_cast<GlobalVariable>(LI->getPointerOperand()))
979  if (GV == ThrewGV) {
980  Threw = ThrewLI = LI;
981  break;
982  }
983  }
984  // Search for the store instruction after the load above
985  // __THREW__ = 0;
986  for (auto I = std::next(BasicBlock::iterator(ThrewLI)), IE = BB->end();
987  I != IE; ++I) {
988  if (auto *SI = dyn_cast<StoreInst>(I))
989  if (auto *GV = dyn_cast<GlobalVariable>(SI->getPointerOperand()))
990  if (GV == ThrewGV && SI->getValueOperand() == IRB.getInt32(0)) {
991  ThrewResetSI = SI;
992  break;
993  }
994  }
995  assert(Threw && ThrewLI && "Cannot find __THREW__ load after invoke");
996  assert(ThrewResetSI && "Cannot find __THREW__ store after invoke");
997  Tail = SplitBlock(BB, ThrewResetSI->getNextNode());
998 
999  } else {
1000  // Wrap call with invoke wrapper and generate preamble/postamble
1001  Threw = wrapInvoke(CI);
1002  ToErase.push_back(CI);
1003  Tail = SplitBlock(BB, CI->getNextNode());
1004  }
1005 
1006  // We need to replace the terminator in Tail - SplitBlock makes BB go
1007  // straight to Tail, we need to check if a longjmp occurred, and go to the
1008  // right setjmp-tail if so
1009  ToErase.push_back(BB->getTerminator());
1010 
1011  // Generate a function call to testSetjmp function and preamble/postamble
1012  // code to figure out (1) whether longjmp occurred (2) if longjmp
1013  // occurred, which setjmp it corresponds to
1014  Value *Label = nullptr;
1015  Value *LongjmpResult = nullptr;
1016  BasicBlock *EndBB = nullptr;
1017  wrapTestSetjmp(BB, CI, Threw, SetjmpTable, SetjmpTableSize, Label,
1018  LongjmpResult, EndBB);
1019  assert(Label && LongjmpResult && EndBB);
1020 
1021  // Create switch instruction
1022  IRB.SetInsertPoint(EndBB);
1023  SwitchInst *SI = IRB.CreateSwitch(Label, Tail, SetjmpRetPHIs.size());
1024  // -1 means no longjmp happened, continue normally (will hit the default
1025  // switch case). 0 means a longjmp that is not ours to handle, needs a
1026  // rethrow. Otherwise the index is the same as the index in P+1 (to avoid
1027  // 0).
1028  for (unsigned I = 0; I < SetjmpRetPHIs.size(); I++) {
1029  SI->addCase(IRB.getInt32(I + 1), SetjmpRetPHIs[I]->getParent());
1030  SetjmpRetPHIs[I]->addIncoming(LongjmpResult, EndBB);
1031  }
1032 
1033  // We are splitting the block here, and must continue to find other calls
1034  // in the block - which is now split. so continue to traverse in the Tail
1035  BBs.push_back(Tail);
1036  }
1037  }
1038 
1039  // Erase everything we no longer need in this function
1040  for (Instruction *I : ToErase)
1041  I->eraseFromParent();
1042 
1043  // Free setjmpTable buffer before each return instruction
1044  for (BasicBlock &BB : F) {
1045  Instruction *TI = BB.getTerminator();
1046  if (isa<ReturnInst>(TI))
1047  CallInst::CreateFree(SetjmpTable, TI);
1048  }
1049 
1050  // Every call to saveSetjmp can change setjmpTable and setjmpTableSize
1051  // (when buffer reallocation occurs)
1052  // entry:
1053  // setjmpTableSize = 4;
1054  // setjmpTable = (int *) malloc(40);
1055  // setjmpTable[0] = 0;
1056  // ...
1057  // somebb:
1058  // setjmpTable = saveSetjmp(buf, label, setjmpTable, setjmpTableSize);
1059  // setjmpTableSize = getTempRet0();
1060  // So we need to make sure the SSA for these variables is valid so that every
1061  // saveSetjmp and testSetjmp calls have the correct arguments.
1062  SSAUpdater SetjmpTableSSA;
1063  SSAUpdater SetjmpTableSizeSSA;
1064  SetjmpTableSSA.Initialize(Type::getInt32PtrTy(C), "setjmpTable");
1065  SetjmpTableSizeSSA.Initialize(Type::getInt32Ty(C), "setjmpTableSize");
1066  for (Instruction *I : SetjmpTableInsts)
1067  SetjmpTableSSA.AddAvailableValue(I->getParent(), I);
1068  for (Instruction *I : SetjmpTableSizeInsts)
1069  SetjmpTableSizeSSA.AddAvailableValue(I->getParent(), I);
1070 
1071  for (auto UI = SetjmpTable->use_begin(), UE = SetjmpTable->use_end();
1072  UI != UE;) {
1073  // Grab the use before incrementing the iterator.
1074  Use &U = *UI;
1075  // Increment the iterator before removing the use from the list.
1076  ++UI;
1077  if (auto *I = dyn_cast<Instruction>(U.getUser()))
1078  if (I->getParent() != &EntryBB)
1079  SetjmpTableSSA.RewriteUse(U);
1080  }
1081  for (auto UI = SetjmpTableSize->use_begin(), UE = SetjmpTableSize->use_end();
1082  UI != UE;) {
1083  Use &U = *UI;
1084  ++UI;
1085  if (auto *I = dyn_cast<Instruction>(U.getUser()))
1086  if (I->getParent() != &EntryBB)
1087  SetjmpTableSizeSSA.RewriteUse(U);
1088  }
1089 
1090  // Finally, our modifications to the cfg can break dominance of SSA variables.
1091  // For example, in this code,
1092  // if (x()) { .. setjmp() .. }
1093  // if (y()) { .. longjmp() .. }
1094  // We must split the longjmp block, and it can jump into the block splitted
1095  // from setjmp one. But that means that when we split the setjmp block, it's
1096  // first part no longer dominates its second part - there is a theoretically
1097  // possible control flow path where x() is false, then y() is true and we
1098  // reach the second part of the setjmp block, without ever reaching the first
1099  // part. So, we rebuild SSA form here.
1100  rebuildSSA(F);
1101  return true;
1102 }
uint64_t CallInst * C
use_iterator use_end()
Definition: Value.h:346
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:853
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:1878
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:134
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:1392
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:64
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:256
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:227
const GlobalVariable * getNamedGlobal(StringRef Name) const
Return the global variable in the module with the specified name, of arbitrary type.
Definition: Module.h:404
iterator find(StringRef Key)
Definition: StringMap.h:332
Externally visible function.
Definition: GlobalValue.h:48
F(f)
param_iterator param_end() const
Definition: DerivedTypes.h:128
An instruction for reading from memory.
Definition: Instructions.h:167
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:137
static Instruction * CreateFree(Value *Source, Instruction *InsertBefore)
Generate the IR for a call to the builtin free function.
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:522
IntegerType * getInt32Ty()
Fetch the type representing a 32-bit integer.
Definition: IRBuilder.h:346
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:133
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:243
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:742
AttributeSet getRetAttributes() const
The attributes for the ret value are returned.
Type * getVoidTy()
Fetch the type representing void.
Definition: IRBuilder.h:379
StoreInst * CreateStore(Value *Val, Value *Ptr, bool isVolatile=false)
Definition: IRBuilder.h:1421
Value * CreateIntToPtr(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1762
User * getUser() const LLVM_READONLY
Returns the User that contains this Use.
Definition: Use.cpp:40
Class to represent function types.
Definition: DerivedTypes.h:102
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:244
AttributeSet getParamAttributes(unsigned ArgNo) const
The attributes for the argument or parameter at the given index are returned.
bool isVarArg() const
Definition: DerivedTypes.h:122
Memory SSA
Definition: MemorySSA.cpp:64
An instruction for storing to memory.
Definition: Instructions.h:320
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:126
Class to represent pointers.
Definition: DerivedTypes.h:498
AttributeSet getAttributes(unsigned Index) const
The attributes for the specified index are returned.
const BasicBlock & getEntryBlock() const
Definition: Function.h:639
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:189
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:216
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:321
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:45
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
void RewriteUseAfterInsertions(Use &U)
Rewrite a use like RewriteUse but handling in-block definitions.
Definition: SSAUpdater.cpp:206
UnreachableInst * CreateUnreachable()
Definition: IRBuilder.h:1013
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:278
ArrayRef< Type * > params() const
Definition: DerivedTypes.h:129
param_iterator param_begin() const
Definition: DerivedTypes.h:127
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:1262
static FunctionType * get(Type *Result, ArrayRef< Type *> Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:296
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:1874
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:1225
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:192
static UndefValue * get(Type *T)
Static factory methods - Return an &#39;undef&#39; object of the specified type.
Definition: Constants.cpp:1414
Value * CreateExtractValue(Value *Agg, ArrayRef< unsigned > Idxs, const Twine &Name="")
Definition: IRBuilder.h:2119
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:384
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:219
std::string & str()
Flushes the stream contents to the target string and returns the string&#39;s reference.
Definition: raw_ostream.h:498
PHINode * CreatePHI(Type *Ty, unsigned NumReservedValues, const Twine &Name="")
Definition: IRBuilder.h:2004
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:513
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:839
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:123
ConstantInt * getInt32(uint32_t C)
Get a constant 32-bit value.
Definition: IRBuilder.h:306
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:219
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:399
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:386
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:876
use_iterator use_begin()
Definition: Value.h:338
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:175
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
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:1284
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:322
CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value *> Args=None, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2009
void eraseFromParent()
eraseFromParent - This method unlinks &#39;this&#39; from the containing module and deletes it...
Definition: Function.cpp:213
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:171
Value * CreateAnd(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1199
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:205
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:482
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:565
LLVM Value Representation.
Definition: Value.h:72
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:847
AttributeSet getFnAttributes() const
The function attributes are returned.
BasicBlock * SplitBlock(BasicBlock *Old, Instruction *SplitPt, DominatorTree *DT=nullptr, LoopInfo *LI=nullptr, MemorySSAUpdater *MSSAU=nullptr)
Split the specified block at the specified instruction - everything before SplitPt stays in Old and e...
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:2127
#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:322
iterator end()
Definition: StringMap.h:317
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:872