IntrinsicLowering.cpp revision 4c4839d12ca71438a1e51e7e8faa0f3d7868ef8f
1//===-- IntrinsicLowering.cpp - Intrinsic Lowering default implementation -===// 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 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#include "llvm/Target/TargetData.h" 22#include "llvm/ADT/SmallVector.h" 23#include "llvm/ADT/STLExtras.h" 24using namespace llvm; 25 26// Return the integer value Val zero-extended or truncated (if necessary) to 27// type ITy. Any new instructions are inserted at InsertBefore. 28template<typename InsertType> 29static Value *getZExtOrTrunc(Value *Val, const IntegerType *ITy, 30 InsertType InsertPoint) { 31 const IntegerType *ValTy = cast<IntegerType>(Val->getType()); 32 if (ValTy == ITy) 33 return Val; 34 Constant *CVal = dyn_cast<Constant>(Val); 35 if (ValTy->getBitWidth() < ITy->getBitWidth()) { 36 if (CVal) 37 return ConstantExpr::getZExt(CVal, ITy); 38 return new ZExtInst(Val, ITy, "", InsertPoint); 39 } else { 40 if (CVal) 41 return ConstantExpr::getTrunc(CVal, ITy); 42 return new TruncInst(Val, ITy, "", InsertPoint); 43 } 44} 45 46template <class ArgIt> 47static void EnsureFunctionExists(Module &M, const char *Name, 48 ArgIt ArgBegin, ArgIt ArgEnd, 49 const Type *RetTy) { 50 // Insert a correctly-typed definition now. 51 std::vector<const Type *> ParamTys; 52 for (ArgIt I = ArgBegin; I != ArgEnd; ++I) 53 ParamTys.push_back(I->getType()); 54 M.getOrInsertFunction(Name, FunctionType::get(RetTy, ParamTys, false)); 55} 56 57static void EnsureFPIntrinsicsExist(Module &M, Function *Fn, 58 const char *FName, 59 const char *DName, const char *LDName) { 60 // Insert definitions for all the floating point types. 61 switch((int)Fn->arg_begin()->getType()->getTypeID()) { 62 case Type::FloatTyID: 63 EnsureFunctionExists(M, FName, Fn->arg_begin(), Fn->arg_end(), 64 Type::FloatTy); 65 break; 66 case Type::DoubleTyID: 67 EnsureFunctionExists(M, DName, Fn->arg_begin(), Fn->arg_end(), 68 Type::DoubleTy); 69 break; 70 case Type::X86_FP80TyID: 71 case Type::FP128TyID: 72 case Type::PPC_FP128TyID: 73 EnsureFunctionExists(M, LDName, Fn->arg_begin(), Fn->arg_end(), 74 Fn->arg_begin()->getType()); 75 break; 76 } 77} 78 79/// ReplaceCallWith - This function is used when we want to lower an intrinsic 80/// call to a call of an external function. This handles hard cases such as 81/// when there was already a prototype for the external function, and if that 82/// prototype doesn't match the arguments we expect to pass in. 83template <class ArgIt> 84static CallInst *ReplaceCallWith(const char *NewFn, CallInst *CI, 85 ArgIt ArgBegin, ArgIt ArgEnd, 86 const Type *RetTy, Constant *&FCache) { 87 if (!FCache) { 88 // If we haven't already looked up this function, check to see if the 89 // program already contains a function with this name. 90 Module *M = CI->getParent()->getParent()->getParent(); 91 // Get or insert the definition now. 92 std::vector<const Type *> ParamTys; 93 for (ArgIt I = ArgBegin; I != ArgEnd; ++I) 94 ParamTys.push_back((*I)->getType()); 95 FCache = M->getOrInsertFunction(NewFn, 96 FunctionType::get(RetTy, ParamTys, false)); 97 } 98 99 SmallVector<Value *, 8> Args(ArgBegin, ArgEnd); 100 CallInst *NewCI = CallInst::Create(FCache, Args.begin(), Args.end(), 101 CI->getName(), CI); 102 if (!CI->use_empty()) 103 CI->replaceAllUsesWith(NewCI); 104 return NewCI; 105} 106 107void IntrinsicLowering::AddPrototypes(Module &M) { 108 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) 109 if (I->isDeclaration() && !I->use_empty()) 110 switch (I->getIntrinsicID()) { 111 default: break; 112 case Intrinsic::setjmp: 113 EnsureFunctionExists(M, "setjmp", I->arg_begin(), I->arg_end(), 114 Type::Int32Ty); 115 break; 116 case Intrinsic::longjmp: 117 EnsureFunctionExists(M, "longjmp", I->arg_begin(), I->arg_end(), 118 Type::VoidTy); 119 break; 120 case Intrinsic::siglongjmp: 121 EnsureFunctionExists(M, "abort", I->arg_end(), I->arg_end(), 122 Type::VoidTy); 123 break; 124 case Intrinsic::memcpy: 125 M.getOrInsertFunction("memcpy", PointerType::getUnqual(Type::Int8Ty), 126 PointerType::getUnqual(Type::Int8Ty), 127 PointerType::getUnqual(Type::Int8Ty), 128 TD.getIntPtrType(), (Type *)0); 129 break; 130 case Intrinsic::memmove: 131 M.getOrInsertFunction("memmove", PointerType::getUnqual(Type::Int8Ty), 132 PointerType::getUnqual(Type::Int8Ty), 133 PointerType::getUnqual(Type::Int8Ty), 134 TD.getIntPtrType(), (Type *)0); 135 break; 136 case Intrinsic::memset: 137 M.getOrInsertFunction("memset", PointerType::getUnqual(Type::Int8Ty), 138 PointerType::getUnqual(Type::Int8Ty), 139 Type::Int32Ty, 140 TD.getIntPtrType(), (Type *)0); 141 break; 142 case Intrinsic::sqrt: 143 EnsureFPIntrinsicsExist(M, I, "sqrtf", "sqrt", "sqrtl"); 144 break; 145 case Intrinsic::sin: 146 EnsureFPIntrinsicsExist(M, I, "sinf", "sin", "sinl"); 147 break; 148 case Intrinsic::cos: 149 EnsureFPIntrinsicsExist(M, I, "cosf", "cos", "cosl"); 150 break; 151 case Intrinsic::pow: 152 EnsureFPIntrinsicsExist(M, I, "powf", "pow", "powl"); 153 break; 154 case Intrinsic::log: 155 EnsureFPIntrinsicsExist(M, I, "logf", "log", "logl"); 156 break; 157 case Intrinsic::log2: 158 EnsureFPIntrinsicsExist(M, I, "log2f", "log2", "log2l"); 159 break; 160 case Intrinsic::log10: 161 EnsureFPIntrinsicsExist(M, I, "log10f", "log10", "log10l"); 162 break; 163 case Intrinsic::exp: 164 EnsureFPIntrinsicsExist(M, I, "expf", "exp", "expl"); 165 break; 166 case Intrinsic::exp2: 167 EnsureFPIntrinsicsExist(M, I, "exp2f", "exp2", "exp2l"); 168 break; 169 } 170} 171 172/// LowerBSWAP - Emit the code to lower bswap of V before the specified 173/// instruction IP. 174static Value *LowerBSWAP(Value *V, Instruction *IP) { 175 assert(V->getType()->isInteger() && "Can't bswap a non-integer type!"); 176 177 unsigned BitSize = V->getType()->getPrimitiveSizeInBits(); 178 179 switch(BitSize) { 180 default: assert(0 && "Unhandled type size of value to byteswap!"); 181 case 16: { 182 Value *Tmp1 = BinaryOperator::CreateShl(V, 183 ConstantInt::get(V->getType(),8),"bswap.2",IP); 184 Value *Tmp2 = BinaryOperator::CreateLShr(V, 185 ConstantInt::get(V->getType(),8),"bswap.1",IP); 186 V = BinaryOperator::CreateOr(Tmp1, Tmp2, "bswap.i16", IP); 187 break; 188 } 189 case 32: { 190 Value *Tmp4 = BinaryOperator::CreateShl(V, 191 ConstantInt::get(V->getType(),24),"bswap.4", IP); 192 Value *Tmp3 = BinaryOperator::CreateShl(V, 193 ConstantInt::get(V->getType(),8),"bswap.3",IP); 194 Value *Tmp2 = BinaryOperator::CreateLShr(V, 195 ConstantInt::get(V->getType(),8),"bswap.2",IP); 196 Value *Tmp1 = BinaryOperator::CreateLShr(V, 197 ConstantInt::get(V->getType(),24),"bswap.1", IP); 198 Tmp3 = BinaryOperator::CreateAnd(Tmp3, 199 ConstantInt::get(Type::Int32Ty, 0xFF0000), 200 "bswap.and3", IP); 201 Tmp2 = BinaryOperator::CreateAnd(Tmp2, 202 ConstantInt::get(Type::Int32Ty, 0xFF00), 203 "bswap.and2", IP); 204 Tmp4 = BinaryOperator::CreateOr(Tmp4, Tmp3, "bswap.or1", IP); 205 Tmp2 = BinaryOperator::CreateOr(Tmp2, Tmp1, "bswap.or2", IP); 206 V = BinaryOperator::CreateOr(Tmp4, Tmp2, "bswap.i32", IP); 207 break; 208 } 209 case 64: { 210 Value *Tmp8 = BinaryOperator::CreateShl(V, 211 ConstantInt::get(V->getType(),56),"bswap.8", IP); 212 Value *Tmp7 = BinaryOperator::CreateShl(V, 213 ConstantInt::get(V->getType(),40),"bswap.7", IP); 214 Value *Tmp6 = BinaryOperator::CreateShl(V, 215 ConstantInt::get(V->getType(),24),"bswap.6", IP); 216 Value *Tmp5 = BinaryOperator::CreateShl(V, 217 ConstantInt::get(V->getType(),8),"bswap.5", IP); 218 Value* Tmp4 = BinaryOperator::CreateLShr(V, 219 ConstantInt::get(V->getType(),8),"bswap.4", IP); 220 Value* Tmp3 = BinaryOperator::CreateLShr(V, 221 ConstantInt::get(V->getType(),24),"bswap.3", IP); 222 Value* Tmp2 = BinaryOperator::CreateLShr(V, 223 ConstantInt::get(V->getType(),40),"bswap.2", IP); 224 Value* Tmp1 = BinaryOperator::CreateLShr(V, 225 ConstantInt::get(V->getType(),56),"bswap.1", IP); 226 Tmp7 = BinaryOperator::CreateAnd(Tmp7, 227 ConstantInt::get(Type::Int64Ty, 228 0xFF000000000000ULL), 229 "bswap.and7", IP); 230 Tmp6 = BinaryOperator::CreateAnd(Tmp6, 231 ConstantInt::get(Type::Int64Ty, 0xFF0000000000ULL), 232 "bswap.and6", IP); 233 Tmp5 = BinaryOperator::CreateAnd(Tmp5, 234 ConstantInt::get(Type::Int64Ty, 0xFF00000000ULL), 235 "bswap.and5", IP); 236 Tmp4 = BinaryOperator::CreateAnd(Tmp4, 237 ConstantInt::get(Type::Int64Ty, 0xFF000000ULL), 238 "bswap.and4", IP); 239 Tmp3 = BinaryOperator::CreateAnd(Tmp3, 240 ConstantInt::get(Type::Int64Ty, 0xFF0000ULL), 241 "bswap.and3", IP); 242 Tmp2 = BinaryOperator::CreateAnd(Tmp2, 243 ConstantInt::get(Type::Int64Ty, 0xFF00ULL), 244 "bswap.and2", IP); 245 Tmp8 = BinaryOperator::CreateOr(Tmp8, Tmp7, "bswap.or1", IP); 246 Tmp6 = BinaryOperator::CreateOr(Tmp6, Tmp5, "bswap.or2", IP); 247 Tmp4 = BinaryOperator::CreateOr(Tmp4, Tmp3, "bswap.or3", IP); 248 Tmp2 = BinaryOperator::CreateOr(Tmp2, Tmp1, "bswap.or4", IP); 249 Tmp8 = BinaryOperator::CreateOr(Tmp8, Tmp6, "bswap.or5", IP); 250 Tmp4 = BinaryOperator::CreateOr(Tmp4, Tmp2, "bswap.or6", IP); 251 V = BinaryOperator::CreateOr(Tmp8, Tmp4, "bswap.i64", IP); 252 break; 253 } 254 } 255 return V; 256} 257 258/// LowerCTPOP - Emit the code to lower ctpop of V before the specified 259/// instruction IP. 260static Value *LowerCTPOP(Value *V, Instruction *IP) { 261 assert(V->getType()->isInteger() && "Can't ctpop a non-integer type!"); 262 263 static const uint64_t MaskValues[6] = { 264 0x5555555555555555ULL, 0x3333333333333333ULL, 265 0x0F0F0F0F0F0F0F0FULL, 0x00FF00FF00FF00FFULL, 266 0x0000FFFF0000FFFFULL, 0x00000000FFFFFFFFULL 267 }; 268 269 unsigned BitSize = V->getType()->getPrimitiveSizeInBits(); 270 unsigned WordSize = (BitSize + 63) / 64; 271 Value *Count = ConstantInt::get(V->getType(), 0); 272 273 for (unsigned n = 0; n < WordSize; ++n) { 274 Value *PartValue = V; 275 for (unsigned i = 1, ct = 0; i < (BitSize>64 ? 64 : BitSize); 276 i <<= 1, ++ct) { 277 Value *MaskCst = ConstantInt::get(V->getType(), MaskValues[ct]); 278 Value *LHS = BinaryOperator::CreateAnd( 279 PartValue, MaskCst, "cppop.and1", IP); 280 Value *VShift = BinaryOperator::CreateLShr(PartValue, 281 ConstantInt::get(V->getType(), i), "ctpop.sh", IP); 282 Value *RHS = BinaryOperator::CreateAnd(VShift, MaskCst, "cppop.and2", IP); 283 PartValue = BinaryOperator::CreateAdd(LHS, RHS, "ctpop.step", IP); 284 } 285 Count = BinaryOperator::CreateAdd(PartValue, Count, "ctpop.part", IP); 286 if (BitSize > 64) { 287 V = BinaryOperator::CreateLShr(V, ConstantInt::get(V->getType(), 64), 288 "ctpop.part.sh", IP); 289 BitSize -= 64; 290 } 291 } 292 293 return Count; 294} 295 296/// LowerCTLZ - Emit the code to lower ctlz of V before the specified 297/// instruction IP. 298static Value *LowerCTLZ(Value *V, Instruction *IP) { 299 300 unsigned BitSize = V->getType()->getPrimitiveSizeInBits(); 301 for (unsigned i = 1; i < BitSize; i <<= 1) { 302 Value *ShVal = ConstantInt::get(V->getType(), i); 303 ShVal = BinaryOperator::CreateLShr(V, ShVal, "ctlz.sh", IP); 304 V = BinaryOperator::CreateOr(V, ShVal, "ctlz.step", IP); 305 } 306 307 V = BinaryOperator::CreateNot(V, "", IP); 308 return LowerCTPOP(V, IP); 309} 310 311/// Convert the llvm.part.select.iX.iY intrinsic. This intrinsic takes 312/// three integer arguments. The first argument is the Value from which the 313/// bits will be selected. It may be of any bit width. The second and third 314/// arguments specify a range of bits to select with the second argument 315/// specifying the low bit and the third argument specifying the high bit. Both 316/// must be type i32. The result is the corresponding selected bits from the 317/// Value in the same width as the Value (first argument). If the low bit index 318/// is higher than the high bit index then the inverse selection is done and 319/// the bits are returned in inverse order. 320/// @brief Lowering of llvm.part.select intrinsic. 321static Instruction *LowerPartSelect(CallInst *CI) { 322 // Make sure we're dealing with a part select intrinsic here 323 Function *F = CI->getCalledFunction(); 324 const FunctionType *FT = F->getFunctionType(); 325 if (!F->isDeclaration() || !FT->getReturnType()->isInteger() || 326 FT->getNumParams() != 3 || !FT->getParamType(0)->isInteger() || 327 !FT->getParamType(1)->isInteger() || !FT->getParamType(2)->isInteger()) 328 return CI; 329 330 // Get the intrinsic implementation function by converting all the . to _ 331 // in the intrinsic's function name and then reconstructing the function 332 // declaration. 333 std::string Name(F->getName()); 334 for (unsigned i = 4; i < Name.length(); ++i) 335 if (Name[i] == '.') 336 Name[i] = '_'; 337 Module* M = F->getParent(); 338 F = cast<Function>(M->getOrInsertFunction(Name, FT)); 339 F->setLinkage(GlobalValue::WeakAnyLinkage); 340 341 // If we haven't defined the impl function yet, do so now 342 if (F->isDeclaration()) { 343 344 // Get the arguments to the function 345 Function::arg_iterator args = F->arg_begin(); 346 Value* Val = args++; Val->setName("Val"); 347 Value* Lo = args++; Lo->setName("Lo"); 348 Value* Hi = args++; Hi->setName("High"); 349 350 // We want to select a range of bits here such that [Hi, Lo] is shifted 351 // down to the low bits. However, it is quite possible that Hi is smaller 352 // than Lo in which case the bits have to be reversed. 353 354 // Create the blocks we will need for the two cases (forward, reverse) 355 BasicBlock* CurBB = BasicBlock::Create("entry", F); 356 BasicBlock *RevSize = BasicBlock::Create("revsize", CurBB->getParent()); 357 BasicBlock *FwdSize = BasicBlock::Create("fwdsize", CurBB->getParent()); 358 BasicBlock *Compute = BasicBlock::Create("compute", CurBB->getParent()); 359 BasicBlock *Reverse = BasicBlock::Create("reverse", CurBB->getParent()); 360 BasicBlock *RsltBlk = BasicBlock::Create("result", CurBB->getParent()); 361 362 // Cast Hi and Lo to the size of Val so the widths are all the same 363 if (Hi->getType() != Val->getType()) 364 Hi = CastInst::CreateIntegerCast(Hi, Val->getType(), false, 365 "tmp", CurBB); 366 if (Lo->getType() != Val->getType()) 367 Lo = CastInst::CreateIntegerCast(Lo, Val->getType(), false, 368 "tmp", CurBB); 369 370 // Compute a few things that both cases will need, up front. 371 Constant* Zero = ConstantInt::get(Val->getType(), 0); 372 Constant* One = ConstantInt::get(Val->getType(), 1); 373 Constant* AllOnes = ConstantInt::getAllOnesValue(Val->getType()); 374 375 // Compare the Hi and Lo bit positions. This is used to determine 376 // which case we have (forward or reverse) 377 ICmpInst *Cmp = new ICmpInst(ICmpInst::ICMP_ULT, Hi, Lo, "less",CurBB); 378 BranchInst::Create(RevSize, FwdSize, Cmp, CurBB); 379 380 // First, copmute the number of bits in the forward case. 381 Instruction* FBitSize = 382 BinaryOperator::CreateSub(Hi, Lo,"fbits", FwdSize); 383 BranchInst::Create(Compute, FwdSize); 384 385 // Second, compute the number of bits in the reverse case. 386 Instruction* RBitSize = 387 BinaryOperator::CreateSub(Lo, Hi, "rbits", RevSize); 388 BranchInst::Create(Compute, RevSize); 389 390 // Now, compute the bit range. Start by getting the bitsize and the shift 391 // amount (either Hi or Lo) from PHI nodes. Then we compute a mask for 392 // the number of bits we want in the range. We shift the bits down to the 393 // least significant bits, apply the mask to zero out unwanted high bits, 394 // and we have computed the "forward" result. It may still need to be 395 // reversed. 396 397 // Get the BitSize from one of the two subtractions 398 PHINode *BitSize = PHINode::Create(Val->getType(), "bits", Compute); 399 BitSize->reserveOperandSpace(2); 400 BitSize->addIncoming(FBitSize, FwdSize); 401 BitSize->addIncoming(RBitSize, RevSize); 402 403 // Get the ShiftAmount as the smaller of Hi/Lo 404 PHINode *ShiftAmt = PHINode::Create(Val->getType(), "shiftamt", Compute); 405 ShiftAmt->reserveOperandSpace(2); 406 ShiftAmt->addIncoming(Lo, FwdSize); 407 ShiftAmt->addIncoming(Hi, RevSize); 408 409 // Increment the bit size 410 Instruction *BitSizePlusOne = 411 BinaryOperator::CreateAdd(BitSize, One, "bits", Compute); 412 413 // Create a Mask to zero out the high order bits. 414 Instruction* Mask = 415 BinaryOperator::CreateShl(AllOnes, BitSizePlusOne, "mask", Compute); 416 Mask = BinaryOperator::CreateNot(Mask, "mask", Compute); 417 418 // Shift the bits down and apply the mask 419 Instruction* FRes = 420 BinaryOperator::CreateLShr(Val, ShiftAmt, "fres", Compute); 421 FRes = BinaryOperator::CreateAnd(FRes, Mask, "fres", Compute); 422 BranchInst::Create(Reverse, RsltBlk, Cmp, Compute); 423 424 // In the Reverse block we have the mask already in FRes but we must reverse 425 // it by shifting FRes bits right and putting them in RRes by shifting them 426 // in from left. 427 428 // First set up our loop counters 429 PHINode *Count = PHINode::Create(Val->getType(), "count", Reverse); 430 Count->reserveOperandSpace(2); 431 Count->addIncoming(BitSizePlusOne, Compute); 432 433 // Next, get the value that we are shifting. 434 PHINode *BitsToShift = PHINode::Create(Val->getType(), "val", Reverse); 435 BitsToShift->reserveOperandSpace(2); 436 BitsToShift->addIncoming(FRes, Compute); 437 438 // Finally, get the result of the last computation 439 PHINode *RRes = PHINode::Create(Val->getType(), "rres", Reverse); 440 RRes->reserveOperandSpace(2); 441 RRes->addIncoming(Zero, Compute); 442 443 // Decrement the counter 444 Instruction *Decr = BinaryOperator::CreateSub(Count, One, "decr", Reverse); 445 Count->addIncoming(Decr, Reverse); 446 447 // Compute the Bit that we want to move 448 Instruction *Bit = 449 BinaryOperator::CreateAnd(BitsToShift, One, "bit", Reverse); 450 451 // Compute the new value for next iteration. 452 Instruction *NewVal = 453 BinaryOperator::CreateLShr(BitsToShift, One, "rshift", Reverse); 454 BitsToShift->addIncoming(NewVal, Reverse); 455 456 // Shift the bit into the low bits of the result. 457 Instruction *NewRes = 458 BinaryOperator::CreateShl(RRes, One, "lshift", Reverse); 459 NewRes = BinaryOperator::CreateOr(NewRes, Bit, "addbit", Reverse); 460 RRes->addIncoming(NewRes, Reverse); 461 462 // Terminate loop if we've moved all the bits. 463 ICmpInst *Cond = 464 new ICmpInst(ICmpInst::ICMP_EQ, Decr, Zero, "cond", Reverse); 465 BranchInst::Create(RsltBlk, Reverse, Cond, Reverse); 466 467 // Finally, in the result block, select one of the two results with a PHI 468 // node and return the result; 469 CurBB = RsltBlk; 470 PHINode *BitSelect = PHINode::Create(Val->getType(), "part_select", CurBB); 471 BitSelect->reserveOperandSpace(2); 472 BitSelect->addIncoming(FRes, Compute); 473 BitSelect->addIncoming(NewRes, Reverse); 474 ReturnInst::Create(BitSelect, CurBB); 475 } 476 477 // Return a call to the implementation function 478 Value *Args[] = { 479 CI->getOperand(1), 480 CI->getOperand(2), 481 CI->getOperand(3) 482 }; 483 return CallInst::Create(F, Args, array_endof(Args), CI->getName(), CI); 484} 485 486/// Convert the llvm.part.set.iX.iY.iZ intrinsic. This intrinsic takes 487/// four integer arguments (iAny %Value, iAny %Replacement, i32 %Low, i32 %High) 488/// The first two arguments can be any bit width. The result is the same width 489/// as %Value. The operation replaces bits between %Low and %High with the value 490/// in %Replacement. If %Replacement is not the same width, it is truncated or 491/// zero extended as appropriate to fit the bits being replaced. If %Low is 492/// greater than %High then the inverse set of bits are replaced. 493/// @brief Lowering of llvm.bit.part.set intrinsic. 494static Instruction *LowerPartSet(CallInst *CI) { 495 // Make sure we're dealing with a part select intrinsic here 496 Function *F = CI->getCalledFunction(); 497 const FunctionType *FT = F->getFunctionType(); 498 if (!F->isDeclaration() || !FT->getReturnType()->isInteger() || 499 FT->getNumParams() != 4 || !FT->getParamType(0)->isInteger() || 500 !FT->getParamType(1)->isInteger() || !FT->getParamType(2)->isInteger() || 501 !FT->getParamType(3)->isInteger()) 502 return CI; 503 504 // Get the intrinsic implementation function by converting all the . to _ 505 // in the intrinsic's function name and then reconstructing the function 506 // declaration. 507 std::string Name(F->getName()); 508 for (unsigned i = 4; i < Name.length(); ++i) 509 if (Name[i] == '.') 510 Name[i] = '_'; 511 Module* M = F->getParent(); 512 F = cast<Function>(M->getOrInsertFunction(Name, FT)); 513 F->setLinkage(GlobalValue::WeakAnyLinkage); 514 515 // If we haven't defined the impl function yet, do so now 516 if (F->isDeclaration()) { 517 // Get the arguments for the function. 518 Function::arg_iterator args = F->arg_begin(); 519 Value* Val = args++; Val->setName("Val"); 520 Value* Rep = args++; Rep->setName("Rep"); 521 Value* Lo = args++; Lo->setName("Lo"); 522 Value* Hi = args++; Hi->setName("Hi"); 523 524 // Get some types we need 525 const IntegerType* ValTy = cast<IntegerType>(Val->getType()); 526 const IntegerType* RepTy = cast<IntegerType>(Rep->getType()); 527 uint32_t RepBits = RepTy->getBitWidth(); 528 529 // Constant Definitions 530 ConstantInt* RepBitWidth = ConstantInt::get(Type::Int32Ty, RepBits); 531 ConstantInt* RepMask = ConstantInt::getAllOnesValue(RepTy); 532 ConstantInt* ValMask = ConstantInt::getAllOnesValue(ValTy); 533 ConstantInt* One = ConstantInt::get(Type::Int32Ty, 1); 534 ConstantInt* ValOne = ConstantInt::get(ValTy, 1); 535 ConstantInt* Zero = ConstantInt::get(Type::Int32Ty, 0); 536 ConstantInt* ValZero = ConstantInt::get(ValTy, 0); 537 538 // Basic blocks we fill in below. 539 BasicBlock* entry = BasicBlock::Create("entry", F, 0); 540 BasicBlock* large = BasicBlock::Create("large", F, 0); 541 BasicBlock* small = BasicBlock::Create("small", F, 0); 542 BasicBlock* reverse = BasicBlock::Create("reverse", F, 0); 543 BasicBlock* result = BasicBlock::Create("result", F, 0); 544 545 // BASIC BLOCK: entry 546 // First, get the number of bits that we're placing as an i32 547 ICmpInst* is_forward = 548 new ICmpInst(ICmpInst::ICMP_ULT, Lo, Hi, "", entry); 549 SelectInst* Hi_pn = SelectInst::Create(is_forward, Hi, Lo, "", entry); 550 SelectInst* Lo_pn = SelectInst::Create(is_forward, Lo, Hi, "", entry); 551 BinaryOperator* NumBits = BinaryOperator::CreateSub(Hi_pn, Lo_pn, "",entry); 552 NumBits = BinaryOperator::CreateAdd(NumBits, One, "", entry); 553 // Now, convert Lo and Hi to ValTy bit width 554 Lo = getZExtOrTrunc(Lo_pn, ValTy, entry); 555 // Determine if the replacement bits are larger than the number of bits we 556 // are replacing and deal with it. 557 ICmpInst* is_large = 558 new ICmpInst(ICmpInst::ICMP_ULT, NumBits, RepBitWidth, "", entry); 559 BranchInst::Create(large, small, is_large, entry); 560 561 // BASIC BLOCK: large 562 Instruction* MaskBits = 563 BinaryOperator::CreateSub(RepBitWidth, NumBits, "", large); 564 MaskBits = CastInst::CreateIntegerCast(MaskBits, RepMask->getType(), 565 false, "", large); 566 BinaryOperator* Mask1 = 567 BinaryOperator::CreateLShr(RepMask, MaskBits, "", large); 568 BinaryOperator* Rep2 = BinaryOperator::CreateAnd(Mask1, Rep, "", large); 569 BranchInst::Create(small, large); 570 571 // BASIC BLOCK: small 572 PHINode* Rep3 = PHINode::Create(RepTy, "", small); 573 Rep3->reserveOperandSpace(2); 574 Rep3->addIncoming(Rep2, large); 575 Rep3->addIncoming(Rep, entry); 576 Value* Rep4 = getZExtOrTrunc(Rep3, ValTy, small); 577 BranchInst::Create(result, reverse, is_forward, small); 578 579 // BASIC BLOCK: reverse (reverses the bits of the replacement) 580 // Set up our loop counter as a PHI so we can decrement on each iteration. 581 // We will loop for the number of bits in the replacement value. 582 PHINode *Count = PHINode::Create(Type::Int32Ty, "count", reverse); 583 Count->reserveOperandSpace(2); 584 Count->addIncoming(NumBits, small); 585 586 // Get the value that we are shifting bits out of as a PHI because 587 // we'll change this with each iteration. 588 PHINode *BitsToShift = PHINode::Create(Val->getType(), "val", reverse); 589 BitsToShift->reserveOperandSpace(2); 590 BitsToShift->addIncoming(Rep4, small); 591 592 // Get the result of the last computation or zero on first iteration 593 PHINode *RRes = PHINode::Create(Val->getType(), "rres", reverse); 594 RRes->reserveOperandSpace(2); 595 RRes->addIncoming(ValZero, small); 596 597 // Decrement the loop counter by one 598 Instruction *Decr = BinaryOperator::CreateSub(Count, One, "", reverse); 599 Count->addIncoming(Decr, reverse); 600 601 // Get the bit that we want to move into the result 602 Value *Bit = BinaryOperator::CreateAnd(BitsToShift, ValOne, "", reverse); 603 604 // Compute the new value of the bits to shift for the next iteration. 605 Value *NewVal = BinaryOperator::CreateLShr(BitsToShift, ValOne,"", reverse); 606 BitsToShift->addIncoming(NewVal, reverse); 607 608 // Shift the bit we extracted into the low bit of the result. 609 Instruction *NewRes = BinaryOperator::CreateShl(RRes, ValOne, "", reverse); 610 NewRes = BinaryOperator::CreateOr(NewRes, Bit, "", reverse); 611 RRes->addIncoming(NewRes, reverse); 612 613 // Terminate loop if we've moved all the bits. 614 ICmpInst *Cond = new ICmpInst(ICmpInst::ICMP_EQ, Decr, Zero, "", reverse); 615 BranchInst::Create(result, reverse, Cond, reverse); 616 617 // BASIC BLOCK: result 618 PHINode *Rplcmnt = PHINode::Create(Val->getType(), "", result); 619 Rplcmnt->reserveOperandSpace(2); 620 Rplcmnt->addIncoming(NewRes, reverse); 621 Rplcmnt->addIncoming(Rep4, small); 622 Value* t0 = CastInst::CreateIntegerCast(NumBits,ValTy,false,"",result); 623 Value* t1 = BinaryOperator::CreateShl(ValMask, Lo, "", result); 624 Value* t2 = BinaryOperator::CreateNot(t1, "", result); 625 Value* t3 = BinaryOperator::CreateShl(t1, t0, "", result); 626 Value* t4 = BinaryOperator::CreateOr(t2, t3, "", result); 627 Value* t5 = BinaryOperator::CreateAnd(t4, Val, "", result); 628 Value* t6 = BinaryOperator::CreateShl(Rplcmnt, Lo, "", result); 629 Value* Rslt = BinaryOperator::CreateOr(t5, t6, "part_set", result); 630 ReturnInst::Create(Rslt, result); 631 } 632 633 // Return a call to the implementation function 634 Value *Args[] = { 635 CI->getOperand(1), 636 CI->getOperand(2), 637 CI->getOperand(3), 638 CI->getOperand(4) 639 }; 640 return CallInst::Create(F, Args, array_endof(Args), CI->getName(), CI); 641} 642 643static void ReplaceFPIntrinsicWithCall(CallInst *CI, Constant *FCache, 644 Constant *DCache, Constant *LDCache, 645 const char *Fname, const char *Dname, 646 const char *LDname) { 647 switch (CI->getOperand(1)->getType()->getTypeID()) { 648 default: assert(0 && "Invalid type in intrinsic"); abort(); 649 case Type::FloatTyID: 650 ReplaceCallWith(Fname, CI, CI->op_begin()+1, CI->op_end(), 651 Type::FloatTy, FCache); 652 break; 653 case Type::DoubleTyID: 654 ReplaceCallWith(Dname, CI, CI->op_begin()+1, CI->op_end(), 655 Type::DoubleTy, DCache); 656 break; 657 case Type::X86_FP80TyID: 658 case Type::FP128TyID: 659 case Type::PPC_FP128TyID: 660 ReplaceCallWith(LDname, CI, CI->op_begin()+1, CI->op_end(), 661 CI->getOperand(1)->getType(), LDCache); 662 break; 663 } 664} 665 666void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) { 667 Function *Callee = CI->getCalledFunction(); 668 assert(Callee && "Cannot lower an indirect call!"); 669 670 switch (Callee->getIntrinsicID()) { 671 case Intrinsic::not_intrinsic: 672 cerr << "Cannot lower a call to a non-intrinsic function '" 673 << Callee->getName() << "'!\n"; 674 abort(); 675 default: 676 cerr << "Error: Code generator does not support intrinsic function '" 677 << Callee->getName() << "'!\n"; 678 abort(); 679 680 // The setjmp/longjmp intrinsics should only exist in the code if it was 681 // never optimized (ie, right out of the CFE), or if it has been hacked on 682 // by the lowerinvoke pass. In both cases, the right thing to do is to 683 // convert the call to an explicit setjmp or longjmp call. 684 case Intrinsic::setjmp: { 685 static Constant *SetjmpFCache = 0; 686 Value *V = ReplaceCallWith("setjmp", CI, CI->op_begin()+1, CI->op_end(), 687 Type::Int32Ty, SetjmpFCache); 688 if (CI->getType() != Type::VoidTy) 689 CI->replaceAllUsesWith(V); 690 break; 691 } 692 case Intrinsic::sigsetjmp: 693 if (CI->getType() != Type::VoidTy) 694 CI->replaceAllUsesWith(Constant::getNullValue(CI->getType())); 695 break; 696 697 case Intrinsic::longjmp: { 698 static Constant *LongjmpFCache = 0; 699 ReplaceCallWith("longjmp", CI, CI->op_begin()+1, CI->op_end(), 700 Type::VoidTy, LongjmpFCache); 701 break; 702 } 703 704 case Intrinsic::siglongjmp: { 705 // Insert the call to abort 706 static Constant *AbortFCache = 0; 707 ReplaceCallWith("abort", CI, CI->op_end(), CI->op_end(), 708 Type::VoidTy, AbortFCache); 709 break; 710 } 711 case Intrinsic::ctpop: 712 CI->replaceAllUsesWith(LowerCTPOP(CI->getOperand(1), CI)); 713 break; 714 715 case Intrinsic::bswap: 716 CI->replaceAllUsesWith(LowerBSWAP(CI->getOperand(1), CI)); 717 break; 718 719 case Intrinsic::ctlz: 720 CI->replaceAllUsesWith(LowerCTLZ(CI->getOperand(1), CI)); 721 break; 722 723 case Intrinsic::cttz: { 724 // cttz(x) -> ctpop(~X & (X-1)) 725 Value *Src = CI->getOperand(1); 726 Value *NotSrc = BinaryOperator::CreateNot(Src, Src->getName()+".not", CI); 727 Value *SrcM1 = ConstantInt::get(Src->getType(), 1); 728 SrcM1 = BinaryOperator::CreateSub(Src, SrcM1, "", CI); 729 Src = LowerCTPOP(BinaryOperator::CreateAnd(NotSrc, SrcM1, "", CI), CI); 730 CI->replaceAllUsesWith(Src); 731 break; 732 } 733 734 case Intrinsic::part_select: 735 CI->replaceAllUsesWith(LowerPartSelect(CI)); 736 break; 737 738 case Intrinsic::part_set: 739 CI->replaceAllUsesWith(LowerPartSet(CI)); 740 break; 741 742 case Intrinsic::stacksave: 743 case Intrinsic::stackrestore: { 744 static bool Warned = false; 745 if (!Warned) 746 cerr << "WARNING: this target does not support the llvm.stack" 747 << (Callee->getIntrinsicID() == Intrinsic::stacksave ? 748 "save" : "restore") << " intrinsic.\n"; 749 Warned = true; 750 if (Callee->getIntrinsicID() == Intrinsic::stacksave) 751 CI->replaceAllUsesWith(Constant::getNullValue(CI->getType())); 752 break; 753 } 754 755 case Intrinsic::returnaddress: 756 case Intrinsic::frameaddress: 757 cerr << "WARNING: this target does not support the llvm." 758 << (Callee->getIntrinsicID() == Intrinsic::returnaddress ? 759 "return" : "frame") << "address intrinsic.\n"; 760 CI->replaceAllUsesWith(ConstantPointerNull::get( 761 cast<PointerType>(CI->getType()))); 762 break; 763 764 case Intrinsic::prefetch: 765 break; // Simply strip out prefetches on unsupported architectures 766 767 case Intrinsic::pcmarker: 768 break; // Simply strip out pcmarker on unsupported architectures 769 case Intrinsic::readcyclecounter: { 770 cerr << "WARNING: this target does not support the llvm.readcyclecoun" 771 << "ter intrinsic. It is being lowered to a constant 0\n"; 772 CI->replaceAllUsesWith(ConstantInt::get(Type::Int64Ty, 0)); 773 break; 774 } 775 776 case Intrinsic::dbg_stoppoint: 777 case Intrinsic::dbg_region_start: 778 case Intrinsic::dbg_region_end: 779 case Intrinsic::dbg_func_start: 780 case Intrinsic::dbg_declare: 781 break; // Simply strip out debugging intrinsics 782 783 case Intrinsic::eh_exception: 784 case Intrinsic::eh_selector_i32: 785 case Intrinsic::eh_selector_i64: 786 CI->replaceAllUsesWith(Constant::getNullValue(CI->getType())); 787 break; 788 789 case Intrinsic::eh_typeid_for_i32: 790 case Intrinsic::eh_typeid_for_i64: 791 // Return something different to eh_selector. 792 CI->replaceAllUsesWith(ConstantInt::get(CI->getType(), 1)); 793 break; 794 795 case Intrinsic::var_annotation: 796 break; // Strip out annotate intrinsic 797 798 case Intrinsic::memcpy: { 799 static Constant *MemcpyFCache = 0; 800 const IntegerType *IntPtr = TD.getIntPtrType(); 801 Value *Size = getZExtOrTrunc(CI->getOperand(3), IntPtr, CI); 802 Value *Ops[3]; 803 Ops[0] = CI->getOperand(1); 804 Ops[1] = CI->getOperand(2); 805 Ops[2] = Size; 806 ReplaceCallWith("memcpy", CI, Ops, Ops+3, CI->getOperand(1)->getType(), 807 MemcpyFCache); 808 break; 809 } 810 case Intrinsic::memmove: { 811 static Constant *MemmoveFCache = 0; 812 const IntegerType *IntPtr = TD.getIntPtrType(); 813 Value *Size = getZExtOrTrunc(CI->getOperand(3), IntPtr, CI); 814 Value *Ops[3]; 815 Ops[0] = CI->getOperand(1); 816 Ops[1] = CI->getOperand(2); 817 Ops[2] = Size; 818 ReplaceCallWith("memmove", CI, Ops, Ops+3, CI->getOperand(1)->getType(), 819 MemmoveFCache); 820 break; 821 } 822 case Intrinsic::memset: { 823 static Constant *MemsetFCache = 0; 824 const IntegerType *IntPtr = TD.getIntPtrType(); 825 Value *Size = getZExtOrTrunc(CI->getOperand(3), IntPtr, CI); 826 Value *Ops[3]; 827 Ops[0] = CI->getOperand(1); 828 // Extend the amount to i32. 829 Ops[1] = getZExtOrTrunc(CI->getOperand(2), Type::Int32Ty, CI); 830 Ops[2] = Size; 831 ReplaceCallWith("memset", CI, Ops, Ops+3, CI->getOperand(1)->getType(), 832 MemsetFCache); 833 break; 834 } 835 case Intrinsic::sqrt: { 836 static Constant *sqrtFCache = 0; 837 static Constant *sqrtDCache = 0; 838 static Constant *sqrtLDCache = 0; 839 ReplaceFPIntrinsicWithCall(CI, sqrtFCache, sqrtDCache, sqrtLDCache, 840 "sqrtf", "sqrt", "sqrtl"); 841 break; 842 } 843 case Intrinsic::log: { 844 static Constant *logFCache = 0; 845 static Constant *logDCache = 0; 846 static Constant *logLDCache = 0; 847 ReplaceFPIntrinsicWithCall(CI, logFCache, logDCache, logLDCache, 848 "logf", "log", "logl"); 849 break; 850 } 851 case Intrinsic::log2: { 852 static Constant *log2FCache = 0; 853 static Constant *log2DCache = 0; 854 static Constant *log2LDCache = 0; 855 ReplaceFPIntrinsicWithCall(CI, log2FCache, log2DCache, log2LDCache, 856 "log2f", "log2", "log2l"); 857 break; 858 } 859 case Intrinsic::log10: { 860 static Constant *log10FCache = 0; 861 static Constant *log10DCache = 0; 862 static Constant *log10LDCache = 0; 863 ReplaceFPIntrinsicWithCall(CI, log10FCache, log10DCache, log10LDCache, 864 "log10f", "log10", "log10l"); 865 break; 866 } 867 case Intrinsic::exp: { 868 static Constant *expFCache = 0; 869 static Constant *expDCache = 0; 870 static Constant *expLDCache = 0; 871 ReplaceFPIntrinsicWithCall(CI, expFCache, expDCache, expLDCache, 872 "expf", "exp", "expl"); 873 break; 874 } 875 case Intrinsic::exp2: { 876 static Constant *exp2FCache = 0; 877 static Constant *exp2DCache = 0; 878 static Constant *exp2LDCache = 0; 879 ReplaceFPIntrinsicWithCall(CI, exp2FCache, exp2DCache, exp2LDCache, 880 "exp2f", "exp2", "exp2l"); 881 break; 882 } 883 case Intrinsic::pow: { 884 static Constant *powFCache = 0; 885 static Constant *powDCache = 0; 886 static Constant *powLDCache = 0; 887 ReplaceFPIntrinsicWithCall(CI, powFCache, powDCache, powLDCache, 888 "powf", "pow", "powl"); 889 break; 890 } 891 case Intrinsic::flt_rounds: 892 // Lower to "round to the nearest" 893 if (CI->getType() != Type::VoidTy) 894 CI->replaceAllUsesWith(ConstantInt::get(CI->getType(), 1)); 895 break; 896 } 897 898 assert(CI->use_empty() && 899 "Lowering should have eliminated any uses of the intrinsic call!"); 900 CI->eraseFromParent(); 901} 902