1 //===-- WinEHPrepare - Prepare exception handling for code generation ---===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This pass lowers LLVM IR exception handling into something closer to what the
11 // backend wants. It snifs the personality function to see which kind of
12 // preparation is necessary. If the personality function uses the Itanium LSDA,
13 // this pass delegates to the DWARF EH preparation pass.
15 //===----------------------------------------------------------------------===//
17 #include "llvm/CodeGen/Passes.h"
18 #include "llvm/ADT/MapVector.h"
19 #include "llvm/ADT/TinyPtrVector.h"
20 #include "llvm/Analysis/LibCallSemantics.h"
21 #include "llvm/Analysis/TargetTransformInfo.h"
22 #include "llvm/IR/Dominators.h"
23 #include "llvm/IR/Function.h"
24 #include "llvm/IR/IRBuilder.h"
25 #include "llvm/IR/Instructions.h"
26 #include "llvm/IR/IntrinsicInst.h"
27 #include "llvm/IR/Module.h"
28 #include "llvm/IR/PatternMatch.h"
29 #include "llvm/Pass.h"
30 #include "llvm/Transforms/Utils/Cloning.h"
31 #include "llvm/Transforms/Utils/Local.h"
35 using namespace llvm::PatternMatch;
37 #define DEBUG_TYPE "winehprepare"
41 // This map is used to model frame variable usage during outlining, to
42 // construct a structure type to hold the frame variables in a frame
43 // allocation block, and to remap the frame variable allocas (including
44 // spill locations as needed) to GEPs that get the variable from the
45 // frame allocation structure.
46 typedef MapVector<Value *, TinyPtrVector<AllocaInst *>> FrameVarInfoMap;
48 class WinEHPrepare : public FunctionPass {
49 std::unique_ptr<FunctionPass> DwarfPrepare;
51 enum HandlerType { Catch, Cleanup };
54 static char ID; // Pass identification, replacement for typeid.
55 WinEHPrepare(const TargetMachine *TM = nullptr)
56 : FunctionPass(ID), DwarfPrepare(createDwarfEHPass(TM)) {}
58 bool runOnFunction(Function &Fn) override;
60 bool doFinalization(Module &M) override;
62 void getAnalysisUsage(AnalysisUsage &AU) const override;
64 const char *getPassName() const override {
65 return "Windows exception handling preparation";
69 bool prepareCPPEHHandlers(Function &F,
70 SmallVectorImpl<LandingPadInst *> &LPads);
71 bool outlineHandler(HandlerType CatchOrCleanup, Function *SrcFn,
72 Constant *SelectorType, LandingPadInst *LPad,
73 FrameVarInfoMap &VarInfo);
76 class WinEHFrameVariableMaterializer : public ValueMaterializer {
78 WinEHFrameVariableMaterializer(Function *OutlinedFn,
79 FrameVarInfoMap &FrameVarInfo);
80 ~WinEHFrameVariableMaterializer() {}
82 virtual Value *materializeValueFor(Value *V) override;
85 FrameVarInfoMap &FrameVarInfo;
89 class WinEHCloningDirectorBase : public CloningDirector {
91 WinEHCloningDirectorBase(LandingPadInst *LPI, Function *HandlerFn,
92 FrameVarInfoMap &VarInfo)
93 : LPI(LPI), Materializer(HandlerFn, VarInfo),
94 SelectorIDType(Type::getInt32Ty(LPI->getContext())),
95 Int8PtrType(Type::getInt8PtrTy(LPI->getContext())),
96 ExtractedEHPtr(nullptr), ExtractedSelector(nullptr),
97 EHPtrStoreAddr(nullptr), SelectorStoreAddr(nullptr) {}
99 CloningAction handleInstruction(ValueToValueMapTy &VMap,
100 const Instruction *Inst,
101 BasicBlock *NewBB) override;
103 virtual CloningAction handleBeginCatch(ValueToValueMapTy &VMap,
104 const Instruction *Inst,
105 BasicBlock *NewBB) = 0;
106 virtual CloningAction handleEndCatch(ValueToValueMapTy &VMap,
107 const Instruction *Inst,
108 BasicBlock *NewBB) = 0;
109 virtual CloningAction handleTypeIdFor(ValueToValueMapTy &VMap,
110 const Instruction *Inst,
111 BasicBlock *NewBB) = 0;
112 virtual CloningAction handleResume(ValueToValueMapTy &VMap,
113 const ResumeInst *Resume,
114 BasicBlock *NewBB) = 0;
116 ValueMaterializer *getValueMaterializer() override { return &Materializer; }
120 WinEHFrameVariableMaterializer Materializer;
121 Type *SelectorIDType;
124 const Value *ExtractedEHPtr;
125 const Value *ExtractedSelector;
126 const Value *EHPtrStoreAddr;
127 const Value *SelectorStoreAddr;
130 class WinEHCatchDirector : public WinEHCloningDirectorBase {
132 WinEHCatchDirector(LandingPadInst *LPI, Function *CatchFn, Value *Selector,
133 FrameVarInfoMap &VarInfo)
134 : WinEHCloningDirectorBase(LPI, CatchFn, VarInfo),
135 CurrentSelector(Selector->stripPointerCasts()) {}
137 CloningAction handleBeginCatch(ValueToValueMapTy &VMap,
138 const Instruction *Inst,
139 BasicBlock *NewBB) override;
140 CloningAction handleEndCatch(ValueToValueMapTy &VMap, const Instruction *Inst,
141 BasicBlock *NewBB) override;
142 CloningAction handleTypeIdFor(ValueToValueMapTy &VMap,
143 const Instruction *Inst,
144 BasicBlock *NewBB) override;
145 CloningAction handleResume(ValueToValueMapTy &VMap, const ResumeInst *Resume,
146 BasicBlock *NewBB) override;
149 Value *CurrentSelector;
152 class WinEHCleanupDirector : public WinEHCloningDirectorBase {
154 WinEHCleanupDirector(LandingPadInst *LPI, Function *CleanupFn,
155 FrameVarInfoMap &VarInfo)
156 : WinEHCloningDirectorBase(LPI, CleanupFn, VarInfo) {}
158 CloningAction handleBeginCatch(ValueToValueMapTy &VMap,
159 const Instruction *Inst,
160 BasicBlock *NewBB) override;
161 CloningAction handleEndCatch(ValueToValueMapTy &VMap, const Instruction *Inst,
162 BasicBlock *NewBB) override;
163 CloningAction handleTypeIdFor(ValueToValueMapTy &VMap,
164 const Instruction *Inst,
165 BasicBlock *NewBB) override;
166 CloningAction handleResume(ValueToValueMapTy &VMap, const ResumeInst *Resume,
167 BasicBlock *NewBB) override;
170 } // end anonymous namespace
172 char WinEHPrepare::ID = 0;
173 INITIALIZE_TM_PASS_BEGIN(WinEHPrepare, "winehprepare",
174 "Prepare Windows exceptions", false, false)
175 INITIALIZE_PASS_DEPENDENCY(DwarfEHPrepare)
176 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
177 INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
178 INITIALIZE_TM_PASS_END(WinEHPrepare, "winehprepare",
179 "Prepare Windows exceptions", false, false)
181 FunctionPass *llvm::createWinEHPass(const TargetMachine *TM) {
182 return new WinEHPrepare(TM);
185 static bool isMSVCPersonality(EHPersonality Pers) {
186 return Pers == EHPersonality::MSVC_Win64SEH ||
187 Pers == EHPersonality::MSVC_CXX;
190 bool WinEHPrepare::runOnFunction(Function &Fn) {
191 SmallVector<LandingPadInst *, 4> LPads;
192 SmallVector<ResumeInst *, 4> Resumes;
193 for (BasicBlock &BB : Fn) {
194 if (auto *LP = BB.getLandingPadInst())
196 if (auto *Resume = dyn_cast<ResumeInst>(BB.getTerminator()))
197 Resumes.push_back(Resume);
200 // No need to prepare functions that lack landing pads.
204 // Classify the personality to see what kind of preparation we need.
205 EHPersonality Pers = classifyEHPersonality(LPads.back()->getPersonalityFn());
207 // Delegate through to the DWARF pass if this is unrecognized.
208 if (!isMSVCPersonality(Pers)) {
209 if (!DwarfPrepare->getResolver()) {
210 // Build an AnalysisResolver with the analyses needed by DwarfEHPrepare.
211 // It will take ownership of the AnalysisResolver.
212 assert(getResolver());
213 auto *AR = new AnalysisResolver(getResolver()->getPMDataManager());
214 AR->addAnalysisImplsPair(
215 &TargetTransformInfoWrapperPass::ID,
216 getResolver()->findImplPass(&TargetTransformInfoWrapperPass::ID));
217 AR->addAnalysisImplsPair(
218 &DominatorTreeWrapperPass::ID,
219 getResolver()->findImplPass(&DominatorTreeWrapperPass::ID));
220 DwarfPrepare->setResolver(AR);
223 return DwarfPrepare->runOnFunction(Fn);
226 // FIXME: This only returns true if the C++ EH handlers were outlined.
227 // When that code is complete, it should always return whatever
228 // prepareCPPEHHandlers returns.
229 if (Pers == EHPersonality::MSVC_CXX && prepareCPPEHHandlers(Fn, LPads))
232 // FIXME: SEH Cleanups are unimplemented. Replace them with unreachable.
236 for (ResumeInst *Resume : Resumes) {
237 IRBuilder<>(Resume).CreateUnreachable();
238 Resume->eraseFromParent();
244 bool WinEHPrepare::doFinalization(Module &M) {
245 return DwarfPrepare->doFinalization(M);
248 void WinEHPrepare::getAnalysisUsage(AnalysisUsage &AU) const {
249 DwarfPrepare->getAnalysisUsage(AU);
252 bool WinEHPrepare::prepareCPPEHHandlers(
253 Function &F, SmallVectorImpl<LandingPadInst *> &LPads) {
254 // These containers are used to re-map frame variables that are used in
255 // outlined catch and cleanup handlers. They will be populated as the
256 // handlers are outlined.
257 FrameVarInfoMap FrameVarInfo;
259 bool HandlersOutlined = false;
261 for (LandingPadInst *LPad : LPads) {
262 // Look for evidence that this landingpad has already been processed.
263 bool LPadHasActionList = false;
264 BasicBlock *LPadBB = LPad->getParent();
265 for (Instruction &Inst : LPadBB->getInstList()) {
266 // FIXME: Make this an intrinsic.
267 if (auto *Call = dyn_cast<CallInst>(&Inst))
268 if (Call->getCalledFunction()->getName() == "llvm.eh.actions") {
269 LPadHasActionList = true;
274 // If we've already outlined the handlers for this landingpad,
275 // there's nothing more to do here.
276 if (LPadHasActionList)
279 for (unsigned Idx = 0, NumClauses = LPad->getNumClauses(); Idx < NumClauses;
281 if (LPad->isCatch(Idx)) {
282 // Create a new instance of the handler data structure in the
283 // HandlerData vector.
284 bool Outlined = outlineHandler(Catch, &F, LPad->getClause(Idx), LPad,
287 HandlersOutlined = true;
289 } // End if (isCatch)
290 } // End for each clause
292 // FIXME: This only handles the simple case where there is a 1:1
293 // correspondence between landing pad and cleanup blocks.
294 // It does not handle cases where there are catch blocks between
295 // cleanup blocks or the case where a cleanup block is shared by
296 // multiple landing pads. Those cases will be supported later
297 // when landing pad block analysis is added.
298 if (LPad->isCleanup()) {
300 outlineHandler(Cleanup, &F, nullptr, LPad, FrameVarInfo);
302 HandlersOutlined = true;
305 } // End for each landingpad
307 // If nothing got outlined, there is no more processing to be done.
308 if (!HandlersOutlined)
311 // FIXME: We will replace the landingpad bodies with llvm.eh.actions
312 // calls and indirect branches here and then delete blocks
313 // which are no longer reachable. That will get rid of the
314 // handlers that we have outlined. There is code below
315 // that looks for allocas with no uses in the parent function.
316 // That will only happen after the pruning is implemented.
318 Module *M = F.getParent();
319 LLVMContext &Context = M->getContext();
320 BasicBlock *Entry = &F.getEntryBlock();
321 IRBuilder<> Builder(F.getParent()->getContext());
322 Builder.SetInsertPoint(Entry->getFirstInsertionPt());
324 Function *FrameEscapeFn =
325 Intrinsic::getDeclaration(M, Intrinsic::frameescape);
326 Function *RecoverFrameFn =
327 Intrinsic::getDeclaration(M, Intrinsic::framerecover);
328 Type *Int8PtrType = Type::getInt8PtrTy(Context);
329 Type *Int32Type = Type::getInt32Ty(Context);
331 // Finally, replace all of the temporary allocas for frame variables used in
332 // the outlined handlers with calls to llvm.framerecover.
333 BasicBlock::iterator II = Entry->getFirstInsertionPt();
334 Instruction *AllocaInsertPt = II;
335 SmallVector<Value *, 8> AllocasToEscape;
336 for (auto &VarInfoEntry : FrameVarInfo) {
337 Value *ParentVal = VarInfoEntry.first;
338 TinyPtrVector<AllocaInst *> &Allocas = VarInfoEntry.second;
340 // If the mapped value isn't already an alloca, we need to spill it if it
341 // is a computed value or copy it if it is an argument.
342 AllocaInst *ParentAlloca = dyn_cast<AllocaInst>(ParentVal);
344 if (auto *Arg = dyn_cast<Argument>(ParentVal)) {
345 // Lower this argument to a copy and then demote that to the stack.
346 // We can't just use the argument location because the handler needs
347 // it to be in the frame allocation block.
348 // Use 'select i8 true, %arg, undef' to simulate a 'no-op' instruction.
349 Value *TrueValue = ConstantInt::getTrue(Context);
350 Value *UndefValue = UndefValue::get(Arg->getType());
352 SelectInst::Create(TrueValue, Arg, UndefValue,
353 Arg->getName() + ".tmp", AllocaInsertPt);
354 Arg->replaceAllUsesWith(SI);
355 // Reset the select operand, because it was clobbered by the RAUW above.
356 SI->setOperand(1, Arg);
357 ParentAlloca = DemoteRegToStack(*SI, true, SI);
358 } else if (auto *PN = dyn_cast<PHINode>(ParentVal)) {
359 ParentAlloca = DemotePHIToStack(PN, AllocaInsertPt);
361 Instruction *ParentInst = cast<Instruction>(ParentVal);
362 ParentAlloca = DemoteRegToStack(*ParentInst, true, ParentInst);
366 // If the parent alloca is no longer used and only one of the handlers used
367 // it, erase the parent and leave the copy in the outlined handler.
368 if (ParentAlloca->getNumUses() == 0 && Allocas.size() == 1) {
369 ParentAlloca->eraseFromParent();
373 // Add this alloca to the list of things to escape.
374 AllocasToEscape.push_back(ParentAlloca);
376 // Next replace all outlined allocas that are mapped to it.
377 for (AllocaInst *TempAlloca : Allocas) {
378 Function *HandlerFn = TempAlloca->getParent()->getParent();
379 // FIXME: Sink this GEP into the blocks where it is used.
380 Builder.SetInsertPoint(TempAlloca);
381 Builder.SetCurrentDebugLocation(TempAlloca->getDebugLoc());
382 Value *RecoverArgs[] = {
383 Builder.CreateBitCast(&F, Int8PtrType, ""),
384 &(HandlerFn->getArgumentList().back()),
385 llvm::ConstantInt::get(Int32Type, AllocasToEscape.size() - 1)};
386 Value *RecoveredAlloca =
387 Builder.CreateCall(RecoverFrameFn, RecoverArgs);
388 // Add a pointer bitcast if the alloca wasn't an i8.
389 if (RecoveredAlloca->getType() != TempAlloca->getType()) {
390 RecoveredAlloca->setName(Twine(TempAlloca->getName()) + ".i8");
392 Builder.CreateBitCast(RecoveredAlloca, TempAlloca->getType());
394 TempAlloca->replaceAllUsesWith(RecoveredAlloca);
395 TempAlloca->removeFromParent();
396 RecoveredAlloca->takeName(TempAlloca);
399 } // End for each FrameVarInfo entry.
401 // Insert 'call void (...)* @llvm.frameescape(...)' at the end of the entry
403 Builder.SetInsertPoint(&F.getEntryBlock().back());
404 Builder.CreateCall(FrameEscapeFn, AllocasToEscape);
406 return HandlersOutlined;
409 bool WinEHPrepare::outlineHandler(HandlerType CatchOrCleanup, Function *SrcFn,
410 Constant *SelectorType, LandingPadInst *LPad,
411 FrameVarInfoMap &VarInfo) {
412 Module *M = SrcFn->getParent();
413 LLVMContext &Context = M->getContext();
415 // Create a new function to receive the handler contents.
416 Type *Int8PtrType = Type::getInt8PtrTy(Context);
417 std::vector<Type *> ArgTys;
418 ArgTys.push_back(Int8PtrType);
419 ArgTys.push_back(Int8PtrType);
421 if (CatchOrCleanup == Catch) {
422 FunctionType *FnType = FunctionType::get(Int8PtrType, ArgTys, false);
423 Handler = Function::Create(FnType, GlobalVariable::InternalLinkage,
424 SrcFn->getName() + ".catch", M);
426 FunctionType *FnType =
427 FunctionType::get(Type::getVoidTy(Context), ArgTys, false);
428 Handler = Function::Create(FnType, GlobalVariable::InternalLinkage,
429 SrcFn->getName() + ".cleanup", M);
432 // Generate a standard prolog to setup the frame recovery structure.
433 IRBuilder<> Builder(Context);
434 BasicBlock *Entry = BasicBlock::Create(Context, "entry");
435 Handler->getBasicBlockList().push_front(Entry);
436 Builder.SetInsertPoint(Entry);
437 Builder.SetCurrentDebugLocation(LPad->getDebugLoc());
439 std::unique_ptr<WinEHCloningDirectorBase> Director;
441 if (CatchOrCleanup == Catch) {
443 new WinEHCatchDirector(LPad, Handler, SelectorType, VarInfo));
445 Director.reset(new WinEHCleanupDirector(LPad, Handler, VarInfo));
448 ValueToValueMapTy VMap;
450 // FIXME: Map other values referenced in the filter handler.
452 SmallVector<ReturnInst *, 8> Returns;
453 ClonedCodeInfo InlinedFunctionInfo;
455 BasicBlock::iterator II = LPad;
457 CloneAndPruneIntoFromInst(Handler, SrcFn, ++II, VMap,
458 /*ModuleLevelChanges=*/false, Returns, "",
459 &InlinedFunctionInfo, Director.get());
461 // Move all the instructions in the first cloned block into our entry block.
462 BasicBlock *FirstClonedBB = std::next(Function::iterator(Entry));
463 Entry->getInstList().splice(Entry->end(), FirstClonedBB->getInstList());
464 FirstClonedBB->eraseFromParent();
469 CloningDirector::CloningAction WinEHCloningDirectorBase::handleInstruction(
470 ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
471 // Intercept instructions which extract values from the landing pad aggregate.
472 if (auto *Extract = dyn_cast<ExtractValueInst>(Inst)) {
473 if (Extract->getAggregateOperand() == LPI) {
474 assert(Extract->getNumIndices() == 1 &&
475 "Unexpected operation: extracting both landing pad values");
476 assert((*(Extract->idx_begin()) == 0 || *(Extract->idx_begin()) == 1) &&
477 "Unexpected operation: extracting an unknown landing pad element");
479 if (*(Extract->idx_begin()) == 0) {
480 // Element 0 doesn't directly corresponds to anything in the WinEH
482 // It will be stored to a memory location, then later loaded and finally
483 // the loaded value will be used as the argument to an
484 // llvm.eh.begincatch
485 // call. We're tracking it here so that we can skip the store and load.
486 ExtractedEHPtr = Inst;
488 // Element 1 corresponds to the filter selector. We'll map it to 1 for
489 // matching purposes, but it will also probably be stored to memory and
490 // reloaded, so we need to track the instuction so that we can map the
492 VMap[Inst] = ConstantInt::get(SelectorIDType, 1);
493 ExtractedSelector = Inst;
496 // Tell the caller not to clone this instruction.
497 return CloningDirector::SkipInstruction;
499 // Other extract value instructions just get cloned.
500 return CloningDirector::CloneInstruction;
503 if (auto *Store = dyn_cast<StoreInst>(Inst)) {
504 // Look for and suppress stores of the extracted landingpad values.
505 const Value *StoredValue = Store->getValueOperand();
506 if (StoredValue == ExtractedEHPtr) {
507 EHPtrStoreAddr = Store->getPointerOperand();
508 return CloningDirector::SkipInstruction;
510 if (StoredValue == ExtractedSelector) {
511 SelectorStoreAddr = Store->getPointerOperand();
512 return CloningDirector::SkipInstruction;
515 // Any other store just gets cloned.
516 return CloningDirector::CloneInstruction;
519 if (auto *Load = dyn_cast<LoadInst>(Inst)) {
520 // Look for loads of (previously suppressed) landingpad values.
521 // The EHPtr load can be ignored (it should only be used as
522 // an argument to llvm.eh.begincatch), but the selector value
523 // needs to be mapped to a constant value of 1 to be used to
524 // simplify the branching to always flow to the current handler.
525 const Value *LoadAddr = Load->getPointerOperand();
526 if (LoadAddr == EHPtrStoreAddr) {
527 VMap[Inst] = UndefValue::get(Int8PtrType);
528 return CloningDirector::SkipInstruction;
530 if (LoadAddr == SelectorStoreAddr) {
531 VMap[Inst] = ConstantInt::get(SelectorIDType, 1);
532 return CloningDirector::SkipInstruction;
535 // Any other loads just get cloned.
536 return CloningDirector::CloneInstruction;
539 if (auto *Resume = dyn_cast<ResumeInst>(Inst))
540 return handleResume(VMap, Resume, NewBB);
542 if (match(Inst, m_Intrinsic<Intrinsic::eh_begincatch>()))
543 return handleBeginCatch(VMap, Inst, NewBB);
544 if (match(Inst, m_Intrinsic<Intrinsic::eh_endcatch>()))
545 return handleEndCatch(VMap, Inst, NewBB);
546 if (match(Inst, m_Intrinsic<Intrinsic::eh_typeid_for>()))
547 return handleTypeIdFor(VMap, Inst, NewBB);
549 // Continue with the default cloning behavior.
550 return CloningDirector::CloneInstruction;
553 CloningDirector::CloningAction WinEHCatchDirector::handleBeginCatch(
554 ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
555 // The argument to the call is some form of the first element of the
556 // landingpad aggregate value, but that doesn't matter. It isn't used
558 // The second argument is an outparameter where the exception object will be
559 // stored. Typically the exception object is a scalar, but it can be an
560 // aggregate when catching by value.
561 // FIXME: Leave something behind to indicate where the exception object lives
562 // for this handler. Should it be part of llvm.eh.actions?
563 return CloningDirector::SkipInstruction;
566 CloningDirector::CloningAction
567 WinEHCatchDirector::handleEndCatch(ValueToValueMapTy &VMap,
568 const Instruction *Inst, BasicBlock *NewBB) {
569 auto *IntrinCall = dyn_cast<IntrinsicInst>(Inst);
570 // It might be interesting to track whether or not we are inside a catch
571 // function, but that might make the algorithm more brittle than it needs
574 // The end catch call can occur in one of two places: either in a
576 // block that is part of the catch handlers exception mechanism, or at the
577 // end of the catch block. If it occurs in a landing pad, we must skip it
578 // and continue so that the landing pad gets cloned.
579 // FIXME: This case isn't fully supported yet and shouldn't turn up in any
580 // of the test cases until it is.
581 if (IntrinCall->getParent()->isLandingPad())
582 return CloningDirector::SkipInstruction;
584 // If an end catch occurs anywhere else the next instruction should be an
585 // unconditional branch instruction that we want to replace with a return
586 // to the the address of the branch target.
587 const BasicBlock *EndCatchBB = IntrinCall->getParent();
588 const TerminatorInst *Terminator = EndCatchBB->getTerminator();
589 const BranchInst *Branch = dyn_cast<BranchInst>(Terminator);
590 assert(Branch && Branch->isUnconditional());
591 assert(std::next(BasicBlock::const_iterator(IntrinCall)) ==
592 BasicBlock::const_iterator(Branch));
594 ReturnInst::Create(NewBB->getContext(),
595 BlockAddress::get(Branch->getSuccessor(0)), NewBB);
597 // We just added a terminator to the cloned block.
598 // Tell the caller to stop processing the current basic block so that
599 // the branch instruction will be skipped.
600 return CloningDirector::StopCloningBB;
603 CloningDirector::CloningAction WinEHCatchDirector::handleTypeIdFor(
604 ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
605 auto *IntrinCall = dyn_cast<IntrinsicInst>(Inst);
606 Value *Selector = IntrinCall->getArgOperand(0)->stripPointerCasts();
607 // This causes a replacement that will collapse the landing pad CFG based
608 // on the filter function we intend to match.
609 if (Selector == CurrentSelector)
610 VMap[Inst] = ConstantInt::get(SelectorIDType, 1);
612 VMap[Inst] = ConstantInt::get(SelectorIDType, 0);
613 // Tell the caller not to clone this instruction.
614 return CloningDirector::SkipInstruction;
617 CloningDirector::CloningAction
618 WinEHCatchDirector::handleResume(ValueToValueMapTy &VMap,
619 const ResumeInst *Resume, BasicBlock *NewBB) {
620 // Resume instructions shouldn't be reachable from catch handlers.
621 // We still need to handle it, but it will be pruned.
622 BasicBlock::InstListType &InstList = NewBB->getInstList();
623 InstList.push_back(new UnreachableInst(NewBB->getContext()));
624 return CloningDirector::StopCloningBB;
627 CloningDirector::CloningAction WinEHCleanupDirector::handleBeginCatch(
628 ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
629 // Catch blocks within cleanup handlers will always be unreachable.
630 // We'll insert an unreachable instruction now, but it will be pruned
631 // before the cloning process is complete.
632 BasicBlock::InstListType &InstList = NewBB->getInstList();
633 InstList.push_back(new UnreachableInst(NewBB->getContext()));
634 return CloningDirector::StopCloningBB;
637 CloningDirector::CloningAction WinEHCleanupDirector::handleEndCatch(
638 ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
639 // Catch blocks within cleanup handlers will always be unreachable.
640 // We'll insert an unreachable instruction now, but it will be pruned
641 // before the cloning process is complete.
642 BasicBlock::InstListType &InstList = NewBB->getInstList();
643 InstList.push_back(new UnreachableInst(NewBB->getContext()));
644 return CloningDirector::StopCloningBB;
647 CloningDirector::CloningAction WinEHCleanupDirector::handleTypeIdFor(
648 ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
649 // This causes a replacement that will collapse the landing pad CFG
650 // to just the cleanup code.
651 VMap[Inst] = ConstantInt::get(SelectorIDType, 0);
652 // Tell the caller not to clone this instruction.
653 return CloningDirector::SkipInstruction;
656 CloningDirector::CloningAction WinEHCleanupDirector::handleResume(
657 ValueToValueMapTy &VMap, const ResumeInst *Resume, BasicBlock *NewBB) {
658 ReturnInst::Create(NewBB->getContext(), nullptr, NewBB);
660 // We just added a terminator to the cloned block.
661 // Tell the caller to stop processing the current basic block so that
662 // the branch instruction will be skipped.
663 return CloningDirector::StopCloningBB;
666 WinEHFrameVariableMaterializer::WinEHFrameVariableMaterializer(
667 Function *OutlinedFn, FrameVarInfoMap &FrameVarInfo)
668 : FrameVarInfo(FrameVarInfo), Builder(OutlinedFn->getContext()) {
669 Builder.SetInsertPoint(&OutlinedFn->getEntryBlock());
670 // FIXME: Do something with the FrameVarMapped so that it is shared across the
674 Value *WinEHFrameVariableMaterializer::materializeValueFor(Value *V) {
675 // If we're asked to materialize a value that is an instruction, we
676 // temporarily create an alloca in the outlined function and add this
677 // to the FrameVarInfo map. When all the outlining is complete, we'll
678 // collect these into a structure, spilling non-alloca values in the
679 // parent frame as necessary, and replace these temporary allocas with
680 // GEPs referencing the frame allocation block.
682 // If the value is an alloca, the mapping is direct.
683 if (auto *AV = dyn_cast<AllocaInst>(V)) {
684 AllocaInst *NewAlloca = dyn_cast<AllocaInst>(AV->clone());
685 Builder.Insert(NewAlloca, AV->getName());
686 FrameVarInfo[AV].push_back(NewAlloca);
690 // For other types of instructions or arguments, we need an alloca based on
691 // the value's type and a load of the alloca. The alloca will be replaced
692 // by a GEP, but the load will stay. In the parent function, the value will
693 // be spilled to a location in the frame allocation block.
694 if (isa<Instruction>(V) || isa<Argument>(V)) {
695 AllocaInst *NewAlloca =
696 Builder.CreateAlloca(V->getType(), nullptr, "eh.temp.alloca");
697 FrameVarInfo[V].push_back(NewAlloca);
698 LoadInst *NewLoad = Builder.CreateLoad(NewAlloca, V->getName() + ".reload");
702 // Don't materialize other values.