Module.cpp revision c8cfaa1625a72aa3660a268dae753748cfed67d0
1//===-- Module.cpp - Implement the Module class ---------------------------===// 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 Module class for the IR library. 11// 12//===----------------------------------------------------------------------===// 13 14#include "llvm/IR/Module.h" 15#include "SymbolTableListTraitsImpl.h" 16#include "llvm/ADT/DenseSet.h" 17#include "llvm/ADT/STLExtras.h" 18#include "llvm/ADT/SmallString.h" 19#include "llvm/ADT/StringExtras.h" 20#include "llvm/GVMaterializer.h" 21#include "llvm/IR/Constants.h" 22#include "llvm/IR/DerivedTypes.h" 23#include "llvm/IR/InstrTypes.h" 24#include "llvm/IR/LLVMContext.h" 25#include "llvm/Support/LeakDetector.h" 26#include <algorithm> 27#include <cstdarg> 28#include <cstdlib> 29using namespace llvm; 30 31//===----------------------------------------------------------------------===// 32// Methods to implement the globals and functions lists. 33// 34 35// Explicit instantiations of SymbolTableListTraits since some of the methods 36// are not in the public header file. 37template class llvm::SymbolTableListTraits<Function, Module>; 38template class llvm::SymbolTableListTraits<GlobalVariable, Module>; 39template class llvm::SymbolTableListTraits<GlobalAlias, Module>; 40 41//===----------------------------------------------------------------------===// 42// Primitive Module methods. 43// 44 45Module::Module(StringRef MID, LLVMContext& C) 46 : Context(C), Materializer(NULL), ModuleID(MID) { 47 ValSymTab = new ValueSymbolTable(); 48 NamedMDSymTab = new StringMap<NamedMDNode *>(); 49 Context.addModule(this); 50} 51 52Module::~Module() { 53 Context.removeModule(this); 54 dropAllReferences(); 55 GlobalList.clear(); 56 FunctionList.clear(); 57 AliasList.clear(); 58 NamedMDList.clear(); 59 delete ValSymTab; 60 delete static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab); 61} 62 63/// Target endian information. 64Module::Endianness Module::getEndianness() const { 65 StringRef temp = DataLayout; 66 Module::Endianness ret = AnyEndianness; 67 68 while (!temp.empty()) { 69 std::pair<StringRef, StringRef> P = getToken(temp, "-"); 70 71 StringRef token = P.first; 72 temp = P.second; 73 74 if (token[0] == 'e') { 75 ret = LittleEndian; 76 } else if (token[0] == 'E') { 77 ret = BigEndian; 78 } 79 } 80 81 return ret; 82} 83 84/// Target Pointer Size information. 85Module::PointerSize Module::getPointerSize() const { 86 StringRef temp = DataLayout; 87 Module::PointerSize ret = AnyPointerSize; 88 89 while (!temp.empty()) { 90 std::pair<StringRef, StringRef> TmpP = getToken(temp, "-"); 91 temp = TmpP.second; 92 TmpP = getToken(TmpP.first, ":"); 93 StringRef token = TmpP.second, signalToken = TmpP.first; 94 95 if (signalToken[0] == 'p') { 96 int size = 0; 97 getToken(token, ":").first.getAsInteger(10, size); 98 if (size == 32) 99 ret = Pointer32; 100 else if (size == 64) 101 ret = Pointer64; 102 } 103 } 104 105 return ret; 106} 107 108/// getNamedValue - Return the first global value in the module with 109/// the specified name, of arbitrary type. This method returns null 110/// if a global with the specified name is not found. 111GlobalValue *Module::getNamedValue(StringRef Name) const { 112 return cast_or_null<GlobalValue>(getValueSymbolTable().lookup(Name)); 113} 114 115/// getMDKindID - Return a unique non-zero ID for the specified metadata kind. 116/// This ID is uniqued across modules in the current LLVMContext. 117unsigned Module::getMDKindID(StringRef Name) const { 118 return Context.getMDKindID(Name); 119} 120 121/// getMDKindNames - Populate client supplied SmallVector with the name for 122/// custom metadata IDs registered in this LLVMContext. ID #0 is not used, 123/// so it is filled in as an empty string. 124void Module::getMDKindNames(SmallVectorImpl<StringRef> &Result) const { 125 return Context.getMDKindNames(Result); 126} 127 128 129//===----------------------------------------------------------------------===// 130// Methods for easy access to the functions in the module. 131// 132 133// getOrInsertFunction - Look up the specified function in the module symbol 134// table. If it does not exist, add a prototype for the function and return 135// it. This is nice because it allows most passes to get away with not handling 136// the symbol table directly for this common task. 137// 138Constant *Module::getOrInsertFunction(StringRef Name, 139 FunctionType *Ty, 140 AttributeSet AttributeList) { 141 // See if we have a definition for the specified function already. 142 GlobalValue *F = getNamedValue(Name); 143 if (F == 0) { 144 // Nope, add it 145 Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage, Name); 146 if (!New->isIntrinsic()) // Intrinsics get attrs set on construction 147 New->setAttributes(AttributeList); 148 FunctionList.push_back(New); 149 return New; // Return the new prototype. 150 } 151 152 // Okay, the function exists. Does it have externally visible linkage? 153 if (F->hasLocalLinkage()) { 154 // Clear the function's name. 155 F->setName(""); 156 // Retry, now there won't be a conflict. 157 Constant *NewF = getOrInsertFunction(Name, Ty); 158 F->setName(Name); 159 return NewF; 160 } 161 162 // If the function exists but has the wrong type, return a bitcast to the 163 // right type. 164 if (F->getType() != PointerType::getUnqual(Ty)) 165 return ConstantExpr::getBitCast(F, PointerType::getUnqual(Ty)); 166 167 // Otherwise, we just found the existing function or a prototype. 168 return F; 169} 170 171Constant *Module::getOrInsertFunction(StringRef Name, 172 FunctionType *Ty) { 173 return getOrInsertFunction(Name, Ty, AttributeSet()); 174} 175 176// getOrInsertFunction - Look up the specified function in the module symbol 177// table. If it does not exist, add a prototype for the function and return it. 178// This version of the method takes a null terminated list of function 179// arguments, which makes it easier for clients to use. 180// 181Constant *Module::getOrInsertFunction(StringRef Name, 182 AttributeSet AttributeList, 183 Type *RetTy, ...) { 184 va_list Args; 185 va_start(Args, RetTy); 186 187 // Build the list of argument types... 188 std::vector<Type*> ArgTys; 189 while (Type *ArgTy = va_arg(Args, Type*)) 190 ArgTys.push_back(ArgTy); 191 192 va_end(Args); 193 194 // Build the function type and chain to the other getOrInsertFunction... 195 return getOrInsertFunction(Name, 196 FunctionType::get(RetTy, ArgTys, false), 197 AttributeList); 198} 199 200Constant *Module::getOrInsertFunction(StringRef Name, 201 Type *RetTy, ...) { 202 va_list Args; 203 va_start(Args, RetTy); 204 205 // Build the list of argument types... 206 std::vector<Type*> ArgTys; 207 while (Type *ArgTy = va_arg(Args, Type*)) 208 ArgTys.push_back(ArgTy); 209 210 va_end(Args); 211 212 // Build the function type and chain to the other getOrInsertFunction... 213 return getOrInsertFunction(Name, 214 FunctionType::get(RetTy, ArgTys, false), 215 AttributeSet()); 216} 217 218// getFunction - Look up the specified function in the module symbol table. 219// If it does not exist, return null. 220// 221Function *Module::getFunction(StringRef Name) const { 222 return dyn_cast_or_null<Function>(getNamedValue(Name)); 223} 224 225//===----------------------------------------------------------------------===// 226// Methods for easy access to the global variables in the module. 227// 228 229/// getGlobalVariable - Look up the specified global variable in the module 230/// symbol table. If it does not exist, return null. The type argument 231/// should be the underlying type of the global, i.e., it should not have 232/// the top-level PointerType, which represents the address of the global. 233/// If AllowLocal is set to true, this function will return types that 234/// have an local. By default, these types are not returned. 235/// 236GlobalVariable *Module::getGlobalVariable(StringRef Name, 237 bool AllowLocal) const { 238 if (GlobalVariable *Result = 239 dyn_cast_or_null<GlobalVariable>(getNamedValue(Name))) 240 if (AllowLocal || !Result->hasLocalLinkage()) 241 return Result; 242 return 0; 243} 244 245/// getOrInsertGlobal - Look up the specified global in the module symbol table. 246/// 1. If it does not exist, add a declaration of the global and return it. 247/// 2. Else, the global exists but has the wrong type: return the function 248/// with a constantexpr cast to the right type. 249/// 3. Finally, if the existing global is the correct delclaration, return the 250/// existing global. 251Constant *Module::getOrInsertGlobal(StringRef Name, Type *Ty) { 252 // See if we have a definition for the specified global already. 253 GlobalVariable *GV = dyn_cast_or_null<GlobalVariable>(getNamedValue(Name)); 254 if (GV == 0) { 255 // Nope, add it 256 GlobalVariable *New = 257 new GlobalVariable(*this, Ty, false, GlobalVariable::ExternalLinkage, 258 0, Name); 259 return New; // Return the new declaration. 260 } 261 262 // If the variable exists but has the wrong type, return a bitcast to the 263 // right type. 264 if (GV->getType() != PointerType::getUnqual(Ty)) 265 return ConstantExpr::getBitCast(GV, PointerType::getUnqual(Ty)); 266 267 // Otherwise, we just found the existing function or a prototype. 268 return GV; 269} 270 271//===----------------------------------------------------------------------===// 272// Methods for easy access to the global variables in the module. 273// 274 275// getNamedAlias - Look up the specified global in the module symbol table. 276// If it does not exist, return null. 277// 278GlobalAlias *Module::getNamedAlias(StringRef Name) const { 279 return dyn_cast_or_null<GlobalAlias>(getNamedValue(Name)); 280} 281 282/// getNamedMetadata - Return the first NamedMDNode in the module with the 283/// specified name. This method returns null if a NamedMDNode with the 284/// specified name is not found. 285NamedMDNode *Module::getNamedMetadata(const Twine &Name) const { 286 SmallString<256> NameData; 287 StringRef NameRef = Name.toStringRef(NameData); 288 return static_cast<StringMap<NamedMDNode*> *>(NamedMDSymTab)->lookup(NameRef); 289} 290 291/// getOrInsertNamedMetadata - Return the first named MDNode in the module 292/// with the specified name. This method returns a new NamedMDNode if a 293/// NamedMDNode with the specified name is not found. 294NamedMDNode *Module::getOrInsertNamedMetadata(StringRef Name) { 295 NamedMDNode *&NMD = 296 (*static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab))[Name]; 297 if (!NMD) { 298 NMD = new NamedMDNode(Name); 299 NMD->setParent(this); 300 NamedMDList.push_back(NMD); 301 } 302 return NMD; 303} 304 305/// eraseNamedMetadata - Remove the given NamedMDNode from this module and 306/// delete it. 307void Module::eraseNamedMetadata(NamedMDNode *NMD) { 308 static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab)->erase(NMD->getName()); 309 NamedMDList.erase(NMD); 310} 311 312/// getModuleFlagsMetadata - Returns the module flags in the provided vector. 313void Module:: 314getModuleFlagsMetadata(SmallVectorImpl<ModuleFlagEntry> &Flags) const { 315 const NamedMDNode *ModFlags = getModuleFlagsMetadata(); 316 if (!ModFlags) return; 317 318 for (unsigned i = 0, e = ModFlags->getNumOperands(); i != e; ++i) { 319 MDNode *Flag = ModFlags->getOperand(i); 320 ConstantInt *Behavior = cast<ConstantInt>(Flag->getOperand(0)); 321 MDString *Key = cast<MDString>(Flag->getOperand(1)); 322 Value *Val = Flag->getOperand(2); 323 Flags.push_back(ModuleFlagEntry(ModFlagBehavior(Behavior->getZExtValue()), 324 Key, Val)); 325 } 326} 327 328/// Return the corresponding value if Key appears in module flags, otherwise 329/// return null. 330Value *Module::getModuleFlag(StringRef Key) const { 331 SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags; 332 getModuleFlagsMetadata(ModuleFlags); 333 for (unsigned I = 0, E = ModuleFlags.size(); I < E; ++I) { 334 const ModuleFlagEntry &MFE = ModuleFlags[I]; 335 if (Key == MFE.Key->getString()) 336 return MFE.Val; 337 } 338 return 0; 339} 340 341/// getModuleFlagsMetadata - Returns the NamedMDNode in the module that 342/// represents module-level flags. This method returns null if there are no 343/// module-level flags. 344NamedMDNode *Module::getModuleFlagsMetadata() const { 345 return getNamedMetadata("llvm.module.flags"); 346} 347 348/// getOrInsertModuleFlagsMetadata - Returns the NamedMDNode in the module that 349/// represents module-level flags. If module-level flags aren't found, it 350/// creates the named metadata that contains them. 351NamedMDNode *Module::getOrInsertModuleFlagsMetadata() { 352 return getOrInsertNamedMetadata("llvm.module.flags"); 353} 354 355/// addModuleFlag - Add a module-level flag to the module-level flags 356/// metadata. It will create the module-level flags named metadata if it doesn't 357/// already exist. 358void Module::addModuleFlag(ModFlagBehavior Behavior, StringRef Key, 359 Value *Val) { 360 Type *Int32Ty = Type::getInt32Ty(Context); 361 Value *Ops[3] = { 362 ConstantInt::get(Int32Ty, Behavior), MDString::get(Context, Key), Val 363 }; 364 getOrInsertModuleFlagsMetadata()->addOperand(MDNode::get(Context, Ops)); 365} 366void Module::addModuleFlag(ModFlagBehavior Behavior, StringRef Key, 367 uint32_t Val) { 368 Type *Int32Ty = Type::getInt32Ty(Context); 369 addModuleFlag(Behavior, Key, ConstantInt::get(Int32Ty, Val)); 370} 371void Module::addModuleFlag(MDNode *Node) { 372 assert(Node->getNumOperands() == 3 && 373 "Invalid number of operands for module flag!"); 374 assert(isa<ConstantInt>(Node->getOperand(0)) && 375 isa<MDString>(Node->getOperand(1)) && 376 "Invalid operand types for module flag!"); 377 getOrInsertModuleFlagsMetadata()->addOperand(Node); 378} 379 380//===----------------------------------------------------------------------===// 381// Methods to control the materialization of GlobalValues in the Module. 382// 383void Module::setMaterializer(GVMaterializer *GVM) { 384 assert(!Materializer && 385 "Module already has a GVMaterializer. Call MaterializeAllPermanently" 386 " to clear it out before setting another one."); 387 Materializer.reset(GVM); 388} 389 390bool Module::isMaterializable(const GlobalValue *GV) const { 391 if (Materializer) 392 return Materializer->isMaterializable(GV); 393 return false; 394} 395 396bool Module::isDematerializable(const GlobalValue *GV) const { 397 if (Materializer) 398 return Materializer->isDematerializable(GV); 399 return false; 400} 401 402bool Module::Materialize(GlobalValue *GV, std::string *ErrInfo) { 403 if (Materializer) 404 return Materializer->Materialize(GV, ErrInfo); 405 return false; 406} 407 408void Module::Dematerialize(GlobalValue *GV) { 409 if (Materializer) 410 return Materializer->Dematerialize(GV); 411} 412 413bool Module::MaterializeAll(std::string *ErrInfo) { 414 if (!Materializer) 415 return false; 416 return Materializer->MaterializeModule(this, ErrInfo); 417} 418 419bool Module::MaterializeAllPermanently(std::string *ErrInfo) { 420 if (MaterializeAll(ErrInfo)) 421 return true; 422 Materializer.reset(); 423 return false; 424} 425 426//===----------------------------------------------------------------------===// 427// Other module related stuff. 428// 429 430 431// dropAllReferences() - This function causes all the subelements to "let go" 432// of all references that they are maintaining. This allows one to 'delete' a 433// whole module at a time, even though there may be circular references... first 434// all references are dropped, and all use counts go to zero. Then everything 435// is deleted for real. Note that no operations are valid on an object that 436// has "dropped all references", except operator delete. 437// 438void Module::dropAllReferences() { 439 for(Module::iterator I = begin(), E = end(); I != E; ++I) 440 I->dropAllReferences(); 441 442 for(Module::global_iterator I = global_begin(), E = global_end(); I != E; ++I) 443 I->dropAllReferences(); 444 445 for(Module::alias_iterator I = alias_begin(), E = alias_end(); I != E; ++I) 446 I->dropAllReferences(); 447} 448