llvm.patch

diff --git a/llvm/lib/CodeGen/DwarfEHPrepare.cpp b/llvm/lib/CodeGen/DwarfEHPrepare.cpp
index 5ca1e91cc5f4..fde7b942665d 100644
--- a/llvm/lib/CodeGen/DwarfEHPrepare.cpp
+++ b/llvm/lib/CodeGen/DwarfEHPrepare.cpp
@@ -1,350 +1,355 @@
 //===- DwarfEHPrepare - Prepare exception handling for code generation ----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This pass mulches exception handling code into a form adapted to code
 // generation. Required if using dwarf exception handling.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/CFG.h"
 #include "llvm/Analysis/DomTreeUpdater.h"
 #include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/CodeGen/RuntimeLibcalls.h"
 #include "llvm/CodeGen/TargetLowering.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include <cstddef>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "dwarfehprepare"
 
 STATISTIC(NumResumesLowered, "Number of resume calls lowered");
 STATISTIC(NumCleanupLandingPadsUnreachable,
           "Number of cleanup landing pads found unreachable");
 STATISTIC(NumCleanupLandingPadsRemaining,
           "Number of cleanup landing pads remaining");
 STATISTIC(NumNoUnwind, "Number of functions with nounwind");
 STATISTIC(NumUnwind, "Number of functions with unwind");
 
 namespace {
 
 class DwarfEHPrepare {
   CodeGenOpt::Level OptLevel;
 
   // RewindFunction - _Unwind_Resume or the target equivalent.
   FunctionCallee &RewindFunction;
 
   Function &F;
   const TargetLowering &TLI;
   DomTreeUpdater *DTU;
   const TargetTransformInfo *TTI;
 
   /// Return the exception object from the value passed into
   /// the 'resume' instruction (typically an aggregate). Clean up any dead
   /// instructions, including the 'resume' instruction.
   Value *GetExceptionObject(ResumeInst *RI);
 
   /// Replace resumes that are not reachable from a cleanup landing pad with
   /// unreachable and then simplify those blocks.
   size_t
   pruneUnreachableResumes(SmallVectorImpl<ResumeInst *> &Resumes,
                           SmallVectorImpl<LandingPadInst *> &CleanupLPads);
 
   /// Convert the ResumeInsts that are still present
   /// into calls to the appropriate _Unwind_Resume function.
   bool InsertUnwindResumeCalls();
 
 public:
   DwarfEHPrepare(CodeGenOpt::Level OptLevel_, FunctionCallee &RewindFunction_,
                  Function &F_, const TargetLowering &TLI_, DomTreeUpdater *DTU_,
                  const TargetTransformInfo *TTI_)
       : OptLevel(OptLevel_), RewindFunction(RewindFunction_), F(F_), TLI(TLI_),
         DTU(DTU_), TTI(TTI_) {}
 
   bool run();
 };
 
 } // namespace
 
 Value *DwarfEHPrepare::GetExceptionObject(ResumeInst *RI) {
   Value *V = RI->getOperand(0);
   Value *ExnObj = nullptr;
   InsertValueInst *SelIVI = dyn_cast<InsertValueInst>(V);
   LoadInst *SelLoad = nullptr;
   InsertValueInst *ExcIVI = nullptr;
   bool EraseIVIs = false;
 
   if (SelIVI) {
     if (SelIVI->getNumIndices() == 1 && *SelIVI->idx_begin() == 1) {
       ExcIVI = dyn_cast<InsertValueInst>(SelIVI->getOperand(0));
       if (ExcIVI && isa<UndefValue>(ExcIVI->getOperand(0)) &&
           ExcIVI->getNumIndices() == 1 && *ExcIVI->idx_begin() == 0) {
         ExnObj = ExcIVI->getOperand(1);
         SelLoad = dyn_cast<LoadInst>(SelIVI->getOperand(1));
         EraseIVIs = true;
       }
     }
   }
 
   if (!ExnObj)
     ExnObj = ExtractValueInst::Create(RI->getOperand(0), 0, "exn.obj", RI);
 
   RI->eraseFromParent();
 
   if (EraseIVIs) {
     if (SelIVI->use_empty())
       SelIVI->eraseFromParent();
     if (ExcIVI->use_empty())
       ExcIVI->eraseFromParent();
     if (SelLoad && SelLoad->use_empty())
       SelLoad->eraseFromParent();
   }
 
   return ExnObj;
 }
 
 size_t DwarfEHPrepare::pruneUnreachableResumes(
     SmallVectorImpl<ResumeInst *> &Resumes,
     SmallVectorImpl<LandingPadInst *> &CleanupLPads) {
   assert(DTU && "Should have DomTreeUpdater here.");
 
   BitVector ResumeReachable(Resumes.size());
   size_t ResumeIndex = 0;
   for (auto *RI : Resumes) {
     for (auto *LP : CleanupLPads) {
       if (isPotentiallyReachable(LP, RI, nullptr, &DTU->getDomTree())) {
         ResumeReachable.set(ResumeIndex);
         break;
       }
     }
     ++ResumeIndex;
   }
 
   // If everything is reachable, there is no change.
   if (ResumeReachable.all())
     return Resumes.size();
 
   LLVMContext &Ctx = F.getContext();
 
   // Otherwise, insert unreachable instructions and call simplifycfg.
   size_t ResumesLeft = 0;
   for (size_t I = 0, E = Resumes.size(); I < E; ++I) {
     ResumeInst *RI = Resumes[I];
     if (ResumeReachable[I]) {
       Resumes[ResumesLeft++] = RI;
     } else {
       BasicBlock *BB = RI->getParent();
       new UnreachableInst(Ctx, RI);
       RI->eraseFromParent();
       simplifyCFG(BB, *TTI, DTU);
     }
   }
   Resumes.resize(ResumesLeft);
   return ResumesLeft;
 }
 
 bool DwarfEHPrepare::InsertUnwindResumeCalls() {
   SmallVector<ResumeInst *, 16> Resumes;
   SmallVector<LandingPadInst *, 16> CleanupLPads;
   if (F.doesNotThrow())
     NumNoUnwind++;
   else
     NumUnwind++;
   for (BasicBlock &BB : F) {
     if (auto *RI = dyn_cast<ResumeInst>(BB.getTerminator()))
       Resumes.push_back(RI);
     if (auto *LP = BB.getLandingPadInst())
       if (LP->isCleanup())
         CleanupLPads.push_back(LP);
   }
 
   NumCleanupLandingPadsRemaining += CleanupLPads.size();
 
   if (Resumes.empty())
     return false;
 
   // Check the personality, don't do anything if it's scope-based.
   EHPersonality Pers = classifyEHPersonality(F.getPersonalityFn());
   if (isScopedEHPersonality(Pers))
     return false;
 
   LLVMContext &Ctx = F.getContext();
 
   size_t ResumesLeft = Resumes.size();
   if (OptLevel != CodeGenOpt::None) {
     ResumesLeft = pruneUnreachableResumes(Resumes, CleanupLPads);
 #if LLVM_ENABLE_STATS
     unsigned NumRemainingLPs = 0;
     for (BasicBlock &BB : F) {
       if (auto *LP = BB.getLandingPadInst())
         if (LP->isCleanup())
           NumRemainingLPs++;
     }
     NumCleanupLandingPadsUnreachable += CleanupLPads.size() - NumRemainingLPs;
     NumCleanupLandingPadsRemaining -= CleanupLPads.size() - NumRemainingLPs;
 #endif
   }
 
   if (ResumesLeft == 0)
     return true; // We pruned them all.
 
   // Find the rewind function if we didn't already.
   if (!RewindFunction) {
     FunctionType *FTy =
         FunctionType::get(Type::getVoidTy(Ctx), Type::getInt8PtrTy(Ctx), false);
     const char *RewindName = TLI.getLibcallName(RTLIB::UNWIND_RESUME);
     RewindFunction = F.getParent()->getOrInsertFunction(RewindName, FTy);
   }
 
   // Create the basic block where the _Unwind_Resume call will live.
   if (ResumesLeft == 1) {
     // Instead of creating a new BB and PHI node, just append the call to
     // _Unwind_Resume to the end of the single resume block.
     ResumeInst *RI = Resumes.front();
     BasicBlock *UnwindBB = RI->getParent();
     Value *ExnObj = GetExceptionObject(RI);
 
     // Call the _Unwind_Resume function.
     CallInst *CI = CallInst::Create(RewindFunction, ExnObj, "", UnwindBB);
     CI->setCallingConv(TLI.getLibcallCallingConv(RTLIB::UNWIND_RESUME));
 
     // We never expect _Unwind_Resume to return.
     CI->setDoesNotReturn();
     new UnreachableInst(Ctx, UnwindBB);
     return true;
   }
 
   std::vector<DominatorTree::UpdateType> Updates;
   Updates.reserve(Resumes.size());
 
   BasicBlock *UnwindBB = BasicBlock::Create(Ctx, "unwind_resume", &F);
   PHINode *PN = PHINode::Create(Type::getInt8PtrTy(Ctx), ResumesLeft, "exn.obj",
                                 UnwindBB);
 
   // Extract the exception object from the ResumeInst and add it to the PHI node
   // that feeds the _Unwind_Resume call.
   for (ResumeInst *RI : Resumes) {
     BasicBlock *Parent = RI->getParent();
     BranchInst::Create(UnwindBB, Parent);
     Updates.push_back({DominatorTree::Insert, Parent, UnwindBB});
 
     Value *ExnObj = GetExceptionObject(RI);
     PN->addIncoming(ExnObj, Parent);
 
     ++NumResumesLowered;
   }
 
   // Call the function.
   CallInst *CI = CallInst::Create(RewindFunction, PN, "", UnwindBB);
   CI->setCallingConv(TLI.getLibcallCallingConv(RTLIB::UNWIND_RESUME));
 
   // We never expect _Unwind_Resume to return.
   CI->setDoesNotReturn();
   new UnreachableInst(Ctx, UnwindBB);
 
   if (DTU)
     DTU->applyUpdates(Updates);
 
   return true;
 }
 
 bool DwarfEHPrepare::run() {
   bool Changed = InsertUnwindResumeCalls();
 
   return Changed;
 }
 
 static bool prepareDwarfEH(CodeGenOpt::Level OptLevel,
                            FunctionCallee &RewindFunction, Function &F,
                            const TargetLowering &TLI, DominatorTree *DT,
                            const TargetTransformInfo *TTI) {
   DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Lazy);
 
   return DwarfEHPrepare(OptLevel, RewindFunction, F, TLI, DT ? &DTU : nullptr,
                         TTI)
       .run();
 }
 
 namespace {
 
 class DwarfEHPrepareLegacyPass : public FunctionPass {
   // RewindFunction - _Unwind_Resume or the target equivalent.
   FunctionCallee RewindFunction = nullptr;
 
   CodeGenOpt::Level OptLevel;
 
 public:
   static char ID; // Pass identification, replacement for typeid.
 
   DwarfEHPrepareLegacyPass(CodeGenOpt::Level OptLevel = CodeGenOpt::Default)
       : FunctionPass(ID), OptLevel(OptLevel) {}
 
   bool runOnFunction(Function &F) override {
     const TargetMachine &TM =
         getAnalysis<TargetPassConfig>().getTM<TargetMachine>();
     const TargetLowering &TLI = *TM.getSubtargetImpl(F)->getTargetLowering();
     DominatorTree *DT = nullptr;
     const TargetTransformInfo *TTI = nullptr;
     if (auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>())
       DT = &DTWP->getDomTree();
     if (OptLevel != CodeGenOpt::None) {
       if (!DT)
         DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
       TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
     }
     return prepareDwarfEH(OptLevel, RewindFunction, F, TLI, DT, TTI);
   }
 
+  bool doFinalization(Module &M) override {
+    RewindFunction = nullptr;
+    return false;
+  }
+
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<TargetPassConfig>();
     AU.addRequired<TargetTransformInfoWrapperPass>();
     if (OptLevel != CodeGenOpt::None) {
       AU.addRequired<DominatorTreeWrapperPass>();
       AU.addRequired<TargetTransformInfoWrapperPass>();
     }
     AU.addPreserved<DominatorTreeWrapperPass>();
   }
 
   StringRef getPassName() const override {
     return "Exception handling preparation";
   }
 };
 
 } // end anonymous namespace
 
 char DwarfEHPrepareLegacyPass::ID = 0;
 
 INITIALIZE_PASS_BEGIN(DwarfEHPrepareLegacyPass, DEBUG_TYPE,
                       "Prepare DWARF exceptions", false, false)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TargetPassConfig)
 INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
 INITIALIZE_PASS_END(DwarfEHPrepareLegacyPass, DEBUG_TYPE,
                     "Prepare DWARF exceptions", false, false)
 
 FunctionPass *llvm::createDwarfEHPass(CodeGenOpt::Level OptLevel) {
   return new DwarfEHPrepareLegacyPass(OptLevel);
 }
diff --git a/llvm/test/CodeGen/X86/dwarf-eh-prepare.ll b/llvm/test/CodeGen/X86/dwarf-eh-prepare.ll
index 921f4f9a7d85..c54fdfceea4b 100644
--- a/llvm/test/CodeGen/X86/dwarf-eh-prepare.ll
+++ b/llvm/test/CodeGen/X86/dwarf-eh-prepare.ll
@@ -1,158 +1,158 @@
-; RUN: opt -mtriple=x86_64-linux-gnu -dwarfehprepare -simplifycfg-require-and-preserve-domtree=1 < %s -S | FileCheck %s
+; RUN: opt -mtriple=x86_64-linux-gnu -dwarfehprepare -simplifycfg-require-and-preserve-domtree=1 -run-twice < %s -S | FileCheck %s
 
 ; Check basic functionality of IR-to-IR DWARF EH preparation. This should
 ; eliminate resumes. This pass requires a TargetMachine, so we put it under X86
 ; and provide an x86 triple.
 
 @int_typeinfo = global i8 0
 
 declare void @might_throw()
 declare void @cleanup()
 
 define i32 @simple_cleanup_catch() personality i32 (...)* @__gxx_personality_v0 {
   invoke void @might_throw()
           to label %cont unwind label %lpad
 
 ; CHECK-LABEL: define i32 @simple_cleanup_catch()
 ; CHECK: invoke void @might_throw()
 
 cont:
   ret i32 0
 
 ; CHECK: ret i32 0
 
 lpad:
   %ehvals = landingpad { i8*, i32 }
       cleanup
       catch i8* @int_typeinfo
   %ehptr = extractvalue { i8*, i32 } %ehvals, 0
   %ehsel = extractvalue { i8*, i32 } %ehvals, 1
   call void @cleanup()
   %int_sel = call i32 @llvm.eh.typeid.for(i8* @int_typeinfo)
   %int_match = icmp eq i32 %ehsel, %int_sel
   br i1 %int_match, label %catch_int, label %eh.resume
 
 ; CHECK: lpad:
 ; CHECK: landingpad { i8*, i32 }
 ; CHECK: call void @cleanup()
 ; CHECK: call i32 @llvm.eh.typeid.for
 ; CHECK: br i1
 
 catch_int:
   ret i32 1
 
 ; CHECK: catch_int:
 ; CHECK: ret i32 1
 
 eh.resume:
   %tmp_ehvals = insertvalue { i8*, i32 } undef, i8* %ehptr, 0
   %new_ehvals = insertvalue { i8*, i32 } %tmp_ehvals, i32 %ehsel, 1
   resume { i8*, i32 } %new_ehvals
 
 ; CHECK: eh.resume:
 ; CHECK-NEXT: call void @_Unwind_Resume(i8* %ehptr)
 }
 
 
 define i32 @catch_no_resume() personality i32 (...)* @__gxx_personality_v0 {
   invoke void @might_throw()
           to label %cont unwind label %lpad
 
 cont:
   ret i32 0
 
 lpad:
   %ehvals = landingpad { i8*, i32 }
       catch i8* @int_typeinfo
   %ehptr = extractvalue { i8*, i32 } %ehvals, 0
   %ehsel = extractvalue { i8*, i32 } %ehvals, 1
   %int_sel = call i32 @llvm.eh.typeid.for(i8* @int_typeinfo)
   %int_match = icmp eq i32 %ehsel, %int_sel
   br i1 %int_match, label %catch_int, label %eh.resume
 
 catch_int:
   ret i32 1
 
 eh.resume:
   %tmp_ehvals = insertvalue { i8*, i32 } undef, i8* %ehptr, 0
   %new_ehvals = insertvalue { i8*, i32 } %tmp_ehvals, i32 %ehsel, 1
   resume { i8*, i32 } %new_ehvals
 }
 
 ; Check that we can prune the unreachable resume instruction.
 
 ; CHECK-LABEL: define i32 @catch_no_resume() personality i32 (...)* @__gxx_personality_v0 {
 ; CHECK: invoke void @might_throw()
 ; CHECK: ret i32 0
 ; CHECK: lpad:
 ; CHECK: landingpad { i8*, i32 }
 ; CHECK-NOT: br i1
 ; CHECK: ret i32 1
 ; CHECK-NOT: call void @_Unwind_Resume
 ; CHECK: {{^[}]}}
 
 
 define i32 @catch_cleanup_merge() personality i32 (...)* @__gxx_personality_v0 {
   invoke void @might_throw()
           to label %inner_invoke unwind label %outer_lpad
 inner_invoke:
   invoke void @might_throw()
           to label %cont unwind label %inner_lpad
 cont:
   ret i32 0
 
 outer_lpad:
   %ehvals1 = landingpad { i8*, i32 }
       catch i8* @int_typeinfo
   br label %catch.dispatch
 
 inner_lpad:
   %ehvals2 = landingpad { i8*, i32 }
       cleanup
       catch i8* @int_typeinfo
   call void @cleanup()
   br label %catch.dispatch
 
 catch.dispatch:
   %ehvals = phi { i8*, i32 } [ %ehvals1, %outer_lpad ], [ %ehvals2, %inner_lpad ]
   %ehptr = extractvalue { i8*, i32 } %ehvals, 0
   %ehsel = extractvalue { i8*, i32 } %ehvals, 1
   %int_sel = call i32 @llvm.eh.typeid.for(i8* @int_typeinfo)
   %int_match = icmp eq i32 %ehsel, %int_sel
   br i1 %int_match, label %catch_int, label %eh.resume
 
 catch_int:
   ret i32 1
 
 eh.resume:
   %tmp_ehvals = insertvalue { i8*, i32 } undef, i8* %ehptr, 0
   %new_ehvals = insertvalue { i8*, i32 } %tmp_ehvals, i32 %ehsel, 1
   resume { i8*, i32 } %new_ehvals
 }
 
 ; We can't prune this merge because one landingpad is a cleanup pad.
 
 ; CHECK-LABEL: define i32 @catch_cleanup_merge()
 ; CHECK: invoke void @might_throw()
 ; CHECK: invoke void @might_throw()
 ; CHECK: ret i32 0
 ;
 ; CHECK: outer_lpad:
 ; CHECK: landingpad { i8*, i32 }
 ; CHECK: br label %catch.dispatch
 ;
 ; CHECK: inner_lpad:
 ; CHECK: landingpad { i8*, i32 }
 ; CHECK: call void @cleanup()
 ; CHECK: br label %catch.dispatch
 ;
 ; CHECK: catch.dispatch:
 ; CHECK: call i32 @llvm.eh.typeid.for
 ; CHECK: br i1
 ; CHECK: catch_int:
 ; CHECK: ret i32 1
 ; CHECK: eh.resume:
 ; CHECK-NEXT: call void @_Unwind_Resume(i8* %ehptr)
 
 declare i32 @__gxx_personality_v0(...)
 declare i32 @llvm.eh.typeid.for(i8*)