Chris Lattner | 3b66ecb | 2003-12-28 08:19:41 +0000 | [diff] [blame] | 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 | |
Chris Lattner | 42450d8 | 2003-12-28 08:30:20 +0000 | [diff] [blame] | 14 | #include "llvm/IntrinsicLowering.h" |
Chris Lattner | cf89908 | 2004-02-14 02:47:17 +0000 | [diff] [blame] | 15 | #include "llvm/Constants.h" |
Chris Lattner | 5fe51cc | 2004-02-12 17:01:09 +0000 | [diff] [blame] | 16 | #include "llvm/DerivedTypes.h" |
Chris Lattner | 3b66ecb | 2003-12-28 08:19:41 +0000 | [diff] [blame] | 17 | #include "llvm/Module.h" |
Chris Lattner | 3b66ecb | 2003-12-28 08:19:41 +0000 | [diff] [blame] | 18 | #include "llvm/iOther.h" |
| 19 | using namespace llvm; |
| 20 | |
Chris Lattner | 0979ca7 | 2004-05-09 04:29:57 +0000 | [diff] [blame] | 21 | template <class ArgIt> |
| 22 | static Function *EnsureFunctionExists(Module &M, const char *Name, |
| 23 | ArgIt ArgBegin, ArgIt ArgEnd, |
| 24 | const Type *RetTy) { |
| 25 | if (Function *F = M.getNamedFunction(Name)) return F; |
| 26 | // It doesn't already exist in the program, insert a new definition now. |
| 27 | std::vector<const Type *> ParamTys; |
| 28 | for (ArgIt I = ArgBegin; I != ArgEnd; ++I) |
| 29 | ParamTys.push_back(I->getType()); |
| 30 | return M.getOrInsertFunction(Name, FunctionType::get(RetTy, ParamTys, false)); |
| 31 | } |
| 32 | |
Chris Lattner | 588e72d | 2004-02-15 22:16:39 +0000 | [diff] [blame] | 33 | /// ReplaceCallWith - This function is used when we want to lower an intrinsic |
| 34 | /// call to a call of an external function. This handles hard cases such as |
| 35 | /// when there was already a prototype for the external function, and if that |
| 36 | /// prototype doesn't match the arguments we expect to pass in. |
| 37 | template <class ArgIt> |
| 38 | static CallInst *ReplaceCallWith(const char *NewFn, CallInst *CI, |
| 39 | ArgIt ArgBegin, ArgIt ArgEnd, |
| 40 | const Type *RetTy, Function *&FCache) { |
| 41 | if (!FCache) { |
| 42 | // If we haven't already looked up this function, check to see if the |
| 43 | // program already contains a function with this name. |
| 44 | Module *M = CI->getParent()->getParent()->getParent(); |
| 45 | FCache = M->getNamedFunction(NewFn); |
| 46 | if (!FCache) { |
| 47 | // It doesn't already exist in the program, insert a new definition now. |
| 48 | std::vector<const Type *> ParamTys; |
| 49 | for (ArgIt I = ArgBegin; I != ArgEnd; ++I) |
| 50 | ParamTys.push_back((*I)->getType()); |
| 51 | FCache = M->getOrInsertFunction(NewFn, |
| 52 | FunctionType::get(RetTy, ParamTys, false)); |
| 53 | } |
Chris Lattner | 0979ca7 | 2004-05-09 04:29:57 +0000 | [diff] [blame] | 54 | } |
Chris Lattner | 588e72d | 2004-02-15 22:16:39 +0000 | [diff] [blame] | 55 | |
| 56 | const FunctionType *FT = FCache->getFunctionType(); |
| 57 | std::vector<Value*> Operands; |
| 58 | unsigned ArgNo = 0; |
| 59 | for (ArgIt I = ArgBegin; I != ArgEnd && ArgNo != FT->getNumParams(); |
| 60 | ++I, ++ArgNo) { |
| 61 | Value *Arg = *I; |
| 62 | if (Arg->getType() != FT->getParamType(ArgNo)) |
| 63 | Arg = new CastInst(Arg, FT->getParamType(ArgNo), Arg->getName(), CI); |
| 64 | Operands.push_back(Arg); |
| 65 | } |
| 66 | // Pass nulls into any additional arguments... |
| 67 | for (; ArgNo != FT->getNumParams(); ++ArgNo) |
| 68 | Operands.push_back(Constant::getNullValue(FT->getParamType(ArgNo))); |
| 69 | |
| 70 | std::string Name = CI->getName(); CI->setName(""); |
| 71 | if (FT->getReturnType() == Type::VoidTy) Name.clear(); |
| 72 | return new CallInst(FCache, Operands, Name, CI); |
| 73 | } |
| 74 | |
Chris Lattner | 0979ca7 | 2004-05-09 04:29:57 +0000 | [diff] [blame] | 75 | void DefaultIntrinsicLowering::AddPrototypes(Module &M) { |
| 76 | for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) |
| 77 | if (I->isExternal() && !I->use_empty()) |
| 78 | switch (I->getIntrinsicID()) { |
| 79 | default: break; |
| 80 | case Intrinsic::setjmp: |
| 81 | EnsureFunctionExists(M, "setjmp", I->abegin(), I->aend(), Type::IntTy); |
| 82 | break; |
| 83 | case Intrinsic::longjmp: |
| 84 | EnsureFunctionExists(M, "longjmp", I->abegin(), I->aend(),Type::VoidTy); |
| 85 | break; |
| 86 | case Intrinsic::siglongjmp: |
| 87 | EnsureFunctionExists(M, "abort", I->aend(), I->aend(), Type::VoidTy); |
| 88 | break; |
| 89 | case Intrinsic::memcpy: |
| 90 | EnsureFunctionExists(M, "memcpy", I->abegin(), --I->aend(), |
| 91 | I->abegin()->getType()); |
| 92 | break; |
| 93 | case Intrinsic::memmove: |
| 94 | EnsureFunctionExists(M, "memmove", I->abegin(), --I->aend(), |
| 95 | I->abegin()->getType()); |
| 96 | break; |
| 97 | case Intrinsic::memset: |
| 98 | EnsureFunctionExists(M, "memset", I->abegin(), --I->aend(), |
| 99 | I->abegin()->getType()); |
| 100 | break; |
| 101 | |
| 102 | } |
| 103 | |
| 104 | } |
Chris Lattner | 588e72d | 2004-02-15 22:16:39 +0000 | [diff] [blame] | 105 | |
Chris Lattner | 3b66ecb | 2003-12-28 08:19:41 +0000 | [diff] [blame] | 106 | void DefaultIntrinsicLowering::LowerIntrinsicCall(CallInst *CI) { |
| 107 | Function *Callee = CI->getCalledFunction(); |
| 108 | assert(Callee && "Cannot lower an indirect call!"); |
| 109 | |
Chris Lattner | 3b66ecb | 2003-12-28 08:19:41 +0000 | [diff] [blame] | 110 | switch (Callee->getIntrinsicID()) { |
| 111 | case Intrinsic::not_intrinsic: |
| 112 | std::cerr << "Cannot lower a call to a non-intrinsic function '" |
| 113 | << Callee->getName() << "'!\n"; |
| 114 | abort(); |
| 115 | default: |
| 116 | std::cerr << "Error: Code generator does not support intrinsic function '" |
| 117 | << Callee->getName() << "'!\n"; |
| 118 | abort(); |
| 119 | |
Chris Lattner | 588e72d | 2004-02-15 22:16:39 +0000 | [diff] [blame] | 120 | // The setjmp/longjmp intrinsics should only exist in the code if it was |
| 121 | // never optimized (ie, right out of the CFE), or if it has been hacked on |
| 122 | // by the lowerinvoke pass. In both cases, the right thing to do is to |
| 123 | // convert the call to an explicit setjmp or longjmp call. |
Chris Lattner | 9b700f7 | 2004-02-15 22:24:51 +0000 | [diff] [blame] | 124 | case Intrinsic::setjmp: { |
| 125 | static Function *SetjmpFCache = 0; |
| 126 | Value *V = ReplaceCallWith("setjmp", CI, CI->op_begin()+1, CI->op_end(), |
| 127 | Type::IntTy, SetjmpFCache); |
Chris Lattner | 3b66ecb | 2003-12-28 08:19:41 +0000 | [diff] [blame] | 128 | if (CI->getType() != Type::VoidTy) |
Chris Lattner | 9b700f7 | 2004-02-15 22:24:51 +0000 | [diff] [blame] | 129 | CI->replaceAllUsesWith(V); |
Chris Lattner | 3b66ecb | 2003-12-28 08:19:41 +0000 | [diff] [blame] | 130 | break; |
Chris Lattner | 9b700f7 | 2004-02-15 22:24:51 +0000 | [diff] [blame] | 131 | } |
| 132 | case Intrinsic::sigsetjmp: |
| 133 | if (CI->getType() != Type::VoidTy) |
| 134 | CI->replaceAllUsesWith(Constant::getNullValue(CI->getType())); |
| 135 | break; |
Chris Lattner | 3b66ecb | 2003-12-28 08:19:41 +0000 | [diff] [blame] | 136 | |
Chris Lattner | f0a3e6c | 2004-06-05 01:05:19 +0000 | [diff] [blame^] | 137 | case Intrinsic::longjmp: { |
Chris Lattner | 9b700f7 | 2004-02-15 22:24:51 +0000 | [diff] [blame] | 138 | static Function *LongjmpFCache = 0; |
| 139 | ReplaceCallWith("longjmp", CI, CI->op_begin()+1, CI->op_end(), |
| 140 | Type::VoidTy, LongjmpFCache); |
| 141 | break; |
Chris Lattner | f0a3e6c | 2004-06-05 01:05:19 +0000 | [diff] [blame^] | 142 | } |
Chris Lattner | 9b700f7 | 2004-02-15 22:24:51 +0000 | [diff] [blame] | 143 | |
Chris Lattner | f0a3e6c | 2004-06-05 01:05:19 +0000 | [diff] [blame^] | 144 | case Intrinsic::siglongjmp: { |
Chris Lattner | 3b66ecb | 2003-12-28 08:19:41 +0000 | [diff] [blame] | 145 | // Insert the call to abort |
Chris Lattner | 588e72d | 2004-02-15 22:16:39 +0000 | [diff] [blame] | 146 | static Function *AbortFCache = 0; |
| 147 | ReplaceCallWith("abort", CI, CI->op_end(), CI->op_end(), Type::VoidTy, |
| 148 | AbortFCache); |
Chris Lattner | 3b66ecb | 2003-12-28 08:19:41 +0000 | [diff] [blame] | 149 | break; |
Chris Lattner | f0a3e6c | 2004-06-05 01:05:19 +0000 | [diff] [blame^] | 150 | } |
Chris Lattner | 77b1330 | 2004-01-05 05:36:30 +0000 | [diff] [blame] | 151 | |
Chris Lattner | cf89908 | 2004-02-14 02:47:17 +0000 | [diff] [blame] | 152 | case Intrinsic::returnaddress: |
| 153 | case Intrinsic::frameaddress: |
Chris Lattner | cc42d2c | 2004-02-14 04:52:06 +0000 | [diff] [blame] | 154 | std::cerr << "WARNING: this target does not support the llvm." |
| 155 | << (Callee->getIntrinsicID() == Intrinsic::returnaddress ? |
| 156 | "return" : "frame") << "address intrinsic.\n"; |
Chris Lattner | cf89908 | 2004-02-14 02:47:17 +0000 | [diff] [blame] | 157 | CI->replaceAllUsesWith(ConstantPointerNull::get( |
| 158 | cast<PointerType>(CI->getType()))); |
| 159 | break; |
| 160 | |
Chris Lattner | 77b1330 | 2004-01-05 05:36:30 +0000 | [diff] [blame] | 161 | case Intrinsic::dbg_stoppoint: |
| 162 | case Intrinsic::dbg_region_start: |
| 163 | case Intrinsic::dbg_region_end: |
Chris Lattner | f907bac | 2004-01-14 20:41:29 +0000 | [diff] [blame] | 164 | case Intrinsic::dbg_declare: |
Chris Lattner | 77b1330 | 2004-01-05 05:36:30 +0000 | [diff] [blame] | 165 | case Intrinsic::dbg_func_start: |
| 166 | if (CI->getType() != Type::VoidTy) |
| 167 | CI->replaceAllUsesWith(Constant::getNullValue(CI->getType())); |
| 168 | break; // Simply strip out debugging intrinsics |
Chris Lattner | 5fe51cc | 2004-02-12 17:01:09 +0000 | [diff] [blame] | 169 | |
Chris Lattner | f0a3e6c | 2004-06-05 01:05:19 +0000 | [diff] [blame^] | 170 | case Intrinsic::memcpy: { |
Chris Lattner | 5fe51cc | 2004-02-12 17:01:09 +0000 | [diff] [blame] | 171 | // The memcpy intrinsic take an extra alignment argument that the memcpy |
| 172 | // libc function does not. |
Chris Lattner | 588e72d | 2004-02-15 22:16:39 +0000 | [diff] [blame] | 173 | static Function *MemcpyFCache = 0; |
| 174 | ReplaceCallWith("memcpy", CI, CI->op_begin()+1, CI->op_end()-1, |
| 175 | (*(CI->op_begin()+1))->getType(), MemcpyFCache); |
Chris Lattner | 5fe51cc | 2004-02-12 17:01:09 +0000 | [diff] [blame] | 176 | break; |
Chris Lattner | f0a3e6c | 2004-06-05 01:05:19 +0000 | [diff] [blame^] | 177 | } |
| 178 | case Intrinsic::memmove: { |
Chris Lattner | cf89908 | 2004-02-14 02:47:17 +0000 | [diff] [blame] | 179 | // The memmove intrinsic take an extra alignment argument that the memmove |
Chris Lattner | 2751e76 | 2004-02-12 18:11:20 +0000 | [diff] [blame] | 180 | // libc function does not. |
Chris Lattner | 588e72d | 2004-02-15 22:16:39 +0000 | [diff] [blame] | 181 | static Function *MemmoveFCache = 0; |
| 182 | ReplaceCallWith("memmove", CI, CI->op_begin()+1, CI->op_end()-1, |
| 183 | (*(CI->op_begin()+1))->getType(), MemmoveFCache); |
Chris Lattner | 2751e76 | 2004-02-12 18:11:20 +0000 | [diff] [blame] | 184 | break; |
Chris Lattner | f0a3e6c | 2004-06-05 01:05:19 +0000 | [diff] [blame^] | 185 | } |
| 186 | case Intrinsic::memset: { |
Chris Lattner | cf89908 | 2004-02-14 02:47:17 +0000 | [diff] [blame] | 187 | // The memset intrinsic take an extra alignment argument that the memset |
| 188 | // libc function does not. |
Chris Lattner | 588e72d | 2004-02-15 22:16:39 +0000 | [diff] [blame] | 189 | static Function *MemsetFCache = 0; |
| 190 | ReplaceCallWith("memset", CI, CI->op_begin()+1, CI->op_end()-1, |
| 191 | (*(CI->op_begin()+1))->getType(), MemsetFCache); |
Chris Lattner | cf89908 | 2004-02-14 02:47:17 +0000 | [diff] [blame] | 192 | break; |
| 193 | } |
Chris Lattner | f0a3e6c | 2004-06-05 01:05:19 +0000 | [diff] [blame^] | 194 | } |
Chris Lattner | 588e72d | 2004-02-15 22:16:39 +0000 | [diff] [blame] | 195 | |
Chris Lattner | 3b66ecb | 2003-12-28 08:19:41 +0000 | [diff] [blame] | 196 | assert(CI->use_empty() && |
| 197 | "Lowering should have eliminated any uses of the intrinsic call!"); |
| 198 | CI->getParent()->getInstList().erase(CI); |
| 199 | } |