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