IntrinsicLowering.cpp revision 86f3e0c24e8834e6ad5ac61f2459fb335549bc24
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 default intrinsic lowering implementation. 11// 12//===----------------------------------------------------------------------===// 13 14#include "llvm/CodeGen/IntrinsicLowering.h" 15#include "llvm/Constants.h" 16#include "llvm/DerivedTypes.h" 17#include "llvm/Module.h" 18#include "llvm/Instructions.h" 19#include "llvm/Type.h" 20#include <iostream> 21 22using namespace llvm; 23 24template <class ArgIt> 25static Function *EnsureFunctionExists(Module &M, const char *Name, 26 ArgIt ArgBegin, ArgIt ArgEnd, 27 const Type *RetTy) { 28 if (Function *F = M.getNamedFunction(Name)) return F; 29 // It doesn't already exist in the program, insert a new definition now. 30 std::vector<const Type *> ParamTys; 31 for (ArgIt I = ArgBegin; I != ArgEnd; ++I) 32 ParamTys.push_back(I->getType()); 33 return M.getOrInsertFunction(Name, FunctionType::get(RetTy, ParamTys, false)); 34} 35 36/// ReplaceCallWith - This function is used when we want to lower an intrinsic 37/// call to a call of an external function. This handles hard cases such as 38/// when there was already a prototype for the external function, and if that 39/// prototype doesn't match the arguments we expect to pass in. 40template <class ArgIt> 41static CallInst *ReplaceCallWith(const char *NewFn, CallInst *CI, 42 ArgIt ArgBegin, ArgIt ArgEnd, 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 Arg = new CastInst(Arg, FT->getParamType(ArgNo), Arg->getName(), CI); 67 Operands.push_back(Arg); 68 } 69 // Pass nulls into any additional arguments... 70 for (; ArgNo != FT->getNumParams(); ++ArgNo) 71 Operands.push_back(Constant::getNullValue(FT->getParamType(ArgNo))); 72 73 std::string Name = CI->getName(); CI->setName(""); 74 if (FT->getReturnType() == Type::VoidTy) Name.clear(); 75 CallInst *NewCI = new CallInst(FCache, Operands, Name, CI); 76 if (!CI->use_empty()) { 77 Value *V = NewCI; 78 if (CI->getType() != NewCI->getType()) 79 V = new CastInst(NewCI, CI->getType(), Name, CI); 80 CI->replaceAllUsesWith(V); 81 } 82 return NewCI; 83} 84 85void DefaultIntrinsicLowering::AddPrototypes(Module &M) { 86 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) 87 if (I->isExternal() && !I->use_empty()) 88 switch (I->getIntrinsicID()) { 89 default: break; 90 case Intrinsic::setjmp: 91 EnsureFunctionExists(M, "setjmp", I->arg_begin(), I->arg_end(), 92 Type::IntTy); 93 break; 94 case Intrinsic::longjmp: 95 EnsureFunctionExists(M, "longjmp", I->arg_begin(), I->arg_end(), 96 Type::VoidTy); 97 break; 98 case Intrinsic::siglongjmp: 99 EnsureFunctionExists(M, "abort", I->arg_end(), I->arg_end(), 100 Type::VoidTy); 101 break; 102 case Intrinsic::memcpy: 103 EnsureFunctionExists(M, "memcpy", I->arg_begin(), --I->arg_end(), 104 I->arg_begin()->getType()); 105 break; 106 case Intrinsic::memmove: 107 EnsureFunctionExists(M, "memmove", I->arg_begin(), --I->arg_end(), 108 I->arg_begin()->getType()); 109 break; 110 case Intrinsic::memset: 111 M.getOrInsertFunction("memset", PointerType::get(Type::SByteTy), 112 PointerType::get(Type::SByteTy), 113 Type::IntTy, (--(--I->arg_end()))->getType(), 0); 114 break; 115 case Intrinsic::isunordered: 116 EnsureFunctionExists(M, "isunordered", I->arg_begin(), I->arg_end(), 117 Type::BoolTy); 118 break; 119 case Intrinsic::sqrt: 120 if(I->arg_begin()->getType() == Type::FloatTy) 121 EnsureFunctionExists(M, "sqrtf", I->arg_begin(), I->arg_end(), 122 Type::FloatTy); 123 else 124 EnsureFunctionExists(M, "sqrt", I->arg_begin(), I->arg_end(), 125 Type::DoubleTy); 126 break; 127 } 128} 129 130/// LowerCTPOP - Emit the code to lower ctpop of V before the specified 131/// instruction. 132static Value *LowerCTPOP(Value *V, Instruction *IP) { 133 assert(V->getType()->isInteger() && "Can't ctpop a non-integer type!"); 134 unsigned BitSize = V->getType()->getPrimitiveSizeInBits(); 135 136 static const uint64_t MaskValues[6] = { 137 0x5555555555555555ULL, 0x3333333333333333ULL, 138 0x0F0F0F0F0F0F0F0FULL, 0x00FF00FF00FF00FFULL, 139 0x0000FFFF0000FFFFULL, 0x00000000FFFFFFFFULL 140 }; 141 142 const Type *DestTy = V->getType(); 143 144 // Force to unsigned so that the shift rights are logical. 145 if (DestTy->isSigned()) 146 V = new CastInst(V, DestTy->getUnsignedVersion(), V->getName(), IP); 147 148 for (unsigned i = 1, ct = 0; i != BitSize; i <<= 1, ++ct) { 149 Value *MaskCst = 150 ConstantExpr::getCast(ConstantUInt::get(Type::ULongTy, 151 MaskValues[ct]), V->getType()); 152 Value *LHS = BinaryOperator::createAnd(V, MaskCst, "cppop.and1", IP); 153 Value *VShift = new ShiftInst(Instruction::Shr, V, 154 ConstantInt::get(Type::UByteTy, i), "ctpop.sh", IP); 155 Value *RHS = BinaryOperator::createAnd(VShift, MaskCst, "cppop.and2", IP); 156 V = BinaryOperator::createAdd(LHS, RHS, "ctpop.step", IP); 157 } 158 159 if (V->getType() != DestTy) 160 V = new CastInst(V, DestTy, V->getName(), IP); 161 return V; 162} 163 164void DefaultIntrinsicLowering::LowerIntrinsicCall(CallInst *CI) { 165 Function *Callee = CI->getCalledFunction(); 166 assert(Callee && "Cannot lower an indirect call!"); 167 168 switch (Callee->getIntrinsicID()) { 169 case Intrinsic::not_intrinsic: 170 std::cerr << "Cannot lower a call to a non-intrinsic function '" 171 << Callee->getName() << "'!\n"; 172 abort(); 173 default: 174 std::cerr << "Error: Code generator does not support intrinsic function '" 175 << Callee->getName() << "'!\n"; 176 abort(); 177 178 // The setjmp/longjmp intrinsics should only exist in the code if it was 179 // never optimized (ie, right out of the CFE), or if it has been hacked on 180 // by the lowerinvoke pass. In both cases, the right thing to do is to 181 // convert the call to an explicit setjmp or longjmp call. 182 case Intrinsic::setjmp: { 183 static Function *SetjmpFCache = 0; 184 Value *V = ReplaceCallWith("setjmp", CI, CI->op_begin()+1, CI->op_end(), 185 Type::IntTy, SetjmpFCache); 186 if (CI->getType() != Type::VoidTy) 187 CI->replaceAllUsesWith(V); 188 break; 189 } 190 case Intrinsic::sigsetjmp: 191 if (CI->getType() != Type::VoidTy) 192 CI->replaceAllUsesWith(Constant::getNullValue(CI->getType())); 193 break; 194 195 case Intrinsic::longjmp: { 196 static Function *LongjmpFCache = 0; 197 ReplaceCallWith("longjmp", CI, CI->op_begin()+1, CI->op_end(), 198 Type::VoidTy, LongjmpFCache); 199 break; 200 } 201 202 case Intrinsic::siglongjmp: { 203 // Insert the call to abort 204 static Function *AbortFCache = 0; 205 ReplaceCallWith("abort", CI, CI->op_end(), CI->op_end(), Type::VoidTy, 206 AbortFCache); 207 break; 208 } 209 case Intrinsic::ctpop: 210 CI->replaceAllUsesWith(LowerCTPOP(CI->getOperand(1), CI)); 211 break; 212 213 case Intrinsic::ctlz: { 214 Value *Src = CI->getOperand(1); 215 Value* SA; 216 switch (CI->getOperand(0)->getType()->getTypeID()) 217 { 218 case Type::LongTyID: 219 case Type::ULongTyID: 220 SA = ConstantUInt::get(Type::UByteTy, 32); 221 Src = BinaryOperator::createOr(Src, new ShiftInst(Instruction::Shr, Src, 222 SA, "", CI), "", CI); 223 case Type::IntTyID: 224 case Type::UIntTyID: 225 SA = ConstantUInt::get(Type::UByteTy, 16); 226 Src = BinaryOperator::createOr(Src, new ShiftInst(Instruction::Shr, 227 Src, SA, "", CI), 228 "", CI); 229 case Type::ShortTyID: 230 case Type::UShortTyID: 231 SA = ConstantUInt::get(Type::UByteTy, 8); 232 Src = BinaryOperator::createOr(Src, new ShiftInst(Instruction::Shr, 233 Src, SA, "", CI), 234 "", CI); 235 default: 236 SA = ConstantUInt::get(Type::UByteTy, 1); 237 Src = BinaryOperator::createOr(Src, new ShiftInst(Instruction::Shr, Src, 238 SA, "", CI), "", CI); 239 SA = ConstantUInt::get(Type::UByteTy, 2); 240 Src = BinaryOperator::createOr(Src, new ShiftInst(Instruction::Shr, Src, 241 SA, "", CI), "", CI); 242 SA = ConstantUInt::get(Type::UByteTy, 4); 243 Src = BinaryOperator::createOr(Src, new ShiftInst(Instruction::Shr, Src, 244 SA, "", CI), "", CI); 245 }; 246 Src = BinaryOperator::createNot(Src, "", CI); 247 248 249 Src = LowerCTPOP(Src, CI); 250 CI->replaceAllUsesWith(Src); 251 break; 252 } 253 case Intrinsic::cttz: { 254 Value *Src = CI->getOperand(1); 255 Value *NotSrc = BinaryOperator::createNot(Src, Src->getName()+".not", CI); 256 Src = BinaryOperator::createAnd(NotSrc, 257 BinaryOperator::createSub(Src, 258 ConstantUInt::get(CI->getOperand(0)->getType(), 1), "", CI)); 259 260 Src = LowerCTPOP(Src, CI); 261 CI->replaceAllUsesWith(Src); 262 break; 263 } 264 265 case Intrinsic::returnaddress: 266 case Intrinsic::frameaddress: 267 std::cerr << "WARNING: this target does not support the llvm." 268 << (Callee->getIntrinsicID() == Intrinsic::returnaddress ? 269 "return" : "frame") << "address intrinsic.\n"; 270 CI->replaceAllUsesWith(ConstantPointerNull::get( 271 cast<PointerType>(CI->getType()))); 272 break; 273 274 case Intrinsic::prefetch: 275 break; // Simply strip out prefetches on unsupported architectures 276 277 case Intrinsic::pcmarker: 278 break; // Simply strip out pcmarker on unsupported architectures 279 280 case Intrinsic::dbg_stoppoint: 281 case Intrinsic::dbg_region_start: 282 case Intrinsic::dbg_region_end: 283 case Intrinsic::dbg_declare: 284 case Intrinsic::dbg_func_start: 285 if (CI->getType() != Type::VoidTy) 286 CI->replaceAllUsesWith(Constant::getNullValue(CI->getType())); 287 break; // Simply strip out debugging intrinsics 288 289 case Intrinsic::memcpy: { 290 // The memcpy intrinsic take an extra alignment argument that the memcpy 291 // libc function does not. 292 static Function *MemcpyFCache = 0; 293 ReplaceCallWith("memcpy", CI, CI->op_begin()+1, CI->op_end()-1, 294 (*(CI->op_begin()+1))->getType(), MemcpyFCache); 295 break; 296 } 297 case Intrinsic::memmove: { 298 // The memmove intrinsic take an extra alignment argument that the memmove 299 // libc function does not. 300 static Function *MemmoveFCache = 0; 301 ReplaceCallWith("memmove", CI, CI->op_begin()+1, CI->op_end()-1, 302 (*(CI->op_begin()+1))->getType(), MemmoveFCache); 303 break; 304 } 305 case Intrinsic::memset: { 306 // The memset intrinsic take an extra alignment argument that the memset 307 // libc function does not. 308 static Function *MemsetFCache = 0; 309 ReplaceCallWith("memset", CI, CI->op_begin()+1, CI->op_end()-1, 310 (*(CI->op_begin()+1))->getType(), MemsetFCache); 311 break; 312 } 313 case Intrinsic::isunordered: { 314 Value *L = CI->getOperand(1); 315 Value *R = CI->getOperand(2); 316 317 Value *LIsNan = new SetCondInst(Instruction::SetNE, L, L, "LIsNan", CI); 318 Value *RIsNan = new SetCondInst(Instruction::SetNE, R, R, "RIsNan", CI); 319 CI->replaceAllUsesWith( 320 BinaryOperator::create(Instruction::Or, LIsNan, RIsNan, 321 "isunordered", CI)); 322 break; 323 } 324 case Intrinsic::sqrt: { 325 static Function *sqrtFCache = 0; 326 static Function *sqrtfFCache = 0; 327 if(CI->getType() == Type::FloatTy) 328 ReplaceCallWith("sqrtf", CI, CI->op_begin()+1, CI->op_end(), 329 Type::FloatTy, sqrtfFCache); 330 else 331 ReplaceCallWith("sqrt", CI, CI->op_begin()+1, CI->op_end(), 332 Type::DoubleTy, sqrtFCache); 333 break; 334 } 335 } 336 337 assert(CI->use_empty() && 338 "Lowering should have eliminated any uses of the intrinsic call!"); 339 CI->eraseFromParent(); 340} 341