Module.cpp revision 263508
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, bool AllowLocal) { 237 if (GlobalVariable *Result = 238 dyn_cast_or_null<GlobalVariable>(getNamedValue(Name))) 239 if (AllowLocal || !Result->hasLocalLinkage()) 240 return Result; 241 return 0; 242} 243 244/// getOrInsertGlobal - Look up the specified global in the module symbol table. 245/// 1. If it does not exist, add a declaration of the global and return it. 246/// 2. Else, the global exists but has the wrong type: return the function 247/// with a constantexpr cast to the right type. 248/// 3. Finally, if the existing global is the correct declaration, return the 249/// existing global. 250Constant *Module::getOrInsertGlobal(StringRef Name, Type *Ty) { 251 // See if we have a definition for the specified global already. 252 GlobalVariable *GV = dyn_cast_or_null<GlobalVariable>(getNamedValue(Name)); 253 if (GV == 0) { 254 // Nope, add it 255 GlobalVariable *New = 256 new GlobalVariable(*this, Ty, false, GlobalVariable::ExternalLinkage, 257 0, Name); 258 return New; // Return the new declaration. 259 } 260 261 // If the variable exists but has the wrong type, return a bitcast to the 262 // right type. 263 Type *GVTy = GV->getType(); 264 PointerType *PTy = PointerType::get(Ty, GVTy->getPointerAddressSpace()); 265 if (GVTy != PTy) 266 return ConstantExpr::getBitCast(GV, PTy); 267 268 // Otherwise, we just found the existing function or a prototype. 269 return GV; 270} 271 272//===----------------------------------------------------------------------===// 273// Methods for easy access to the global variables in the module. 274// 275 276// getNamedAlias - Look up the specified global in the module symbol table. 277// If it does not exist, return null. 278// 279GlobalAlias *Module::getNamedAlias(StringRef Name) const { 280 return dyn_cast_or_null<GlobalAlias>(getNamedValue(Name)); 281} 282 283/// getNamedMetadata - Return the first NamedMDNode in the module with the 284/// specified name. This method returns null if a NamedMDNode with the 285/// specified name is not found. 286NamedMDNode *Module::getNamedMetadata(const Twine &Name) const { 287 SmallString<256> NameData; 288 StringRef NameRef = Name.toStringRef(NameData); 289 return static_cast<StringMap<NamedMDNode*> *>(NamedMDSymTab)->lookup(NameRef); 290} 291 292/// getOrInsertNamedMetadata - Return the first named MDNode in the module 293/// with the specified name. This method returns a new NamedMDNode if a 294/// NamedMDNode with the specified name is not found. 295NamedMDNode *Module::getOrInsertNamedMetadata(StringRef Name) { 296 NamedMDNode *&NMD = 297 (*static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab))[Name]; 298 if (!NMD) { 299 NMD = new NamedMDNode(Name); 300 NMD->setParent(this); 301 NamedMDList.push_back(NMD); 302 } 303 return NMD; 304} 305 306/// eraseNamedMetadata - Remove the given NamedMDNode from this module and 307/// delete it. 308void Module::eraseNamedMetadata(NamedMDNode *NMD) { 309 static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab)->erase(NMD->getName()); 310 NamedMDList.erase(NMD); 311} 312 313/// getModuleFlagsMetadata - Returns the module flags in the provided vector. 314void Module:: 315getModuleFlagsMetadata(SmallVectorImpl<ModuleFlagEntry> &Flags) const { 316 const NamedMDNode *ModFlags = getModuleFlagsMetadata(); 317 if (!ModFlags) return; 318 319 for (unsigned i = 0, e = ModFlags->getNumOperands(); i != e; ++i) { 320 MDNode *Flag = ModFlags->getOperand(i); 321 if (Flag->getNumOperands() >= 3 && isa<ConstantInt>(Flag->getOperand(0)) && 322 isa<MDString>(Flag->getOperand(1))) { 323 // Check the operands of the MDNode before accessing the operands. 324 // The verifier will actually catch these failures. 325 ConstantInt *Behavior = cast<ConstantInt>(Flag->getOperand(0)); 326 MDString *Key = cast<MDString>(Flag->getOperand(1)); 327 Value *Val = Flag->getOperand(2); 328 Flags.push_back(ModuleFlagEntry(ModFlagBehavior(Behavior->getZExtValue()), 329 Key, Val)); 330 } 331 } 332} 333 334/// Return the corresponding value if Key appears in module flags, otherwise 335/// return null. 336Value *Module::getModuleFlag(StringRef Key) const { 337 SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags; 338 getModuleFlagsMetadata(ModuleFlags); 339 for (unsigned I = 0, E = ModuleFlags.size(); I < E; ++I) { 340 const ModuleFlagEntry &MFE = ModuleFlags[I]; 341 if (Key == MFE.Key->getString()) 342 return MFE.Val; 343 } 344 return 0; 345} 346 347/// getModuleFlagsMetadata - Returns the NamedMDNode in the module that 348/// represents module-level flags. This method returns null if there are no 349/// module-level flags. 350NamedMDNode *Module::getModuleFlagsMetadata() const { 351 return getNamedMetadata("llvm.module.flags"); 352} 353 354/// getOrInsertModuleFlagsMetadata - Returns the NamedMDNode in the module that 355/// represents module-level flags. If module-level flags aren't found, it 356/// creates the named metadata that contains them. 357NamedMDNode *Module::getOrInsertModuleFlagsMetadata() { 358 return getOrInsertNamedMetadata("llvm.module.flags"); 359} 360 361/// addModuleFlag - Add a module-level flag to the module-level flags 362/// metadata. It will create the module-level flags named metadata if it doesn't 363/// already exist. 364void Module::addModuleFlag(ModFlagBehavior Behavior, StringRef Key, 365 Value *Val) { 366 Type *Int32Ty = Type::getInt32Ty(Context); 367 Value *Ops[3] = { 368 ConstantInt::get(Int32Ty, Behavior), MDString::get(Context, Key), Val 369 }; 370 getOrInsertModuleFlagsMetadata()->addOperand(MDNode::get(Context, Ops)); 371} 372void Module::addModuleFlag(ModFlagBehavior Behavior, StringRef Key, 373 uint32_t Val) { 374 Type *Int32Ty = Type::getInt32Ty(Context); 375 addModuleFlag(Behavior, Key, ConstantInt::get(Int32Ty, Val)); 376} 377void Module::addModuleFlag(MDNode *Node) { 378 assert(Node->getNumOperands() == 3 && 379 "Invalid number of operands for module flag!"); 380 assert(isa<ConstantInt>(Node->getOperand(0)) && 381 isa<MDString>(Node->getOperand(1)) && 382 "Invalid operand types for module flag!"); 383 getOrInsertModuleFlagsMetadata()->addOperand(Node); 384} 385 386//===----------------------------------------------------------------------===// 387// Methods to control the materialization of GlobalValues in the Module. 388// 389void Module::setMaterializer(GVMaterializer *GVM) { 390 assert(!Materializer && 391 "Module already has a GVMaterializer. Call MaterializeAllPermanently" 392 " to clear it out before setting another one."); 393 Materializer.reset(GVM); 394} 395 396bool Module::isMaterializable(const GlobalValue *GV) const { 397 if (Materializer) 398 return Materializer->isMaterializable(GV); 399 return false; 400} 401 402bool Module::isDematerializable(const GlobalValue *GV) const { 403 if (Materializer) 404 return Materializer->isDematerializable(GV); 405 return false; 406} 407 408bool Module::Materialize(GlobalValue *GV, std::string *ErrInfo) { 409 if (!Materializer) 410 return false; 411 412 error_code EC = Materializer->Materialize(GV); 413 if (!EC) 414 return false; 415 if (ErrInfo) 416 *ErrInfo = EC.message(); 417 return true; 418} 419 420void Module::Dematerialize(GlobalValue *GV) { 421 if (Materializer) 422 return Materializer->Dematerialize(GV); 423} 424 425bool Module::MaterializeAll(std::string *ErrInfo) { 426 if (!Materializer) 427 return false; 428 error_code EC = Materializer->MaterializeModule(this); 429 if (!EC) 430 return false; 431 if (ErrInfo) 432 *ErrInfo = EC.message(); 433 return true; 434} 435 436bool Module::MaterializeAllPermanently(std::string *ErrInfo) { 437 if (MaterializeAll(ErrInfo)) 438 return true; 439 Materializer.reset(); 440 return false; 441} 442 443//===----------------------------------------------------------------------===// 444// Other module related stuff. 445// 446 447 448// dropAllReferences() - This function causes all the subelements to "let go" 449// of all references that they are maintaining. This allows one to 'delete' a 450// whole module at a time, even though there may be circular references... first 451// all references are dropped, and all use counts go to zero. Then everything 452// is deleted for real. Note that no operations are valid on an object that 453// has "dropped all references", except operator delete. 454// 455void Module::dropAllReferences() { 456 for(Module::iterator I = begin(), E = end(); I != E; ++I) 457 I->dropAllReferences(); 458 459 for(Module::global_iterator I = global_begin(), E = global_end(); I != E; ++I) 460 I->dropAllReferences(); 461 462 for(Module::alias_iterator I = alias_begin(), E = alias_end(); I != E; ++I) 463 I->dropAllReferences(); 464} 465