src/LLVM/lib/VMCore/AutoUpgrade.cpp

//===-- AutoUpgrade.cpp - Implement auto-upgrade helper functions ---------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the auto-upgrade helper functions 
//
//===----------------------------------------------------------------------===//

#include "llvm/AutoUpgrade.h"
#include "llvm/Constants.h"
#include "llvm/Function.h"
#include "llvm/Instruction.h"
#include "llvm/LLVMContext.h"
#include "llvm/Module.h"
#include "llvm/IntrinsicInst.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/CallSite.h"
#include "llvm/Support/CFG.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/IRBuilder.h"
#include <cstring>
using namespace llvm;


static bool UpgradeIntrinsicFunction1(Function *F, Function *&NewFn) {
  assert(F && "Illegal to upgrade a non-existent Function.");

  // Quickly eliminate it, if it's not a candidate.
  StringRef Name = F->getName();
  if (Name.size() <= 8 || !Name.startswith("llvm."))
    return false;
  Name = Name.substr(5); // Strip off "llvm."

  FunctionType *FTy = F->getFunctionType();
  Module *M = F->getParent();
  
  switch (Name[0]) {
  default: break;
  case 'a':
    if (Name.startswith("atomic.cmp.swap") ||
        Name.startswith("atomic.swap") ||
        Name.startswith("atomic.load.add") ||
        Name.startswith("atomic.load.sub") ||
        Name.startswith("atomic.load.and") ||
        Name.startswith("atomic.load.nand") ||
        Name.startswith("atomic.load.or") ||
        Name.startswith("atomic.load.xor") ||
        Name.startswith("atomic.load.max") ||
        Name.startswith("atomic.load.min") ||
        Name.startswith("atomic.load.umax") ||
        Name.startswith("atomic.load.umin"))
      return true;
  case 'i':
    //  This upgrades the old llvm.init.trampoline to the new
    //  llvm.init.trampoline and llvm.adjust.trampoline pair.
    if (Name == "init.trampoline") {
      // The new llvm.init.trampoline returns nothing.
      if (FTy->getReturnType()->isVoidTy())
        break;

      assert(FTy->getNumParams() == 3 && "old init.trampoline takes 3 args!");

      // Change the name of the old intrinsic so that we can play with its type.
      std::string NameTmp = F->getName();
      F->setName("");
      NewFn = cast<Function>(M->getOrInsertFunction(
                               NameTmp,
                               Type::getVoidTy(M->getContext()),
                               FTy->getParamType(0), FTy->getParamType(1),
                               FTy->getParamType(2), (Type *)0));
      return true;
    }
  case 'm':
    if (Name == "memory.barrier")
      return true;
  case 'p':
    //  This upgrades the llvm.prefetch intrinsic to accept one more parameter,
    //  which is a instruction / data cache identifier. The old version only
    //  implicitly accepted the data version.
    if (Name == "prefetch") {
      // Don't do anything if it has the correct number of arguments already
      if (FTy->getNumParams() == 4)
        break;

      assert(FTy->getNumParams() == 3 && "old prefetch takes 3 args!");
      //  We first need to change the name of the old (bad) intrinsic, because
      //  its type is incorrect, but we cannot overload that name. We
      //  arbitrarily unique it here allowing us to construct a correctly named
      //  and typed function below.
      std::string NameTmp = F->getName();
      F->setName("");
      NewFn = cast<Function>(M->getOrInsertFunction(NameTmp,
                                                    FTy->getReturnType(),
                                                    FTy->getParamType(0),
                                                    FTy->getParamType(1),
                                                    FTy->getParamType(2),
                                                    FTy->getParamType(2),
                                                    (Type*)0));
      return true;
    }

    break;
  case 'x': {
    const char *NewFnName = NULL;
    // This fixes the poorly named crc32 intrinsics.
    if (Name == "x86.sse42.crc32.8")
      NewFnName = "llvm.x86.sse42.crc32.32.8";
    else if (Name == "x86.sse42.crc32.16")
      NewFnName = "llvm.x86.sse42.crc32.32.16";
    else if (Name == "x86.sse42.crc32.32")
      NewFnName = "llvm.x86.sse42.crc32.32.32";
    else if (Name == "x86.sse42.crc64.8")
      NewFnName = "llvm.x86.sse42.crc32.64.8";
    else if (Name == "x86.sse42.crc64.64")
      NewFnName = "llvm.x86.sse42.crc32.64.64";
    
    if (NewFnName) {
      F->setName(NewFnName);
      NewFn = F;
      return true;
    }

    // Calls to these instructions are transformed into unaligned loads.
    if (Name == "x86.sse.loadu.ps" || Name == "x86.sse2.loadu.dq" ||
        Name == "x86.sse2.loadu.pd")
      return true;
      
    // Calls to these instructions are transformed into nontemporal stores.
    if (Name == "x86.sse.movnt.ps"  || Name == "x86.sse2.movnt.dq" ||
        Name == "x86.sse2.movnt.pd" || Name == "x86.sse2.movnt.i")
      return true;

    break;
  }
  }

  //  This may not belong here. This function is effectively being overloaded 
  //  to both detect an intrinsic which needs upgrading, and to provide the 
  //  upgraded form of the intrinsic. We should perhaps have two separate 
  //  functions for this.
  return false;
}

bool llvm::UpgradeIntrinsicFunction(Function *F, Function *&NewFn) {
  NewFn = 0;
  bool Upgraded = UpgradeIntrinsicFunction1(F, NewFn);

  // Upgrade intrinsic attributes.  This does not change the function.
  if (NewFn)
    F = NewFn;
  if (unsigned id = F->getIntrinsicID())
    F->setAttributes(Intrinsic::getAttributes((Intrinsic::ID)id));
  return Upgraded;
}

bool llvm::UpgradeGlobalVariable(GlobalVariable *GV) {
  // Nothing to do yet.
  return false;
}

// UpgradeIntrinsicCall - Upgrade a call to an old intrinsic to be a call the 
// upgraded intrinsic. All argument and return casting must be provided in 
// order to seamlessly integrate with existing context.
void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
  Function *F = CI->getCalledFunction();
  LLVMContext &C = CI->getContext();
  ImmutableCallSite CS(CI);

  assert(F && "CallInst has no function associated with it.");

  if (!NewFn) {
    if (F->getName() == "llvm.x86.sse.loadu.ps" ||
        F->getName() == "llvm.x86.sse2.loadu.dq" ||
        F->getName() == "llvm.x86.sse2.loadu.pd") {
      // Convert to a native, unaligned load.
      Type *VecTy = CI->getType();
      Type *IntTy = IntegerType::get(C, 128);
      IRBuilder<> Builder(C);
      Builder.SetInsertPoint(CI->getParent(), CI);

      Value *BC = Builder.CreateBitCast(CI->getArgOperand(0),
                                        PointerType::getUnqual(IntTy),
                                        "cast");
      LoadInst *LI = Builder.CreateLoad(BC, CI->getName());
      LI->setAlignment(1);      // Unaligned load.
      BC = Builder.CreateBitCast(LI, VecTy, "new.cast");

      // Fix up all the uses with our new load.
      if (!CI->use_empty())
        CI->replaceAllUsesWith(BC);

      // Remove intrinsic.
      CI->eraseFromParent();
    } else if (F->getName() == "llvm.x86.sse.movnt.ps" ||
               F->getName() == "llvm.x86.sse2.movnt.dq" ||
               F->getName() == "llvm.x86.sse2.movnt.pd" ||
               F->getName() == "llvm.x86.sse2.movnt.i") {
      IRBuilder<> Builder(C);
      Builder.SetInsertPoint(CI->getParent(), CI);

      Module *M = F->getParent();
      SmallVector<Value *, 1> Elts;
      Elts.push_back(ConstantInt::get(Type::getInt32Ty(C), 1));
      MDNode *Node = MDNode::get(C, Elts);

      Value *Arg0 = CI->getArgOperand(0);
      Value *Arg1 = CI->getArgOperand(1);

      // Convert the type of the pointer to a pointer to the stored type.
      Value *BC = Builder.CreateBitCast(Arg0,
                                        PointerType::getUnqual(Arg1->getType()),
                                        "cast");
      StoreInst *SI = Builder.CreateStore(Arg1, BC);
      SI->setMetadata(M->getMDKindID("nontemporal"), Node);
      SI->setAlignment(16);

      // Remove intrinsic.
      CI->eraseFromParent();
    } else if (F->getName().startswith("llvm.atomic.cmp.swap")) {
      IRBuilder<> Builder(C);
      Builder.SetInsertPoint(CI->getParent(), CI);
      Value *Val = Builder.CreateAtomicCmpXchg(CI->getArgOperand(0),
                                               CI->getArgOperand(1),
                                               CI->getArgOperand(2),
                                               Monotonic);

      // Replace intrinsic.
      Val->takeName(CI);
      if (!CI->use_empty())
        CI->replaceAllUsesWith(Val);
      CI->eraseFromParent();
    } else if (F->getName().startswith("llvm.atomic")) {
      IRBuilder<> Builder(C);
      Builder.SetInsertPoint(CI->getParent(), CI);

      AtomicRMWInst::BinOp Op;
      if (F->getName().startswith("llvm.atomic.swap"))
        Op = AtomicRMWInst::Xchg;
      else if (F->getName().startswith("llvm.atomic.load.add"))
        Op = AtomicRMWInst::Add;
      else if (F->getName().startswith("llvm.atomic.load.sub"))
        Op = AtomicRMWInst::Sub;
      else if (F->getName().startswith("llvm.atomic.load.and"))
        Op = AtomicRMWInst::And;
      else if (F->getName().startswith("llvm.atomic.load.nand"))
        Op = AtomicRMWInst::Nand;
      else if (F->getName().startswith("llvm.atomic.load.or"))
        Op = AtomicRMWInst::Or;
      else if (F->getName().startswith("llvm.atomic.load.xor"))
        Op = AtomicRMWInst::Xor;
      else if (F->getName().startswith("llvm.atomic.load.max"))
        Op = AtomicRMWInst::Max;
      else if (F->getName().startswith("llvm.atomic.load.min"))
        Op = AtomicRMWInst::Min;
      else if (F->getName().startswith("llvm.atomic.load.umax"))
        Op = AtomicRMWInst::UMax;
      else if (F->getName().startswith("llvm.atomic.load.umin"))
        Op = AtomicRMWInst::UMin;
      else
        llvm_unreachable("Unknown atomic");

      Value *Val = Builder.CreateAtomicRMW(Op, CI->getArgOperand(0),
                                           CI->getArgOperand(1),
                                           Monotonic);

      // Replace intrinsic.
      Val->takeName(CI);
      if (!CI->use_empty())
        CI->replaceAllUsesWith(Val);
      CI->eraseFromParent();
    } else if (F->getName() == "llvm.memory.barrier") {
      IRBuilder<> Builder(C);
      Builder.SetInsertPoint(CI->getParent(), CI);

      // Note that this conversion ignores the "device" bit; it was not really
      // well-defined, and got abused because nobody paid enough attention to
      // get it right. In practice, this probably doesn't matter; application
      // code generally doesn't need anything stronger than
      // SequentiallyConsistent (and realistically, SequentiallyConsistent
      // is lowered to a strong enough barrier for almost anything).

      if (cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue())
        Builder.CreateFence(SequentiallyConsistent);
      else if (!cast<ConstantInt>(CI->getArgOperand(0))->getZExtValue())
        Builder.CreateFence(Release);
      else if (!cast<ConstantInt>(CI->getArgOperand(3))->getZExtValue())
        Builder.CreateFence(Acquire);
      else
        Builder.CreateFence(AcquireRelease);

      // Remove intrinsic.
      CI->eraseFromParent();
    } else {
      llvm_unreachable("Unknown function for CallInst upgrade.");
    }
    return;
  }

  switch (NewFn->getIntrinsicID()) {
  case Intrinsic::prefetch: {
    IRBuilder<> Builder(C);
    Builder.SetInsertPoint(CI->getParent(), CI);
    llvm::Type *I32Ty = llvm::Type::getInt32Ty(CI->getContext());

    // Add the extra "data cache" argument
    Value *Operands[4] = { CI->getArgOperand(0), CI->getArgOperand(1),
                           CI->getArgOperand(2),
                           llvm::ConstantInt::get(I32Ty, 1) };
    CallInst *NewCI = CallInst::Create(NewFn, Operands,
                                       CI->getName(), CI);
    NewCI->setTailCall(CI->isTailCall());
    NewCI->setCallingConv(CI->getCallingConv());
    //  Handle any uses of the old CallInst.
    if (!CI->use_empty())
      //  Replace all uses of the old call with the new cast which has the
      //  correct type.
      CI->replaceAllUsesWith(NewCI);

    //  Clean up the old call now that it has been completely upgraded.
    CI->eraseFromParent();
    break;
  }
  case Intrinsic::init_trampoline: {

    //  Transform
    //    %tramp = call i8* llvm.init.trampoline (i8* x, i8* y, i8* z)
    //  to
    //    call void llvm.init.trampoline (i8* %x, i8* %y, i8* %z)
    //    %tramp = call i8* llvm.adjust.trampoline (i8* %x)

    Function *AdjustTrampolineFn =
      cast<Function>(Intrinsic::getDeclaration(F->getParent(),
                                               Intrinsic::adjust_trampoline));

    IRBuilder<> Builder(C);
    Builder.SetInsertPoint(CI);

    Builder.CreateCall3(NewFn, CI->getArgOperand(0), CI->getArgOperand(1),
                        CI->getArgOperand(2));

    CallInst *AdjustCall = Builder.CreateCall(AdjustTrampolineFn,
                                              CI->getArgOperand(0),
                                              CI->getName());
    if (!CI->use_empty())
      CI->replaceAllUsesWith(AdjustCall);
    CI->eraseFromParent();
    break;
  }
  }
}

// This tests each Function to determine if it needs upgrading. When we find 
// one we are interested in, we then upgrade all calls to reflect the new 
// function.
void llvm::UpgradeCallsToIntrinsic(Function* F) {
  assert(F && "Illegal attempt to upgrade a non-existent intrinsic.");

  // Upgrade the function and check if it is a totaly new function.
  Function *NewFn;
  if (UpgradeIntrinsicFunction(F, NewFn)) {
    if (NewFn != F) {
      // Replace all uses to the old function with the new one if necessary.
      for (Value::use_iterator UI = F->use_begin(), UE = F->use_end();
           UI != UE; ) {
        if (CallInst *CI = dyn_cast<CallInst>(*UI++))
          UpgradeIntrinsicCall(CI, NewFn);
      }
      // Remove old function, no longer used, from the module.
      F->eraseFromParent();
    }
  }
}

/// This function strips all debug info intrinsics, except for llvm.dbg.declare.
/// If an llvm.dbg.declare intrinsic is invalid, then this function simply
/// strips that use.
void llvm::CheckDebugInfoIntrinsics(Module *M) {
  if (Function *FuncStart = M->getFunction("llvm.dbg.func.start")) {
    while (!FuncStart->use_empty())
      cast<CallInst>(FuncStart->use_back())->eraseFromParent();
    FuncStart->eraseFromParent();
  }
  
  if (Function *StopPoint = M->getFunction("llvm.dbg.stoppoint")) {
    while (!StopPoint->use_empty())
      cast<CallInst>(StopPoint->use_back())->eraseFromParent();
    StopPoint->eraseFromParent();
  }

  if (Function *RegionStart = M->getFunction("llvm.dbg.region.start")) {
    while (!RegionStart->use_empty())
      cast<CallInst>(RegionStart->use_back())->eraseFromParent();
    RegionStart->eraseFromParent();
  }

  if (Function *RegionEnd = M->getFunction("llvm.dbg.region.end")) {
    while (!RegionEnd->use_empty())
      cast<CallInst>(RegionEnd->use_back())->eraseFromParent();
    RegionEnd->eraseFromParent();
  }
  
  if (Function *Declare = M->getFunction("llvm.dbg.declare")) {
    if (!Declare->use_empty()) {
      DbgDeclareInst *DDI = cast<DbgDeclareInst>(Declare->use_back());
      if (!isa<MDNode>(DDI->getArgOperand(0)) ||
          !isa<MDNode>(DDI->getArgOperand(1))) {
        while (!Declare->use_empty()) {
          CallInst *CI = cast<CallInst>(Declare->use_back());
          CI->eraseFromParent();
        }
        Declare->eraseFromParent();
      }
    }
  }
}

/// FindExnAndSelIntrinsics - Find the eh_exception and eh_selector intrinsic
/// calls reachable from the unwind basic block.
static void FindExnAndSelIntrinsics(BasicBlock *BB, CallInst *&Exn,
                                    CallInst *&Sel,
                                    SmallPtrSet<BasicBlock*, 8> &Visited) {
  if (!Visited.insert(BB)) return;

  for (BasicBlock::iterator
         I = BB->begin(), E = BB->end(); I != E; ++I) {
    if (CallInst *CI = dyn_cast<CallInst>(I)) {
      switch (CI->getCalledFunction()->getIntrinsicID()) {
      default: break;
      case Intrinsic::eh_exception:
        assert(!Exn && "Found more than one eh.exception call!");
        Exn = CI;
        break;
      case Intrinsic::eh_selector:
        assert(!Sel && "Found more than one eh.selector call!");
        Sel = CI;
        break;
      }

      if (Exn && Sel) return;
    }
  }

  if (Exn && Sel) return;

  for (succ_iterator I = succ_begin(BB), E = succ_end(BB); I != E; ++I) {
    FindExnAndSelIntrinsics(*I, Exn, Sel, Visited);
    if (Exn && Sel) return;
  }
}

/// TransferClausesToLandingPadInst - Transfer the exception handling clauses
/// from the eh_selector call to the new landingpad instruction.
static void TransferClausesToLandingPadInst(LandingPadInst *LPI,
                                            CallInst *EHSel) {
  LLVMContext &Context = LPI->getContext();
  unsigned N = EHSel->getNumArgOperands();

  for (unsigned i = N - 1; i > 1; --i) {
    if (const ConstantInt *CI = dyn_cast<ConstantInt>(EHSel->getArgOperand(i))){
      unsigned FilterLength = CI->getZExtValue();
      unsigned FirstCatch = i + FilterLength + !FilterLength;
      assert(FirstCatch <= N && "Invalid filter length");

      if (FirstCatch < N)
        for (unsigned j = FirstCatch; j < N; ++j) {
          Value *Val = EHSel->getArgOperand(j);
          if (!Val->hasName() || Val->getName() != "llvm.eh.catch.all.value") {
            LPI->addClause(EHSel->getArgOperand(j));
          } else {
            GlobalVariable *GV = cast<GlobalVariable>(Val);
            LPI->addClause(GV->getInitializer());
          }
        }

      if (!FilterLength) {
        // Cleanup.
        LPI->setCleanup(true);
      } else {
        // Filter.
        SmallVector<Constant *, 4> TyInfo;
        TyInfo.reserve(FilterLength - 1);
        for (unsigned j = i + 1; j < FirstCatch; ++j)
          TyInfo.push_back(cast<Constant>(EHSel->getArgOperand(j)));
        ArrayType *AType =
          ArrayType::get(!TyInfo.empty() ? TyInfo[0]->getType() :
                         PointerType::getUnqual(Type::getInt8Ty(Context)),
                         TyInfo.size());
        LPI->addClause(ConstantArray::get(AType, TyInfo));
      }

      N = i;
    }
  }

  if (N > 2)
    for (unsigned j = 2; j < N; ++j) {
      Value *Val = EHSel->getArgOperand(j);
      if (!Val->hasName() || Val->getName() != "llvm.eh.catch.all.value") {
        LPI->addClause(EHSel->getArgOperand(j));
      } else {
        GlobalVariable *GV = cast<GlobalVariable>(Val);
        LPI->addClause(GV->getInitializer());
      }
    }
}

/// This function upgrades the old pre-3.0 exception handling system to the new
/// one. N.B. This will be removed in 3.1.
void llvm::UpgradeExceptionHandling(Module *M) {
  Function *EHException = M->getFunction("llvm.eh.exception");
  Function *EHSelector = M->getFunction("llvm.eh.selector");
  if (!EHException || !EHSelector)
    return;

  LLVMContext &Context = M->getContext();
  Type *ExnTy = PointerType::getUnqual(Type::getInt8Ty(Context));
  Type *SelTy = Type::getInt32Ty(Context);
  Type *LPadSlotTy = StructType::get(ExnTy, SelTy, NULL);

  // This map links the invoke instruction with the eh.exception and eh.selector
  // calls associated with it.
  DenseMap<InvokeInst*, std::pair<Value*, Value*> > InvokeToIntrinsicsMap;
  for (Module::iterator
         I = M->begin(), E = M->end(); I != E; ++I) {
    Function &F = *I;

    for (Function::iterator
           II = F.begin(), IE = F.end(); II != IE; ++II) {
      BasicBlock *BB = &*II;
      InvokeInst *Inst = dyn_cast<InvokeInst>(BB->getTerminator());
      if (!Inst) continue;
      BasicBlock *UnwindDest = Inst->getUnwindDest();
      if (UnwindDest->isLandingPad()) continue; // Already converted.

      SmallPtrSet<BasicBlock*, 8> Visited;
      CallInst *Exn = 0;
      CallInst *Sel = 0;
      FindExnAndSelIntrinsics(UnwindDest, Exn, Sel, Visited);
      assert(Exn && Sel && "Cannot find eh.exception and eh.selector calls!");
      InvokeToIntrinsicsMap[Inst] = std::make_pair(Exn, Sel);
    }
  }

  // This map stores the slots where the exception object and selector value are
  // stored within a function.
  DenseMap<Function*, std::pair<Value*, Value*> > FnToLPadSlotMap;
  SmallPtrSet<Instruction*, 32> DeadInsts;
  for (DenseMap<InvokeInst*, std::pair<Value*, Value*> >::iterator
         I = InvokeToIntrinsicsMap.begin(), E = InvokeToIntrinsicsMap.end();
       I != E; ++I) {
    InvokeInst *Invoke = I->first;
    BasicBlock *UnwindDest = Invoke->getUnwindDest();
    Function *F = UnwindDest->getParent();
    std::pair<Value*, Value*> EHIntrinsics = I->second;
    CallInst *Exn = cast<CallInst>(EHIntrinsics.first);
    CallInst *Sel = cast<CallInst>(EHIntrinsics.second);

    // Store the exception object and selector value in the entry block.
    Value *ExnSlot = 0;
    Value *SelSlot = 0;
    if (!FnToLPadSlotMap[F].first) {
      BasicBlock *Entry = &F->front();
      ExnSlot = new AllocaInst(ExnTy, "exn", Entry->getTerminator());
      SelSlot = new AllocaInst(SelTy, "sel", Entry->getTerminator());
      FnToLPadSlotMap[F] = std::make_pair(ExnSlot, SelSlot);
    } else {
      ExnSlot = FnToLPadSlotMap[F].first;
      SelSlot = FnToLPadSlotMap[F].second;
    }

    if (!UnwindDest->getSinglePredecessor()) {
      // The unwind destination doesn't have a single predecessor. Create an
      // unwind destination which has only one predecessor.
      BasicBlock *NewBB = BasicBlock::Create(Context, "new.lpad",
                                             UnwindDest->getParent());
      BranchInst::Create(UnwindDest, NewBB);
      Invoke->setUnwindDest(NewBB);

      // Fix up any PHIs in the original unwind destination block.
      for (BasicBlock::iterator
             II = UnwindDest->begin(); isa<PHINode>(II); ++II) {
        PHINode *PN = cast<PHINode>(II);
        int Idx = PN->getBasicBlockIndex(Invoke->getParent());
        if (Idx == -1) continue;
        PN->setIncomingBlock(Idx, NewBB);
      }

      UnwindDest = NewBB;
    }

    IRBuilder<> Builder(Context);
    Builder.SetInsertPoint(UnwindDest, UnwindDest->getFirstInsertionPt());

    Value *PersFn = Sel->getArgOperand(1);
    LandingPadInst *LPI = Builder.CreateLandingPad(LPadSlotTy, PersFn, 0);
    Value *LPExn = Builder.CreateExtractValue(LPI, 0);
    Value *LPSel = Builder.CreateExtractValue(LPI, 1);
    Builder.CreateStore(LPExn, ExnSlot);
    Builder.CreateStore(LPSel, SelSlot);

    TransferClausesToLandingPadInst(LPI, Sel);

    DeadInsts.insert(Exn);
    DeadInsts.insert(Sel);
  }

  // Replace the old intrinsic calls with the values from the landingpad
  // instruction(s). These values were stored in allocas for us to use here.
  for (DenseMap<InvokeInst*, std::pair<Value*, Value*> >::iterator
         I = InvokeToIntrinsicsMap.begin(), E = InvokeToIntrinsicsMap.end();
       I != E; ++I) {
    std::pair<Value*, Value*> EHIntrinsics = I->second;
    CallInst *Exn = cast<CallInst>(EHIntrinsics.first);
    CallInst *Sel = cast<CallInst>(EHIntrinsics.second);
    BasicBlock *Parent = Exn->getParent();

    std::pair<Value*,Value*> ExnSelSlots = FnToLPadSlotMap[Parent->getParent()];

    IRBuilder<> Builder(Context);
    Builder.SetInsertPoint(Parent, Exn);
    LoadInst *LPExn = Builder.CreateLoad(ExnSelSlots.first, "exn.load");
    LoadInst *LPSel = Builder.CreateLoad(ExnSelSlots.second, "sel.load");

    Exn->replaceAllUsesWith(LPExn);
    Sel->replaceAllUsesWith(LPSel);
  }

  // Remove the dead instructions.
  for (SmallPtrSet<Instruction*, 32>::iterator
         I = DeadInsts.begin(), E = DeadInsts.end(); I != E; ++I) {
    Instruction *Inst = *I;
    Inst->eraseFromParent();
  }

  // Replace calls to "llvm.eh.resume" with the 'resume' instruction. Load the
  // exception and selector values from the stored place.
  Function *EHResume = M->getFunction("llvm.eh.resume");
  if (!EHResume) return;

  while (!EHResume->use_empty()) {
    CallInst *Resume = cast<CallInst>(EHResume->use_back());
    BasicBlock *BB = Resume->getParent();

    IRBuilder<> Builder(Context);
    Builder.SetInsertPoint(BB, Resume);

    Value *LPadVal =
      Builder.CreateInsertValue(UndefValue::get(LPadSlotTy),
                                Resume->getArgOperand(0), 0, "lpad.val");
    LPadVal = Builder.CreateInsertValue(LPadVal, Resume->getArgOperand(1),
                                        1, "lpad.val");
    Builder.CreateResume(LPadVal);

    // Remove all instructions after the 'resume.'
    BasicBlock::iterator I = Resume;
    while (I != BB->end()) {
      Instruction *Inst = &*I++;
      Inst->eraseFromParent();
    }
  }
}