lib/VMCore/AutoUpgrade.cpp

   1 //===-- AutoUpgrade.cpp - Implement auto-upgrade helper functions ---------===//
   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 file implements the auto-upgrade helper functions
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/AutoUpgrade.h"
  15 #include "llvm/Constants.h"
  16 #include "llvm/Function.h"
  17 #include "llvm/Instruction.h"
  18 #include "llvm/LLVMContext.h"
  19 #include "llvm/Module.h"
  20 #include "llvm/IntrinsicInst.h"
  21 #include "llvm/ADT/DenseMap.h"
  22 #include "llvm/ADT/SmallPtrSet.h"
  23 #include "llvm/ADT/SmallVector.h"
  24 #include "llvm/Support/CallSite.h"
  25 #include "llvm/Support/CFG.h"
  26 #include "llvm/Support/ErrorHandling.h"
  27 #include "llvm/Support/IRBuilder.h"
  28 #include <cstring>
  29 using namespace llvm;
  30
  31
  32 static bool UpgradeIntrinsicFunction1(Function *F, Function *&NewFn) {
  33   assert(F && "Illegal to upgrade a non-existent Function.");
  34
  35   // Quickly eliminate it, if it's not a candidate.
  36   StringRef Name = F->getName();
  37   if (Name.size() <= 8 || !Name.startswith("llvm."))
  38     return false;
  39   Name = Name.substr(5); // Strip off "llvm."
  40
  41   FunctionType *FTy = F->getFunctionType();
  42   Module *M = F->getParent();
  43
  44   switch (Name[0]) {
  45   default: break;
  46   case 'a':
  47     if (Name.startswith("atomic.cmp.swap") ||
  48         Name.startswith("atomic.swap") ||
  49         Name.startswith("atomic.load.add") ||
  50         Name.startswith("atomic.load.sub") ||
  51         Name.startswith("atomic.load.and") ||
  52         Name.startswith("atomic.load.nand") ||
  53         Name.startswith("atomic.load.or") ||
  54         Name.startswith("atomic.load.xor") ||
  55         Name.startswith("atomic.load.max") ||
  56         Name.startswith("atomic.load.min") ||
  57         Name.startswith("atomic.load.umax") ||
  58         Name.startswith("atomic.load.umin"))
  59       return true;
  60   case 'i':
  61     //  This upgrades the old llvm.init.trampoline to the new
  62     //  llvm.init.trampoline and llvm.adjust.trampoline pair.
  63     if (Name == "init.trampoline") {
  64       // The new llvm.init.trampoline returns nothing.
  65       if (FTy->getReturnType()->isVoidTy())
  66         break;
  67
  68       assert(FTy->getNumParams() == 3 && "old init.trampoline takes 3 args!");
  69
  70       // Change the name of the old intrinsic so that we can play with its type.
  71       std::string NameTmp = F->getName();
  72       F->setName("");
  73       NewFn = cast<Function>(M->getOrInsertFunction(
  74                                NameTmp,
  75                                Type::getVoidTy(M->getContext()),
  76                                FTy->getParamType(0), FTy->getParamType(1),
  77                                FTy->getParamType(2), (Type *)0));
  78       return true;
  79     }
  80   case 'm':
  81     if (Name == "memory.barrier")
  82       return true;
  83   case 'p':
  84     //  This upgrades the llvm.prefetch intrinsic to accept one more parameter,
  85     //  which is a instruction / data cache identifier. The old version only
  86     //  implicitly accepted the data version.
  87     if (Name == "prefetch") {
  88       // Don't do anything if it has the correct number of arguments already
  89       if (FTy->getNumParams() == 4)
  90         break;
  91
  92       assert(FTy->getNumParams() == 3 && "old prefetch takes 3 args!");
  93       //  We first need to change the name of the old (bad) intrinsic, because
  94       //  its type is incorrect, but we cannot overload that name. We
  95       //  arbitrarily unique it here allowing us to construct a correctly named
  96       //  and typed function below.
  97       std::string NameTmp = F->getName();
  98       F->setName("");
  99       NewFn = cast<Function>(M->getOrInsertFunction(NameTmp,
 100                                                     FTy->getReturnType(),
 101                                                     FTy->getParamType(0),
 102                                                     FTy->getParamType(1),
 103                                                     FTy->getParamType(2),
 104                                                     FTy->getParamType(2),
 105                                                     (Type*)0));
 106       return true;
 107     }
 108
 109     break;
 110   case 'x': {
 111     const char *NewFnName = NULL;
 112     // This fixes the poorly named crc32 intrinsics.
 113     if (Name == "x86.sse42.crc32.8")
 114       NewFnName = "llvm.x86.sse42.crc32.32.8";
 115     else if (Name == "x86.sse42.crc32.16")
 116       NewFnName = "llvm.x86.sse42.crc32.32.16";
 117     else if (Name == "x86.sse42.crc32.32")
 118       NewFnName = "llvm.x86.sse42.crc32.32.32";
 119     else if (Name == "x86.sse42.crc64.8")
 120       NewFnName = "llvm.x86.sse42.crc32.64.8";
 121     else if (Name == "x86.sse42.crc64.64")
 122       NewFnName = "llvm.x86.sse42.crc32.64.64";
 123
 124     if (NewFnName) {
 125       F->setName(NewFnName);
 126       NewFn = F;
 127       return true;
 128     }
 129
 130     // Calls to these instructions are transformed into unaligned loads.
 131     if (Name == "x86.sse.loadu.ps" || Name == "x86.sse2.loadu.dq" ||
 132         Name == "x86.sse2.loadu.pd")
 133       return true;
 134
 135     // Calls to these instructions are transformed into nontemporal stores.
 136     if (Name == "x86.sse.movnt.ps"  || Name == "x86.sse2.movnt.dq" ||
 137         Name == "x86.sse2.movnt.pd" || Name == "x86.sse2.movnt.i")
 138       return true;
 139
 140     break;
 141   }
 142   }
 143
 144   //  This may not belong here. This function is effectively being overloaded
 145   //  to both detect an intrinsic which needs upgrading, and to provide the
 146   //  upgraded form of the intrinsic. We should perhaps have two separate
 147   //  functions for this.
 148   return false;
 149 }
 150
 151 bool llvm::UpgradeIntrinsicFunction(Function *F, Function *&NewFn) {
 152   NewFn = 0;
 153   bool Upgraded = UpgradeIntrinsicFunction1(F, NewFn);
 154
 155   // Upgrade intrinsic attributes.  This does not change the function.
 156   if (NewFn)
 157     F = NewFn;
 158   if (unsigned id = F->getIntrinsicID())
 159     F->setAttributes(Intrinsic::getAttributes((Intrinsic::ID)id));
 160   return Upgraded;
 161 }
 162
 163 bool llvm::UpgradeGlobalVariable(GlobalVariable *GV) {
 164   // Nothing to do yet.
 165   return false;
 166 }
 167
 168 // UpgradeIntrinsicCall - Upgrade a call to an old intrinsic to be a call the
 169 // upgraded intrinsic. All argument and return casting must be provided in
 170 // order to seamlessly integrate with existing context.
 171 void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
 172   Function *F = CI->getCalledFunction();
 173   LLVMContext &C = CI->getContext();
 174   ImmutableCallSite CS(CI);
 175
 176   assert(F && "CallInst has no function associated with it.");
 177
 178   if (!NewFn) {
 179     if (F->getName() == "llvm.x86.sse.loadu.ps" ||
 180         F->getName() == "llvm.x86.sse2.loadu.dq" ||
 181         F->getName() == "llvm.x86.sse2.loadu.pd") {
 182       // Convert to a native, unaligned load.
 183       Type *VecTy = CI->getType();
 184       Type *IntTy = IntegerType::get(C, 128);
 185       IRBuilder<> Builder(C);
 186       Builder.SetInsertPoint(CI->getParent(), CI);
 187
 188       Value *BC = Builder.CreateBitCast(CI->getArgOperand(0),
 189                                         PointerType::getUnqual(IntTy),
 190                                         "cast");
 191       LoadInst *LI = Builder.CreateLoad(BC, CI->getName());
 192       LI->setAlignment(1);      // Unaligned load.
 193       BC = Builder.CreateBitCast(LI, VecTy, "new.cast");
 194
 195       // Fix up all the uses with our new load.
 196       if (!CI->use_empty())
 197         CI->replaceAllUsesWith(BC);
 198
 199       // Remove intrinsic.
 200       CI->eraseFromParent();
 201     } else if (F->getName() == "llvm.x86.sse.movnt.ps" ||
 202                F->getName() == "llvm.x86.sse2.movnt.dq" ||
 203                F->getName() == "llvm.x86.sse2.movnt.pd" ||
 204                F->getName() == "llvm.x86.sse2.movnt.i") {
 205       IRBuilder<> Builder(C);
 206       Builder.SetInsertPoint(CI->getParent(), CI);
 207
 208       Module *M = F->getParent();
 209       SmallVector<Value *, 1> Elts;
 210       Elts.push_back(ConstantInt::get(Type::getInt32Ty(C), 1));
 211       MDNode *Node = MDNode::get(C, Elts);
 212
 213       Value *Arg0 = CI->getArgOperand(0);
 214       Value *Arg1 = CI->getArgOperand(1);
 215
 216       // Convert the type of the pointer to a pointer to the stored type.
 217       Value *BC = Builder.CreateBitCast(Arg0,
 218                                         PointerType::getUnqual(Arg1->getType()),
 219                                         "cast");
 220       StoreInst *SI = Builder.CreateStore(Arg1, BC);
 221       SI->setMetadata(M->getMDKindID("nontemporal"), Node);
 222       SI->setAlignment(16);
 223
 224       // Remove intrinsic.
 225       CI->eraseFromParent();
 226     } else if (F->getName().startswith("llvm.atomic.cmp.swap")) {
 227       IRBuilder<> Builder(C);
 228       Builder.SetInsertPoint(CI->getParent(), CI);
 229       Value *Val = Builder.CreateAtomicCmpXchg(CI->getArgOperand(0),
 230                                                CI->getArgOperand(1),
 231                                                CI->getArgOperand(2),
 232                                                Monotonic);
 233
 234       // Replace intrinsic.
 235       Val->takeName(CI);
 236       if (!CI->use_empty())
 237         CI->replaceAllUsesWith(Val);
 238       CI->eraseFromParent();
 239     } else if (F->getName().startswith("llvm.atomic")) {
 240       IRBuilder<> Builder(C);
 241       Builder.SetInsertPoint(CI->getParent(), CI);
 242
 243       AtomicRMWInst::BinOp Op;
 244       if (F->getName().startswith("llvm.atomic.swap"))
 245         Op = AtomicRMWInst::Xchg;
 246       else if (F->getName().startswith("llvm.atomic.load.add"))
 247         Op = AtomicRMWInst::Add;
 248       else if (F->getName().startswith("llvm.atomic.load.sub"))
 249         Op = AtomicRMWInst::Sub;
 250       else if (F->getName().startswith("llvm.atomic.load.and"))
 251         Op = AtomicRMWInst::And;
 252       else if (F->getName().startswith("llvm.atomic.load.nand"))
 253         Op = AtomicRMWInst::Nand;
 254       else if (F->getName().startswith("llvm.atomic.load.or"))
 255         Op = AtomicRMWInst::Or;
 256       else if (F->getName().startswith("llvm.atomic.load.xor"))
 257         Op = AtomicRMWInst::Xor;
 258       else if (F->getName().startswith("llvm.atomic.load.max"))
 259         Op = AtomicRMWInst::Max;
 260       else if (F->getName().startswith("llvm.atomic.load.min"))
 261         Op = AtomicRMWInst::Min;
 262       else if (F->getName().startswith("llvm.atomic.load.umax"))
 263         Op = AtomicRMWInst::UMax;
 264       else if (F->getName().startswith("llvm.atomic.load.umin"))
 265         Op = AtomicRMWInst::UMin;
 266       else
 267         llvm_unreachable("Unknown atomic");
 268
 269       Value *Val = Builder.CreateAtomicRMW(Op, CI->getArgOperand(0),
 270                                            CI->getArgOperand(1),
 271                                            Monotonic);
 272
 273       // Replace intrinsic.
 274       Val->takeName(CI);
 275       if (!CI->use_empty())
 276         CI->replaceAllUsesWith(Val);
 277       CI->eraseFromParent();
 278     } else if (F->getName() == "llvm.memory.barrier") {
 279       IRBuilder<> Builder(C);
 280       Builder.SetInsertPoint(CI->getParent(), CI);
 281
 282       // Note that this conversion ignores the "device" bit; it was not really
 283       // well-defined, and got abused because nobody paid enough attention to
 284       // get it right. In practice, this probably doesn't matter; application
 285       // code generally doesn't need anything stronger than
 286       // SequentiallyConsistent (and realistically, SequentiallyConsistent
 287       // is lowered to a strong enough barrier for almost anything).
 288
 289       if (cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue())
 290         Builder.CreateFence(SequentiallyConsistent);
 291       else if (!cast<ConstantInt>(CI->getArgOperand(0))->getZExtValue())
 292         Builder.CreateFence(Release);
 293       else if (!cast<ConstantInt>(CI->getArgOperand(3))->getZExtValue())
 294         Builder.CreateFence(Acquire);
 295       else
 296         Builder.CreateFence(AcquireRelease);
 297
 298       // Remove intrinsic.
 299       CI->eraseFromParent();
 300     } else {
 301       llvm_unreachable("Unknown function for CallInst upgrade.");
 302     }
 303     return;
 304   }
 305
 306   switch (NewFn->getIntrinsicID()) {
 307   case Intrinsic::prefetch: {
 308     IRBuilder<> Builder(C);
 309     Builder.SetInsertPoint(CI->getParent(), CI);
 310     llvm::Type *I32Ty = llvm::Type::getInt32Ty(CI->getContext());
 311
 312     // Add the extra "data cache" argument
 313     Value *Operands[4] = { CI->getArgOperand(0), CI->getArgOperand(1),
 314                            CI->getArgOperand(2),
 315                            llvm::ConstantInt::get(I32Ty, 1) };
 316     CallInst *NewCI = CallInst::Create(NewFn, Operands,
 317                                        CI->getName(), CI);
 318     NewCI->setTailCall(CI->isTailCall());
 319     NewCI->setCallingConv(CI->getCallingConv());
 320     //  Handle any uses of the old CallInst.
 321     if (!CI->use_empty())
 322       //  Replace all uses of the old call with the new cast which has the
 323       //  correct type.
 324       CI->replaceAllUsesWith(NewCI);
 325
 326     //  Clean up the old call now that it has been completely upgraded.
 327     CI->eraseFromParent();
 328     break;
 329   }
 330   case Intrinsic::init_trampoline: {
 331
 332     //  Transform
 333     //    %tramp = call i8* llvm.init.trampoline (i8* x, i8* y, i8* z)
 334     //  to
 335     //    call void llvm.init.trampoline (i8* %x, i8* %y, i8* %z)
 336     //    %tramp = call i8* llvm.adjust.trampoline (i8* %x)
 337
 338     Function *AdjustTrampolineFn =
 339       cast<Function>(Intrinsic::getDeclaration(F->getParent(),
 340                                                Intrinsic::adjust_trampoline));
 341
 342     IRBuilder<> Builder(C);
 343     Builder.SetInsertPoint(CI);
 344
 345     Builder.CreateCall3(NewFn, CI->getArgOperand(0), CI->getArgOperand(1),
 346                         CI->getArgOperand(2));
 347
 348     CallInst *AdjustCall = Builder.CreateCall(AdjustTrampolineFn,
 349                                               CI->getArgOperand(0),
 350                                               CI->getName());
 351     if (!CI->use_empty())
 352       CI->replaceAllUsesWith(AdjustCall);
 353     CI->eraseFromParent();
 354     break;
 355   }
 356   }
 357 }
 358
 359 // This tests each Function to determine if it needs upgrading. When we find
 360 // one we are interested in, we then upgrade all calls to reflect the new
 361 // function.
 362 void llvm::UpgradeCallsToIntrinsic(Function* F) {
 363   assert(F && "Illegal attempt to upgrade a non-existent intrinsic.");
 364
 365   // Upgrade the function and check if it is a totaly new function.
 366   Function *NewFn;
 367   if (UpgradeIntrinsicFunction(F, NewFn)) {
 368     if (NewFn != F) {
 369       // Replace all uses to the old function with the new one if necessary.
 370       for (Value::use_iterator UI = F->use_begin(), UE = F->use_end();
 371            UI != UE; ) {
 372         if (CallInst *CI = dyn_cast<CallInst>(*UI++))
 373           UpgradeIntrinsicCall(CI, NewFn);
 374       }
 375       // Remove old function, no longer used, from the module.
 376       F->eraseFromParent();
 377     }
 378   }
 379 }
 380
 381 /// This function strips all debug info intrinsics, except for llvm.dbg.declare.
 382 /// If an llvm.dbg.declare intrinsic is invalid, then this function simply
 383 /// strips that use.
 384 void llvm::CheckDebugInfoIntrinsics(Module *M) {
 385   if (Function *FuncStart = M->getFunction("llvm.dbg.func.start")) {
 386     while (!FuncStart->use_empty())
 387       cast<CallInst>(FuncStart->use_back())->eraseFromParent();
 388     FuncStart->eraseFromParent();
 389   }
 390
 391   if (Function *StopPoint = M->getFunction("llvm.dbg.stoppoint")) {
 392     while (!StopPoint->use_empty())
 393       cast<CallInst>(StopPoint->use_back())->eraseFromParent();
 394     StopPoint->eraseFromParent();
 395   }
 396
 397   if (Function *RegionStart = M->getFunction("llvm.dbg.region.start")) {
 398     while (!RegionStart->use_empty())
 399       cast<CallInst>(RegionStart->use_back())->eraseFromParent();
 400     RegionStart->eraseFromParent();
 401   }
 402
 403   if (Function *RegionEnd = M->getFunction("llvm.dbg.region.end")) {
 404     while (!RegionEnd->use_empty())
 405       cast<CallInst>(RegionEnd->use_back())->eraseFromParent();
 406     RegionEnd->eraseFromParent();
 407   }
 408
 409   if (Function *Declare = M->getFunction("llvm.dbg.declare")) {
 410     if (!Declare->use_empty()) {
 411       DbgDeclareInst *DDI = cast<DbgDeclareInst>(Declare->use_back());
 412       if (!isa<MDNode>(DDI->getArgOperand(0)) ||
 413           !isa<MDNode>(DDI->getArgOperand(1))) {
 414         while (!Declare->use_empty()) {
 415           CallInst *CI = cast<CallInst>(Declare->use_back());
 416           CI->eraseFromParent();
 417         }
 418         Declare->eraseFromParent();
 419       }
 420     }
 421   }
 422 }
 423
 424 /// FindExnAndSelIntrinsics - Find the eh_exception and eh_selector intrinsic
 425 /// calls reachable from the unwind basic block.
 426 static void FindExnAndSelIntrinsics(BasicBlock *BB, CallInst *&Exn,
 427                                     CallInst *&Sel,
 428                                     SmallPtrSet<BasicBlock*, 8> &Visited) {
 429   if (!Visited.insert(BB)) return;
 430
 431   for (BasicBlock::iterator
 432          I = BB->begin(), E = BB->end(); I != E; ++I) {
 433     if (CallInst *CI = dyn_cast<CallInst>(I)) {
 434       switch (CI->getCalledFunction()->getIntrinsicID()) {
 435       default: break;
 436       case Intrinsic::eh_exception:
 437         assert(!Exn && "Found more than one eh.exception call!");
 438         Exn = CI;
 439         break;
 440       case Intrinsic::eh_selector:
 441         assert(!Sel && "Found more than one eh.selector call!");
 442         Sel = CI;
 443         break;
 444       }
 445
 446       if (Exn && Sel) return;
 447     }
 448   }
 449
 450   if (Exn && Sel) return;
 451
 452   for (succ_iterator I = succ_begin(BB), E = succ_end(BB); I != E; ++I) {
 453     FindExnAndSelIntrinsics(*I, Exn, Sel, Visited);
 454     if (Exn && Sel) return;
 455   }
 456 }
 457
 458 /// TransferClausesToLandingPadInst - Transfer the exception handling clauses
 459 /// from the eh_selector call to the new landingpad instruction.
 460 static void TransferClausesToLandingPadInst(LandingPadInst *LPI,
 461                                             CallInst *EHSel) {
 462   LLVMContext &Context = LPI->getContext();
 463   unsigned N = EHSel->getNumArgOperands();
 464
 465   for (unsigned i = N - 1; i > 1; --i) {
 466     if (const ConstantInt *CI = dyn_cast<ConstantInt>(EHSel->getArgOperand(i))){
 467       unsigned FilterLength = CI->getZExtValue();
 468       unsigned FirstCatch = i + FilterLength + !FilterLength;
 469       assert(FirstCatch <= N && "Invalid filter length");
 470
 471       if (FirstCatch < N)
 472         for (unsigned j = FirstCatch; j < N; ++j) {
 473           Value *Val = EHSel->getArgOperand(j);
 474           if (!Val->hasName() || Val->getName() != "llvm.eh.catch.all.value") {
 475             LPI->addClause(EHSel->getArgOperand(j));
 476           } else {
 477             GlobalVariable *GV = cast<GlobalVariable>(Val);
 478             LPI->addClause(GV->getInitializer());
 479           }
 480         }
 481
 482       if (!FilterLength) {
 483         // Cleanup.
 484         LPI->setCleanup(true);
 485       } else {
 486         // Filter.
 487         SmallVector<Constant *, 4> TyInfo;
 488         TyInfo.reserve(FilterLength - 1);
 489         for (unsigned j = i + 1; j < FirstCatch; ++j)
 490           TyInfo.push_back(cast<Constant>(EHSel->getArgOperand(j)));
 491         ArrayType *AType =
 492           ArrayType::get(!TyInfo.empty() ? TyInfo[0]->getType() :
 493                          PointerType::getUnqual(Type::getInt8Ty(Context)),
 494                          TyInfo.size());
 495         LPI->addClause(ConstantArray::get(AType, TyInfo));
 496       }
 497
 498       N = i;
 499     }
 500   }
 501
 502   if (N > 2)
 503     for (unsigned j = 2; j < N; ++j) {
 504       Value *Val = EHSel->getArgOperand(j);
 505       if (!Val->hasName() || Val->getName() != "llvm.eh.catch.all.value") {
 506         LPI->addClause(EHSel->getArgOperand(j));
 507       } else {
 508         GlobalVariable *GV = cast<GlobalVariable>(Val);
 509         LPI->addClause(GV->getInitializer());
 510       }
 511     }
 512 }
 513
 514 /// This function upgrades the old pre-3.0 exception handling system to the new
 515 /// one. N.B. This will be removed in 3.1.
 516 void llvm::UpgradeExceptionHandling(Module *M) {
 517   Function *EHException = M->getFunction("llvm.eh.exception");
 518   Function *EHSelector = M->getFunction("llvm.eh.selector");
 519   if (!EHException || !EHSelector)
 520     return;
 521
 522   LLVMContext &Context = M->getContext();
 523   Type *ExnTy = PointerType::getUnqual(Type::getInt8Ty(Context));
 524   Type *SelTy = Type::getInt32Ty(Context);
 525   Type *LPadSlotTy = StructType::get(ExnTy, SelTy, NULL);
 526
 527   // This map links the invoke instruction with the eh.exception and eh.selector
 528   // calls associated with it.
 529   DenseMap<InvokeInst*, std::pair<Value*, Value*> > InvokeToIntrinsicsMap;
 530   for (Module::iterator
 531          I = M->begin(), E = M->end(); I != E; ++I) {
 532     Function &F = *I;
 533
 534     for (Function::iterator
 535            II = F.begin(), IE = F.end(); II != IE; ++II) {
 536       BasicBlock *BB = &*II;
 537       InvokeInst *Inst = dyn_cast<InvokeInst>(BB->getTerminator());
 538       if (!Inst) continue;
 539       BasicBlock *UnwindDest = Inst->getUnwindDest();
 540       if (UnwindDest->isLandingPad()) continue; // Already converted.
 541
 542       SmallPtrSet<BasicBlock*, 8> Visited;
 543       CallInst *Exn = 0;
 544       CallInst *Sel = 0;
 545       FindExnAndSelIntrinsics(UnwindDest, Exn, Sel, Visited);
 546       assert(Exn && Sel && "Cannot find eh.exception and eh.selector calls!");
 547       InvokeToIntrinsicsMap[Inst] = std::make_pair(Exn, Sel);
 548     }
 549   }
 550
 551   // This map stores the slots where the exception object and selector value are
 552   // stored within a function.
 553   DenseMap<Function*, std::pair<Value*, Value*> > FnToLPadSlotMap;
 554   SmallPtrSet<Instruction*, 32> DeadInsts;
 555   for (DenseMap<InvokeInst*, std::pair<Value*, Value*> >::iterator
 556          I = InvokeToIntrinsicsMap.begin(), E = InvokeToIntrinsicsMap.end();
 557        I != E; ++I) {
 558     InvokeInst *Invoke = I->first;
 559     BasicBlock *UnwindDest = Invoke->getUnwindDest();
 560     Function *F = UnwindDest->getParent();
 561     std::pair<Value*, Value*> EHIntrinsics = I->second;
 562     CallInst *Exn = cast<CallInst>(EHIntrinsics.first);
 563     CallInst *Sel = cast<CallInst>(EHIntrinsics.second);
 564
 565     // Store the exception object and selector value in the entry block.
 566     Value *ExnSlot = 0;
 567     Value *SelSlot = 0;
 568     if (!FnToLPadSlotMap[F].first) {
 569       BasicBlock *Entry = &F->front();
 570       ExnSlot = new AllocaInst(ExnTy, "exn", Entry->getTerminator());
 571       SelSlot = new AllocaInst(SelTy, "sel", Entry->getTerminator());
 572       FnToLPadSlotMap[F] = std::make_pair(ExnSlot, SelSlot);
 573     } else {
 574       ExnSlot = FnToLPadSlotMap[F].first;
 575       SelSlot = FnToLPadSlotMap[F].second;
 576     }
 577
 578     if (!UnwindDest->getSinglePredecessor()) {
 579       // The unwind destination doesn't have a single predecessor. Create an
 580       // unwind destination which has only one predecessor.
 581       BasicBlock *NewBB = BasicBlock::Create(Context, "new.lpad",
 582                                              UnwindDest->getParent());
 583       BranchInst::Create(UnwindDest, NewBB);
 584       Invoke->setUnwindDest(NewBB);
 585
 586       // Fix up any PHIs in the original unwind destination block.
 587       for (BasicBlock::iterator
 588              II = UnwindDest->begin(); isa<PHINode>(II); ++II) {
 589         PHINode *PN = cast<PHINode>(II);
 590         int Idx = PN->getBasicBlockIndex(Invoke->getParent());
 591         if (Idx == -1) continue;
 592         PN->setIncomingBlock(Idx, NewBB);
 593       }
 594
 595       UnwindDest = NewBB;
 596     }
 597
 598     IRBuilder<> Builder(Context);
 599     Builder.SetInsertPoint(UnwindDest, UnwindDest->getFirstInsertionPt());
 600
 601     Value *PersFn = Sel->getArgOperand(1);
 602     LandingPadInst *LPI = Builder.CreateLandingPad(LPadSlotTy, PersFn, 0);
 603     Value *LPExn = Builder.CreateExtractValue(LPI, 0);
 604     Value *LPSel = Builder.CreateExtractValue(LPI, 1);
 605     Builder.CreateStore(LPExn, ExnSlot);
 606     Builder.CreateStore(LPSel, SelSlot);
 607
 608     TransferClausesToLandingPadInst(LPI, Sel);
 609
 610     DeadInsts.insert(Exn);
 611     DeadInsts.insert(Sel);
 612   }
 613
 614   // Replace the old intrinsic calls with the values from the landingpad
 615   // instruction(s). These values were stored in allocas for us to use here.
 616   for (DenseMap<InvokeInst*, std::pair<Value*, Value*> >::iterator
 617          I = InvokeToIntrinsicsMap.begin(), E = InvokeToIntrinsicsMap.end();
 618        I != E; ++I) {
 619     std::pair<Value*, Value*> EHIntrinsics = I->second;
 620     CallInst *Exn = cast<CallInst>(EHIntrinsics.first);
 621     CallInst *Sel = cast<CallInst>(EHIntrinsics.second);
 622     BasicBlock *Parent = Exn->getParent();
 623
 624     std::pair<Value*,Value*> ExnSelSlots = FnToLPadSlotMap[Parent->getParent()];
 625
 626     IRBuilder<> Builder(Context);
 627     Builder.SetInsertPoint(Parent, Exn);
 628     LoadInst *LPExn = Builder.CreateLoad(ExnSelSlots.first, "exn.load");
 629     LoadInst *LPSel = Builder.CreateLoad(ExnSelSlots.second, "sel.load");
 630
 631     Exn->replaceAllUsesWith(LPExn);
 632     Sel->replaceAllUsesWith(LPSel);
 633   }
 634
 635   // Remove the dead instructions.
 636   for (SmallPtrSet<Instruction*, 32>::iterator
 637          I = DeadInsts.begin(), E = DeadInsts.end(); I != E; ++I) {
 638     Instruction *Inst = *I;
 639     Inst->eraseFromParent();
 640   }
 641
 642   // Replace calls to "llvm.eh.resume" with the 'resume' instruction. Load the
 643   // exception and selector values from the stored place.
 644   Function *EHResume = M->getFunction("llvm.eh.resume");
 645   if (!EHResume) return;
 646
 647   while (!EHResume->use_empty()) {
 648     CallInst *Resume = cast<CallInst>(EHResume->use_back());
 649     BasicBlock *BB = Resume->getParent();
 650
 651     IRBuilder<> Builder(Context);
 652     Builder.SetInsertPoint(BB, Resume);
 653
 654     Value *LPadVal =
 655       Builder.CreateInsertValue(UndefValue::get(LPadSlotTy),
 656                                 Resume->getArgOperand(0), 0, "lpad.val");
 657     LPadVal = Builder.CreateInsertValue(LPadVal, Resume->getArgOperand(1),
 658                                         1, "lpad.val");
 659     Builder.CreateResume(LPadVal);
 660
 661     // Remove all instructions after the 'resume.'
 662     BasicBlock::iterator I = Resume;
 663     while (I != BB->end()) {
 664       Instruction *Inst = &*I++;
 665       Inst->eraseFromParent();
 666     }
 667   }
 668 }