lib/CodeGen/WinEHPrepare.cpp

   1 //===-- WinEHPrepare - Prepare exception handling for code generation ---===//
   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 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.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #include "llvm/CodeGen/Passes.h"
  18 #include "llvm/ADT/MapVector.h"
  19 #include "llvm/ADT/STLExtras.h"
  20 #include "llvm/ADT/SmallSet.h"
  21 #include "llvm/ADT/TinyPtrVector.h"
  22 #include "llvm/Analysis/LibCallSemantics.h"
  23 #include "llvm/CodeGen/WinEHFuncInfo.h"
  24 #include "llvm/IR/Dominators.h"
  25 #include "llvm/IR/Function.h"
  26 #include "llvm/IR/IRBuilder.h"
  27 #include "llvm/IR/Instructions.h"
  28 #include "llvm/IR/IntrinsicInst.h"
  29 #include "llvm/IR/Module.h"
  30 #include "llvm/IR/PatternMatch.h"
  31 #include "llvm/Pass.h"
  32 #include "llvm/Support/CommandLine.h"
  33 #include "llvm/Support/Debug.h"
  34 #include "llvm/Support/raw_ostream.h"
  35 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
  36 #include "llvm/Transforms/Utils/Cloning.h"
  37 #include "llvm/Transforms/Utils/Local.h"
  38 #include "llvm/Transforms/Utils/PromoteMemToReg.h"
  39 #include <memory>
  40
  41 using namespace llvm;
  42 using namespace llvm::PatternMatch;
  43
  44 #define DEBUG_TYPE "winehprepare"
  45
  46 namespace {
  47
  48 // This map is used to model frame variable usage during outlining, to
  49 // construct a structure type to hold the frame variables in a frame
  50 // allocation block, and to remap the frame variable allocas (including
  51 // spill locations as needed) to GEPs that get the variable from the
  52 // frame allocation structure.
  53 typedef MapVector<Value *, TinyPtrVector<AllocaInst *>> FrameVarInfoMap;
  54
  55 // TinyPtrVector cannot hold nullptr, so we need our own sentinel that isn't
  56 // quite null.
  57 AllocaInst *getCatchObjectSentinel() {
  58   return static_cast<AllocaInst *>(nullptr) + 1;
  59 }
  60
  61 typedef SmallSet<BasicBlock *, 4> VisitedBlockSet;
  62
  63 class LandingPadActions;
  64 class LandingPadMap;
  65
  66 typedef DenseMap<const BasicBlock *, CatchHandler *> CatchHandlerMapTy;
  67 typedef DenseMap<const BasicBlock *, CleanupHandler *> CleanupHandlerMapTy;
  68
  69 class WinEHPrepare : public FunctionPass {
  70 public:
  71   static char ID; // Pass identification, replacement for typeid.
  72   WinEHPrepare(const TargetMachine *TM = nullptr)
  73       : FunctionPass(ID), DT(nullptr) {}
  74
  75   bool runOnFunction(Function &Fn) override;
  76
  77   bool doFinalization(Module &M) override;
  78
  79   void getAnalysisUsage(AnalysisUsage &AU) const override;
  80
  81   const char *getPassName() const override {
  82     return "Windows exception handling preparation";
  83   }
  84
  85 private:
  86   bool prepareExceptionHandlers(Function &F,
  87                                 SmallVectorImpl<LandingPadInst *> &LPads);
  88   void promoteLandingPadValues(LandingPadInst *LPad);
  89   void completeNestedLandingPad(Function *ParentFn,
  90                                 LandingPadInst *OutlinedLPad,
  91                                 const LandingPadInst *OriginalLPad,
  92                                 FrameVarInfoMap &VarInfo);
  93   bool outlineHandler(ActionHandler *Action, Function *SrcFn,
  94                       LandingPadInst *LPad, BasicBlock *StartBB,
  95                       FrameVarInfoMap &VarInfo);
  96
  97   void mapLandingPadBlocks(LandingPadInst *LPad, LandingPadActions &Actions);
  98   CatchHandler *findCatchHandler(BasicBlock *BB, BasicBlock *&NextBB,
  99                                  VisitedBlockSet &VisitedBlocks);
 100   CleanupHandler *findCleanupHandler(BasicBlock *StartBB, BasicBlock *EndBB);
 101
 102   void processSEHCatchHandler(CatchHandler *Handler, BasicBlock *StartBB);
 103
 104   // All fields are reset by runOnFunction.
 105   DominatorTree *DT;
 106   EHPersonality Personality;
 107   CatchHandlerMapTy CatchHandlerMap;
 108   CleanupHandlerMapTy CleanupHandlerMap;
 109   DenseMap<const LandingPadInst *, LandingPadMap> LPadMaps;
 110
 111   // This maps landing pad instructions found in outlined handlers to
 112   // the landing pad instruction in the parent function from which they
 113   // were cloned.  The cloned/nested landing pad is used as the key
 114   // because the landing pad may be cloned into multiple handlers.
 115   // This map will be used to add the llvm.eh.actions call to the nested
 116   // landing pads after all handlers have been outlined.
 117   DenseMap<LandingPadInst *, const LandingPadInst *> NestedLPtoOriginalLP;
 118
 119   // This maps blocks in the parent function which are destinations of
 120   // catch handlers to cloned blocks in (other) outlined handlers. This
 121   // handles the case where a nested landing pads has a catch handler that
 122   // returns to a handler function rather than the parent function.
 123   // The original block is used as the key here because there should only
 124   // ever be one handler function from which the cloned block is not pruned.
 125   // The original block will be pruned from the parent function after all
 126   // handlers have been outlined.  This map will be used to adjust the
 127   // return instructions of handlers which return to the block that was
 128   // outlined into a handler.  This is done after all handlers have been
 129   // outlined but before the outlined code is pruned from the parent function.
 130   DenseMap<const BasicBlock *, BasicBlock *> LPadTargetBlocks;
 131 };
 132
 133 class WinEHFrameVariableMaterializer : public ValueMaterializer {
 134 public:
 135   WinEHFrameVariableMaterializer(Function *OutlinedFn,
 136                                  FrameVarInfoMap &FrameVarInfo);
 137   ~WinEHFrameVariableMaterializer() {}
 138
 139   virtual Value *materializeValueFor(Value *V) override;
 140
 141   void escapeCatchObject(Value *V);
 142
 143 private:
 144   FrameVarInfoMap &FrameVarInfo;
 145   IRBuilder<> Builder;
 146 };
 147
 148 class LandingPadMap {
 149 public:
 150   LandingPadMap() : OriginLPad(nullptr) {}
 151   void mapLandingPad(const LandingPadInst *LPad);
 152
 153   bool isInitialized() { return OriginLPad != nullptr; }
 154
 155   bool isOriginLandingPadBlock(const BasicBlock *BB) const;
 156   bool isLandingPadSpecificInst(const Instruction *Inst) const;
 157
 158   void remapEHValues(ValueToValueMapTy &VMap, Value *EHPtrValue,
 159                      Value *SelectorValue) const;
 160
 161 private:
 162   const LandingPadInst *OriginLPad;
 163   // We will normally only see one of each of these instructions, but
 164   // if more than one occurs for some reason we can handle that.
 165   TinyPtrVector<const ExtractValueInst *> ExtractedEHPtrs;
 166   TinyPtrVector<const ExtractValueInst *> ExtractedSelectors;
 167 };
 168
 169 class WinEHCloningDirectorBase : public CloningDirector {
 170 public:
 171   WinEHCloningDirectorBase(Function *HandlerFn, FrameVarInfoMap &VarInfo,
 172                            LandingPadMap &LPadMap)
 173       : Materializer(HandlerFn, VarInfo),
 174         SelectorIDType(Type::getInt32Ty(HandlerFn->getContext())),
 175         Int8PtrType(Type::getInt8PtrTy(HandlerFn->getContext())),
 176         LPadMap(LPadMap) {}
 177
 178   CloningAction handleInstruction(ValueToValueMapTy &VMap,
 179                                   const Instruction *Inst,
 180                                   BasicBlock *NewBB) override;
 181
 182   virtual CloningAction handleBeginCatch(ValueToValueMapTy &VMap,
 183                                          const Instruction *Inst,
 184                                          BasicBlock *NewBB) = 0;
 185   virtual CloningAction handleEndCatch(ValueToValueMapTy &VMap,
 186                                        const Instruction *Inst,
 187                                        BasicBlock *NewBB) = 0;
 188   virtual CloningAction handleTypeIdFor(ValueToValueMapTy &VMap,
 189                                         const Instruction *Inst,
 190                                         BasicBlock *NewBB) = 0;
 191   virtual CloningAction handleInvoke(ValueToValueMapTy &VMap,
 192                                      const InvokeInst *Invoke,
 193                                      BasicBlock *NewBB) = 0;
 194   virtual CloningAction handleResume(ValueToValueMapTy &VMap,
 195                                      const ResumeInst *Resume,
 196                                      BasicBlock *NewBB) = 0;
 197   virtual CloningAction handleLandingPad(ValueToValueMapTy &VMap,
 198                                          const LandingPadInst *LPad,
 199                                          BasicBlock *NewBB) = 0;
 200
 201   ValueMaterializer *getValueMaterializer() override { return &Materializer; }
 202
 203 protected:
 204   WinEHFrameVariableMaterializer Materializer;
 205   Type *SelectorIDType;
 206   Type *Int8PtrType;
 207   LandingPadMap &LPadMap;
 208 };
 209
 210 class WinEHCatchDirector : public WinEHCloningDirectorBase {
 211 public:
 212   WinEHCatchDirector(
 213       Function *CatchFn, Value *Selector, FrameVarInfoMap &VarInfo,
 214       LandingPadMap &LPadMap,
 215       DenseMap<LandingPadInst *, const LandingPadInst *> &NestedLPads)
 216       : WinEHCloningDirectorBase(CatchFn, VarInfo, LPadMap),
 217         CurrentSelector(Selector->stripPointerCasts()),
 218         ExceptionObjectVar(nullptr), NestedLPtoOriginalLP(NestedLPads) {}
 219
 220   CloningAction handleBeginCatch(ValueToValueMapTy &VMap,
 221                                  const Instruction *Inst,
 222                                  BasicBlock *NewBB) override;
 223   CloningAction handleEndCatch(ValueToValueMapTy &VMap, const Instruction *Inst,
 224                                BasicBlock *NewBB) override;
 225   CloningAction handleTypeIdFor(ValueToValueMapTy &VMap,
 226                                 const Instruction *Inst,
 227                                 BasicBlock *NewBB) override;
 228   CloningAction handleInvoke(ValueToValueMapTy &VMap, const InvokeInst *Invoke,
 229                              BasicBlock *NewBB) override;
 230   CloningAction handleResume(ValueToValueMapTy &VMap, const ResumeInst *Resume,
 231                              BasicBlock *NewBB) override;
 232   CloningAction handleLandingPad(ValueToValueMapTy &VMap,
 233                                  const LandingPadInst *LPad,
 234                                  BasicBlock *NewBB) override;
 235
 236   Value *getExceptionVar() { return ExceptionObjectVar; }
 237   TinyPtrVector<BasicBlock *> &getReturnTargets() { return ReturnTargets; }
 238
 239 private:
 240   Value *CurrentSelector;
 241
 242   Value *ExceptionObjectVar;
 243   TinyPtrVector<BasicBlock *> ReturnTargets;
 244
 245   // This will be a reference to the field of the same name in the WinEHPrepare
 246   // object which instantiates this WinEHCatchDirector object.
 247   DenseMap<LandingPadInst *, const LandingPadInst *> &NestedLPtoOriginalLP;
 248 };
 249
 250 class WinEHCleanupDirector : public WinEHCloningDirectorBase {
 251 public:
 252   WinEHCleanupDirector(Function *CleanupFn, FrameVarInfoMap &VarInfo,
 253                        LandingPadMap &LPadMap)
 254       : WinEHCloningDirectorBase(CleanupFn, VarInfo, LPadMap) {}
 255
 256   CloningAction handleBeginCatch(ValueToValueMapTy &VMap,
 257                                  const Instruction *Inst,
 258                                  BasicBlock *NewBB) override;
 259   CloningAction handleEndCatch(ValueToValueMapTy &VMap, const Instruction *Inst,
 260                                BasicBlock *NewBB) override;
 261   CloningAction handleTypeIdFor(ValueToValueMapTy &VMap,
 262                                 const Instruction *Inst,
 263                                 BasicBlock *NewBB) override;
 264   CloningAction handleInvoke(ValueToValueMapTy &VMap, const InvokeInst *Invoke,
 265                              BasicBlock *NewBB) override;
 266   CloningAction handleResume(ValueToValueMapTy &VMap, const ResumeInst *Resume,
 267                              BasicBlock *NewBB) override;
 268   CloningAction handleLandingPad(ValueToValueMapTy &VMap,
 269                                  const LandingPadInst *LPad,
 270                                  BasicBlock *NewBB) override;
 271 };
 272
 273 class LandingPadActions {
 274 public:
 275   LandingPadActions() : HasCleanupHandlers(false) {}
 276
 277   void insertCatchHandler(CatchHandler *Action) { Actions.push_back(Action); }
 278   void insertCleanupHandler(CleanupHandler *Action) {
 279     Actions.push_back(Action);
 280     HasCleanupHandlers = true;
 281   }
 282
 283   bool includesCleanup() const { return HasCleanupHandlers; }
 284
 285   SmallVectorImpl<ActionHandler *> &actions() { return Actions; }
 286   SmallVectorImpl<ActionHandler *>::iterator begin() { return Actions.begin(); }
 287   SmallVectorImpl<ActionHandler *>::iterator end() { return Actions.end(); }
 288
 289 private:
 290   // Note that this class does not own the ActionHandler objects in this vector.
 291   // The ActionHandlers are owned by the CatchHandlerMap and CleanupHandlerMap
 292   // in the WinEHPrepare class.
 293   SmallVector<ActionHandler *, 4> Actions;
 294   bool HasCleanupHandlers;
 295 };
 296
 297 } // end anonymous namespace
 298
 299 char WinEHPrepare::ID = 0;
 300 INITIALIZE_TM_PASS(WinEHPrepare, "winehprepare", "Prepare Windows exceptions",
 301                    false, false)
 302
 303 FunctionPass *llvm::createWinEHPass(const TargetMachine *TM) {
 304   return new WinEHPrepare(TM);
 305 }
 306
 307 // FIXME: Remove this once the backend can handle the prepared IR.
 308 static cl::opt<bool>
 309     SEHPrepare("sehprepare", cl::Hidden,
 310                cl::desc("Prepare functions with SEH personalities"));
 311
 312 bool WinEHPrepare::runOnFunction(Function &Fn) {
 313   SmallVector<LandingPadInst *, 4> LPads;
 314   SmallVector<ResumeInst *, 4> Resumes;
 315   for (BasicBlock &BB : Fn) {
 316     if (auto *LP = BB.getLandingPadInst())
 317       LPads.push_back(LP);
 318     if (auto *Resume = dyn_cast<ResumeInst>(BB.getTerminator()))
 319       Resumes.push_back(Resume);
 320   }
 321
 322   // No need to prepare functions that lack landing pads.
 323   if (LPads.empty())
 324     return false;
 325
 326   // Classify the personality to see what kind of preparation we need.
 327   Personality = classifyEHPersonality(LPads.back()->getPersonalityFn());
 328
 329   // Do nothing if this is not an MSVC personality.
 330   if (!isMSVCEHPersonality(Personality))
 331     return false;
 332
 333   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
 334
 335   if (isAsynchronousEHPersonality(Personality) && !SEHPrepare) {
 336     // Replace all resume instructions with unreachable.
 337     // FIXME: Remove this once the backend can handle the prepared IR.
 338     for (ResumeInst *Resume : Resumes) {
 339       IRBuilder<>(Resume).CreateUnreachable();
 340       Resume->eraseFromParent();
 341     }
 342     return true;
 343   }
 344
 345   // If there were any landing pads, prepareExceptionHandlers will make changes.
 346   prepareExceptionHandlers(Fn, LPads);
 347   return true;
 348 }
 349
 350 bool WinEHPrepare::doFinalization(Module &M) { return false; }
 351
 352 void WinEHPrepare::getAnalysisUsage(AnalysisUsage &AU) const {
 353   AU.addRequired<DominatorTreeWrapperPass>();
 354 }
 355
 356 bool WinEHPrepare::prepareExceptionHandlers(
 357     Function &F, SmallVectorImpl<LandingPadInst *> &LPads) {
 358   // These containers are used to re-map frame variables that are used in
 359   // outlined catch and cleanup handlers.  They will be populated as the
 360   // handlers are outlined.
 361   FrameVarInfoMap FrameVarInfo;
 362
 363   bool HandlersOutlined = false;
 364
 365   Module *M = F.getParent();
 366   LLVMContext &Context = M->getContext();
 367
 368   // Create a new function to receive the handler contents.
 369   PointerType *Int8PtrType = Type::getInt8PtrTy(Context);
 370   Type *Int32Type = Type::getInt32Ty(Context);
 371   Function *ActionIntrin = Intrinsic::getDeclaration(M, Intrinsic::eh_actions);
 372
 373   for (LandingPadInst *LPad : LPads) {
 374     // Look for evidence that this landingpad has already been processed.
 375     bool LPadHasActionList = false;
 376     BasicBlock *LPadBB = LPad->getParent();
 377     for (Instruction &Inst : *LPadBB) {
 378       if (auto *IntrinCall = dyn_cast<IntrinsicInst>(&Inst)) {
 379         if (IntrinCall->getIntrinsicID() == Intrinsic::eh_actions) {
 380           LPadHasActionList = true;
 381           break;
 382         }
 383       }
 384       // FIXME: This is here to help with the development of nested landing pad
 385       //        outlining.  It should be removed when that is finished.
 386       if (isa<UnreachableInst>(Inst)) {
 387         LPadHasActionList = true;
 388         break;
 389       }
 390     }
 391
 392     // If we've already outlined the handlers for this landingpad,
 393     // there's nothing more to do here.
 394     if (LPadHasActionList)
 395       continue;
 396
 397     // If either of the values in the aggregate returned by the landing pad is
 398     // extracted and stored to memory, promote the stored value to a register.
 399     promoteLandingPadValues(LPad);
 400
 401     LandingPadActions Actions;
 402     mapLandingPadBlocks(LPad, Actions);
 403
 404     for (ActionHandler *Action : Actions) {
 405       if (Action->hasBeenProcessed())
 406         continue;
 407       BasicBlock *StartBB = Action->getStartBlock();
 408
 409       // SEH doesn't do any outlining for catches. Instead, pass the handler
 410       // basic block addr to llvm.eh.actions and list the block as a return
 411       // target.
 412       if (isAsynchronousEHPersonality(Personality)) {
 413         if (auto *CatchAction = dyn_cast<CatchHandler>(Action)) {
 414           processSEHCatchHandler(CatchAction, StartBB);
 415           HandlersOutlined = true;
 416           continue;
 417         }
 418       }
 419
 420       if (outlineHandler(Action, &F, LPad, StartBB, FrameVarInfo)) {
 421         HandlersOutlined = true;
 422       }
 423     } // End for each Action
 424
 425     // FIXME: We need a guard against partially outlined functions.
 426     if (!HandlersOutlined)
 427       continue;
 428
 429     // Replace the landing pad with a new llvm.eh.action based landing pad.
 430     BasicBlock *NewLPadBB = BasicBlock::Create(Context, "lpad", &F, LPadBB);
 431     assert(!isa<PHINode>(LPadBB->begin()));
 432     auto *NewLPad = cast<LandingPadInst>(LPad->clone());
 433     NewLPadBB->getInstList().push_back(NewLPad);
 434     while (!pred_empty(LPadBB)) {
 435       auto *pred = *pred_begin(LPadBB);
 436       InvokeInst *Invoke = cast<InvokeInst>(pred->getTerminator());
 437       Invoke->setUnwindDest(NewLPadBB);
 438     }
 439
 440     // Replace the mapping of any nested landing pad that previously mapped
 441     // to this landing pad with a referenced to the cloned version.
 442     for (auto &LPadPair : NestedLPtoOriginalLP) {
 443       const LandingPadInst *OriginalLPad = LPadPair.second;
 444       if (OriginalLPad == LPad) {
 445         LPadPair.second = NewLPad;
 446       }
 447     }
 448
 449     // Replace uses of the old lpad in phis with this block and delete the old
 450     // block.
 451     LPadBB->replaceSuccessorsPhiUsesWith(NewLPadBB);
 452     LPadBB->getTerminator()->eraseFromParent();
 453     new UnreachableInst(LPadBB->getContext(), LPadBB);
 454
 455     // Add a call to describe the actions for this landing pad.
 456     std::vector<Value *> ActionArgs;
 457     for (ActionHandler *Action : Actions) {
 458       // Action codes from docs are: 0 cleanup, 1 catch.
 459       if (auto *CatchAction = dyn_cast<CatchHandler>(Action)) {
 460         ActionArgs.push_back(ConstantInt::get(Int32Type, 1));
 461         ActionArgs.push_back(CatchAction->getSelector());
 462         // Find the frame escape index of the exception object alloca in the
 463         // parent.
 464         int FrameEscapeIdx = -1;
 465         Value *EHObj = const_cast<Value *>(CatchAction->getExceptionVar());
 466         if (EHObj && !isa<ConstantPointerNull>(EHObj)) {
 467           auto I = FrameVarInfo.find(EHObj);
 468           assert(I != FrameVarInfo.end() &&
 469                  "failed to map llvm.eh.begincatch var");
 470           FrameEscapeIdx = std::distance(FrameVarInfo.begin(), I);
 471         }
 472         ActionArgs.push_back(ConstantInt::get(Int32Type, FrameEscapeIdx));
 473       } else {
 474         ActionArgs.push_back(ConstantInt::get(Int32Type, 0));
 475       }
 476       ActionArgs.push_back(Action->getHandlerBlockOrFunc());
 477     }
 478     CallInst *Recover =
 479         CallInst::Create(ActionIntrin, ActionArgs, "recover", NewLPadBB);
 480
 481     // Add an indirect branch listing possible successors of the catch handlers.
 482     IndirectBrInst *Branch = IndirectBrInst::Create(Recover, 0, NewLPadBB);
 483     for (ActionHandler *Action : Actions) {
 484       if (auto *CatchAction = dyn_cast<CatchHandler>(Action)) {
 485         for (auto *Target : CatchAction->getReturnTargets()) {
 486           Branch->addDestination(Target);
 487         }
 488       }
 489     }
 490   } // End for each landingpad
 491
 492   // If nothing got outlined, there is no more processing to be done.
 493   if (!HandlersOutlined)
 494     return false;
 495
 496   // Replace any nested landing pad stubs with the correct action handler.
 497   // This must be done before we remove unreachable blocks because it
 498   // cleans up references to outlined blocks that will be deleted.
 499   for (auto &LPadPair : NestedLPtoOriginalLP)
 500     completeNestedLandingPad(&F, LPadPair.first, LPadPair.second, FrameVarInfo);
 501
 502   F.addFnAttr("wineh-parent", F.getName());
 503
 504   // Delete any blocks that were only used by handlers that were outlined above.
 505   removeUnreachableBlocks(F);
 506
 507   BasicBlock *Entry = &F.getEntryBlock();
 508   IRBuilder<> Builder(F.getParent()->getContext());
 509   Builder.SetInsertPoint(Entry->getFirstInsertionPt());
 510
 511   Function *FrameEscapeFn =
 512       Intrinsic::getDeclaration(M, Intrinsic::frameescape);
 513   Function *RecoverFrameFn =
 514       Intrinsic::getDeclaration(M, Intrinsic::framerecover);
 515
 516   // Finally, replace all of the temporary allocas for frame variables used in
 517   // the outlined handlers with calls to llvm.framerecover.
 518   BasicBlock::iterator II = Entry->getFirstInsertionPt();
 519   Instruction *AllocaInsertPt = II;
 520   SmallVector<Value *, 8> AllocasToEscape;
 521   for (auto &VarInfoEntry : FrameVarInfo) {
 522     Value *ParentVal = VarInfoEntry.first;
 523     TinyPtrVector<AllocaInst *> &Allocas = VarInfoEntry.second;
 524
 525     // If the mapped value isn't already an alloca, we need to spill it if it
 526     // is a computed value or copy it if it is an argument.
 527     AllocaInst *ParentAlloca = dyn_cast<AllocaInst>(ParentVal);
 528     if (!ParentAlloca) {
 529       if (auto *Arg = dyn_cast<Argument>(ParentVal)) {
 530         // Lower this argument to a copy and then demote that to the stack.
 531         // We can't just use the argument location because the handler needs
 532         // it to be in the frame allocation block.
 533         // Use 'select i8 true, %arg, undef' to simulate a 'no-op' instruction.
 534         Value *TrueValue = ConstantInt::getTrue(Context);
 535         Value *UndefValue = UndefValue::get(Arg->getType());
 536         Instruction *SI =
 537             SelectInst::Create(TrueValue, Arg, UndefValue,
 538                                Arg->getName() + ".tmp", AllocaInsertPt);
 539         Arg->replaceAllUsesWith(SI);
 540         // Reset the select operand, because it was clobbered by the RAUW above.
 541         SI->setOperand(1, Arg);
 542         ParentAlloca = DemoteRegToStack(*SI, true, SI);
 543       } else if (auto *PN = dyn_cast<PHINode>(ParentVal)) {
 544         ParentAlloca = DemotePHIToStack(PN, AllocaInsertPt);
 545       } else {
 546         Instruction *ParentInst = cast<Instruction>(ParentVal);
 547         // FIXME: This is a work-around to temporarily handle the case where an
 548         //        instruction that is only used in handlers is not sunk.
 549         //        Without uses, DemoteRegToStack would just eliminate the value.
 550         //        This will fail if ParentInst is an invoke.
 551         if (ParentInst->getNumUses() == 0) {
 552           BasicBlock::iterator InsertPt = ParentInst;
 553           ++InsertPt;
 554           ParentAlloca =
 555               new AllocaInst(ParentInst->getType(), nullptr,
 556                              ParentInst->getName() + ".reg2mem", InsertPt);
 557           new StoreInst(ParentInst, ParentAlloca, InsertPt);
 558         } else {
 559           ParentAlloca = DemoteRegToStack(*ParentInst, true, ParentInst);
 560         }
 561       }
 562     }
 563
 564     // If the parent alloca is used by exactly one handler and is not a catch
 565     // parameter, erase the parent and leave the copy in the outlined handler.
 566     // Catch parameters are indicated by a single null pointer in Allocas.
 567     if (ParentAlloca->getNumUses() == 0 && Allocas.size() == 1 &&
 568         Allocas[0] != getCatchObjectSentinel()) {
 569       ParentAlloca->eraseFromParent();
 570       // FIXME: Put a null entry in the llvm.frameescape call because we've
 571       // already created llvm.eh.actions calls with indices into it.
 572       AllocasToEscape.push_back(Constant::getNullValue(Int8PtrType));
 573       continue;
 574     }
 575
 576     // Add this alloca to the list of things to escape.
 577     AllocasToEscape.push_back(ParentAlloca);
 578
 579     // Next replace all outlined allocas that are mapped to it.
 580     for (AllocaInst *TempAlloca : Allocas) {
 581       if (TempAlloca == getCatchObjectSentinel())
 582         continue; // Skip catch parameter sentinels.
 583       Function *HandlerFn = TempAlloca->getParent()->getParent();
 584       // FIXME: Sink this GEP into the blocks where it is used.
 585       Builder.SetInsertPoint(TempAlloca);
 586       Builder.SetCurrentDebugLocation(TempAlloca->getDebugLoc());
 587       Value *RecoverArgs[] = {
 588           Builder.CreateBitCast(&F, Int8PtrType, ""),
 589           &(HandlerFn->getArgumentList().back()),
 590           llvm::ConstantInt::get(Int32Type, AllocasToEscape.size() - 1)};
 591       Value *RecoveredAlloca = Builder.CreateCall(RecoverFrameFn, RecoverArgs);
 592       // Add a pointer bitcast if the alloca wasn't an i8.
 593       if (RecoveredAlloca->getType() != TempAlloca->getType()) {
 594         RecoveredAlloca->setName(Twine(TempAlloca->getName()) + ".i8");
 595         RecoveredAlloca =
 596             Builder.CreateBitCast(RecoveredAlloca, TempAlloca->getType());
 597       }
 598       TempAlloca->replaceAllUsesWith(RecoveredAlloca);
 599       TempAlloca->removeFromParent();
 600       RecoveredAlloca->takeName(TempAlloca);
 601       delete TempAlloca;
 602     }
 603   } // End for each FrameVarInfo entry.
 604
 605   // Insert 'call void (...)* @llvm.frameescape(...)' at the end of the entry
 606   // block.
 607   Builder.SetInsertPoint(&F.getEntryBlock().back());
 608   Builder.CreateCall(FrameEscapeFn, AllocasToEscape);
 609
 610   // Clean up the handler action maps we created for this function
 611   DeleteContainerSeconds(CatchHandlerMap);
 612   CatchHandlerMap.clear();
 613   DeleteContainerSeconds(CleanupHandlerMap);
 614   CleanupHandlerMap.clear();
 615
 616   return HandlersOutlined;
 617 }
 618
 619 void WinEHPrepare::promoteLandingPadValues(LandingPadInst *LPad) {
 620   // If the return values of the landing pad instruction are extracted and
 621   // stored to memory, we want to promote the store locations to reg values.
 622   SmallVector<AllocaInst *, 2> EHAllocas;
 623
 624   // The landingpad instruction returns an aggregate value.  Typically, its
 625   // value will be passed to a pair of extract value instructions and the
 626   // results of those extracts are often passed to store instructions.
 627   // In unoptimized code the stored value will often be loaded and then stored
 628   // again.
 629   for (auto *U : LPad->users()) {
 630     ExtractValueInst *Extract = dyn_cast<ExtractValueInst>(U);
 631     if (!Extract)
 632       continue;
 633
 634     for (auto *EU : Extract->users()) {
 635       if (auto *Store = dyn_cast<StoreInst>(EU)) {
 636         auto *AV = cast<AllocaInst>(Store->getPointerOperand());
 637         EHAllocas.push_back(AV);
 638       }
 639     }
 640   }
 641
 642   // We can't do this without a dominator tree.
 643   assert(DT);
 644
 645   if (!EHAllocas.empty()) {
 646     PromoteMemToReg(EHAllocas, *DT);
 647     EHAllocas.clear();
 648   }
 649 }
 650
 651 void WinEHPrepare::completeNestedLandingPad(Function *ParentFn,
 652                                             LandingPadInst *OutlinedLPad,
 653                                             const LandingPadInst *OriginalLPad,
 654                                             FrameVarInfoMap &FrameVarInfo) {
 655   // Get the nested block and erase the unreachable instruction that was
 656   // temporarily inserted as its terminator.
 657   LLVMContext &Context = ParentFn->getContext();
 658   BasicBlock *OutlinedBB = OutlinedLPad->getParent();
 659   assert(isa<UnreachableInst>(OutlinedBB->getTerminator()));
 660   OutlinedBB->getTerminator()->eraseFromParent();
 661   // That should leave OutlinedLPad as the last instruction in its block.
 662   assert(&OutlinedBB->back() == OutlinedLPad);
 663
 664   // The original landing pad will have already had its action intrinsic
 665   // built by the outlining loop.  We need to clone that into the outlined
 666   // location.  It may also be necessary to add references to the exception
 667   // variables to the outlined handler in which this landing pad is nested
 668   // and remap return instructions in the nested handlers that should return
 669   // to an address in the outlined handler.
 670   Function *OutlinedHandlerFn = OutlinedBB->getParent();
 671   BasicBlock::const_iterator II = OriginalLPad;
 672   ++II;
 673   // The instruction after the landing pad should now be a call to eh.actions.
 674   const Instruction *Recover = II;
 675   assert(match(Recover, m_Intrinsic<Intrinsic::eh_actions>()));
 676   IntrinsicInst *EHActions = cast<IntrinsicInst>(Recover->clone());
 677
 678   // Remap the exception variables into the outlined function.
 679   WinEHFrameVariableMaterializer Materializer(OutlinedHandlerFn, FrameVarInfo);
 680   SmallVector<BlockAddress *, 4> ActionTargets;
 681   SmallVector<ActionHandler *, 4> ActionList;
 682   parseEHActions(EHActions, ActionList);
 683   for (auto *Action : ActionList) {
 684     auto *Catch = dyn_cast<CatchHandler>(Action);
 685     if (!Catch)
 686       continue;
 687     // The dyn_cast to function here selects C++ catch handlers and skips
 688     // SEH catch handlers.
 689     auto *Handler = dyn_cast<Function>(Catch->getHandlerBlockOrFunc());
 690     if (!Handler)
 691       continue;
 692     // Visit all the return instructions, looking for places that return
 693     // to a location within OutlinedHandlerFn.
 694     for (BasicBlock &NestedHandlerBB : *Handler) {
 695       auto *Ret = dyn_cast<ReturnInst>(NestedHandlerBB.getTerminator());
 696       if (!Ret)
 697         continue;
 698
 699       // Handler functions must always return a block address.
 700       BlockAddress *BA = cast<BlockAddress>(Ret->getReturnValue());
 701       // The original target will have been in the main parent function,
 702       // but if it is the address of a block that has been outlined, it
 703       // should be a block that was outlined into OutlinedHandlerFn.
 704       assert(BA->getFunction() == ParentFn);
 705
 706       // Ignore targets that aren't part of OutlinedHandlerFn.
 707       if (!LPadTargetBlocks.count(BA->getBasicBlock()))
 708         continue;
 709
 710       // If the return value is the address ofF a block that we
 711       // previously outlined into the parent handler function, replace
 712       // the return instruction and add the mapped target to the list
 713       // of possible return addresses.
 714       BasicBlock *MappedBB = LPadTargetBlocks[BA->getBasicBlock()];
 715       assert(MappedBB->getParent() == OutlinedHandlerFn);
 716       BlockAddress *NewBA = BlockAddress::get(OutlinedHandlerFn, MappedBB);
 717       Ret->eraseFromParent();
 718       ReturnInst::Create(Context, NewBA, &NestedHandlerBB);
 719       ActionTargets.push_back(NewBA);
 720     }
 721   }
 722   DeleteContainerPointers(ActionList);
 723   ActionList.clear();
 724   OutlinedBB->getInstList().push_back(EHActions);
 725
 726   // Insert an indirect branch into the outlined landing pad BB.
 727   IndirectBrInst *IBr = IndirectBrInst::Create(EHActions, 0, OutlinedBB);
 728   // Add the previously collected action targets.
 729   for (auto *Target : ActionTargets)
 730     IBr->addDestination(Target->getBasicBlock());
 731 }
 732
 733 // This function examines a block to determine whether the block ends with a
 734 // conditional branch to a catch handler based on a selector comparison.
 735 // This function is used both by the WinEHPrepare::findSelectorComparison() and
 736 // WinEHCleanupDirector::handleTypeIdFor().
 737 static bool isSelectorDispatch(BasicBlock *BB, BasicBlock *&CatchHandler,
 738                                Constant *&Selector, BasicBlock *&NextBB) {
 739   ICmpInst::Predicate Pred;
 740   BasicBlock *TBB, *FBB;
 741   Value *LHS, *RHS;
 742
 743   if (!match(BB->getTerminator(),
 744              m_Br(m_ICmp(Pred, m_Value(LHS), m_Value(RHS)), TBB, FBB)))
 745     return false;
 746
 747   if (!match(LHS,
 748              m_Intrinsic<Intrinsic::eh_typeid_for>(m_Constant(Selector))) &&
 749       !match(RHS, m_Intrinsic<Intrinsic::eh_typeid_for>(m_Constant(Selector))))
 750     return false;
 751
 752   if (Pred == CmpInst::ICMP_EQ) {
 753     CatchHandler = TBB;
 754     NextBB = FBB;
 755     return true;
 756   }
 757
 758   if (Pred == CmpInst::ICMP_NE) {
 759     CatchHandler = FBB;
 760     NextBB = TBB;
 761     return true;
 762   }
 763
 764   return false;
 765 }
 766
 767 bool WinEHPrepare::outlineHandler(ActionHandler *Action, Function *SrcFn,
 768                                   LandingPadInst *LPad, BasicBlock *StartBB,
 769                                   FrameVarInfoMap &VarInfo) {
 770   Module *M = SrcFn->getParent();
 771   LLVMContext &Context = M->getContext();
 772
 773   // Create a new function to receive the handler contents.
 774   Type *Int8PtrType = Type::getInt8PtrTy(Context);
 775   std::vector<Type *> ArgTys;
 776   ArgTys.push_back(Int8PtrType);
 777   ArgTys.push_back(Int8PtrType);
 778   Function *Handler;
 779   if (Action->getType() == Catch) {
 780     FunctionType *FnType = FunctionType::get(Int8PtrType, ArgTys, false);
 781     Handler = Function::Create(FnType, GlobalVariable::InternalLinkage,
 782                                SrcFn->getName() + ".catch", M);
 783   } else {
 784     FunctionType *FnType =
 785         FunctionType::get(Type::getVoidTy(Context), ArgTys, false);
 786     Handler = Function::Create(FnType, GlobalVariable::InternalLinkage,
 787                                SrcFn->getName() + ".cleanup", M);
 788   }
 789
 790   Handler->addFnAttr("wineh-parent", SrcFn->getName());
 791
 792   // Generate a standard prolog to setup the frame recovery structure.
 793   IRBuilder<> Builder(Context);
 794   BasicBlock *Entry = BasicBlock::Create(Context, "entry");
 795   Handler->getBasicBlockList().push_front(Entry);
 796   Builder.SetInsertPoint(Entry);
 797   Builder.SetCurrentDebugLocation(LPad->getDebugLoc());
 798
 799   std::unique_ptr<WinEHCloningDirectorBase> Director;
 800
 801   ValueToValueMapTy VMap;
 802
 803   LandingPadMap &LPadMap = LPadMaps[LPad];
 804   if (!LPadMap.isInitialized())
 805     LPadMap.mapLandingPad(LPad);
 806   if (auto *CatchAction = dyn_cast<CatchHandler>(Action)) {
 807     Constant *Sel = CatchAction->getSelector();
 808     Director.reset(new WinEHCatchDirector(Handler, Sel, VarInfo, LPadMap,
 809                                           NestedLPtoOriginalLP));
 810     LPadMap.remapEHValues(VMap, UndefValue::get(Int8PtrType),
 811                           ConstantInt::get(Type::getInt32Ty(Context), 1));
 812   } else {
 813     Director.reset(new WinEHCleanupDirector(Handler, VarInfo, LPadMap));
 814     LPadMap.remapEHValues(VMap, UndefValue::get(Int8PtrType),
 815                           UndefValue::get(Type::getInt32Ty(Context)));
 816   }
 817
 818   SmallVector<ReturnInst *, 8> Returns;
 819   ClonedCodeInfo OutlinedFunctionInfo;
 820
 821   // If the start block contains PHI nodes, we need to map them.
 822   BasicBlock::iterator II = StartBB->begin();
 823   while (auto *PN = dyn_cast<PHINode>(II)) {
 824     bool Mapped = false;
 825     // Look for PHI values that we have already mapped (such as the selector).
 826     for (Value *Val : PN->incoming_values()) {
 827       if (VMap.count(Val)) {
 828         VMap[PN] = VMap[Val];
 829         Mapped = true;
 830       }
 831     }
 832     // If we didn't find a match for this value, map it as an undef.
 833     if (!Mapped) {
 834       VMap[PN] = UndefValue::get(PN->getType());
 835     }
 836     ++II;
 837   }
 838
 839   // Skip over PHIs and, if applicable, landingpad instructions.
 840   II = StartBB->getFirstInsertionPt();
 841
 842   CloneAndPruneIntoFromInst(Handler, SrcFn, II, VMap,
 843                             /*ModuleLevelChanges=*/false, Returns, "",
 844                             &OutlinedFunctionInfo, Director.get());
 845
 846   // Move all the instructions in the first cloned block into our entry block.
 847   BasicBlock *FirstClonedBB = std::next(Function::iterator(Entry));
 848   Entry->getInstList().splice(Entry->end(), FirstClonedBB->getInstList());
 849   FirstClonedBB->eraseFromParent();
 850
 851   if (auto *CatchAction = dyn_cast<CatchHandler>(Action)) {
 852     WinEHCatchDirector *CatchDirector =
 853         reinterpret_cast<WinEHCatchDirector *>(Director.get());
 854     CatchAction->setExceptionVar(CatchDirector->getExceptionVar());
 855     CatchAction->setReturnTargets(CatchDirector->getReturnTargets());
 856
 857     // Look for blocks that are not part of the landing pad that we just
 858     // outlined but terminate with a call to llvm.eh.endcatch and a
 859     // branch to a block that is in the handler we just outlined.
 860     // These blocks will be part of a nested landing pad that intends to
 861     // return to an address in this handler.  This case is best handled
 862     // after both landing pads have been outlined, so for now we'll just
 863     // save the association of the blocks in LPadTargetBlocks.  The
 864     // return instructions which are created from these branches will be
 865     // replaced after all landing pads have been outlined.
 866     for (const auto &MapEntry : VMap) {
 867       // VMap maps all values and blocks that were just cloned, but dead
 868       // blocks which were pruned will map to nullptr.
 869       if (!isa<BasicBlock>(MapEntry.first) || MapEntry.second == nullptr)
 870         continue;
 871       const BasicBlock *MappedBB = cast<BasicBlock>(MapEntry.first);
 872       for (auto *Pred : predecessors(const_cast<BasicBlock *>(MappedBB))) {
 873         auto *Branch = dyn_cast<BranchInst>(Pred->getTerminator());
 874         if (!Branch || !Branch->isUnconditional() || Pred->size() <= 1)
 875           continue;
 876         BasicBlock::iterator II = const_cast<BranchInst *>(Branch);
 877         --II;
 878         if (match(cast<Value>(II), m_Intrinsic<Intrinsic::eh_endcatch>())) {
 879           // This would indicate that a nested landing pad wants to return
 880           // to a block that is outlined into two different handlers.
 881           assert(!LPadTargetBlocks.count(MappedBB));
 882           LPadTargetBlocks[MappedBB] = cast<BasicBlock>(MapEntry.second);
 883         }
 884       }
 885     }
 886   } // End if (CatchAction)
 887
 888   Action->setHandlerBlockOrFunc(Handler);
 889
 890   return true;
 891 }
 892
 893 /// This BB must end in a selector dispatch. All we need to do is pass the
 894 /// handler block to llvm.eh.actions and list it as a possible indirectbr
 895 /// target.
 896 void WinEHPrepare::processSEHCatchHandler(CatchHandler *CatchAction,
 897                                           BasicBlock *StartBB) {
 898   BasicBlock *HandlerBB;
 899   BasicBlock *NextBB;
 900   Constant *Selector;
 901   bool Res = isSelectorDispatch(StartBB, HandlerBB, Selector, NextBB);
 902   if (Res) {
 903     // If this was EH dispatch, this must be a conditional branch to the handler
 904     // block.
 905     // FIXME: Handle instructions in the dispatch block. Currently we drop them,
 906     // leading to crashes if some optimization hoists stuff here.
 907     assert(CatchAction->getSelector() && HandlerBB &&
 908            "expected catch EH dispatch");
 909   } else {
 910     // This must be a catch-all. Split the block after the landingpad.
 911     assert(CatchAction->getSelector()->isNullValue() && "expected catch-all");
 912     HandlerBB =
 913         StartBB->splitBasicBlock(StartBB->getFirstInsertionPt(), "catch.all");
 914   }
 915   CatchAction->setHandlerBlockOrFunc(BlockAddress::get(HandlerBB));
 916   TinyPtrVector<BasicBlock *> Targets(HandlerBB);
 917   CatchAction->setReturnTargets(Targets);
 918 }
 919
 920 void LandingPadMap::mapLandingPad(const LandingPadInst *LPad) {
 921   // Each instance of this class should only ever be used to map a single
 922   // landing pad.
 923   assert(OriginLPad == nullptr || OriginLPad == LPad);
 924
 925   // If the landing pad has already been mapped, there's nothing more to do.
 926   if (OriginLPad == LPad)
 927     return;
 928
 929   OriginLPad = LPad;
 930
 931   // The landingpad instruction returns an aggregate value.  Typically, its
 932   // value will be passed to a pair of extract value instructions and the
 933   // results of those extracts will have been promoted to reg values before
 934   // this routine is called.
 935   for (auto *U : LPad->users()) {
 936     const ExtractValueInst *Extract = dyn_cast<ExtractValueInst>(U);
 937     if (!Extract)
 938       continue;
 939     assert(Extract->getNumIndices() == 1 &&
 940            "Unexpected operation: extracting both landing pad values");
 941     unsigned int Idx = *(Extract->idx_begin());
 942     assert((Idx == 0 || Idx == 1) &&
 943            "Unexpected operation: extracting an unknown landing pad element");
 944     if (Idx == 0) {
 945       ExtractedEHPtrs.push_back(Extract);
 946     } else if (Idx == 1) {
 947       ExtractedSelectors.push_back(Extract);
 948     }
 949   }
 950 }
 951
 952 bool LandingPadMap::isOriginLandingPadBlock(const BasicBlock *BB) const {
 953   return BB->getLandingPadInst() == OriginLPad;
 954 }
 955
 956 bool LandingPadMap::isLandingPadSpecificInst(const Instruction *Inst) const {
 957   if (Inst == OriginLPad)
 958     return true;
 959   for (auto *Extract : ExtractedEHPtrs) {
 960     if (Inst == Extract)
 961       return true;
 962   }
 963   for (auto *Extract : ExtractedSelectors) {
 964     if (Inst == Extract)
 965       return true;
 966   }
 967   return false;
 968 }
 969
 970 void LandingPadMap::remapEHValues(ValueToValueMapTy &VMap, Value *EHPtrValue,
 971                                   Value *SelectorValue) const {
 972   // Remap all landing pad extract instructions to the specified values.
 973   for (auto *Extract : ExtractedEHPtrs)
 974     VMap[Extract] = EHPtrValue;
 975   for (auto *Extract : ExtractedSelectors)
 976     VMap[Extract] = SelectorValue;
 977 }
 978
 979 CloningDirector::CloningAction WinEHCloningDirectorBase::handleInstruction(
 980     ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
 981   // If this is one of the boilerplate landing pad instructions, skip it.
 982   // The instruction will have already been remapped in VMap.
 983   if (LPadMap.isLandingPadSpecificInst(Inst))
 984     return CloningDirector::SkipInstruction;
 985
 986   // Nested landing pads will be cloned as stubs, with just the
 987   // landingpad instruction and an unreachable instruction. When
 988   // all landingpads have been outlined, we'll replace this with the
 989   // llvm.eh.actions call and indirect branch created when the
 990   // landing pad was outlined.
 991   if (auto *LPad = dyn_cast<LandingPadInst>(Inst)) {
 992     return handleLandingPad(VMap, LPad, NewBB);
 993   }
 994
 995   if (auto *Invoke = dyn_cast<InvokeInst>(Inst))
 996     return handleInvoke(VMap, Invoke, NewBB);
 997
 998   if (auto *Resume = dyn_cast<ResumeInst>(Inst))
 999     return handleResume(VMap, Resume, NewBB);
1000
1001   if (match(Inst, m_Intrinsic<Intrinsic::eh_begincatch>()))
1002     return handleBeginCatch(VMap, Inst, NewBB);
1003   if (match(Inst, m_Intrinsic<Intrinsic::eh_endcatch>()))
1004     return handleEndCatch(VMap, Inst, NewBB);
1005   if (match(Inst, m_Intrinsic<Intrinsic::eh_typeid_for>()))
1006     return handleTypeIdFor(VMap, Inst, NewBB);
1007
1008   // Continue with the default cloning behavior.
1009   return CloningDirector::CloneInstruction;
1010 }
1011
1012 CloningDirector::CloningAction WinEHCatchDirector::handleLandingPad(
1013     ValueToValueMapTy &VMap, const LandingPadInst *LPad, BasicBlock *NewBB) {
1014   Instruction *NewInst = LPad->clone();
1015   if (LPad->hasName())
1016     NewInst->setName(LPad->getName());
1017   // Save this correlation for later processing.
1018   NestedLPtoOriginalLP[cast<LandingPadInst>(NewInst)] = LPad;
1019   VMap[LPad] = NewInst;
1020   BasicBlock::InstListType &InstList = NewBB->getInstList();
1021   InstList.push_back(NewInst);
1022   InstList.push_back(new UnreachableInst(NewBB->getContext()));
1023   return CloningDirector::StopCloningBB;
1024 }
1025
1026 CloningDirector::CloningAction WinEHCatchDirector::handleBeginCatch(
1027     ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
1028   // The argument to the call is some form of the first element of the
1029   // landingpad aggregate value, but that doesn't matter.  It isn't used
1030   // here.
1031   // The second argument is an outparameter where the exception object will be
1032   // stored. Typically the exception object is a scalar, but it can be an
1033   // aggregate when catching by value.
1034   // FIXME: Leave something behind to indicate where the exception object lives
1035   // for this handler. Should it be part of llvm.eh.actions?
1036   assert(ExceptionObjectVar == nullptr && "Multiple calls to "
1037                                           "llvm.eh.begincatch found while "
1038                                           "outlining catch handler.");
1039   ExceptionObjectVar = Inst->getOperand(1)->stripPointerCasts();
1040   if (isa<ConstantPointerNull>(ExceptionObjectVar))
1041     return CloningDirector::SkipInstruction;
1042   assert(cast<AllocaInst>(ExceptionObjectVar)->isStaticAlloca() &&
1043          "catch parameter is not static alloca");
1044   Materializer.escapeCatchObject(ExceptionObjectVar);
1045   return CloningDirector::SkipInstruction;
1046 }
1047
1048 CloningDirector::CloningAction
1049 WinEHCatchDirector::handleEndCatch(ValueToValueMapTy &VMap,
1050                                    const Instruction *Inst, BasicBlock *NewBB) {
1051   auto *IntrinCall = dyn_cast<IntrinsicInst>(Inst);
1052   // It might be interesting to track whether or not we are inside a catch
1053   // function, but that might make the algorithm more brittle than it needs
1054   // to be.
1055
1056   // The end catch call can occur in one of two places: either in a
1057   // landingpad block that is part of the catch handlers exception mechanism,
1058   // or at the end of the catch block.  However, a catch-all handler may call
1059   // end catch from the original landing pad.  If the call occurs in a nested
1060   // landing pad block, we must skip it and continue so that the landing pad
1061   // gets cloned.
1062   auto *ParentBB = IntrinCall->getParent();
1063   if (ParentBB->isLandingPad() && !LPadMap.isOriginLandingPadBlock(ParentBB))
1064     return CloningDirector::SkipInstruction;
1065
1066   // If an end catch occurs anywhere else we want to terminate the handler
1067   // with a return to the code that follows the endcatch call.  If the
1068   // next instruction is not an unconditional branch, we need to split the
1069   // block to provide a clear target for the return instruction.
1070   BasicBlock *ContinueBB;
1071   auto Next = std::next(BasicBlock::const_iterator(IntrinCall));
1072   const BranchInst *Branch = dyn_cast<BranchInst>(Next);
1073   if (!Branch || !Branch->isUnconditional()) {
1074     // We're interrupting the cloning process at this location, so the
1075     // const_cast we're doing here will not cause a problem.
1076     ContinueBB = SplitBlock(const_cast<BasicBlock *>(ParentBB),
1077                             const_cast<Instruction *>(cast<Instruction>(Next)));
1078   } else {
1079     ContinueBB = Branch->getSuccessor(0);
1080   }
1081
1082   ReturnInst::Create(NewBB->getContext(), BlockAddress::get(ContinueBB), NewBB);
1083   ReturnTargets.push_back(ContinueBB);
1084
1085   // We just added a terminator to the cloned block.
1086   // Tell the caller to stop processing the current basic block so that
1087   // the branch instruction will be skipped.
1088   return CloningDirector::StopCloningBB;
1089 }
1090
1091 CloningDirector::CloningAction WinEHCatchDirector::handleTypeIdFor(
1092     ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
1093   auto *IntrinCall = dyn_cast<IntrinsicInst>(Inst);
1094   Value *Selector = IntrinCall->getArgOperand(0)->stripPointerCasts();
1095   // This causes a replacement that will collapse the landing pad CFG based
1096   // on the filter function we intend to match.
1097   if (Selector == CurrentSelector)
1098     VMap[Inst] = ConstantInt::get(SelectorIDType, 1);
1099   else
1100     VMap[Inst] = ConstantInt::get(SelectorIDType, 0);
1101   // Tell the caller not to clone this instruction.
1102   return CloningDirector::SkipInstruction;
1103 }
1104
1105 CloningDirector::CloningAction
1106 WinEHCatchDirector::handleInvoke(ValueToValueMapTy &VMap,
1107                                  const InvokeInst *Invoke, BasicBlock *NewBB) {
1108   return CloningDirector::CloneInstruction;
1109 }
1110
1111 CloningDirector::CloningAction
1112 WinEHCatchDirector::handleResume(ValueToValueMapTy &VMap,
1113                                  const ResumeInst *Resume, BasicBlock *NewBB) {
1114   // Resume instructions shouldn't be reachable from catch handlers.
1115   // We still need to handle it, but it will be pruned.
1116   BasicBlock::InstListType &InstList = NewBB->getInstList();
1117   InstList.push_back(new UnreachableInst(NewBB->getContext()));
1118   return CloningDirector::StopCloningBB;
1119 }
1120
1121 CloningDirector::CloningAction WinEHCleanupDirector::handleLandingPad(
1122     ValueToValueMapTy &VMap, const LandingPadInst *LPad, BasicBlock *NewBB) {
1123   // The MS runtime will terminate the process if an exception occurs in a
1124   // cleanup handler, so we shouldn't encounter landing pads in the actual
1125   // cleanup code, but they may appear in catch blocks.  Depending on where
1126   // we started cloning we may see one, but it will get dropped during dead
1127   // block pruning.
1128   Instruction *NewInst = new UnreachableInst(NewBB->getContext());
1129   VMap[LPad] = NewInst;
1130   BasicBlock::InstListType &InstList = NewBB->getInstList();
1131   InstList.push_back(NewInst);
1132   return CloningDirector::StopCloningBB;
1133 }
1134
1135 CloningDirector::CloningAction WinEHCleanupDirector::handleBeginCatch(
1136     ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
1137   // Catch blocks within cleanup handlers will always be unreachable.
1138   // We'll insert an unreachable instruction now, but it will be pruned
1139   // before the cloning process is complete.
1140   BasicBlock::InstListType &InstList = NewBB->getInstList();
1141   InstList.push_back(new UnreachableInst(NewBB->getContext()));
1142   return CloningDirector::StopCloningBB;
1143 }
1144
1145 CloningDirector::CloningAction WinEHCleanupDirector::handleEndCatch(
1146     ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
1147   // Catch blocks within cleanup handlers will always be unreachable.
1148   // We'll insert an unreachable instruction now, but it will be pruned
1149   // before the cloning process is complete.
1150   BasicBlock::InstListType &InstList = NewBB->getInstList();
1151   InstList.push_back(new UnreachableInst(NewBB->getContext()));
1152   return CloningDirector::StopCloningBB;
1153 }
1154
1155 CloningDirector::CloningAction WinEHCleanupDirector::handleTypeIdFor(
1156     ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB) {
1157   // If we encounter a selector comparison while cloning a cleanup handler,
1158   // we want to stop cloning immediately.  Anything after the dispatch
1159   // will be outlined into a different handler.
1160   BasicBlock *CatchHandler;
1161   Constant *Selector;
1162   BasicBlock *NextBB;
1163   if (isSelectorDispatch(const_cast<BasicBlock *>(Inst->getParent()),
1164                          CatchHandler, Selector, NextBB)) {
1165     ReturnInst::Create(NewBB->getContext(), nullptr, NewBB);
1166     return CloningDirector::StopCloningBB;
1167   }
1168   // If eg.typeid.for is called for any other reason, it can be ignored.
1169   VMap[Inst] = ConstantInt::get(SelectorIDType, 0);
1170   return CloningDirector::SkipInstruction;
1171 }
1172
1173 CloningDirector::CloningAction WinEHCleanupDirector::handleInvoke(
1174     ValueToValueMapTy &VMap, const InvokeInst *Invoke, BasicBlock *NewBB) {
1175   // All invokes in cleanup handlers can be replaced with calls.
1176   SmallVector<Value *, 16> CallArgs(Invoke->op_begin(), Invoke->op_end() - 3);
1177   // Insert a normal call instruction...
1178   CallInst *NewCall =
1179       CallInst::Create(const_cast<Value *>(Invoke->getCalledValue()), CallArgs,
1180                        Invoke->getName(), NewBB);
1181   NewCall->setCallingConv(Invoke->getCallingConv());
1182   NewCall->setAttributes(Invoke->getAttributes());
1183   NewCall->setDebugLoc(Invoke->getDebugLoc());
1184   VMap[Invoke] = NewCall;
1185
1186   // Insert an unconditional branch to the normal destination.
1187   BranchInst::Create(Invoke->getNormalDest(), NewBB);
1188
1189   // The unwind destination won't be cloned into the new function, so
1190   // we don't need to clean up its phi nodes.
1191
1192   // We just added a terminator to the cloned block.
1193   // Tell the caller to stop processing the current basic block.
1194   return CloningDirector::StopCloningBB;
1195 }
1196
1197 CloningDirector::CloningAction WinEHCleanupDirector::handleResume(
1198     ValueToValueMapTy &VMap, const ResumeInst *Resume, BasicBlock *NewBB) {
1199   ReturnInst::Create(NewBB->getContext(), nullptr, NewBB);
1200
1201   // We just added a terminator to the cloned block.
1202   // Tell the caller to stop processing the current basic block so that
1203   // the branch instruction will be skipped.
1204   return CloningDirector::StopCloningBB;
1205 }
1206
1207 WinEHFrameVariableMaterializer::WinEHFrameVariableMaterializer(
1208     Function *OutlinedFn, FrameVarInfoMap &FrameVarInfo)
1209     : FrameVarInfo(FrameVarInfo), Builder(OutlinedFn->getContext()) {
1210   BasicBlock *EntryBB = &OutlinedFn->getEntryBlock();
1211   Builder.SetInsertPoint(EntryBB, EntryBB->getFirstInsertionPt());
1212 }
1213
1214 Value *WinEHFrameVariableMaterializer::materializeValueFor(Value *V) {
1215   // If we're asked to materialize a value that is an instruction, we
1216   // temporarily create an alloca in the outlined function and add this
1217   // to the FrameVarInfo map.  When all the outlining is complete, we'll
1218   // collect these into a structure, spilling non-alloca values in the
1219   // parent frame as necessary, and replace these temporary allocas with
1220   // GEPs referencing the frame allocation block.
1221
1222   // If the value is an alloca, the mapping is direct.
1223   if (auto *AV = dyn_cast<AllocaInst>(V)) {
1224     AllocaInst *NewAlloca = dyn_cast<AllocaInst>(AV->clone());
1225     Builder.Insert(NewAlloca, AV->getName());
1226     FrameVarInfo[AV].push_back(NewAlloca);
1227     return NewAlloca;
1228   }
1229
1230   // For other types of instructions or arguments, we need an alloca based on
1231   // the value's type and a load of the alloca.  The alloca will be replaced
1232   // by a GEP, but the load will stay.  In the parent function, the value will
1233   // be spilled to a location in the frame allocation block.
1234   if (isa<Instruction>(V) || isa<Argument>(V)) {
1235     AllocaInst *NewAlloca =
1236         Builder.CreateAlloca(V->getType(), nullptr, "eh.temp.alloca");
1237     FrameVarInfo[V].push_back(NewAlloca);
1238     LoadInst *NewLoad = Builder.CreateLoad(NewAlloca, V->getName() + ".reload");
1239     return NewLoad;
1240   }
1241
1242   // Don't materialize other values.
1243   return nullptr;
1244 }
1245
1246 void WinEHFrameVariableMaterializer::escapeCatchObject(Value *V) {
1247   // Catch parameter objects have to live in the parent frame. When we see a use
1248   // of a catch parameter, add a sentinel to the multimap to indicate that it's
1249   // used from another handler. This will prevent us from trying to sink the
1250   // alloca into the handler and ensure that the catch parameter is present in
1251   // the call to llvm.frameescape.
1252   FrameVarInfo[V].push_back(getCatchObjectSentinel());
1253 }
1254
1255 // This function maps the catch and cleanup handlers that are reachable from the
1256 // specified landing pad. The landing pad sequence will have this basic shape:
1257 //
1258 //  <cleanup handler>
1259 //  <selector comparison>
1260 //  <catch handler>
1261 //  <cleanup handler>
1262 //  <selector comparison>
1263 //  <catch handler>
1264 //  <cleanup handler>
1265 //  ...
1266 //
1267 // Any of the cleanup slots may be absent.  The cleanup slots may be occupied by
1268 // any arbitrary control flow, but all paths through the cleanup code must
1269 // eventually reach the next selector comparison and no path can skip to a
1270 // different selector comparisons, though some paths may terminate abnormally.
1271 // Therefore, we will use a depth first search from the start of any given
1272 // cleanup block and stop searching when we find the next selector comparison.
1273 //
1274 // If the landingpad instruction does not have a catch clause, we will assume
1275 // that any instructions other than selector comparisons and catch handlers can
1276 // be ignored.  In practice, these will only be the boilerplate instructions.
1277 //
1278 // The catch handlers may also have any control structure, but we are only
1279 // interested in the start of the catch handlers, so we don't need to actually
1280 // follow the flow of the catch handlers.  The start of the catch handlers can
1281 // be located from the compare instructions, but they can be skipped in the
1282 // flow by following the contrary branch.
1283 void WinEHPrepare::mapLandingPadBlocks(LandingPadInst *LPad,
1284                                        LandingPadActions &Actions) {
1285   unsigned int NumClauses = LPad->getNumClauses();
1286   unsigned int HandlersFound = 0;
1287   BasicBlock *BB = LPad->getParent();
1288
1289   DEBUG(dbgs() << "Mapping landing pad: " << BB->getName() << "\n");
1290
1291   if (NumClauses == 0) {
1292     // This landing pad contains only cleanup code.
1293     CleanupHandler *Action = new CleanupHandler(BB);
1294     CleanupHandlerMap[BB] = Action;
1295     Actions.insertCleanupHandler(Action);
1296     DEBUG(dbgs() << "  Assuming cleanup code in block " << BB->getName()
1297                  << "\n");
1298     assert(LPad->isCleanup());
1299     return;
1300   }
1301
1302   VisitedBlockSet VisitedBlocks;
1303
1304   while (HandlersFound != NumClauses) {
1305     BasicBlock *NextBB = nullptr;
1306
1307     // See if the clause we're looking for is a catch-all.
1308     // If so, the catch begins immediately.
1309     if (isa<ConstantPointerNull>(LPad->getClause(HandlersFound))) {
1310       // The catch all must occur last.
1311       assert(HandlersFound == NumClauses - 1);
1312
1313       // For C++ EH, check if there is any interesting cleanup code before we
1314       // begin the catch. This is important because cleanups cannot rethrow
1315       // exceptions but code called from catches can. For SEH, it isn't
1316       // important if some finally code before a catch-all is executed out of
1317       // line or after recovering from the exception.
1318       if (Personality == EHPersonality::MSVC_CXX) {
1319         if (auto *CleanupAction = findCleanupHandler(BB, BB)) {
1320           //   Add a cleanup entry to the list
1321           Actions.insertCleanupHandler(CleanupAction);
1322           DEBUG(dbgs() << "  Found cleanup code in block "
1323                        << CleanupAction->getStartBlock()->getName() << "\n");
1324         }
1325       }
1326
1327       // Add the catch handler to the action list.
1328       CatchHandler *Action =
1329           new CatchHandler(BB, LPad->getClause(HandlersFound), nullptr);
1330       CatchHandlerMap[BB] = Action;
1331       Actions.insertCatchHandler(Action);
1332       DEBUG(dbgs() << "  Catch all handler at block " << BB->getName() << "\n");
1333       ++HandlersFound;
1334
1335       // Once we reach a catch-all, don't expect to hit a resume instruction.
1336       BB = nullptr;
1337       break;
1338     }
1339
1340     CatchHandler *CatchAction = findCatchHandler(BB, NextBB, VisitedBlocks);
1341     // See if there is any interesting code executed before the dispatch.
1342     if (auto *CleanupAction =
1343             findCleanupHandler(BB, CatchAction->getStartBlock())) {
1344       //   Add a cleanup entry to the list
1345       Actions.insertCleanupHandler(CleanupAction);
1346       DEBUG(dbgs() << "  Found cleanup code in block "
1347                    << CleanupAction->getStartBlock()->getName() << "\n");
1348     }
1349
1350     assert(CatchAction);
1351     ++HandlersFound;
1352
1353     // Add the catch handler to the action list.
1354     Actions.insertCatchHandler(CatchAction);
1355     DEBUG(dbgs() << "  Found catch dispatch in block "
1356                  << CatchAction->getStartBlock()->getName() << "\n");
1357
1358     // Move on to the block after the catch handler.
1359     BB = NextBB;
1360   }
1361
1362   // If we didn't wind up in a catch-all, see if there is any interesting code
1363   // executed before the resume.
1364   if (auto *CleanupAction = findCleanupHandler(BB, BB)) {
1365     //   Add a cleanup entry to the list
1366     Actions.insertCleanupHandler(CleanupAction);
1367     DEBUG(dbgs() << "  Found cleanup code in block "
1368                  << CleanupAction->getStartBlock()->getName() << "\n");
1369   }
1370
1371   // It's possible that some optimization moved code into a landingpad that
1372   // wasn't
1373   // previously being used for cleanup.  If that happens, we need to execute
1374   // that
1375   // extra code from a cleanup handler.
1376   if (Actions.includesCleanup() && !LPad->isCleanup())
1377     LPad->setCleanup(true);
1378 }
1379
1380 // This function searches starting with the input block for the next
1381 // block that terminates with a branch whose condition is based on a selector
1382 // comparison.  This may be the input block.  See the mapLandingPadBlocks
1383 // comments for a discussion of control flow assumptions.
1384 //
1385 CatchHandler *WinEHPrepare::findCatchHandler(BasicBlock *BB,
1386                                              BasicBlock *&NextBB,
1387                                              VisitedBlockSet &VisitedBlocks) {
1388   // See if we've already found a catch handler use it.
1389   // Call count() first to avoid creating a null entry for blocks
1390   // we haven't seen before.
1391   if (CatchHandlerMap.count(BB) && CatchHandlerMap[BB] != nullptr) {
1392     CatchHandler *Action = cast<CatchHandler>(CatchHandlerMap[BB]);
1393     NextBB = Action->getNextBB();
1394     return Action;
1395   }
1396
1397   // VisitedBlocks applies only to the current search.  We still
1398   // need to consider blocks that we've visited while mapping other
1399   // landing pads.
1400   VisitedBlocks.insert(BB);
1401
1402   BasicBlock *CatchBlock = nullptr;
1403   Constant *Selector = nullptr;
1404
1405   // If this is the first time we've visited this block from any landing pad
1406   // look to see if it is a selector dispatch block.
1407   if (!CatchHandlerMap.count(BB)) {
1408     if (isSelectorDispatch(BB, CatchBlock, Selector, NextBB)) {
1409       CatchHandler *Action = new CatchHandler(BB, Selector, NextBB);
1410       CatchHandlerMap[BB] = Action;
1411       return Action;
1412     }
1413   }
1414
1415   // Visit each successor, looking for the dispatch.
1416   // FIXME: We expect to find the dispatch quickly, so this will probably
1417   //        work better as a breadth first search.
1418   for (BasicBlock *Succ : successors(BB)) {
1419     if (VisitedBlocks.count(Succ))
1420       continue;
1421
1422     CatchHandler *Action = findCatchHandler(Succ, NextBB, VisitedBlocks);
1423     if (Action)
1424       return Action;
1425   }
1426   return nullptr;
1427 }
1428
1429 // These are helper functions to combine repeated code from findCleanupHandler.
1430 static CleanupHandler *
1431 createCleanupHandler(CleanupHandlerMapTy &CleanupHandlerMap, BasicBlock *BB) {
1432   CleanupHandler *Action = new CleanupHandler(BB);
1433   CleanupHandlerMap[BB] = Action;
1434   return Action;
1435 }
1436
1437 // This function searches starting with the input block for the next block that
1438 // contains code that is not part of a catch handler and would not be eliminated
1439 // during handler outlining.
1440 //
1441 CleanupHandler *WinEHPrepare::findCleanupHandler(BasicBlock *StartBB,
1442                                                  BasicBlock *EndBB) {
1443   // Here we will skip over the following:
1444   //
1445   // landing pad prolog:
1446   //
1447   // Unconditional branches
1448   //
1449   // Selector dispatch
1450   //
1451   // Resume pattern
1452   //
1453   // Anything else marks the start of an interesting block
1454
1455   BasicBlock *BB = StartBB;
1456   // Anything other than an unconditional branch will kick us out of this loop
1457   // one way or another.
1458   while (BB) {
1459     // If we've already scanned this block, don't scan it again.  If it is
1460     // a cleanup block, there will be an action in the CleanupHandlerMap.
1461     // If we've scanned it and it is not a cleanup block, there will be a
1462     // nullptr in the CleanupHandlerMap.  If we have not scanned it, there will
1463     // be no entry in the CleanupHandlerMap.  We must call count() first to
1464     // avoid creating a null entry for blocks we haven't scanned.
1465     if (CleanupHandlerMap.count(BB)) {
1466       if (auto *Action = CleanupHandlerMap[BB]) {
1467         return cast<CleanupHandler>(Action);
1468       } else {
1469         // Here we handle the case where the cleanup handler map contains a
1470         // value for this block but the value is a nullptr.  This means that
1471         // we have previously analyzed the block and determined that it did
1472         // not contain any cleanup code.  Based on the earlier analysis, we
1473         // know the the block must end in either an unconditional branch, a
1474         // resume or a conditional branch that is predicated on a comparison
1475         // with a selector.  Either the resume or the selector dispatch
1476         // would terminate the search for cleanup code, so the unconditional
1477         // branch is the only case for which we might need to continue
1478         // searching.
1479         if (BB == EndBB)
1480           return nullptr;
1481         BasicBlock *SuccBB;
1482         if (!match(BB->getTerminator(), m_UnconditionalBr(SuccBB)))
1483           return nullptr;
1484         BB = SuccBB;
1485         continue;
1486       }
1487     }
1488
1489     // Create an entry in the cleanup handler map for this block.  Initially
1490     // we create an entry that says this isn't a cleanup block.  If we find
1491     // cleanup code, the caller will replace this entry.
1492     CleanupHandlerMap[BB] = nullptr;
1493
1494     TerminatorInst *Terminator = BB->getTerminator();
1495
1496     // Landing pad blocks have extra instructions we need to accept.
1497     LandingPadMap *LPadMap = nullptr;
1498     if (BB->isLandingPad()) {
1499       LandingPadInst *LPad = BB->getLandingPadInst();
1500       LPadMap = &LPadMaps[LPad];
1501       if (!LPadMap->isInitialized())
1502         LPadMap->mapLandingPad(LPad);
1503     }
1504
1505     // Look for the bare resume pattern:
1506     //   %lpad.val1 = insertvalue { i8*, i32 } undef, i8* %exn, 0
1507     //   %lpad.val2 = insertvalue { i8*, i32 } %lpad.val1, i32 %sel, 1
1508     //   resume { i8*, i32 } %lpad.val2
1509     if (auto *Resume = dyn_cast<ResumeInst>(Terminator)) {
1510       InsertValueInst *Insert1 = nullptr;
1511       InsertValueInst *Insert2 = nullptr;
1512       Value *ResumeVal = Resume->getOperand(0);
1513       // If there is only one landingpad, we may use the lpad directly with no
1514       // insertions.
1515       if (isa<LandingPadInst>(ResumeVal))
1516         return nullptr;
1517       if (!isa<PHINode>(ResumeVal)) {
1518         Insert2 = dyn_cast<InsertValueInst>(ResumeVal);
1519         if (!Insert2)
1520           return createCleanupHandler(CleanupHandlerMap, BB);
1521         Insert1 = dyn_cast<InsertValueInst>(Insert2->getAggregateOperand());
1522         if (!Insert1)
1523           return createCleanupHandler(CleanupHandlerMap, BB);
1524       }
1525       for (BasicBlock::iterator II = BB->getFirstNonPHIOrDbg(), IE = BB->end();
1526            II != IE; ++II) {
1527         Instruction *Inst = II;
1528         if (LPadMap && LPadMap->isLandingPadSpecificInst(Inst))
1529           continue;
1530         if (Inst == Insert1 || Inst == Insert2 || Inst == Resume)
1531           continue;
1532         if (!Inst->hasOneUse() ||
1533             (Inst->user_back() != Insert1 && Inst->user_back() != Insert2)) {
1534           return createCleanupHandler(CleanupHandlerMap, BB);
1535         }
1536       }
1537       return nullptr;
1538     }
1539
1540     BranchInst *Branch = dyn_cast<BranchInst>(Terminator);
1541     if (Branch && Branch->isConditional()) {
1542       // Look for the selector dispatch.
1543       //   %2 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIf to i8*))
1544       //   %matches = icmp eq i32 %sel, %2
1545       //   br i1 %matches, label %catch14, label %eh.resume
1546       CmpInst *Compare = dyn_cast<CmpInst>(Branch->getCondition());
1547       if (!Compare || !Compare->isEquality())
1548         return createCleanupHandler(CleanupHandlerMap, BB);
1549       for (BasicBlock::iterator II = BB->getFirstNonPHIOrDbg(),
1550         IE = BB->end();
1551         II != IE; ++II) {
1552         Instruction *Inst = II;
1553         if (LPadMap && LPadMap->isLandingPadSpecificInst(Inst))
1554           continue;
1555         if (Inst == Compare || Inst == Branch)
1556           continue;
1557         if (match(Inst, m_Intrinsic<Intrinsic::eh_typeid_for>()))
1558           continue;
1559         return createCleanupHandler(CleanupHandlerMap, BB);
1560       }
1561       // The selector dispatch block should always terminate our search.
1562       assert(BB == EndBB);
1563       return nullptr;
1564     }
1565
1566     // Anything else is either a catch block or interesting cleanup code.
1567     for (BasicBlock::iterator II = BB->getFirstNonPHIOrDbg(),
1568       IE = BB->end();
1569       II != IE; ++II) {
1570       Instruction *Inst = II;
1571       if (LPadMap && LPadMap->isLandingPadSpecificInst(Inst))
1572         continue;
1573       // Unconditional branches fall through to this loop.
1574       if (Inst == Branch)
1575         continue;
1576       // If this is a catch block, there is no cleanup code to be found.
1577       if (match(Inst, m_Intrinsic<Intrinsic::eh_begincatch>()))
1578         return nullptr;
1579       // If this a nested landing pad, it may contain an endcatch call.
1580       if (match(Inst, m_Intrinsic<Intrinsic::eh_endcatch>()))
1581         return nullptr;
1582       // Anything else makes this interesting cleanup code.
1583       return createCleanupHandler(CleanupHandlerMap, BB);
1584     }
1585
1586     // Only unconditional branches in empty blocks should get this far.
1587     assert(Branch && Branch->isUnconditional());
1588     if (BB == EndBB)
1589       return nullptr;
1590     BB = Branch->getSuccessor(0);
1591   }
1592   return nullptr;
1593 }
1594
1595 // This is a public function, declared in WinEHFuncInfo.h and is also
1596 // referenced by WinEHNumbering in FunctionLoweringInfo.cpp.
1597 void llvm::parseEHActions(const IntrinsicInst *II,
1598   SmallVectorImpl<ActionHandler *> &Actions) {
1599   for (unsigned I = 0, E = II->getNumArgOperands(); I != E;) {
1600     uint64_t ActionKind =
1601       cast<ConstantInt>(II->getArgOperand(I))->getZExtValue();
1602     if (ActionKind == /*catch=*/1) {
1603       auto *Selector = cast<Constant>(II->getArgOperand(I + 1));
1604       ConstantInt *EHObjIndex = cast<ConstantInt>(II->getArgOperand(I + 2));
1605       int64_t EHObjIndexVal = EHObjIndex->getSExtValue();
1606       Constant *Handler = cast<Constant>(II->getArgOperand(I + 3));
1607       I += 4;
1608       auto *CH = new CatchHandler(/*BB=*/nullptr, Selector, /*NextBB=*/nullptr);
1609       CH->setHandlerBlockOrFunc(Handler);
1610       CH->setExceptionVarIndex(EHObjIndexVal);
1611       Actions.push_back(CH);
1612     }
1613     else {
1614       assert(ActionKind == 0 && "expected a cleanup or a catch action!");
1615       Constant *Handler = cast<Constant>(II->getArgOperand(I + 1));
1616       I += 2;
1617       auto *CH = new CleanupHandler(/*BB=*/nullptr);
1618       CH->setHandlerBlockOrFunc(Handler);
1619       Actions.push_back(CH);
1620     }
1621   }
1622   std::reverse(Actions.begin(), Actions.end());
1623 }
1624