lib/CodeGen/IntrinsicLowering.cpp

   1 //===-- IntrinsicLowering.cpp - Intrinsic Lowering default implementation -===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the IntrinsicLowering class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Constants.h"
  15 #include "llvm/DerivedTypes.h"
  16 #include "llvm/Module.h"
  17 #include "llvm/Instructions.h"
  18 #include "llvm/Type.h"
  19 #include "llvm/CodeGen/IntrinsicLowering.h"
  20 #include "llvm/Support/Streams.h"
  21 using namespace llvm;
  22
  23 template <class ArgIt>
  24 static Function *EnsureFunctionExists(Module &M, const char *Name,
  25                                       ArgIt ArgBegin, ArgIt ArgEnd,
  26                                       const Type *RetTy) {
  27   if (Function *F = M.getNamedFunction(Name)) return F;
  28   // It doesn't already exist in the program, insert a new definition now.
  29   std::vector<const Type *> ParamTys;
  30   for (ArgIt I = ArgBegin; I != ArgEnd; ++I)
  31     ParamTys.push_back(I->getType());
  32   return M.getOrInsertFunction(Name, FunctionType::get(RetTy, ParamTys, false));
  33 }
  34
  35 /// ReplaceCallWith - This function is used when we want to lower an intrinsic
  36 /// call to a call of an external function.  This handles hard cases such as
  37 /// when there was already a prototype for the external function, and if that
  38 /// prototype doesn't match the arguments we expect to pass in.
  39 template <class ArgIt>
  40 static CallInst *ReplaceCallWith(const char *NewFn, CallInst *CI,
  41                                  ArgIt ArgBegin, ArgIt ArgEnd,
  42                                  const unsigned *castOpcodes,
  43                                  const Type *RetTy, Function *&FCache) {
  44   if (!FCache) {
  45     // If we haven't already looked up this function, check to see if the
  46     // program already contains a function with this name.
  47     Module *M = CI->getParent()->getParent()->getParent();
  48     FCache = M->getNamedFunction(NewFn);
  49     if (!FCache) {
  50       // It doesn't already exist in the program, insert a new definition now.
  51       std::vector<const Type *> ParamTys;
  52       for (ArgIt I = ArgBegin; I != ArgEnd; ++I)
  53         ParamTys.push_back((*I)->getType());
  54       FCache = M->getOrInsertFunction(NewFn,
  55                                      FunctionType::get(RetTy, ParamTys, false));
  56     }
  57    }
  58
  59   const FunctionType *FT = FCache->getFunctionType();
  60   std::vector<Value*> Operands;
  61   unsigned ArgNo = 0;
  62   for (ArgIt I = ArgBegin; I != ArgEnd && ArgNo != FT->getNumParams();
  63        ++I, ++ArgNo) {
  64     Value *Arg = *I;
  65     if (Arg->getType() != FT->getParamType(ArgNo))
  66       if (castOpcodes[ArgNo])
  67         Arg = CastInst::create(Instruction::CastOps(castOpcodes[ArgNo]),
  68           Arg, FT->getParamType(ArgNo), Arg->getName(), CI);
  69       else {
  70         Instruction::CastOps opcode = CastInst::getCastOpcode(Arg,
  71             Arg->getType()->isSigned(), FT->getParamType(ArgNo),
  72             FT->getParamType(ArgNo)->isSigned());
  73         Arg = CastInst::create(opcode, Arg, FT->getParamType(ArgNo),
  74                                Arg->getName(), CI);
  75       }
  76     Operands.push_back(Arg);
  77   }
  78   // Pass nulls into any additional arguments...
  79   for (; ArgNo != FT->getNumParams(); ++ArgNo)
  80     Operands.push_back(Constant::getNullValue(FT->getParamType(ArgNo)));
  81
  82   std::string Name = CI->getName(); CI->setName("");
  83   if (FT->getReturnType() == Type::VoidTy) Name.clear();
  84   CallInst *NewCI = new CallInst(FCache, Operands, Name, CI);
  85   if (!CI->use_empty()) {
  86     Value *V = NewCI;
  87     if (CI->getType() != NewCI->getType()) {
  88       Instruction::CastOps opcode = CastInst::getCastOpcode(NewCI,
  89           NewCI->getType()->isSigned(), CI->getType(),
  90           CI->getType()->isSigned());
  91       V = CastInst::create(opcode, NewCI, CI->getType(), Name, CI);
  92     }
  93     CI->replaceAllUsesWith(V);
  94   }
  95   return NewCI;
  96 }
  97
  98 void IntrinsicLowering::AddPrototypes(Module &M) {
  99   for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
 100     if (I->isExternal() && !I->use_empty())
 101       switch (I->getIntrinsicID()) {
 102       default: break;
 103       case Intrinsic::setjmp:
 104         EnsureFunctionExists(M, "setjmp", I->arg_begin(), I->arg_end(),
 105                              Type::IntTy);
 106         break;
 107       case Intrinsic::longjmp:
 108         EnsureFunctionExists(M, "longjmp", I->arg_begin(), I->arg_end(),
 109                              Type::VoidTy);
 110         break;
 111       case Intrinsic::siglongjmp:
 112         EnsureFunctionExists(M, "abort", I->arg_end(), I->arg_end(),
 113                              Type::VoidTy);
 114         break;
 115       case Intrinsic::memcpy_i32:
 116       case Intrinsic::memcpy_i64:
 117         EnsureFunctionExists(M, "memcpy", I->arg_begin(), --I->arg_end(),
 118                              I->arg_begin()->getType());
 119         break;
 120       case Intrinsic::memmove_i32:
 121       case Intrinsic::memmove_i64:
 122         EnsureFunctionExists(M, "memmove", I->arg_begin(), --I->arg_end(),
 123                              I->arg_begin()->getType());
 124         break;
 125       case Intrinsic::memset_i32:
 126       case Intrinsic::memset_i64:
 127         M.getOrInsertFunction("memset", PointerType::get(Type::SByteTy),
 128                               PointerType::get(Type::SByteTy),
 129                               Type::IntTy, (--(--I->arg_end()))->getType(),
 130                               (Type *)0);
 131         break;
 132       case Intrinsic::isunordered_f32:
 133       case Intrinsic::isunordered_f64:
 134         EnsureFunctionExists(M, "isunordered", I->arg_begin(), I->arg_end(),
 135                              Type::BoolTy);
 136         break;
 137       case Intrinsic::sqrt_f32:
 138       case Intrinsic::sqrt_f64:
 139         if(I->arg_begin()->getType() == Type::FloatTy)
 140           EnsureFunctionExists(M, "sqrtf", I->arg_begin(), I->arg_end(),
 141                                Type::FloatTy);
 142         else
 143           EnsureFunctionExists(M, "sqrt", I->arg_begin(), I->arg_end(),
 144                                Type::DoubleTy);
 145         break;
 146       }
 147 }
 148
 149 /// LowerBSWAP - Emit the code to lower bswap of V before the specified
 150 /// instruction IP.
 151 static Value *LowerBSWAP(Value *V, Instruction *IP) {
 152   assert(V->getType()->isInteger() && "Can't bswap a non-integer type!");
 153
 154   unsigned BitSize = V->getType()->getPrimitiveSizeInBits();
 155
 156   switch(BitSize) {
 157   default: assert(0 && "Unhandled type size of value to byteswap!");
 158   case 16: {
 159     Value *Tmp1 = new ShiftInst(Instruction::Shl, V,
 160                                 ConstantInt::get(Type::UByteTy,8),"bswap.2",IP);
 161     Value *Tmp2 = new ShiftInst(Instruction::LShr, V,
 162                                 ConstantInt::get(Type::UByteTy,8),"bswap.1",IP);
 163     V = BinaryOperator::createOr(Tmp1, Tmp2, "bswap.i16", IP);
 164     break;
 165   }
 166   case 32: {
 167     Value *Tmp4 = new ShiftInst(Instruction::Shl, V,
 168                               ConstantInt::get(Type::UByteTy,24),"bswap.4", IP);
 169     Value *Tmp3 = new ShiftInst(Instruction::Shl, V,
 170                               ConstantInt::get(Type::UByteTy,8),"bswap.3",IP);
 171     Value *Tmp2 = new ShiftInst(Instruction::LShr, V,
 172                               ConstantInt::get(Type::UByteTy,8),"bswap.2",IP);
 173     Value *Tmp1 = new ShiftInst(Instruction::LShr, V,
 174                               ConstantInt::get(Type::UByteTy,24),"bswap.1", IP);
 175     Tmp3 = BinaryOperator::createAnd(Tmp3,
 176                                      ConstantInt::get(Type::UIntTy, 0xFF0000),
 177                                      "bswap.and3", IP);
 178     Tmp2 = BinaryOperator::createAnd(Tmp2,
 179                                      ConstantInt::get(Type::UIntTy, 0xFF00),
 180                                      "bswap.and2", IP);
 181     Tmp4 = BinaryOperator::createOr(Tmp4, Tmp3, "bswap.or1", IP);
 182     Tmp2 = BinaryOperator::createOr(Tmp2, Tmp1, "bswap.or2", IP);
 183     V = BinaryOperator::createOr(Tmp4, Tmp3, "bswap.i32", IP);
 184     break;
 185   }
 186   case 64: {
 187     Value *Tmp8 = new ShiftInst(Instruction::Shl, V,
 188                               ConstantInt::get(Type::UByteTy,56),"bswap.8", IP);
 189     Value *Tmp7 = new ShiftInst(Instruction::Shl, V,
 190                               ConstantInt::get(Type::UByteTy,40),"bswap.7", IP);
 191     Value *Tmp6 = new ShiftInst(Instruction::Shl, V,
 192                               ConstantInt::get(Type::UByteTy,24),"bswap.6", IP);
 193     Value *Tmp5 = new ShiftInst(Instruction::Shl, V,
 194                               ConstantInt::get(Type::UByteTy,8),"bswap.5", IP);
 195     Value* Tmp4 = new ShiftInst(Instruction::LShr, V,
 196                               ConstantInt::get(Type::UByteTy,8),"bswap.4", IP);
 197     Value* Tmp3 = new ShiftInst(Instruction::LShr, V,
 198                               ConstantInt::get(Type::UByteTy,24),"bswap.3", IP);
 199     Value* Tmp2 = new ShiftInst(Instruction::LShr, V,
 200                               ConstantInt::get(Type::UByteTy,40),"bswap.2", IP);
 201     Value* Tmp1 = new ShiftInst(Instruction::LShr, V,
 202                               ConstantInt::get(Type::UByteTy,56),"bswap.1", IP);
 203     Tmp7 = BinaryOperator::createAnd(Tmp7,
 204                              ConstantInt::get(Type::ULongTy,
 205                                0xFF000000000000ULL),
 206                              "bswap.and7", IP);
 207     Tmp6 = BinaryOperator::createAnd(Tmp6,
 208                              ConstantInt::get(Type::ULongTy, 0xFF0000000000ULL),
 209                              "bswap.and6", IP);
 210     Tmp5 = BinaryOperator::createAnd(Tmp5,
 211                              ConstantInt::get(Type::ULongTy, 0xFF00000000ULL),
 212                              "bswap.and5", IP);
 213     Tmp4 = BinaryOperator::createAnd(Tmp4,
 214                              ConstantInt::get(Type::ULongTy, 0xFF000000ULL),
 215                              "bswap.and4", IP);
 216     Tmp3 = BinaryOperator::createAnd(Tmp3,
 217                              ConstantInt::get(Type::ULongTy, 0xFF0000ULL),
 218                              "bswap.and3", IP);
 219     Tmp2 = BinaryOperator::createAnd(Tmp2,
 220                              ConstantInt::get(Type::ULongTy, 0xFF00ULL),
 221                              "bswap.and2", IP);
 222     Tmp8 = BinaryOperator::createOr(Tmp8, Tmp7, "bswap.or1", IP);
 223     Tmp6 = BinaryOperator::createOr(Tmp6, Tmp5, "bswap.or2", IP);
 224     Tmp4 = BinaryOperator::createOr(Tmp4, Tmp3, "bswap.or3", IP);
 225     Tmp2 = BinaryOperator::createOr(Tmp2, Tmp1, "bswap.or4", IP);
 226     Tmp8 = BinaryOperator::createOr(Tmp8, Tmp6, "bswap.or5", IP);
 227     Tmp4 = BinaryOperator::createOr(Tmp4, Tmp2, "bswap.or6", IP);
 228     V = BinaryOperator::createOr(Tmp8, Tmp4, "bswap.i64", IP);
 229     break;
 230   }
 231   }
 232   return V;
 233 }
 234
 235 /// LowerCTPOP - Emit the code to lower ctpop of V before the specified
 236 /// instruction IP.
 237 static Value *LowerCTPOP(Value *V, Instruction *IP) {
 238   assert(V->getType()->isInteger() && "Can't ctpop a non-integer type!");
 239
 240   static const uint64_t MaskValues[6] = {
 241     0x5555555555555555ULL, 0x3333333333333333ULL,
 242     0x0F0F0F0F0F0F0F0FULL, 0x00FF00FF00FF00FFULL,
 243     0x0000FFFF0000FFFFULL, 0x00000000FFFFFFFFULL
 244   };
 245
 246   unsigned BitSize = V->getType()->getPrimitiveSizeInBits();
 247
 248   for (unsigned i = 1, ct = 0; i != BitSize; i <<= 1, ++ct) {
 249     Value *MaskCst = ConstantInt::get(V->getType(), MaskValues[ct]);
 250     Value *LHS = BinaryOperator::createAnd(V, MaskCst, "cppop.and1", IP);
 251     Value *VShift = new ShiftInst(Instruction::LShr, V,
 252                       ConstantInt::get(Type::UByteTy, i), "ctpop.sh", IP);
 253     Value *RHS = BinaryOperator::createAnd(VShift, MaskCst, "cppop.and2", IP);
 254     V = BinaryOperator::createAdd(LHS, RHS, "ctpop.step", IP);
 255   }
 256
 257   return V;
 258 }
 259
 260 /// LowerCTLZ - Emit the code to lower ctlz of V before the specified
 261 /// instruction IP.
 262 static Value *LowerCTLZ(Value *V, Instruction *IP) {
 263
 264   unsigned BitSize = V->getType()->getPrimitiveSizeInBits();
 265   for (unsigned i = 1; i != BitSize; i <<= 1) {
 266     Value *ShVal = ConstantInt::get(Type::UByteTy, i);
 267     ShVal = new ShiftInst(Instruction::LShr, V, ShVal, "ctlz.sh", IP);
 268     V = BinaryOperator::createOr(V, ShVal, "ctlz.step", IP);
 269   }
 270
 271   V = BinaryOperator::createNot(V, "", IP);
 272   return LowerCTPOP(V, IP);
 273 }
 274
 275
 276
 277 void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) {
 278   Function *Callee = CI->getCalledFunction();
 279   assert(Callee && "Cannot lower an indirect call!");
 280
 281   switch (Callee->getIntrinsicID()) {
 282   case Intrinsic::not_intrinsic:
 283     cerr << "Cannot lower a call to a non-intrinsic function '"
 284          << Callee->getName() << "'!\n";
 285     abort();
 286   default:
 287     cerr << "Error: Code generator does not support intrinsic function '"
 288          << Callee->getName() << "'!\n";
 289     abort();
 290
 291     // The setjmp/longjmp intrinsics should only exist in the code if it was
 292     // never optimized (ie, right out of the CFE), or if it has been hacked on
 293     // by the lowerinvoke pass.  In both cases, the right thing to do is to
 294     // convert the call to an explicit setjmp or longjmp call.
 295   case Intrinsic::setjmp: {
 296     static Function *SetjmpFCache = 0;
 297     static const unsigned castOpcodes[] = { Instruction::BitCast };
 298     Value *V = ReplaceCallWith("setjmp", CI, CI->op_begin()+1, CI->op_end(),
 299                                castOpcodes, Type::IntTy, SetjmpFCache);
 300     if (CI->getType() != Type::VoidTy)
 301       CI->replaceAllUsesWith(V);
 302     break;
 303   }
 304   case Intrinsic::sigsetjmp:
 305      if (CI->getType() != Type::VoidTy)
 306        CI->replaceAllUsesWith(Constant::getNullValue(CI->getType()));
 307      break;
 308
 309   case Intrinsic::longjmp: {
 310     static Function *LongjmpFCache = 0;
 311     static const unsigned castOpcodes[] =
 312       { Instruction::BitCast, 0 };
 313     ReplaceCallWith("longjmp", CI, CI->op_begin()+1, CI->op_end(),
 314                     castOpcodes, Type::VoidTy, LongjmpFCache);
 315     break;
 316   }
 317
 318   case Intrinsic::siglongjmp: {
 319     // Insert the call to abort
 320     static Function *AbortFCache = 0;
 321     static const unsigned castOpcodes[] =
 322       { Instruction::BitCast, 0 };
 323     ReplaceCallWith("abort", CI, CI->op_end(), CI->op_end(),
 324                     castOpcodes, Type::VoidTy, AbortFCache);
 325     break;
 326   }
 327   case Intrinsic::ctpop_i8:
 328   case Intrinsic::ctpop_i16:
 329   case Intrinsic::ctpop_i32:
 330   case Intrinsic::ctpop_i64:
 331     CI->replaceAllUsesWith(LowerCTPOP(CI->getOperand(1), CI));
 332     break;
 333
 334   case Intrinsic::bswap_i16:
 335   case Intrinsic::bswap_i32:
 336   case Intrinsic::bswap_i64:
 337     CI->replaceAllUsesWith(LowerBSWAP(CI->getOperand(1), CI));
 338     break;
 339
 340   case Intrinsic::ctlz_i8:
 341   case Intrinsic::ctlz_i16:
 342   case Intrinsic::ctlz_i32:
 343   case Intrinsic::ctlz_i64:
 344     CI->replaceAllUsesWith(LowerCTLZ(CI->getOperand(1), CI));
 345     break;
 346
 347   case Intrinsic::cttz_i8:
 348   case Intrinsic::cttz_i16:
 349   case Intrinsic::cttz_i32:
 350   case Intrinsic::cttz_i64: {
 351     // cttz(x) -> ctpop(~X & (X-1))
 352     Value *Src = CI->getOperand(1);
 353     Value *NotSrc = BinaryOperator::createNot(Src, Src->getName()+".not", CI);
 354     Value *SrcM1  = ConstantInt::get(Src->getType(), 1);
 355     SrcM1 = BinaryOperator::createSub(Src, SrcM1, "", CI);
 356     Src = LowerCTPOP(BinaryOperator::createAnd(NotSrc, SrcM1, "", CI), CI);
 357     CI->replaceAllUsesWith(Src);
 358     break;
 359   }
 360
 361   case Intrinsic::stacksave:
 362   case Intrinsic::stackrestore: {
 363     static bool Warned = false;
 364     if (!Warned)
 365       cerr << "WARNING: this target does not support the llvm.stack"
 366            << (Callee->getIntrinsicID() == Intrinsic::stacksave ?
 367                "save" : "restore") << " intrinsic.\n";
 368     Warned = true;
 369     if (Callee->getIntrinsicID() == Intrinsic::stacksave)
 370       CI->replaceAllUsesWith(Constant::getNullValue(CI->getType()));
 371     break;
 372   }
 373
 374   case Intrinsic::returnaddress:
 375   case Intrinsic::frameaddress:
 376     cerr << "WARNING: this target does not support the llvm."
 377          << (Callee->getIntrinsicID() == Intrinsic::returnaddress ?
 378              "return" : "frame") << "address intrinsic.\n";
 379     CI->replaceAllUsesWith(ConstantPointerNull::get(
 380                                             cast<PointerType>(CI->getType())));
 381     break;
 382
 383   case Intrinsic::prefetch:
 384     break;    // Simply strip out prefetches on unsupported architectures
 385
 386   case Intrinsic::pcmarker:
 387     break;    // Simply strip out pcmarker on unsupported architectures
 388   case Intrinsic::readcyclecounter: {
 389     cerr << "WARNING: this target does not support the llvm.readcyclecoun"
 390          << "ter intrinsic.  It is being lowered to a constant 0\n";
 391     CI->replaceAllUsesWith(ConstantInt::get(Type::ULongTy, 0));
 392     break;
 393   }
 394
 395   case Intrinsic::dbg_stoppoint:
 396   case Intrinsic::dbg_region_start:
 397   case Intrinsic::dbg_region_end:
 398   case Intrinsic::dbg_func_start:
 399   case Intrinsic::dbg_declare:
 400     break;    // Simply strip out debugging intrinsics
 401
 402   case Intrinsic::memcpy_i32: {
 403     // The memcpy intrinsic take an extra alignment argument that the memcpy
 404     // libc function does not.
 405     static unsigned opcodes[] =
 406       { Instruction::BitCast, Instruction::BitCast, Instruction::BitCast };
 407     // FIXME:
 408     // if (target_is_64_bit) opcodes[2] = Instruction::ZExt;
 409     // else opcodes[2] = Instruction::BitCast;
 410     static Function *MemcpyFCache = 0;
 411     ReplaceCallWith("memcpy", CI, CI->op_begin()+1, CI->op_end()-1,
 412                     opcodes, (*(CI->op_begin()+1))->getType(), MemcpyFCache);
 413     break;
 414   }
 415   case Intrinsic::memcpy_i64: {
 416     static unsigned opcodes[] =
 417       { Instruction::BitCast, Instruction::BitCast, Instruction::Trunc };
 418     // FIXME:
 419     // if (target_is_64_bit) opcodes[2] = Instruction::BitCast;
 420     // else opcodes[2] = Instruction::Trunc;
 421     static Function *MemcpyFCache = 0;
 422     ReplaceCallWith("memcpy", CI, CI->op_begin()+1, CI->op_end()-1,
 423                      opcodes, (*(CI->op_begin()+1))->getType(), MemcpyFCache);
 424     break;
 425   }
 426   case Intrinsic::memmove_i32: {
 427     // The memmove intrinsic take an extra alignment argument that the memmove
 428     // libc function does not.
 429     static unsigned opcodes[] =
 430       { Instruction::BitCast, Instruction::BitCast, Instruction::BitCast };
 431     // FIXME:
 432     // if (target_is_64_bit) opcodes[2] = Instruction::ZExt;
 433     // else opcodes[2] = Instruction::BitCast;
 434     static Function *MemmoveFCache = 0;
 435     ReplaceCallWith("memmove", CI, CI->op_begin()+1, CI->op_end()-1,
 436                     opcodes, (*(CI->op_begin()+1))->getType(), MemmoveFCache);
 437     break;
 438   }
 439   case Intrinsic::memmove_i64: {
 440     // The memmove intrinsic take an extra alignment argument that the memmove
 441     // libc function does not.
 442     static const unsigned opcodes[] =
 443       { Instruction::BitCast, Instruction::BitCast, Instruction::Trunc };
 444     // if (target_is_64_bit) opcodes[2] = Instruction::BitCast;
 445     // else opcodes[2] = Instruction::Trunc;
 446     static Function *MemmoveFCache = 0;
 447     ReplaceCallWith("memmove", CI, CI->op_begin()+1, CI->op_end()-1,
 448                     opcodes, (*(CI->op_begin()+1))->getType(), MemmoveFCache);
 449     break;
 450   }
 451   case Intrinsic::memset_i32: {
 452     // The memset intrinsic take an extra alignment argument that the memset
 453     // libc function does not.
 454     static const unsigned opcodes[] =
 455       { Instruction::BitCast, Instruction::ZExt, Instruction::ZExt, 0 };
 456     // if (target_is_64_bit) opcodes[2] = Instruction::BitCast;
 457     // else opcodes[2] = Instruction::ZExt;
 458     static Function *MemsetFCache = 0;
 459     ReplaceCallWith("memset", CI, CI->op_begin()+1, CI->op_end()-1,
 460                     opcodes, (*(CI->op_begin()+1))->getType(), MemsetFCache);
 461   }
 462   case Intrinsic::memset_i64: {
 463     // The memset intrinsic take an extra alignment argument that the memset
 464     // libc function does not.
 465     static const unsigned opcodes[] =
 466       { Instruction::BitCast, Instruction::ZExt, Instruction::Trunc, 0 };
 467     // if (target_is_64_bit) opcodes[2] = Instruction::BitCast;
 468     // else opcodes[2] = Instruction::Trunc;
 469     static Function *MemsetFCache = 0;
 470     ReplaceCallWith("memset", CI, CI->op_begin()+1, CI->op_end()-1,
 471                     opcodes, (*(CI->op_begin()+1))->getType(), MemsetFCache);
 472     break;
 473   }
 474   case Intrinsic::isunordered_f32:
 475   case Intrinsic::isunordered_f64: {
 476     Value *L = CI->getOperand(1);
 477     Value *R = CI->getOperand(2);
 478
 479     Value *LIsNan = new SetCondInst(Instruction::SetNE, L, L, "LIsNan", CI);
 480     Value *RIsNan = new SetCondInst(Instruction::SetNE, R, R, "RIsNan", CI);
 481     CI->replaceAllUsesWith(
 482       BinaryOperator::create(Instruction::Or, LIsNan, RIsNan,
 483                              "isunordered", CI));
 484     break;
 485   }
 486   case Intrinsic::sqrt_f32: {
 487     static const unsigned opcodes[] = { 0 };
 488     static Function *sqrtfFCache = 0;
 489     ReplaceCallWith("sqrtf", CI, CI->op_begin()+1, CI->op_end(),
 490                     opcodes, Type::FloatTy, sqrtfFCache);
 491     break;
 492   }
 493   case Intrinsic::sqrt_f64: {
 494     static const unsigned opcodes[] =  { 0 };
 495     static Function *sqrtFCache = 0;
 496     ReplaceCallWith("sqrt", CI, CI->op_begin()+1, CI->op_end(),
 497                     opcodes, Type::DoubleTy, sqrtFCache);
 498     break;
 499   }
 500   }
 501
 502   assert(CI->use_empty() &&
 503          "Lowering should have eliminated any uses of the intrinsic call!");
 504   CI->eraseFromParent();
 505 }