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