Chris Lattner | cf3056d | 2003-10-13 03:32:08 +0000 | [diff] [blame] | 1 | //===-- Module.cpp - Implement the Module class ---------------------------===// |
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 | // |
| 10 | // This file implements the Module class for the VMCore library. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 14 | #include "llvm/Module.h" |
Chris Lattner | 28bf86a | 2001-06-30 04:35:40 +0000 | [diff] [blame] | 15 | #include "llvm/InstrTypes.h" |
Chris Lattner | 31bcdb8 | 2002-04-28 19:55:58 +0000 | [diff] [blame] | 16 | #include "llvm/Constants.h" |
Chris Lattner | 6056c49 | 2002-03-29 03:44:18 +0000 | [diff] [blame] | 17 | #include "llvm/DerivedTypes.h" |
Reid Spencer | 551ccae | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 18 | #include "llvm/ADT/STLExtras.h" |
Owen Anderson | 1d8b853 | 2006-05-18 02:10:31 +0000 | [diff] [blame] | 19 | #include "llvm/ADT/StringExtras.h" |
Reid Spencer | 551ccae | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 20 | #include "llvm/Support/LeakDetector.h" |
Chris Lattner | 7e70829 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 21 | #include "SymbolTableListTraitsImpl.h" |
Reid Spencer | 78d033e | 2007-01-06 07:24:44 +0000 | [diff] [blame] | 22 | #include "llvm/TypeSymbolTable.h" |
Chris Lattner | 7e70829 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 23 | #include <algorithm> |
Chris Lattner | 0ae8e87 | 2003-08-31 00:19:28 +0000 | [diff] [blame] | 24 | #include <cstdarg> |
Owen Anderson | 1d8b853 | 2006-05-18 02:10:31 +0000 | [diff] [blame] | 25 | #include <cstdlib> |
Chris Lattner | dd6dfbc | 2001-10-13 06:58:40 +0000 | [diff] [blame] | 26 | #include <map> |
Chris Lattner | 31f8499 | 2003-11-21 20:23:48 +0000 | [diff] [blame] | 27 | using namespace llvm; |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 28 | |
Chris Lattner | 6083782 | 2003-12-31 08:43:01 +0000 | [diff] [blame] | 29 | //===----------------------------------------------------------------------===// |
Misha Brukman | af76cfb | 2004-04-21 18:27:56 +0000 | [diff] [blame] | 30 | // Methods to implement the globals and functions lists. |
Chris Lattner | 6083782 | 2003-12-31 08:43:01 +0000 | [diff] [blame] | 31 | // |
| 32 | |
Chris Lattner | bca8144 | 2005-01-30 00:09:23 +0000 | [diff] [blame] | 33 | Function *ilist_traits<Function>::createSentinel() { |
Chris Lattner | d1e693f | 2002-09-08 18:59:35 +0000 | [diff] [blame] | 34 | FunctionType *FTy = |
Reid Spencer | 8129a39 | 2007-04-09 06:12:07 +0000 | [diff] [blame] | 35 | FunctionType::get(Type::VoidTy, std::vector<const Type*>(), false); |
Chris Lattner | 4ad02e7 | 2003-04-16 20:28:45 +0000 | [diff] [blame] | 36 | Function *Ret = new Function(FTy, GlobalValue::ExternalLinkage); |
Chris Lattner | d1e693f | 2002-09-08 18:59:35 +0000 | [diff] [blame] | 37 | // This should not be garbage monitored. |
| 38 | LeakDetector::removeGarbageObject(Ret); |
| 39 | return Ret; |
Chris Lattner | 7e70829 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 40 | } |
Chris Lattner | bca8144 | 2005-01-30 00:09:23 +0000 | [diff] [blame] | 41 | GlobalVariable *ilist_traits<GlobalVariable>::createSentinel() { |
Reid Spencer | 79e21d3 | 2006-12-31 05:26:44 +0000 | [diff] [blame] | 42 | GlobalVariable *Ret = new GlobalVariable(Type::Int32Ty, false, |
Chris Lattner | 4ad02e7 | 2003-04-16 20:28:45 +0000 | [diff] [blame] | 43 | GlobalValue::ExternalLinkage); |
Chris Lattner | d1e693f | 2002-09-08 18:59:35 +0000 | [diff] [blame] | 44 | // This should not be garbage monitored. |
| 45 | LeakDetector::removeGarbageObject(Ret); |
| 46 | return Ret; |
Chris Lattner | 7e70829 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 47 | } |
Anton Korobeynikov | 8b0a8c8 | 2007-04-25 14:27:10 +0000 | [diff] [blame] | 48 | GlobalAlias *ilist_traits<GlobalAlias>::createSentinel() { |
| 49 | GlobalAlias *Ret = new GlobalAlias(Type::Int32Ty, GlobalValue::ExternalLinkage); |
| 50 | // This should not be garbage monitored. |
| 51 | LeakDetector::removeGarbageObject(Ret); |
| 52 | return Ret; |
| 53 | } |
Chris Lattner | 7e70829 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 54 | |
| 55 | iplist<Function> &ilist_traits<Function>::getList(Module *M) { |
| 56 | return M->getFunctionList(); |
| 57 | } |
| 58 | iplist<GlobalVariable> &ilist_traits<GlobalVariable>::getList(Module *M) { |
| 59 | return M->getGlobalList(); |
| 60 | } |
Anton Korobeynikov | 8b0a8c8 | 2007-04-25 14:27:10 +0000 | [diff] [blame] | 61 | iplist<GlobalAlias> &ilist_traits<GlobalAlias>::getList(Module *M) { |
| 62 | return M->getAliasList(); |
| 63 | } |
Chris Lattner | 7e70829 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 64 | |
| 65 | // Explicit instantiations of SymbolTableListTraits since some of the methods |
Chris Lattner | cc041ba | 2006-01-24 04:13:11 +0000 | [diff] [blame] | 66 | // are not in the public header file. |
Chris Lattner | 17fcdd5 | 2007-04-17 03:26:42 +0000 | [diff] [blame] | 67 | template class SymbolTableListTraits<GlobalVariable, Module>; |
| 68 | template class SymbolTableListTraits<Function, Module>; |
Anton Korobeynikov | 8b0a8c8 | 2007-04-25 14:27:10 +0000 | [diff] [blame] | 69 | template class SymbolTableListTraits<GlobalAlias, Module>; |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 70 | |
Chris Lattner | 6083782 | 2003-12-31 08:43:01 +0000 | [diff] [blame] | 71 | //===----------------------------------------------------------------------===// |
| 72 | // Primitive Module methods. |
| 73 | // |
Chris Lattner | dd6dfbc | 2001-10-13 06:58:40 +0000 | [diff] [blame] | 74 | |
Chris Lattner | 678c6a0 | 2003-04-22 18:02:04 +0000 | [diff] [blame] | 75 | Module::Module(const std::string &MID) |
Owen Anderson | 1d8b853 | 2006-05-18 02:10:31 +0000 | [diff] [blame] | 76 | : ModuleID(MID), DataLayout("") { |
Reid Spencer | ef9b9a7 | 2007-02-05 20:47:22 +0000 | [diff] [blame] | 77 | ValSymTab = new ValueSymbolTable(); |
Reid Spencer | 78d033e | 2007-01-06 07:24:44 +0000 | [diff] [blame] | 78 | TypeSymTab = new TypeSymbolTable(); |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 79 | } |
| 80 | |
| 81 | Module::~Module() { |
| 82 | dropAllReferences(); |
Chris Lattner | 7e70829 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 83 | GlobalList.clear(); |
Chris Lattner | 7e70829 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 84 | FunctionList.clear(); |
Anton Korobeynikov | 8b0a8c8 | 2007-04-25 14:27:10 +0000 | [diff] [blame] | 85 | AliasList.clear(); |
Reid Spencer | 801db47 | 2004-07-25 18:08:57 +0000 | [diff] [blame] | 86 | LibraryList.clear(); |
Reid Spencer | 78d033e | 2007-01-06 07:24:44 +0000 | [diff] [blame] | 87 | delete ValSymTab; |
| 88 | delete TypeSymTab; |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 89 | } |
| 90 | |
Chris Lattner | 9da0715 | 2002-08-17 23:32:47 +0000 | [diff] [blame] | 91 | // Module::dump() - Allow printing from debugger |
| 92 | void Module::dump() const { |
Bill Wendling | 832171c | 2006-12-07 20:04:42 +0000 | [diff] [blame] | 93 | print(*cerr.stream()); |
Chris Lattner | 9da0715 | 2002-08-17 23:32:47 +0000 | [diff] [blame] | 94 | } |
| 95 | |
Owen Anderson | 1d8b853 | 2006-05-18 02:10:31 +0000 | [diff] [blame] | 96 | /// Target endian information... |
| 97 | Module::Endianness Module::getEndianness() const { |
| 98 | std::string temp = DataLayout; |
Owen Anderson | ac4c75b | 2006-05-18 05:46:08 +0000 | [diff] [blame] | 99 | Module::Endianness ret = AnyEndianness; |
Owen Anderson | 1d8b853 | 2006-05-18 02:10:31 +0000 | [diff] [blame] | 100 | |
Owen Anderson | ac4c75b | 2006-05-18 05:46:08 +0000 | [diff] [blame] | 101 | while (!temp.empty()) { |
Owen Anderson | 1d8b853 | 2006-05-18 02:10:31 +0000 | [diff] [blame] | 102 | std::string token = getToken(temp, "-"); |
| 103 | |
| 104 | if (token[0] == 'e') { |
Owen Anderson | ac4c75b | 2006-05-18 05:46:08 +0000 | [diff] [blame] | 105 | ret = LittleEndian; |
Owen Anderson | 1d8b853 | 2006-05-18 02:10:31 +0000 | [diff] [blame] | 106 | } else if (token[0] == 'E') { |
Owen Anderson | ac4c75b | 2006-05-18 05:46:08 +0000 | [diff] [blame] | 107 | ret = BigEndian; |
Owen Anderson | 1d8b853 | 2006-05-18 02:10:31 +0000 | [diff] [blame] | 108 | } |
| 109 | } |
| 110 | |
Owen Anderson | ac4c75b | 2006-05-18 05:46:08 +0000 | [diff] [blame] | 111 | return ret; |
Owen Anderson | 1d8b853 | 2006-05-18 02:10:31 +0000 | [diff] [blame] | 112 | } |
| 113 | |
Owen Anderson | 1d8b853 | 2006-05-18 02:10:31 +0000 | [diff] [blame] | 114 | /// Target Pointer Size information... |
| 115 | Module::PointerSize Module::getPointerSize() const { |
| 116 | std::string temp = DataLayout; |
Owen Anderson | ac4c75b | 2006-05-18 05:46:08 +0000 | [diff] [blame] | 117 | Module::PointerSize ret = AnyPointerSize; |
Owen Anderson | 1d8b853 | 2006-05-18 02:10:31 +0000 | [diff] [blame] | 118 | |
Owen Anderson | ac4c75b | 2006-05-18 05:46:08 +0000 | [diff] [blame] | 119 | while (!temp.empty()) { |
Owen Anderson | 1d8b853 | 2006-05-18 02:10:31 +0000 | [diff] [blame] | 120 | std::string token = getToken(temp, "-"); |
| 121 | char signal = getToken(token, ":")[0]; |
| 122 | |
| 123 | if (signal == 'p') { |
| 124 | int size = atoi(getToken(token, ":").c_str()); |
| 125 | if (size == 32) |
Owen Anderson | ac4c75b | 2006-05-18 05:46:08 +0000 | [diff] [blame] | 126 | ret = Pointer32; |
Owen Anderson | 1d8b853 | 2006-05-18 02:10:31 +0000 | [diff] [blame] | 127 | else if (size == 64) |
Owen Anderson | ac4c75b | 2006-05-18 05:46:08 +0000 | [diff] [blame] | 128 | ret = Pointer64; |
Owen Anderson | 1d8b853 | 2006-05-18 02:10:31 +0000 | [diff] [blame] | 129 | } |
| 130 | } |
| 131 | |
Owen Anderson | ac4c75b | 2006-05-18 05:46:08 +0000 | [diff] [blame] | 132 | return ret; |
Owen Anderson | 1d8b853 | 2006-05-18 02:10:31 +0000 | [diff] [blame] | 133 | } |
| 134 | |
Chris Lattner | 6083782 | 2003-12-31 08:43:01 +0000 | [diff] [blame] | 135 | //===----------------------------------------------------------------------===// |
| 136 | // Methods for easy access to the functions in the module. |
| 137 | // |
| 138 | |
Reid Spencer | ef9b9a7 | 2007-02-05 20:47:22 +0000 | [diff] [blame] | 139 | // getOrInsertFunction - Look up the specified function in the module symbol |
| 140 | // table. If it does not exist, add a prototype for the function and return |
| 141 | // it. This is nice because it allows most passes to get away with not handling |
| 142 | // the symbol table directly for this common task. |
| 143 | // |
Chris Lattner | 70d1305 | 2007-01-07 08:09:25 +0000 | [diff] [blame] | 144 | Constant *Module::getOrInsertFunction(const std::string &Name, |
Chris Lattner | 6056c49 | 2002-03-29 03:44:18 +0000 | [diff] [blame] | 145 | const FunctionType *Ty) { |
Reid Spencer | ef9b9a7 | 2007-02-05 20:47:22 +0000 | [diff] [blame] | 146 | ValueSymbolTable &SymTab = getValueSymbolTable(); |
Chris Lattner | 6056c49 | 2002-03-29 03:44:18 +0000 | [diff] [blame] | 147 | |
Reid Spencer | ef9b9a7 | 2007-02-05 20:47:22 +0000 | [diff] [blame] | 148 | // See if we have a definition for the specified function already. |
Reid Spencer | 688b049 | 2007-02-05 21:19:13 +0000 | [diff] [blame] | 149 | GlobalValue *F = dyn_cast_or_null<GlobalValue>(SymTab.lookup(Name)); |
Chris Lattner | 70d1305 | 2007-01-07 08:09:25 +0000 | [diff] [blame] | 150 | if (F == 0) { |
Reid Spencer | ef9b9a7 | 2007-02-05 20:47:22 +0000 | [diff] [blame] | 151 | // Nope, add it |
Chris Lattner | 4ad02e7 | 2003-04-16 20:28:45 +0000 | [diff] [blame] | 152 | Function *New = new Function(Ty, GlobalVariable::ExternalLinkage, Name); |
Chris Lattner | 6056c49 | 2002-03-29 03:44:18 +0000 | [diff] [blame] | 153 | FunctionList.push_back(New); |
Chris Lattner | 70d1305 | 2007-01-07 08:09:25 +0000 | [diff] [blame] | 154 | return New; // Return the new prototype. |
Chris Lattner | 6056c49 | 2002-03-29 03:44:18 +0000 | [diff] [blame] | 155 | } |
Chris Lattner | 70d1305 | 2007-01-07 08:09:25 +0000 | [diff] [blame] | 156 | |
| 157 | // Okay, the function exists. Does it have externally visible linkage? |
| 158 | if (F->hasInternalLinkage()) { |
| 159 | // Rename the function. |
Reid Spencer | ef9b9a7 | 2007-02-05 20:47:22 +0000 | [diff] [blame] | 160 | F->setName(SymTab.getUniqueName(F->getName())); |
Chris Lattner | 70d1305 | 2007-01-07 08:09:25 +0000 | [diff] [blame] | 161 | // Retry, now there won't be a conflict. |
| 162 | return getOrInsertFunction(Name, Ty); |
| 163 | } |
| 164 | |
| 165 | // If the function exists but has the wrong type, return a bitcast to the |
| 166 | // right type. |
Christopher Lamb | 43ad6b3 | 2007-12-17 01:12:55 +0000 | [diff] [blame] | 167 | if (F->getType() != PointerType::getUnqual(Ty)) |
| 168 | return ConstantExpr::getBitCast(F, PointerType::getUnqual(Ty)); |
Chris Lattner | 70d1305 | 2007-01-07 08:09:25 +0000 | [diff] [blame] | 169 | |
| 170 | // Otherwise, we just found the existing function or a prototype. |
| 171 | return F; |
Chris Lattner | 6056c49 | 2002-03-29 03:44:18 +0000 | [diff] [blame] | 172 | } |
| 173 | |
Chris Lattner | 0ae8e87 | 2003-08-31 00:19:28 +0000 | [diff] [blame] | 174 | // getOrInsertFunction - Look up the specified function in the module symbol |
| 175 | // table. If it does not exist, add a prototype for the function and return it. |
| 176 | // This version of the method takes a null terminated list of function |
| 177 | // arguments, which makes it easier for clients to use. |
| 178 | // |
Chris Lattner | 70d1305 | 2007-01-07 08:09:25 +0000 | [diff] [blame] | 179 | Constant *Module::getOrInsertFunction(const std::string &Name, |
Chris Lattner | 0ae8e87 | 2003-08-31 00:19:28 +0000 | [diff] [blame] | 180 | const Type *RetTy, ...) { |
| 181 | va_list Args; |
| 182 | va_start(Args, RetTy); |
| 183 | |
| 184 | // Build the list of argument types... |
| 185 | std::vector<const Type*> ArgTys; |
| 186 | while (const Type *ArgTy = va_arg(Args, const Type*)) |
| 187 | ArgTys.push_back(ArgTy); |
| 188 | |
| 189 | va_end(Args); |
| 190 | |
| 191 | // Build the function type and chain to the other getOrInsertFunction... |
| 192 | return getOrInsertFunction(Name, FunctionType::get(RetTy, ArgTys, false)); |
| 193 | } |
| 194 | |
| 195 | |
Chris Lattner | 6056c49 | 2002-03-29 03:44:18 +0000 | [diff] [blame] | 196 | // getFunction - Look up the specified function in the module symbol table. |
| 197 | // If it does not exist, return null. |
| 198 | // |
Reid Spencer | ef9b9a7 | 2007-02-05 20:47:22 +0000 | [diff] [blame] | 199 | Function *Module::getFunction(const std::string &Name) const { |
| 200 | const ValueSymbolTable &SymTab = getValueSymbolTable(); |
| 201 | return dyn_cast_or_null<Function>(SymTab.lookup(Name)); |
Chris Lattner | a9a93f3 | 2002-11-08 20:34:02 +0000 | [diff] [blame] | 202 | } |
| 203 | |
Chris Lattner | 6083782 | 2003-12-31 08:43:01 +0000 | [diff] [blame] | 204 | //===----------------------------------------------------------------------===// |
| 205 | // Methods for easy access to the global variables in the module. |
| 206 | // |
| 207 | |
| 208 | /// getGlobalVariable - Look up the specified global variable in the module |
Chris Lattner | 3061467 | 2005-12-05 05:30:21 +0000 | [diff] [blame] | 209 | /// symbol table. If it does not exist, return null. The type argument |
| 210 | /// should be the underlying type of the global, i.e., it should not have |
| 211 | /// the top-level PointerType, which represents the address of the global. |
| 212 | /// If AllowInternal is set to true, this function will return types that |
| 213 | /// have InternalLinkage. By default, these types are not returned. |
Chris Lattner | 6083782 | 2003-12-31 08:43:01 +0000 | [diff] [blame] | 214 | /// |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 215 | GlobalVariable *Module::getGlobalVariable(const std::string &Name, |
Reid Spencer | ef9b9a7 | 2007-02-05 20:47:22 +0000 | [diff] [blame] | 216 | bool AllowInternal) const { |
| 217 | if (Value *V = ValSymTab->lookup(Name)) { |
| 218 | GlobalVariable *Result = dyn_cast<GlobalVariable>(V); |
| 219 | if (Result && (AllowInternal || !Result->hasInternalLinkage())) |
Chris Lattner | 6083782 | 2003-12-31 08:43:01 +0000 | [diff] [blame] | 220 | return Result; |
| 221 | } |
| 222 | return 0; |
| 223 | } |
| 224 | |
Chris Lattner | 6083782 | 2003-12-31 08:43:01 +0000 | [diff] [blame] | 225 | //===----------------------------------------------------------------------===// |
Anton Korobeynikov | 8b0a8c8 | 2007-04-25 14:27:10 +0000 | [diff] [blame] | 226 | // Methods for easy access to the global variables in the module. |
| 227 | // |
| 228 | |
| 229 | // getNamedAlias - Look up the specified global in the module symbol table. |
| 230 | // If it does not exist, return null. |
| 231 | // |
| 232 | GlobalAlias *Module::getNamedAlias(const std::string &Name) const { |
| 233 | const ValueSymbolTable &SymTab = getValueSymbolTable(); |
| 234 | return dyn_cast_or_null<GlobalAlias>(SymTab.lookup(Name)); |
| 235 | } |
| 236 | |
| 237 | //===----------------------------------------------------------------------===// |
Chris Lattner | 6083782 | 2003-12-31 08:43:01 +0000 | [diff] [blame] | 238 | // Methods for easy access to the types in the module. |
| 239 | // |
| 240 | |
Chris Lattner | a9a93f3 | 2002-11-08 20:34:02 +0000 | [diff] [blame] | 241 | |
Chris Lattner | 6d28a26 | 2003-12-31 07:09:33 +0000 | [diff] [blame] | 242 | // addTypeName - Insert an entry in the symbol table mapping Str to Type. If |
| 243 | // there is already an entry for this name, true is returned and the symbol |
| 244 | // table is not modified. |
| 245 | // |
| 246 | bool Module::addTypeName(const std::string &Name, const Type *Ty) { |
Reid Spencer | 78d033e | 2007-01-06 07:24:44 +0000 | [diff] [blame] | 247 | TypeSymbolTable &ST = getTypeSymbolTable(); |
Chris Lattner | 6d28a26 | 2003-12-31 07:09:33 +0000 | [diff] [blame] | 248 | |
Reid Spencer | 78d033e | 2007-01-06 07:24:44 +0000 | [diff] [blame] | 249 | if (ST.lookup(Name)) return true; // Already in symtab... |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 250 | |
Chris Lattner | 6d28a26 | 2003-12-31 07:09:33 +0000 | [diff] [blame] | 251 | // Not in symbol table? Set the name with the Symtab as an argument so the |
| 252 | // type knows what to update... |
Reid Spencer | 3ba415a | 2004-07-10 16:37:42 +0000 | [diff] [blame] | 253 | ST.insert(Name, Ty); |
Chris Lattner | 6d28a26 | 2003-12-31 07:09:33 +0000 | [diff] [blame] | 254 | |
| 255 | return false; |
| 256 | } |
| 257 | |
| 258 | /// getTypeByName - Return the type with the specified name in this module, or |
| 259 | /// null if there is none by that name. |
| 260 | const Type *Module::getTypeByName(const std::string &Name) const { |
Reid Spencer | 78d033e | 2007-01-06 07:24:44 +0000 | [diff] [blame] | 261 | const TypeSymbolTable &ST = getTypeSymbolTable(); |
| 262 | return cast_or_null<Type>(ST.lookup(Name)); |
Chris Lattner | 6d28a26 | 2003-12-31 07:09:33 +0000 | [diff] [blame] | 263 | } |
Chris Lattner | a9a93f3 | 2002-11-08 20:34:02 +0000 | [diff] [blame] | 264 | |
Chris Lattner | f33fa6f | 2002-04-13 18:58:33 +0000 | [diff] [blame] | 265 | // getTypeName - If there is at least one entry in the symbol table for the |
| 266 | // specified type, return it. |
| 267 | // |
Chris Lattner | 6d28a26 | 2003-12-31 07:09:33 +0000 | [diff] [blame] | 268 | std::string Module::getTypeName(const Type *Ty) const { |
Reid Spencer | 78d033e | 2007-01-06 07:24:44 +0000 | [diff] [blame] | 269 | const TypeSymbolTable &ST = getTypeSymbolTable(); |
Chris Lattner | f33fa6f | 2002-04-13 18:58:33 +0000 | [diff] [blame] | 270 | |
Reid Spencer | 78d033e | 2007-01-06 07:24:44 +0000 | [diff] [blame] | 271 | TypeSymbolTable::const_iterator TI = ST.begin(); |
| 272 | TypeSymbolTable::const_iterator TE = ST.end(); |
Reid Spencer | 567bc2c | 2004-05-25 08:52:20 +0000 | [diff] [blame] | 273 | if ( TI == TE ) return ""; // No names for types |
Chris Lattner | f33fa6f | 2002-04-13 18:58:33 +0000 | [diff] [blame] | 274 | |
Reid Spencer | 567bc2c | 2004-05-25 08:52:20 +0000 | [diff] [blame] | 275 | while (TI != TE && TI->second != Ty) |
Chris Lattner | f33fa6f | 2002-04-13 18:58:33 +0000 | [diff] [blame] | 276 | ++TI; |
| 277 | |
| 278 | if (TI != TE) // Must have found an entry! |
| 279 | return TI->first; |
| 280 | return ""; // Must not have found anything... |
| 281 | } |
| 282 | |
Chris Lattner | 6083782 | 2003-12-31 08:43:01 +0000 | [diff] [blame] | 283 | //===----------------------------------------------------------------------===// |
| 284 | // Other module related stuff. |
| 285 | // |
| 286 | |
| 287 | |
Chris Lattner | 9da0715 | 2002-08-17 23:32:47 +0000 | [diff] [blame] | 288 | // dropAllReferences() - This function causes all the subelementss to "let go" |
| 289 | // of all references that they are maintaining. This allows one to 'delete' a |
| 290 | // whole module at a time, even though there may be circular references... first |
| 291 | // all references are dropped, and all use counts go to zero. Then everything |
Misha Brukman | 6b63452 | 2003-10-10 17:54:14 +0000 | [diff] [blame] | 292 | // is deleted for real. Note that no operations are valid on an object that |
Chris Lattner | 9da0715 | 2002-08-17 23:32:47 +0000 | [diff] [blame] | 293 | // has "dropped all references", except operator delete. |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 294 | // |
| 295 | void Module::dropAllReferences() { |
Chris Lattner | 7e70829 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 296 | for(Module::iterator I = begin(), E = end(); I != E; ++I) |
| 297 | I->dropAllReferences(); |
Chris Lattner | dd6dfbc | 2001-10-13 06:58:40 +0000 | [diff] [blame] | 298 | |
Chris Lattner | e4d5c44 | 2005-03-15 04:54:21 +0000 | [diff] [blame] | 299 | for(Module::global_iterator I = global_begin(), E = global_end(); I != E; ++I) |
Chris Lattner | 7e70829 | 2002-06-25 16:13:24 +0000 | [diff] [blame] | 300 | I->dropAllReferences(); |
Anton Korobeynikov | a80e118 | 2007-04-28 13:45:00 +0000 | [diff] [blame] | 301 | |
| 302 | for(Module::alias_iterator I = alias_begin(), E = alias_end(); I != E; ++I) |
| 303 | I->dropAllReferences(); |
Chris Lattner | 0095054 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 304 | } |
Chris Lattner | 28bf86a | 2001-06-30 04:35:40 +0000 | [diff] [blame] | 305 | |
Reid Spencer | 6734b57 | 2007-02-04 00:40:42 +0000 | [diff] [blame] | 306 | void Module::addLibrary(const std::string& Lib) { |
| 307 | for (Module::lib_iterator I = lib_begin(), E = lib_end(); I != E; ++I) |
| 308 | if (*I == Lib) |
| 309 | return; |
| 310 | LibraryList.push_back(Lib); |
| 311 | } |
| 312 | |
| 313 | void Module::removeLibrary(const std::string& Lib) { |
| 314 | LibraryListType::iterator I = LibraryList.begin(); |
| 315 | LibraryListType::iterator E = LibraryList.end(); |
| 316 | for (;I != E; ++I) |
| 317 | if (*I == Lib) { |
| 318 | LibraryList.erase(I); |
| 319 | return; |
| 320 | } |
| 321 | } |
| 322 | |