Chris Lattner | cf3056d | 2003-10-13 03:32:08 +0000 | [diff] [blame] | 1 | //===-- Function.cpp - Implement the Global object classes ----------------===// |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 2 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 4ee451d | 2007-12-29 20:36:04 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 7 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 9 | // |
Reid Spencer | ef9b9a7 | 2007-02-05 20:47:22 +0000 | [diff] [blame] | 10 | // This file implements the Function class for the VMCore library. |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 14 | #include "llvm/Module.h" |
Chris Lattner | 4827015 | 2002-09-06 20:46:32 +0000 | [diff] [blame] | 15 | #include "llvm/DerivedTypes.h" |
Chris Lattner | 4ec82eb | 2004-10-12 04:20:25 +0000 | [diff] [blame] | 16 | #include "llvm/IntrinsicInst.h" |
Dan Gohman | 7abff31 | 2007-08-20 19:23:34 +0000 | [diff] [blame] | 17 | #include "llvm/CodeGen/ValueTypes.h" |
Reid Spencer | 551ccae | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 18 | #include "llvm/Support/LeakDetector.h" |
Gordon Henriksen | 80a75bf | 2007-12-10 03:18:06 +0000 | [diff] [blame] | 19 | #include "llvm/Support/StringPool.h" |
Chris Lattner | 7e70829 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 20 | #include "SymbolTableListTraitsImpl.h" |
Duncan Sands | a3355ff | 2007-12-03 20:06:50 +0000 | [diff] [blame] | 21 | #include "llvm/ADT/BitVector.h" |
Gordon Henriksen | 80a75bf | 2007-12-10 03:18:06 +0000 | [diff] [blame] | 22 | #include "llvm/ADT/DenseMap.h" |
Chris Lattner | caa4ae7 | 2004-12-05 06:43:27 +0000 | [diff] [blame] | 23 | #include "llvm/ADT/StringExtras.h" |
Chris Lattner | 31f8499 | 2003-11-21 20:23:48 +0000 | [diff] [blame] | 24 | using namespace llvm; |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 25 | |
Chris Lattner | bca8144 | 2005-01-30 00:09:23 +0000 | [diff] [blame] | 26 | BasicBlock *ilist_traits<BasicBlock>::createSentinel() { |
Gabor Greif | 051a950 | 2008-04-06 20:25:17 +0000 | [diff] [blame^] | 27 | BasicBlock *Ret = BasicBlock::Create(); |
Chris Lattner | d1e693f | 2002-09-08 18:59:35 +0000 | [diff] [blame] | 28 | // This should not be garbage monitored. |
| 29 | LeakDetector::removeGarbageObject(Ret); |
| 30 | return Ret; |
Chris Lattner | bded132 | 2002-09-06 21:33:15 +0000 | [diff] [blame] | 31 | } |
| 32 | |
Chris Lattner | 7e70829 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 33 | iplist<BasicBlock> &ilist_traits<BasicBlock>::getList(Function *F) { |
| 34 | return F->getBasicBlockList(); |
| 35 | } |
| 36 | |
Chris Lattner | bca8144 | 2005-01-30 00:09:23 +0000 | [diff] [blame] | 37 | Argument *ilist_traits<Argument>::createSentinel() { |
Reid Spencer | 79e21d3 | 2006-12-31 05:26:44 +0000 | [diff] [blame] | 38 | Argument *Ret = new Argument(Type::Int32Ty); |
Chris Lattner | d1e693f | 2002-09-08 18:59:35 +0000 | [diff] [blame] | 39 | // This should not be garbage monitored. |
| 40 | LeakDetector::removeGarbageObject(Ret); |
| 41 | return Ret; |
Chris Lattner | 7e70829 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 42 | } |
| 43 | |
| 44 | iplist<Argument> &ilist_traits<Argument>::getList(Function *F) { |
| 45 | return F->getArgumentList(); |
| 46 | } |
| 47 | |
| 48 | // Explicit instantiations of SymbolTableListTraits since some of the methods |
| 49 | // are not in the public header file... |
Chris Lattner | 17fcdd5 | 2007-04-17 03:26:42 +0000 | [diff] [blame] | 50 | template class SymbolTableListTraits<Argument, Function>; |
| 51 | template class SymbolTableListTraits<BasicBlock, Function>; |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 52 | |
Chris Lattner | 70cc339 | 2001-09-10 07:58:01 +0000 | [diff] [blame] | 53 | //===----------------------------------------------------------------------===// |
Chris Lattner | 80dd50b | 2002-04-09 19:39:35 +0000 | [diff] [blame] | 54 | // Argument Implementation |
| 55 | //===----------------------------------------------------------------------===// |
| 56 | |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 57 | Argument::Argument(const Type *Ty, const std::string &Name, Function *Par) |
Chris Lattner | dec628e | 2007-02-12 05:18:08 +0000 | [diff] [blame] | 58 | : Value(Ty, Value::ArgumentVal) { |
Chris Lattner | bded132 | 2002-09-06 21:33:15 +0000 | [diff] [blame] | 59 | Parent = 0; |
Chris Lattner | d1e693f | 2002-09-08 18:59:35 +0000 | [diff] [blame] | 60 | |
| 61 | // Make sure that we get added to a function |
| 62 | LeakDetector::addGarbageObject(this); |
| 63 | |
Chris Lattner | bded132 | 2002-09-06 21:33:15 +0000 | [diff] [blame] | 64 | if (Par) |
| 65 | Par->getArgumentList().push_back(this); |
Chris Lattner | dec628e | 2007-02-12 05:18:08 +0000 | [diff] [blame] | 66 | setName(Name); |
Chris Lattner | bded132 | 2002-09-06 21:33:15 +0000 | [diff] [blame] | 67 | } |
| 68 | |
Chris Lattner | bded132 | 2002-09-06 21:33:15 +0000 | [diff] [blame] | 69 | void Argument::setParent(Function *parent) { |
Chris Lattner | d1e693f | 2002-09-08 18:59:35 +0000 | [diff] [blame] | 70 | if (getParent()) |
| 71 | LeakDetector::addGarbageObject(this); |
Chris Lattner | bded132 | 2002-09-06 21:33:15 +0000 | [diff] [blame] | 72 | Parent = parent; |
Chris Lattner | d1e693f | 2002-09-08 18:59:35 +0000 | [diff] [blame] | 73 | if (getParent()) |
| 74 | LeakDetector::removeGarbageObject(this); |
Chris Lattner | bded132 | 2002-09-06 21:33:15 +0000 | [diff] [blame] | 75 | } |
| 76 | |
Chris Lattner | de6fa5f | 2008-01-24 17:47:11 +0000 | [diff] [blame] | 77 | /// getArgNo - Return the index of this formal argument in its containing |
| 78 | /// function. For example in "void foo(int a, float b)" a is 0 and b is 1. |
| 79 | unsigned Argument::getArgNo() const { |
| 80 | const Function *F = getParent(); |
| 81 | assert(F && "Argument is not in a function"); |
| 82 | |
| 83 | Function::const_arg_iterator AI = F->arg_begin(); |
| 84 | unsigned ArgIdx = 0; |
| 85 | for (; &*AI != this; ++AI) |
| 86 | ++ArgIdx; |
| 87 | |
| 88 | return ArgIdx; |
| 89 | } |
| 90 | |
| 91 | /// hasByValAttr - Return true if this argument has the byval attribute on it |
| 92 | /// in its containing function. |
| 93 | bool Argument::hasByValAttr() const { |
| 94 | if (!isa<PointerType>(getType())) return false; |
| 95 | return getParent()->paramHasAttr(getArgNo()+1, ParamAttr::ByVal); |
| 96 | } |
| 97 | |
| 98 | /// hasNoAliasAttr - Return true if this argument has the noalias attribute on |
| 99 | /// it in its containing function. |
| 100 | bool Argument::hasNoAliasAttr() const { |
| 101 | if (!isa<PointerType>(getType())) return false; |
| 102 | return getParent()->paramHasAttr(getArgNo()+1, ParamAttr::NoAlias); |
| 103 | } |
| 104 | |
Owen Anderson | 7d54254 | 2008-02-17 23:22:28 +0000 | [diff] [blame] | 105 | /// hasSRetAttr - Return true if this argument has the sret attribute on |
| 106 | /// it in its containing function. |
| 107 | bool Argument::hasStructRetAttr() const { |
| 108 | if (!isa<PointerType>(getType())) return false; |
Owen Anderson | 874a892 | 2008-02-18 09:22:21 +0000 | [diff] [blame] | 109 | if (this != getParent()->arg_begin()) return false; // StructRet param must be first param |
Owen Anderson | 9eb948b | 2008-02-18 04:06:26 +0000 | [diff] [blame] | 110 | return getParent()->paramHasAttr(1, ParamAttr::StructRet); |
Owen Anderson | 7d54254 | 2008-02-17 23:22:28 +0000 | [diff] [blame] | 111 | } |
| 112 | |
Chris Lattner | de6fa5f | 2008-01-24 17:47:11 +0000 | [diff] [blame] | 113 | |
| 114 | |
| 115 | |
Chris Lattner | 80dd50b | 2002-04-09 19:39:35 +0000 | [diff] [blame] | 116 | //===----------------------------------------------------------------------===// |
Chris Lattner | 50ee9dd | 2008-01-02 23:42:30 +0000 | [diff] [blame] | 117 | // Helper Methods in Function |
Reid Spencer | 4746ecf | 2007-04-09 15:01:12 +0000 | [diff] [blame] | 118 | //===----------------------------------------------------------------------===// |
| 119 | |
Chris Lattner | 50ee9dd | 2008-01-02 23:42:30 +0000 | [diff] [blame] | 120 | const FunctionType *Function::getFunctionType() const { |
| 121 | return cast<FunctionType>(getType()->getElementType()); |
Reid Spencer | 4746ecf | 2007-04-09 15:01:12 +0000 | [diff] [blame] | 122 | } |
| 123 | |
Chris Lattner | 50ee9dd | 2008-01-02 23:42:30 +0000 | [diff] [blame] | 124 | bool Function::isVarArg() const { |
| 125 | return getFunctionType()->isVarArg(); |
Reid Spencer | 4746ecf | 2007-04-09 15:01:12 +0000 | [diff] [blame] | 126 | } |
| 127 | |
Chris Lattner | 50ee9dd | 2008-01-02 23:42:30 +0000 | [diff] [blame] | 128 | const Type *Function::getReturnType() const { |
| 129 | return getFunctionType()->getReturnType(); |
Duncan Sands | 827cde1 | 2007-11-25 14:10:56 +0000 | [diff] [blame] | 130 | } |
| 131 | |
Chris Lattner | 50ee9dd | 2008-01-02 23:42:30 +0000 | [diff] [blame] | 132 | void Function::removeFromParent() { |
| 133 | getParent()->getFunctionList().remove(this); |
Duncan Sands | 827cde1 | 2007-11-25 14:10:56 +0000 | [diff] [blame] | 134 | } |
| 135 | |
Chris Lattner | 50ee9dd | 2008-01-02 23:42:30 +0000 | [diff] [blame] | 136 | void Function::eraseFromParent() { |
| 137 | getParent()->getFunctionList().erase(this); |
Reid Spencer | 4746ecf | 2007-04-09 15:01:12 +0000 | [diff] [blame] | 138 | } |
| 139 | |
Reid Spencer | 4746ecf | 2007-04-09 15:01:12 +0000 | [diff] [blame] | 140 | //===----------------------------------------------------------------------===// |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 141 | // Function Implementation |
Chris Lattner | 70cc339 | 2001-09-10 07:58:01 +0000 | [diff] [blame] | 142 | //===----------------------------------------------------------------------===// |
| 143 | |
Chris Lattner | 4ad02e7 | 2003-04-16 20:28:45 +0000 | [diff] [blame] | 144 | Function::Function(const FunctionType *Ty, LinkageTypes Linkage, |
Chris Lattner | 4827015 | 2002-09-06 20:46:32 +0000 | [diff] [blame] | 145 | const std::string &name, Module *ParentModule) |
Christopher Lamb | 43ad6b3 | 2007-12-17 01:12:55 +0000 | [diff] [blame] | 146 | : GlobalValue(PointerType::getUnqual(Ty), |
Chris Lattner | 58d7491 | 2008-03-12 17:45:29 +0000 | [diff] [blame] | 147 | Value::FunctionVal, 0, 0, Linkage, name) { |
Reid Spencer | ef9b9a7 | 2007-02-05 20:47:22 +0000 | [diff] [blame] | 148 | SymTab = new ValueSymbolTable(); |
Chris Lattner | 4827015 | 2002-09-06 20:46:32 +0000 | [diff] [blame] | 149 | |
Devang Patel | 93f9d57 | 2008-02-20 22:36:03 +0000 | [diff] [blame] | 150 | assert((getReturnType()->isFirstClassType() ||getReturnType() == Type::VoidTy |
Devang Patel | 6c94b70 | 2008-02-21 22:24:17 +0000 | [diff] [blame] | 151 | || isa<StructType>(getReturnType())) |
Chris Lattner | c282f5a | 2003-11-21 22:32:23 +0000 | [diff] [blame] | 152 | && "LLVM functions cannot return aggregate values!"); |
| 153 | |
Chris Lattner | 0162c18 | 2007-08-18 06:14:52 +0000 | [diff] [blame] | 154 | // If the function has arguments, mark them as lazily built. |
| 155 | if (Ty->getNumParams()) |
| 156 | SubclassData = 1; // Set the "has lazy arguments" bit. |
| 157 | |
Chris Lattner | d1e693f | 2002-09-08 18:59:35 +0000 | [diff] [blame] | 158 | // Make sure that we get added to a function |
| 159 | LeakDetector::addGarbageObject(this); |
| 160 | |
Chris Lattner | 4827015 | 2002-09-06 20:46:32 +0000 | [diff] [blame] | 161 | if (ParentModule) |
| 162 | ParentModule->getFunctionList().push_back(this); |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 163 | } |
| 164 | |
Gordon Henriksen | afba8fe | 2007-12-10 02:14:30 +0000 | [diff] [blame] | 165 | Function::~Function() { |
| 166 | dropAllReferences(); // After this it is safe to delete instructions. |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 167 | |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 168 | // Delete all of the method arguments and unlink from symbol table... |
Gordon Henriksen | afba8fe | 2007-12-10 02:14:30 +0000 | [diff] [blame] | 169 | ArgumentList.clear(); |
| 170 | delete SymTab; |
Reid Spencer | b90909e | 2007-04-22 17:28:03 +0000 | [diff] [blame] | 171 | |
Gordon Henriksen | 80a75bf | 2007-12-10 03:18:06 +0000 | [diff] [blame] | 172 | // Remove the function from the on-the-side collector table. |
| 173 | clearCollector(); |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 174 | } |
| 175 | |
Chris Lattner | 0162c18 | 2007-08-18 06:14:52 +0000 | [diff] [blame] | 176 | void Function::BuildLazyArguments() const { |
| 177 | // Create the arguments vector, all arguments start out unnamed. |
| 178 | const FunctionType *FT = getFunctionType(); |
| 179 | for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) { |
| 180 | assert(FT->getParamType(i) != Type::VoidTy && |
| 181 | "Cannot have void typed arguments!"); |
| 182 | ArgumentList.push_back(new Argument(FT->getParamType(i))); |
| 183 | } |
| 184 | |
| 185 | // Clear the lazy arguments bit. |
| 186 | const_cast<Function*>(this)->SubclassData &= ~1; |
| 187 | } |
| 188 | |
| 189 | size_t Function::arg_size() const { |
| 190 | return getFunctionType()->getNumParams(); |
| 191 | } |
| 192 | bool Function::arg_empty() const { |
| 193 | return getFunctionType()->getNumParams() == 0; |
| 194 | } |
| 195 | |
Chris Lattner | e7506a3 | 2002-03-23 22:51:58 +0000 | [diff] [blame] | 196 | void Function::setParent(Module *parent) { |
Chris Lattner | d1e693f | 2002-09-08 18:59:35 +0000 | [diff] [blame] | 197 | if (getParent()) |
| 198 | LeakDetector::addGarbageObject(this); |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 199 | Parent = parent; |
Chris Lattner | d1e693f | 2002-09-08 18:59:35 +0000 | [diff] [blame] | 200 | if (getParent()) |
| 201 | LeakDetector::removeGarbageObject(this); |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 202 | } |
| 203 | |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 204 | // dropAllReferences() - This function causes all the subinstructions to "let |
| 205 | // go" of all references that they are maintaining. This allows one to |
| 206 | // 'delete' a whole class at a time, even though there may be circular |
| 207 | // references... first all references are dropped, and all use counts go to |
Misha Brukman | 6b63452 | 2003-10-10 17:54:14 +0000 | [diff] [blame] | 208 | // zero. Then everything is deleted for real. Note that no operations are |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 209 | // valid on an object that has "dropped all references", except operator |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 210 | // delete. |
| 211 | // |
Chris Lattner | e7506a3 | 2002-03-23 22:51:58 +0000 | [diff] [blame] | 212 | void Function::dropAllReferences() { |
Chris Lattner | 7e70829 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 213 | for (iterator I = begin(), E = end(); I != E; ++I) |
| 214 | I->dropAllReferences(); |
Chris Lattner | 0981b62 | 2003-09-17 04:58:59 +0000 | [diff] [blame] | 215 | BasicBlocks.clear(); // Delete all basic blocks... |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 216 | } |
Chris Lattner | 70cc339 | 2001-09-10 07:58:01 +0000 | [diff] [blame] | 217 | |
Gordon Henriksen | 80a75bf | 2007-12-10 03:18:06 +0000 | [diff] [blame] | 218 | // Maintain the collector name for each function in an on-the-side table. This |
| 219 | // saves allocating an additional word in Function for programs which do not use |
| 220 | // GC (i.e., most programs) at the cost of increased overhead for clients which |
| 221 | // do use GC. |
| 222 | static DenseMap<const Function*,PooledStringPtr> *CollectorNames; |
| 223 | static StringPool *CollectorNamePool; |
| 224 | |
| 225 | bool Function::hasCollector() const { |
| 226 | return CollectorNames && CollectorNames->count(this); |
| 227 | } |
| 228 | |
| 229 | const char *Function::getCollector() const { |
| 230 | assert(hasCollector() && "Function has no collector"); |
| 231 | return *(*CollectorNames)[this]; |
| 232 | } |
| 233 | |
| 234 | void Function::setCollector(const char *Str) { |
| 235 | if (!CollectorNamePool) |
| 236 | CollectorNamePool = new StringPool(); |
| 237 | if (!CollectorNames) |
| 238 | CollectorNames = new DenseMap<const Function*,PooledStringPtr>(); |
| 239 | (*CollectorNames)[this] = CollectorNamePool->intern(Str); |
| 240 | } |
| 241 | |
| 242 | void Function::clearCollector() { |
| 243 | if (CollectorNames) { |
| 244 | CollectorNames->erase(this); |
| 245 | if (CollectorNames->empty()) { |
| 246 | delete CollectorNames; |
| 247 | CollectorNames = 0; |
Gordon Henriksen | 53c34b1 | 2007-12-10 03:35:18 +0000 | [diff] [blame] | 248 | if (CollectorNamePool->empty()) { |
| 249 | delete CollectorNamePool; |
| 250 | CollectorNamePool = 0; |
| 251 | } |
Gordon Henriksen | 80a75bf | 2007-12-10 03:18:06 +0000 | [diff] [blame] | 252 | } |
| 253 | } |
| 254 | } |
| 255 | |
Chris Lattner | dd035d1 | 2003-05-08 03:47:33 +0000 | [diff] [blame] | 256 | /// getIntrinsicID - This method returns the ID number of the specified |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 257 | /// function, or Intrinsic::not_intrinsic if the function is not an |
Misha Brukman | 6b63452 | 2003-10-10 17:54:14 +0000 | [diff] [blame] | 258 | /// intrinsic, or if the pointer is null. This value is always defined to be |
Chris Lattner | dd035d1 | 2003-05-08 03:47:33 +0000 | [diff] [blame] | 259 | /// zero to allow easy checking for whether a function is intrinsic or not. The |
| 260 | /// particular intrinsic functions which correspond to this value are defined in |
| 261 | /// llvm/Intrinsics.h. |
| 262 | /// |
Reid Spencer | 2db15e2 | 2007-04-16 06:54:34 +0000 | [diff] [blame] | 263 | unsigned Function::getIntrinsicID(bool noAssert) const { |
Chris Lattner | 3b51580 | 2007-02-15 19:17:16 +0000 | [diff] [blame] | 264 | const ValueName *ValName = this->getValueName(); |
Reid Spencer | 085659f | 2007-04-16 07:08:44 +0000 | [diff] [blame] | 265 | if (!ValName) |
| 266 | return 0; |
Chris Lattner | 3b51580 | 2007-02-15 19:17:16 +0000 | [diff] [blame] | 267 | unsigned Len = ValName->getKeyLength(); |
| 268 | const char *Name = ValName->getKeyData(); |
| 269 | |
Reid Spencer | 9c15de1 | 2007-04-16 16:56:54 +0000 | [diff] [blame] | 270 | if (Len < 5 || Name[4] != '.' || Name[0] != 'l' || Name[1] != 'l' |
Reid Spencer | 0b11820 | 2006-01-16 21:12:35 +0000 | [diff] [blame] | 271 | || Name[2] != 'v' || Name[3] != 'm') |
Chris Lattner | dd035d1 | 2003-05-08 03:47:33 +0000 | [diff] [blame] | 272 | return 0; // All intrinsics start with 'llvm.' |
Chris Lattner | 095e907 | 2003-09-19 19:31:41 +0000 | [diff] [blame] | 273 | |
Reid Spencer | 2db15e2 | 2007-04-16 06:54:34 +0000 | [diff] [blame] | 274 | assert((Len != 5 || noAssert) && "'llvm.' is an invalid intrinsic name!"); |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 275 | |
Chris Lattner | 9a016ff | 2006-03-09 20:35:01 +0000 | [diff] [blame] | 276 | #define GET_FUNCTION_RECOGNIZER |
| 277 | #include "llvm/Intrinsics.gen" |
| 278 | #undef GET_FUNCTION_RECOGNIZER |
Reid Spencer | 2db15e2 | 2007-04-16 06:54:34 +0000 | [diff] [blame] | 279 | assert(noAssert && "Invalid LLVM intrinsic name"); |
Chris Lattner | dd035d1 | 2003-05-08 03:47:33 +0000 | [diff] [blame] | 280 | return 0; |
| 281 | } |
| 282 | |
Reid Spencer | 1437a09 | 2007-04-01 07:25:33 +0000 | [diff] [blame] | 283 | std::string Intrinsic::getName(ID id, const Type **Tys, unsigned numTys) { |
Chris Lattner | b847423 | 2006-03-25 06:32:47 +0000 | [diff] [blame] | 284 | assert(id < num_intrinsics && "Invalid intrinsic ID!"); |
| 285 | const char * const Table[] = { |
| 286 | "not_intrinsic", |
| 287 | #define GET_INTRINSIC_NAME_TABLE |
| 288 | #include "llvm/Intrinsics.gen" |
| 289 | #undef GET_INTRINSIC_NAME_TABLE |
| 290 | }; |
Reid Spencer | 1437a09 | 2007-04-01 07:25:33 +0000 | [diff] [blame] | 291 | if (numTys == 0) |
| 292 | return Table[id]; |
| 293 | std::string Result(Table[id]); |
| 294 | for (unsigned i = 0; i < numTys; ++i) |
| 295 | if (Tys[i]) |
Dan Gohman | 7abff31 | 2007-08-20 19:23:34 +0000 | [diff] [blame] | 296 | Result += "." + MVT::getValueTypeString(MVT::getValueType(Tys[i])); |
Reid Spencer | 1437a09 | 2007-04-01 07:25:33 +0000 | [diff] [blame] | 297 | return Result; |
Chris Lattner | b847423 | 2006-03-25 06:32:47 +0000 | [diff] [blame] | 298 | } |
| 299 | |
Reid Spencer | 1437a09 | 2007-04-01 07:25:33 +0000 | [diff] [blame] | 300 | const FunctionType *Intrinsic::getType(ID id, const Type **Tys, |
Chris Lattner | 1405d00 | 2007-06-05 23:49:06 +0000 | [diff] [blame] | 301 | unsigned numTys) { |
Jim Laskey | 95af592 | 2007-02-07 20:38:26 +0000 | [diff] [blame] | 302 | const Type *ResultTy = NULL; |
| 303 | std::vector<const Type*> ArgTys; |
Jim Laskey | 95af592 | 2007-02-07 20:38:26 +0000 | [diff] [blame] | 304 | bool IsVarArg = false; |
| 305 | |
| 306 | #define GET_INTRINSIC_GENERATOR |
| 307 | #include "llvm/Intrinsics.gen" |
| 308 | #undef GET_INTRINSIC_GENERATOR |
| 309 | |
Reid Spencer | ac66f42 | 2007-04-09 06:11:23 +0000 | [diff] [blame] | 310 | return FunctionType::get(ResultTy, ArgTys, IsVarArg); |
Jim Laskey | 95af592 | 2007-02-07 20:38:26 +0000 | [diff] [blame] | 311 | } |
| 312 | |
Chris Lattner | 58d7491 | 2008-03-12 17:45:29 +0000 | [diff] [blame] | 313 | PAListPtr Intrinsic::getParamAttrs(ID id) { |
Dale Johannesen | 0d51e7e | 2008-02-19 21:38:47 +0000 | [diff] [blame] | 314 | ParameterAttributes Attr = ParamAttr::None; |
Duncan Sands | a3355ff | 2007-12-03 20:06:50 +0000 | [diff] [blame] | 315 | |
| 316 | #define GET_INTRINSIC_ATTRIBUTES |
| 317 | #include "llvm/Intrinsics.gen" |
| 318 | #undef GET_INTRINSIC_ATTRIBUTES |
| 319 | |
| 320 | // Intrinsics cannot throw exceptions. |
| 321 | Attr |= ParamAttr::NoUnwind; |
| 322 | |
Chris Lattner | 58d7491 | 2008-03-12 17:45:29 +0000 | [diff] [blame] | 323 | ParamAttrsWithIndex PAWI = ParamAttrsWithIndex::get(0, Attr); |
| 324 | return PAListPtr::get(&PAWI, 1); |
Duncan Sands | a3355ff | 2007-12-03 20:06:50 +0000 | [diff] [blame] | 325 | } |
| 326 | |
Reid Spencer | 1437a09 | 2007-04-01 07:25:33 +0000 | [diff] [blame] | 327 | Function *Intrinsic::getDeclaration(Module *M, ID id, const Type **Tys, |
| 328 | unsigned numTys) { |
Duncan Sands | a3355ff | 2007-12-03 20:06:50 +0000 | [diff] [blame] | 329 | // There can never be multiple globals with the same name of different types, |
| 330 | // because intrinsics must be a specific type. |
| 331 | Function *F = |
| 332 | cast<Function>(M->getOrInsertFunction(getName(id, Tys, numTys), |
| 333 | getType(id, Tys, numTys))); |
| 334 | F->setParamAttrs(getParamAttrs(id)); |
| 335 | return F; |
Jim Laskey | 95af592 | 2007-02-07 20:38:26 +0000 | [diff] [blame] | 336 | } |
| 337 | |
Chris Lattner | a28809d | 2004-10-12 04:32:37 +0000 | [diff] [blame] | 338 | Value *IntrinsicInst::StripPointerCasts(Value *Ptr) { |
Chris Lattner | 4ec82eb | 2004-10-12 04:20:25 +0000 | [diff] [blame] | 339 | if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr)) { |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame] | 340 | if (CE->getOpcode() == Instruction::BitCast) { |
Chris Lattner | 4ec82eb | 2004-10-12 04:20:25 +0000 | [diff] [blame] | 341 | if (isa<PointerType>(CE->getOperand(0)->getType())) |
| 342 | return StripPointerCasts(CE->getOperand(0)); |
| 343 | } else if (CE->getOpcode() == Instruction::GetElementPtr) { |
| 344 | for (unsigned i = 1, e = CE->getNumOperands(); i != e; ++i) |
| 345 | if (!CE->getOperand(i)->isNullValue()) |
| 346 | return Ptr; |
| 347 | return StripPointerCasts(CE->getOperand(0)); |
| 348 | } |
| 349 | return Ptr; |
| 350 | } |
| 351 | |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame] | 352 | if (BitCastInst *CI = dyn_cast<BitCastInst>(Ptr)) { |
Chris Lattner | 4ec82eb | 2004-10-12 04:20:25 +0000 | [diff] [blame] | 353 | if (isa<PointerType>(CI->getOperand(0)->getType())) |
| 354 | return StripPointerCasts(CI->getOperand(0)); |
| 355 | } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Ptr)) { |
Chris Lattner | 1a34b7b | 2007-04-25 05:49:09 +0000 | [diff] [blame] | 356 | if (GEP->hasAllZeroIndices()) |
| 357 | return StripPointerCasts(GEP->getOperand(0)); |
Chris Lattner | 4ec82eb | 2004-10-12 04:20:25 +0000 | [diff] [blame] | 358 | } |
| 359 | return Ptr; |
| 360 | } |
Chris Lattner | dd035d1 | 2003-05-08 03:47:33 +0000 | [diff] [blame] | 361 | |
Reid Spencer | bb90515 | 2004-07-17 23:50:19 +0000 | [diff] [blame] | 362 | // vim: sw=2 ai |