Line data Source code
1 : //===- SjLjEHPrepare.cpp - Eliminate Invoke & Unwind instructions ---------===//
2 : //
3 : // The LLVM Compiler Infrastructure
4 : //
5 : // This file is distributed under the University of Illinois Open Source
6 : // License. See LICENSE.TXT for details.
7 : //
8 : //===----------------------------------------------------------------------===//
9 : //
10 : // This transformation is designed for use by code generators which use SjLj
11 : // based exception handling.
12 : //
13 : //===----------------------------------------------------------------------===//
14 :
15 : #include "llvm/ADT/SetVector.h"
16 : #include "llvm/ADT/SmallPtrSet.h"
17 : #include "llvm/ADT/SmallVector.h"
18 : #include "llvm/ADT/Statistic.h"
19 : #include "llvm/Transforms/Utils/Local.h"
20 : #include "llvm/CodeGen/Passes.h"
21 : #include "llvm/IR/Constants.h"
22 : #include "llvm/IR/DataLayout.h"
23 : #include "llvm/IR/DerivedTypes.h"
24 : #include "llvm/IR/IRBuilder.h"
25 : #include "llvm/IR/Instructions.h"
26 : #include "llvm/IR/Intrinsics.h"
27 : #include "llvm/IR/Module.h"
28 : #include "llvm/Pass.h"
29 : #include "llvm/Support/Debug.h"
30 : #include "llvm/Support/raw_ostream.h"
31 : using namespace llvm;
32 :
33 : #define DEBUG_TYPE "sjljehprepare"
34 :
35 : STATISTIC(NumInvokes, "Number of invokes replaced");
36 : STATISTIC(NumSpilled, "Number of registers live across unwind edges");
37 :
38 : namespace {
39 : class SjLjEHPrepare : public FunctionPass {
40 : Type *doubleUnderDataTy;
41 : Type *doubleUnderJBufTy;
42 : Type *FunctionContextTy;
43 : Constant *RegisterFn;
44 : Constant *UnregisterFn;
45 : Constant *BuiltinSetupDispatchFn;
46 : Constant *FrameAddrFn;
47 : Constant *StackAddrFn;
48 : Constant *StackRestoreFn;
49 : Constant *LSDAAddrFn;
50 : Constant *CallSiteFn;
51 : Constant *FuncCtxFn;
52 : AllocaInst *FuncCtx;
53 :
54 : public:
55 : static char ID; // Pass identification, replacement for typeid
56 1428 : explicit SjLjEHPrepare() : FunctionPass(ID) {}
57 : bool doInitialization(Module &M) override;
58 : bool runOnFunction(Function &F) override;
59 :
60 711 : void getAnalysisUsage(AnalysisUsage &AU) const override {}
61 0 : StringRef getPassName() const override {
62 0 : return "SJLJ Exception Handling preparation";
63 : }
64 :
65 : private:
66 : bool setupEntryBlockAndCallSites(Function &F);
67 : void substituteLPadValues(LandingPadInst *LPI, Value *ExnVal, Value *SelVal);
68 : Value *setupFunctionContext(Function &F, ArrayRef<LandingPadInst *> LPads);
69 : void lowerIncomingArguments(Function &F);
70 : void lowerAcrossUnwindEdges(Function &F, ArrayRef<InvokeInst *> Invokes);
71 : void insertCallSiteStore(Instruction *I, int Number);
72 : };
73 : } // end anonymous namespace
74 :
75 : char SjLjEHPrepare::ID = 0;
76 21478 : INITIALIZE_PASS(SjLjEHPrepare, DEBUG_TYPE, "Prepare SjLj exceptions",
77 : false, false)
78 :
79 : // Public Interface To the SjLjEHPrepare pass.
80 712 : FunctionPass *llvm::createSjLjEHPreparePass() { return new SjLjEHPrepare(); }
81 : // doInitialization - Set up decalarations and types needed to process
82 : // exceptions.
83 711 : bool SjLjEHPrepare::doInitialization(Module &M) {
84 : // Build the function context structure.
85 : // builtin_setjmp uses a five word jbuf
86 711 : Type *VoidPtrTy = Type::getInt8PtrTy(M.getContext());
87 711 : Type *Int32Ty = Type::getInt32Ty(M.getContext());
88 711 : doubleUnderDataTy = ArrayType::get(Int32Ty, 4);
89 711 : doubleUnderJBufTy = ArrayType::get(VoidPtrTy, 5);
90 711 : FunctionContextTy = StructType::get(VoidPtrTy, // __prev
91 : Int32Ty, // call_site
92 : doubleUnderDataTy, // __data
93 : VoidPtrTy, // __personality
94 : VoidPtrTy, // __lsda
95 : doubleUnderJBufTy // __jbuf
96 : );
97 :
98 711 : return true;
99 : }
100 :
101 : /// insertCallSiteStore - Insert a store of the call-site value to the
102 : /// function context
103 0 : void SjLjEHPrepare::insertCallSiteStore(Instruction *I, int Number) {
104 0 : IRBuilder<> Builder(I);
105 :
106 : // Get a reference to the call_site field.
107 0 : Type *Int32Ty = Type::getInt32Ty(I->getContext());
108 0 : Value *Zero = ConstantInt::get(Int32Ty, 0);
109 0 : Value *One = ConstantInt::get(Int32Ty, 1);
110 0 : Value *Idxs[2] = { Zero, One };
111 : Value *CallSite =
112 0 : Builder.CreateGEP(FunctionContextTy, FuncCtx, Idxs, "call_site");
113 :
114 : // Insert a store of the call-site number
115 : ConstantInt *CallSiteNoC =
116 0 : ConstantInt::get(Type::getInt32Ty(I->getContext()), Number);
117 0 : Builder.CreateStore(CallSiteNoC, CallSite, true /*volatile*/);
118 0 : }
119 :
120 : /// MarkBlocksLiveIn - Insert BB and all of its predecessors into LiveBBs until
121 : /// we reach blocks we've already seen.
122 612 : static void MarkBlocksLiveIn(BasicBlock *BB,
123 : SmallPtrSetImpl<BasicBlock *> &LiveBBs) {
124 612 : if (!LiveBBs.insert(BB).second)
125 322 : return; // already been here.
126 :
127 : df_iterator_default_set<BasicBlock*> Visited;
128 :
129 4592 : for (BasicBlock *B : inverse_depth_first_ext(BB, Visited))
130 3722 : LiveBBs.insert(B);
131 :
132 : }
133 :
134 : /// substituteLPadValues - Substitute the values returned by the landingpad
135 : /// instruction with those returned by the personality function.
136 0 : void SjLjEHPrepare::substituteLPadValues(LandingPadInst *LPI, Value *ExnVal,
137 : Value *SelVal) {
138 0 : SmallVector<Value *, 8> UseWorkList(LPI->user_begin(), LPI->user_end());
139 0 : while (!UseWorkList.empty()) {
140 : Value *Val = UseWorkList.pop_back_val();
141 : auto *EVI = dyn_cast<ExtractValueInst>(Val);
142 0 : if (!EVI)
143 0 : continue;
144 0 : if (EVI->getNumIndices() != 1)
145 0 : continue;
146 0 : if (*EVI->idx_begin() == 0)
147 0 : EVI->replaceAllUsesWith(ExnVal);
148 0 : else if (*EVI->idx_begin() == 1)
149 0 : EVI->replaceAllUsesWith(SelVal);
150 0 : if (EVI->use_empty())
151 0 : EVI->eraseFromParent();
152 : }
153 :
154 0 : if (LPI->use_empty())
155 0 : return;
156 :
157 : // There are still some uses of LPI. Construct an aggregate with the exception
158 : // values and replace the LPI with that aggregate.
159 0 : Type *LPadType = LPI->getType();
160 0 : Value *LPadVal = UndefValue::get(LPadType);
161 : auto *SelI = cast<Instruction>(SelVal);
162 0 : IRBuilder<> Builder(SelI->getParent(), std::next(SelI->getIterator()));
163 0 : LPadVal = Builder.CreateInsertValue(LPadVal, ExnVal, 0, "lpad.val");
164 0 : LPadVal = Builder.CreateInsertValue(LPadVal, SelVal, 1, "lpad.val");
165 :
166 0 : LPI->replaceAllUsesWith(LPadVal);
167 : }
168 :
169 : /// setupFunctionContext - Allocate the function context on the stack and fill
170 : /// it with all of the data that we know at this point.
171 39 : Value *SjLjEHPrepare::setupFunctionContext(Function &F,
172 : ArrayRef<LandingPadInst *> LPads) {
173 : BasicBlock *EntryBB = &F.front();
174 :
175 : // Create an alloca for the incoming jump buffer ptr and the new jump buffer
176 : // that needs to be restored on all exits from the function. This is an alloca
177 : // because the value needs to be added to the global context list.
178 39 : auto &DL = F.getParent()->getDataLayout();
179 39 : unsigned Align = DL.getPrefTypeAlignment(FunctionContextTy);
180 39 : FuncCtx = new AllocaInst(FunctionContextTy, DL.getAllocaAddrSpace(),
181 39 : nullptr, Align, "fn_context", &EntryBB->front());
182 :
183 : // Fill in the function context structure.
184 170 : for (LandingPadInst *LPI : LPads) {
185 : IRBuilder<> Builder(LPI->getParent(),
186 262 : LPI->getParent()->getFirstInsertionPt());
187 :
188 : // Reference the __data field.
189 : Value *FCData =
190 131 : Builder.CreateConstGEP2_32(FunctionContextTy, FuncCtx, 0, 2, "__data");
191 :
192 : // The exception values come back in context->__data[0].
193 131 : Value *ExceptionAddr = Builder.CreateConstGEP2_32(doubleUnderDataTy, FCData,
194 : 0, 0, "exception_gep");
195 131 : Value *ExnVal = Builder.CreateLoad(ExceptionAddr, true, "exn_val");
196 262 : ExnVal = Builder.CreateIntToPtr(ExnVal, Builder.getInt8PtrTy());
197 :
198 131 : Value *SelectorAddr = Builder.CreateConstGEP2_32(doubleUnderDataTy, FCData,
199 : 0, 1, "exn_selector_gep");
200 131 : Value *SelVal = Builder.CreateLoad(SelectorAddr, true, "exn_selector_val");
201 :
202 131 : substituteLPadValues(LPI, ExnVal, SelVal);
203 : }
204 :
205 : // Personality function
206 39 : IRBuilder<> Builder(EntryBB->getTerminator());
207 39 : Value *PersonalityFn = F.getPersonalityFn();
208 39 : Value *PersonalityFieldPtr = Builder.CreateConstGEP2_32(
209 39 : FunctionContextTy, FuncCtx, 0, 3, "pers_fn_gep");
210 39 : Builder.CreateStore(
211 39 : Builder.CreateBitCast(PersonalityFn, Builder.getInt8PtrTy()),
212 : PersonalityFieldPtr, /*isVolatile=*/true);
213 :
214 : // LSDA address
215 39 : Value *LSDA = Builder.CreateCall(LSDAAddrFn, {}, "lsda_addr");
216 : Value *LSDAFieldPtr =
217 39 : Builder.CreateConstGEP2_32(FunctionContextTy, FuncCtx, 0, 4, "lsda_gep");
218 39 : Builder.CreateStore(LSDA, LSDAFieldPtr, /*isVolatile=*/true);
219 :
220 39 : return FuncCtx;
221 : }
222 :
223 : /// lowerIncomingArguments - To avoid having to handle incoming arguments
224 : /// specially, we lower each arg to a copy instruction in the entry block. This
225 : /// ensures that the argument value itself cannot be live out of the entry
226 : /// block.
227 0 : void SjLjEHPrepare::lowerIncomingArguments(Function &F) {
228 : BasicBlock::iterator AfterAllocaInsPt = F.begin()->begin();
229 0 : while (isa<AllocaInst>(AfterAllocaInsPt) &&
230 0 : cast<AllocaInst>(AfterAllocaInsPt)->isStaticAlloca())
231 : ++AfterAllocaInsPt;
232 : assert(AfterAllocaInsPt != F.front().end());
233 :
234 0 : for (auto &AI : F.args()) {
235 : // Swift error really is a register that we model as memory -- instruction
236 : // selection will perform mem-to-reg for us and spill/reload appropriately
237 : // around calls that clobber it. There is no need to spill this
238 : // value to the stack and doing so would not be allowed.
239 0 : if (AI.isSwiftError())
240 0 : continue;
241 :
242 0 : Type *Ty = AI.getType();
243 :
244 : // Use 'select i8 true, %arg, undef' to simulate a 'no-op' instruction.
245 0 : Value *TrueValue = ConstantInt::getTrue(F.getContext());
246 0 : Value *UndefValue = UndefValue::get(Ty);
247 : Instruction *SI = SelectInst::Create(
248 0 : TrueValue, &AI, UndefValue, AI.getName() + ".tmp", &*AfterAllocaInsPt);
249 0 : AI.replaceAllUsesWith(SI);
250 :
251 : // Reset the operand, because it was clobbered by the RAUW above.
252 0 : SI->setOperand(1, &AI);
253 : }
254 0 : }
255 :
256 : /// lowerAcrossUnwindEdges - Find all variables which are alive across an unwind
257 : /// edge and spill them.
258 0 : void SjLjEHPrepare::lowerAcrossUnwindEdges(Function &F,
259 : ArrayRef<InvokeInst *> Invokes) {
260 : // Finally, scan the code looking for instructions with bad live ranges.
261 0 : for (BasicBlock &BB : F) {
262 0 : for (Instruction &Inst : BB) {
263 : // Ignore obvious cases we don't have to handle. In particular, most
264 : // instructions either have no uses or only have a single use inside the
265 : // current block. Ignore them quickly.
266 0 : if (Inst.use_empty())
267 0 : continue;
268 0 : if (Inst.hasOneUse() &&
269 0 : cast<Instruction>(Inst.user_back())->getParent() == &BB &&
270 : !isa<PHINode>(Inst.user_back()))
271 0 : continue;
272 :
273 : // If this is an alloca in the entry block, it's not a real register
274 : // value.
275 : if (auto *AI = dyn_cast<AllocaInst>(&Inst))
276 0 : if (AI->isStaticAlloca())
277 0 : continue;
278 :
279 : // Avoid iterator invalidation by copying users to a temporary vector.
280 : SmallVector<Instruction *, 16> Users;
281 0 : for (User *U : Inst.users()) {
282 0 : Instruction *UI = cast<Instruction>(U);
283 0 : if (UI->getParent() != &BB || isa<PHINode>(UI))
284 0 : Users.push_back(UI);
285 : }
286 :
287 : // Find all of the blocks that this value is live in.
288 : SmallPtrSet<BasicBlock *, 32> LiveBBs;
289 0 : LiveBBs.insert(&BB);
290 0 : while (!Users.empty()) {
291 : Instruction *U = Users.pop_back_val();
292 :
293 0 : if (!isa<PHINode>(U)) {
294 0 : MarkBlocksLiveIn(U->getParent(), LiveBBs);
295 : } else {
296 : // Uses for a PHI node occur in their predecessor block.
297 : PHINode *PN = cast<PHINode>(U);
298 0 : for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
299 0 : if (PN->getIncomingValue(i) == &Inst)
300 0 : MarkBlocksLiveIn(PN->getIncomingBlock(i), LiveBBs);
301 : }
302 : }
303 :
304 : // Now that we know all of the blocks that this thing is live in, see if
305 : // it includes any of the unwind locations.
306 : bool NeedsSpill = false;
307 0 : for (InvokeInst *Invoke : Invokes) {
308 : BasicBlock *UnwindBlock = Invoke->getUnwindDest();
309 0 : if (UnwindBlock != &BB && LiveBBs.count(UnwindBlock)) {
310 : LLVM_DEBUG(dbgs() << "SJLJ Spill: " << Inst << " around "
311 : << UnwindBlock->getName() << "\n");
312 : NeedsSpill = true;
313 : break;
314 : }
315 : }
316 :
317 : // If we decided we need a spill, do it.
318 : // FIXME: Spilling this way is overkill, as it forces all uses of
319 : // the value to be reloaded from the stack slot, even those that aren't
320 : // in the unwind blocks. We should be more selective.
321 0 : if (NeedsSpill) {
322 0 : DemoteRegToStack(Inst, true);
323 : ++NumSpilled;
324 : }
325 : }
326 : }
327 :
328 : // Go through the landing pads and remove any PHIs there.
329 0 : for (InvokeInst *Invoke : Invokes) {
330 : BasicBlock *UnwindBlock = Invoke->getUnwindDest();
331 : LandingPadInst *LPI = UnwindBlock->getLandingPadInst();
332 :
333 : // Place PHIs into a set to avoid invalidating the iterator.
334 : SmallPtrSet<PHINode *, 8> PHIsToDemote;
335 0 : for (BasicBlock::iterator PN = UnwindBlock->begin(); isa<PHINode>(PN); ++PN)
336 0 : PHIsToDemote.insert(cast<PHINode>(PN));
337 0 : if (PHIsToDemote.empty())
338 : continue;
339 :
340 : // Demote the PHIs to the stack.
341 0 : for (PHINode *PN : PHIsToDemote)
342 0 : DemotePHIToStack(PN);
343 :
344 : // Move the landingpad instruction back to the top of the landing pad block.
345 0 : LPI->moveBefore(&UnwindBlock->front());
346 : }
347 0 : }
348 :
349 : /// setupEntryBlockAndCallSites - Setup the entry block by creating and filling
350 : /// the function context and marking the call sites with the appropriate
351 : /// values. These values are used by the DWARF EH emitter.
352 2309 : bool SjLjEHPrepare::setupEntryBlockAndCallSites(Function &F) {
353 : SmallVector<ReturnInst *, 16> Returns;
354 : SmallVector<InvokeInst *, 16> Invokes;
355 : SmallSetVector<LandingPadInst *, 16> LPads;
356 :
357 : // Look through the terminators of the basic blocks to find invokes.
358 6628 : for (BasicBlock &BB : F)
359 4319 : if (auto *II = dyn_cast<InvokeInst>(BB.getTerminator())) {
360 : if (Function *Callee = II->getCalledFunction())
361 175 : if (Callee->getIntrinsicID() == Intrinsic::donothing) {
362 : // Remove the NOP invoke.
363 0 : BranchInst::Create(II->getNormalDest(), II);
364 0 : II->eraseFromParent();
365 0 : continue;
366 : }
367 :
368 178 : Invokes.push_back(II);
369 178 : LPads.insert(II->getUnwindDest()->getLandingPadInst());
370 4141 : } else if (auto *RI = dyn_cast<ReturnInst>(BB.getTerminator())) {
371 2359 : Returns.push_back(RI);
372 : }
373 :
374 2309 : if (Invokes.empty())
375 : return false;
376 :
377 : NumInvokes += Invokes.size();
378 :
379 39 : lowerIncomingArguments(F);
380 39 : lowerAcrossUnwindEdges(F, Invokes);
381 :
382 : Value *FuncCtx =
383 39 : setupFunctionContext(F, makeArrayRef(LPads.begin(), LPads.end()));
384 : BasicBlock *EntryBB = &F.front();
385 39 : IRBuilder<> Builder(EntryBB->getTerminator());
386 :
387 : // Get a reference to the jump buffer.
388 : Value *JBufPtr =
389 39 : Builder.CreateConstGEP2_32(FunctionContextTy, FuncCtx, 0, 5, "jbuf_gep");
390 :
391 : // Save the frame pointer.
392 39 : Value *FramePtr = Builder.CreateConstGEP2_32(doubleUnderJBufTy, JBufPtr, 0, 0,
393 : "jbuf_fp_gep");
394 :
395 39 : Value *Val = Builder.CreateCall(FrameAddrFn, Builder.getInt32(0), "fp");
396 39 : Builder.CreateStore(Val, FramePtr, /*isVolatile=*/true);
397 :
398 : // Save the stack pointer.
399 39 : Value *StackPtr = Builder.CreateConstGEP2_32(doubleUnderJBufTy, JBufPtr, 0, 2,
400 : "jbuf_sp_gep");
401 :
402 39 : Val = Builder.CreateCall(StackAddrFn, {}, "sp");
403 39 : Builder.CreateStore(Val, StackPtr, /*isVolatile=*/true);
404 :
405 : // Call the setup_dispatch instrinsic. It fills in the rest of the jmpbuf.
406 39 : Builder.CreateCall(BuiltinSetupDispatchFn, {});
407 :
408 : // Store a pointer to the function context so that the back-end will know
409 : // where to look for it.
410 39 : Value *FuncCtxArg = Builder.CreateBitCast(FuncCtx, Builder.getInt8PtrTy());
411 39 : Builder.CreateCall(FuncCtxFn, FuncCtxArg);
412 :
413 : // At this point, we are all set up, update the invoke instructions to mark
414 : // their call_site values.
415 217 : for (unsigned I = 0, E = Invokes.size(); I != E; ++I) {
416 356 : insertCallSiteStore(Invokes[I], I + 1);
417 :
418 : ConstantInt *CallSiteNum =
419 178 : ConstantInt::get(Type::getInt32Ty(F.getContext()), I + 1);
420 :
421 : // Record the call site value for the back end so it stays associated with
422 : // the invoke.
423 356 : CallInst::Create(CallSiteFn, CallSiteNum, "", Invokes[I]);
424 : }
425 :
426 : // Mark call instructions that aren't nounwind as no-action (call_site ==
427 : // -1). Skip the entry block, as prior to then, no function context has been
428 : // created for this function and any unexpected exceptions thrown will go
429 : // directly to the caller's context, which is what we want anyway, so no need
430 : // to do anything here.
431 419 : for (BasicBlock &BB : F) {
432 380 : if (&BB == &F.front())
433 : continue;
434 5831 : for (Instruction &I : BB)
435 5490 : if (I.mayThrow())
436 786 : insertCallSiteStore(&I, -1);
437 : }
438 :
439 : // Register the function context and make sure it's known to not throw
440 : CallInst *Register =
441 39 : CallInst::Create(RegisterFn, FuncCtx, "", EntryBB->getTerminator());
442 39 : Register->setDoesNotThrow();
443 :
444 : // Following any allocas not in the entry block, update the saved SP in the
445 : // jmpbuf to the new value.
446 419 : for (BasicBlock &BB : F) {
447 380 : if (&BB == &F.front())
448 : continue;
449 7403 : for (Instruction &I : BB) {
450 : if (auto *CI = dyn_cast<CallInst>(&I)) {
451 1268 : if (CI->getCalledFunction() != StackRestoreFn)
452 : continue;
453 5794 : } else if (!isa<AllocaInst>(&I)) {
454 : continue;
455 : }
456 0 : Instruction *StackAddr = CallInst::Create(StackAddrFn, "sp");
457 0 : StackAddr->insertAfter(&I);
458 0 : Instruction *StoreStackAddr = new StoreInst(StackAddr, StackPtr, true);
459 0 : StoreStackAddr->insertAfter(StackAddr);
460 : }
461 : }
462 :
463 : // Finally, for any returns from this function, if this function contains an
464 : // invoke, add a call to unregister the function context.
465 73 : for (ReturnInst *Return : Returns)
466 34 : CallInst::Create(UnregisterFn, FuncCtx, "", Return);
467 :
468 : return true;
469 : }
470 :
471 2309 : bool SjLjEHPrepare::runOnFunction(Function &F) {
472 2309 : Module &M = *F.getParent();
473 2309 : RegisterFn = M.getOrInsertFunction(
474 : "_Unwind_SjLj_Register", Type::getVoidTy(M.getContext()),
475 : PointerType::getUnqual(FunctionContextTy));
476 4618 : UnregisterFn = M.getOrInsertFunction(
477 : "_Unwind_SjLj_Unregister", Type::getVoidTy(M.getContext()),
478 : PointerType::getUnqual(FunctionContextTy));
479 2309 : FrameAddrFn = Intrinsic::getDeclaration(&M, Intrinsic::frameaddress);
480 2309 : StackAddrFn = Intrinsic::getDeclaration(&M, Intrinsic::stacksave);
481 2309 : StackRestoreFn = Intrinsic::getDeclaration(&M, Intrinsic::stackrestore);
482 2309 : BuiltinSetupDispatchFn =
483 2309 : Intrinsic::getDeclaration(&M, Intrinsic::eh_sjlj_setup_dispatch);
484 2309 : LSDAAddrFn = Intrinsic::getDeclaration(&M, Intrinsic::eh_sjlj_lsda);
485 2309 : CallSiteFn = Intrinsic::getDeclaration(&M, Intrinsic::eh_sjlj_callsite);
486 2309 : FuncCtxFn = Intrinsic::getDeclaration(&M, Intrinsic::eh_sjlj_functioncontext);
487 :
488 2309 : bool Res = setupEntryBlockAndCallSites(F);
489 2309 : return Res;
490 : }
|
