• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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/STLExtras.h"
17 #include "llvm/ADT/SmallPtrSet.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/DebugInfoMetadata.h"
23 #include "llvm/IR/GVMaterializer.h"
24 #include "llvm/IR/InstrTypes.h"
25 #include "llvm/IR/LLVMContext.h"
26 #include "llvm/IR/TypeFinder.h"
27 #include "llvm/Support/Dwarf.h"
28 #include "llvm/Support/Path.h"
29 #include "llvm/Support/RandomNumberGenerator.h"
30 #include <algorithm>
31 #include <cstdarg>
32 #include <cstdlib>
33 
34 using namespace llvm;
35 
36 //===----------------------------------------------------------------------===//
37 // Methods to implement the globals and functions lists.
38 //
39 
40 // Explicit instantiations of SymbolTableListTraits since some of the methods
41 // are not in the public header file.
42 template class llvm::SymbolTableListTraits<Function>;
43 template class llvm::SymbolTableListTraits<GlobalVariable>;
44 template class llvm::SymbolTableListTraits<GlobalAlias>;
45 template class llvm::SymbolTableListTraits<GlobalIFunc>;
46 
47 //===----------------------------------------------------------------------===//
48 // Primitive Module methods.
49 //
50 
Module(StringRef MID,LLVMContext & C)51 Module::Module(StringRef MID, LLVMContext &C)
52     : Context(C), Materializer(), ModuleID(MID), SourceFileName(MID), DL("") {
53   ValSymTab = new ValueSymbolTable();
54   NamedMDSymTab = new StringMap<NamedMDNode *>();
55   Context.addModule(this);
56 }
57 
~Module()58 Module::~Module() {
59   Context.removeModule(this);
60   dropAllReferences();
61   GlobalList.clear();
62   FunctionList.clear();
63   AliasList.clear();
64   IFuncList.clear();
65   NamedMDList.clear();
66   delete ValSymTab;
67   delete static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab);
68 }
69 
createRNG(const Pass * P) const70 RandomNumberGenerator *Module::createRNG(const Pass* P) const {
71   SmallString<32> Salt(P->getPassName());
72 
73   // This RNG is guaranteed to produce the same random stream only
74   // when the Module ID and thus the input filename is the same. This
75   // might be problematic if the input filename extension changes
76   // (e.g. from .c to .bc or .ll).
77   //
78   // We could store this salt in NamedMetadata, but this would make
79   // the parameter non-const. This would unfortunately make this
80   // interface unusable by any Machine passes, since they only have a
81   // const reference to their IR Module. Alternatively we can always
82   // store salt metadata from the Module constructor.
83   Salt += sys::path::filename(getModuleIdentifier());
84 
85   return new RandomNumberGenerator(Salt);
86 }
87 
88 /// getNamedValue - Return the first global value in the module with
89 /// the specified name, of arbitrary type.  This method returns null
90 /// if a global with the specified name is not found.
getNamedValue(StringRef Name) const91 GlobalValue *Module::getNamedValue(StringRef Name) const {
92   return cast_or_null<GlobalValue>(getValueSymbolTable().lookup(Name));
93 }
94 
95 /// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
96 /// This ID is uniqued across modules in the current LLVMContext.
getMDKindID(StringRef Name) const97 unsigned Module::getMDKindID(StringRef Name) const {
98   return Context.getMDKindID(Name);
99 }
100 
101 /// getMDKindNames - Populate client supplied SmallVector with the name for
102 /// custom metadata IDs registered in this LLVMContext.   ID #0 is not used,
103 /// so it is filled in as an empty string.
getMDKindNames(SmallVectorImpl<StringRef> & Result) const104 void Module::getMDKindNames(SmallVectorImpl<StringRef> &Result) const {
105   return Context.getMDKindNames(Result);
106 }
107 
getOperandBundleTags(SmallVectorImpl<StringRef> & Result) const108 void Module::getOperandBundleTags(SmallVectorImpl<StringRef> &Result) const {
109   return Context.getOperandBundleTags(Result);
110 }
111 
112 //===----------------------------------------------------------------------===//
113 // Methods for easy access to the functions in the module.
114 //
115 
116 // getOrInsertFunction - Look up the specified function in the module symbol
117 // table.  If it does not exist, add a prototype for the function and return
118 // it.  This is nice because it allows most passes to get away with not handling
119 // the symbol table directly for this common task.
120 //
getOrInsertFunction(StringRef Name,FunctionType * Ty,AttributeSet AttributeList)121 Constant *Module::getOrInsertFunction(StringRef Name,
122                                       FunctionType *Ty,
123                                       AttributeSet AttributeList) {
124   // See if we have a definition for the specified function already.
125   GlobalValue *F = getNamedValue(Name);
126   if (!F) {
127     // Nope, add it
128     Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage, Name);
129     if (!New->isIntrinsic())       // Intrinsics get attrs set on construction
130       New->setAttributes(AttributeList);
131     FunctionList.push_back(New);
132     return New;                    // Return the new prototype.
133   }
134 
135   // If the function exists but has the wrong type, return a bitcast to the
136   // right type.
137   if (F->getType() != PointerType::getUnqual(Ty))
138     return ConstantExpr::getBitCast(F, PointerType::getUnqual(Ty));
139 
140   // Otherwise, we just found the existing function or a prototype.
141   return F;
142 }
143 
getOrInsertFunction(StringRef Name,FunctionType * Ty)144 Constant *Module::getOrInsertFunction(StringRef Name,
145                                       FunctionType *Ty) {
146   return getOrInsertFunction(Name, Ty, AttributeSet());
147 }
148 
149 // getOrInsertFunction - Look up the specified function in the module symbol
150 // table.  If it does not exist, add a prototype for the function and return it.
151 // This version of the method takes a null terminated list of function
152 // arguments, which makes it easier for clients to use.
153 //
getOrInsertFunction(StringRef Name,AttributeSet AttributeList,Type * RetTy,...)154 Constant *Module::getOrInsertFunction(StringRef Name,
155                                       AttributeSet AttributeList,
156                                       Type *RetTy, ...) {
157   va_list Args;
158   va_start(Args, RetTy);
159 
160   // Build the list of argument types...
161   std::vector<Type*> ArgTys;
162   while (Type *ArgTy = va_arg(Args, Type*))
163     ArgTys.push_back(ArgTy);
164 
165   va_end(Args);
166 
167   // Build the function type and chain to the other getOrInsertFunction...
168   return getOrInsertFunction(Name,
169                              FunctionType::get(RetTy, ArgTys, false),
170                              AttributeList);
171 }
172 
getOrInsertFunction(StringRef Name,Type * RetTy,...)173 Constant *Module::getOrInsertFunction(StringRef Name,
174                                       Type *RetTy, ...) {
175   va_list Args;
176   va_start(Args, RetTy);
177 
178   // Build the list of argument types...
179   std::vector<Type*> ArgTys;
180   while (Type *ArgTy = va_arg(Args, Type*))
181     ArgTys.push_back(ArgTy);
182 
183   va_end(Args);
184 
185   // Build the function type and chain to the other getOrInsertFunction...
186   return getOrInsertFunction(Name,
187                              FunctionType::get(RetTy, ArgTys, false),
188                              AttributeSet());
189 }
190 
191 // getFunction - Look up the specified function in the module symbol table.
192 // If it does not exist, return null.
193 //
getFunction(StringRef Name) const194 Function *Module::getFunction(StringRef Name) const {
195   return dyn_cast_or_null<Function>(getNamedValue(Name));
196 }
197 
198 //===----------------------------------------------------------------------===//
199 // Methods for easy access to the global variables in the module.
200 //
201 
202 /// getGlobalVariable - Look up the specified global variable in the module
203 /// symbol table.  If it does not exist, return null.  The type argument
204 /// should be the underlying type of the global, i.e., it should not have
205 /// the top-level PointerType, which represents the address of the global.
206 /// If AllowLocal is set to true, this function will return types that
207 /// have an local. By default, these types are not returned.
208 ///
getGlobalVariable(StringRef Name,bool AllowLocal)209 GlobalVariable *Module::getGlobalVariable(StringRef Name, bool AllowLocal) {
210   if (GlobalVariable *Result =
211       dyn_cast_or_null<GlobalVariable>(getNamedValue(Name)))
212     if (AllowLocal || !Result->hasLocalLinkage())
213       return Result;
214   return nullptr;
215 }
216 
217 /// getOrInsertGlobal - Look up the specified global in the module symbol table.
218 ///   1. If it does not exist, add a declaration of the global and return it.
219 ///   2. Else, the global exists but has the wrong type: return the function
220 ///      with a constantexpr cast to the right type.
221 ///   3. Finally, if the existing global is the correct declaration, return the
222 ///      existing global.
getOrInsertGlobal(StringRef Name,Type * Ty)223 Constant *Module::getOrInsertGlobal(StringRef Name, Type *Ty) {
224   // See if we have a definition for the specified global already.
225   GlobalVariable *GV = dyn_cast_or_null<GlobalVariable>(getNamedValue(Name));
226   if (!GV) {
227     // Nope, add it
228     GlobalVariable *New =
229       new GlobalVariable(*this, Ty, false, GlobalVariable::ExternalLinkage,
230                          nullptr, Name);
231      return New;                    // Return the new declaration.
232   }
233 
234   // If the variable exists but has the wrong type, return a bitcast to the
235   // right type.
236   Type *GVTy = GV->getType();
237   PointerType *PTy = PointerType::get(Ty, GVTy->getPointerAddressSpace());
238   if (GVTy != PTy)
239     return ConstantExpr::getBitCast(GV, PTy);
240 
241   // Otherwise, we just found the existing function or a prototype.
242   return GV;
243 }
244 
245 //===----------------------------------------------------------------------===//
246 // Methods for easy access to the global variables in the module.
247 //
248 
249 // getNamedAlias - Look up the specified global in the module symbol table.
250 // If it does not exist, return null.
251 //
getNamedAlias(StringRef Name) const252 GlobalAlias *Module::getNamedAlias(StringRef Name) const {
253   return dyn_cast_or_null<GlobalAlias>(getNamedValue(Name));
254 }
255 
getNamedIFunc(StringRef Name) const256 GlobalIFunc *Module::getNamedIFunc(StringRef Name) const {
257   return dyn_cast_or_null<GlobalIFunc>(getNamedValue(Name));
258 }
259 
260 /// getNamedMetadata - Return the first NamedMDNode in the module with the
261 /// specified name. This method returns null if a NamedMDNode with the
262 /// specified name is not found.
getNamedMetadata(const Twine & Name) const263 NamedMDNode *Module::getNamedMetadata(const Twine &Name) const {
264   SmallString<256> NameData;
265   StringRef NameRef = Name.toStringRef(NameData);
266   return static_cast<StringMap<NamedMDNode*> *>(NamedMDSymTab)->lookup(NameRef);
267 }
268 
269 /// getOrInsertNamedMetadata - Return the first named MDNode in the module
270 /// with the specified name. This method returns a new NamedMDNode if a
271 /// NamedMDNode with the specified name is not found.
getOrInsertNamedMetadata(StringRef Name)272 NamedMDNode *Module::getOrInsertNamedMetadata(StringRef Name) {
273   NamedMDNode *&NMD =
274     (*static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab))[Name];
275   if (!NMD) {
276     NMD = new NamedMDNode(Name);
277     NMD->setParent(this);
278     NamedMDList.push_back(NMD);
279   }
280   return NMD;
281 }
282 
283 /// eraseNamedMetadata - Remove the given NamedMDNode from this module and
284 /// delete it.
eraseNamedMetadata(NamedMDNode * NMD)285 void Module::eraseNamedMetadata(NamedMDNode *NMD) {
286   static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab)->erase(NMD->getName());
287   NamedMDList.erase(NMD->getIterator());
288 }
289 
isValidModFlagBehavior(Metadata * MD,ModFlagBehavior & MFB)290 bool Module::isValidModFlagBehavior(Metadata *MD, ModFlagBehavior &MFB) {
291   if (ConstantInt *Behavior = mdconst::dyn_extract_or_null<ConstantInt>(MD)) {
292     uint64_t Val = Behavior->getLimitedValue();
293     if (Val >= ModFlagBehaviorFirstVal && Val <= ModFlagBehaviorLastVal) {
294       MFB = static_cast<ModFlagBehavior>(Val);
295       return true;
296     }
297   }
298   return false;
299 }
300 
301 /// getModuleFlagsMetadata - Returns the module flags in the provided vector.
302 void Module::
getModuleFlagsMetadata(SmallVectorImpl<ModuleFlagEntry> & Flags) const303 getModuleFlagsMetadata(SmallVectorImpl<ModuleFlagEntry> &Flags) const {
304   const NamedMDNode *ModFlags = getModuleFlagsMetadata();
305   if (!ModFlags) return;
306 
307   for (const MDNode *Flag : ModFlags->operands()) {
308     ModFlagBehavior MFB;
309     if (Flag->getNumOperands() >= 3 &&
310         isValidModFlagBehavior(Flag->getOperand(0), MFB) &&
311         dyn_cast_or_null<MDString>(Flag->getOperand(1))) {
312       // Check the operands of the MDNode before accessing the operands.
313       // The verifier will actually catch these failures.
314       MDString *Key = cast<MDString>(Flag->getOperand(1));
315       Metadata *Val = Flag->getOperand(2);
316       Flags.push_back(ModuleFlagEntry(MFB, Key, Val));
317     }
318   }
319 }
320 
321 /// Return the corresponding value if Key appears in module flags, otherwise
322 /// return null.
getModuleFlag(StringRef Key) const323 Metadata *Module::getModuleFlag(StringRef Key) const {
324   SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
325   getModuleFlagsMetadata(ModuleFlags);
326   for (const ModuleFlagEntry &MFE : ModuleFlags) {
327     if (Key == MFE.Key->getString())
328       return MFE.Val;
329   }
330   return nullptr;
331 }
332 
333 /// getModuleFlagsMetadata - Returns the NamedMDNode in the module that
334 /// represents module-level flags. This method returns null if there are no
335 /// module-level flags.
getModuleFlagsMetadata() const336 NamedMDNode *Module::getModuleFlagsMetadata() const {
337   return getNamedMetadata("llvm.module.flags");
338 }
339 
340 /// getOrInsertModuleFlagsMetadata - Returns the NamedMDNode in the module that
341 /// represents module-level flags. If module-level flags aren't found, it
342 /// creates the named metadata that contains them.
getOrInsertModuleFlagsMetadata()343 NamedMDNode *Module::getOrInsertModuleFlagsMetadata() {
344   return getOrInsertNamedMetadata("llvm.module.flags");
345 }
346 
347 /// addModuleFlag - Add a module-level flag to the module-level flags
348 /// metadata. It will create the module-level flags named metadata if it doesn't
349 /// already exist.
addModuleFlag(ModFlagBehavior Behavior,StringRef Key,Metadata * Val)350 void Module::addModuleFlag(ModFlagBehavior Behavior, StringRef Key,
351                            Metadata *Val) {
352   Type *Int32Ty = Type::getInt32Ty(Context);
353   Metadata *Ops[3] = {
354       ConstantAsMetadata::get(ConstantInt::get(Int32Ty, Behavior)),
355       MDString::get(Context, Key), Val};
356   getOrInsertModuleFlagsMetadata()->addOperand(MDNode::get(Context, Ops));
357 }
addModuleFlag(ModFlagBehavior Behavior,StringRef Key,Constant * Val)358 void Module::addModuleFlag(ModFlagBehavior Behavior, StringRef Key,
359                            Constant *Val) {
360   addModuleFlag(Behavior, Key, ConstantAsMetadata::get(Val));
361 }
addModuleFlag(ModFlagBehavior Behavior,StringRef Key,uint32_t Val)362 void Module::addModuleFlag(ModFlagBehavior Behavior, StringRef Key,
363                            uint32_t Val) {
364   Type *Int32Ty = Type::getInt32Ty(Context);
365   addModuleFlag(Behavior, Key, ConstantInt::get(Int32Ty, Val));
366 }
addModuleFlag(MDNode * Node)367 void Module::addModuleFlag(MDNode *Node) {
368   assert(Node->getNumOperands() == 3 &&
369          "Invalid number of operands for module flag!");
370   assert(mdconst::hasa<ConstantInt>(Node->getOperand(0)) &&
371          isa<MDString>(Node->getOperand(1)) &&
372          "Invalid operand types for module flag!");
373   getOrInsertModuleFlagsMetadata()->addOperand(Node);
374 }
375 
setDataLayout(StringRef Desc)376 void Module::setDataLayout(StringRef Desc) {
377   DL.reset(Desc);
378 }
379 
setDataLayout(const DataLayout & Other)380 void Module::setDataLayout(const DataLayout &Other) { DL = Other; }
381 
getDataLayout() const382 const DataLayout &Module::getDataLayout() const { return DL; }
383 
operator *() const384 DICompileUnit *Module::debug_compile_units_iterator::operator*() const {
385   return cast<DICompileUnit>(CUs->getOperand(Idx));
386 }
operator ->() const387 DICompileUnit *Module::debug_compile_units_iterator::operator->() const {
388   return cast<DICompileUnit>(CUs->getOperand(Idx));
389 }
390 
SkipNoDebugCUs()391 void Module::debug_compile_units_iterator::SkipNoDebugCUs() {
392   while (CUs && (Idx < CUs->getNumOperands()) &&
393          ((*this)->getEmissionKind() == DICompileUnit::NoDebug))
394     ++Idx;
395 }
396 
397 //===----------------------------------------------------------------------===//
398 // Methods to control the materialization of GlobalValues in the Module.
399 //
setMaterializer(GVMaterializer * GVM)400 void Module::setMaterializer(GVMaterializer *GVM) {
401   assert(!Materializer &&
402          "Module already has a GVMaterializer.  Call materializeAll"
403          " to clear it out before setting another one.");
404   Materializer.reset(GVM);
405 }
406 
materialize(GlobalValue * GV)407 std::error_code Module::materialize(GlobalValue *GV) {
408   if (!Materializer)
409     return std::error_code();
410 
411   return Materializer->materialize(GV);
412 }
413 
materializeAll()414 std::error_code Module::materializeAll() {
415   if (!Materializer)
416     return std::error_code();
417   std::unique_ptr<GVMaterializer> M = std::move(Materializer);
418   return M->materializeModule();
419 }
420 
materializeMetadata()421 std::error_code Module::materializeMetadata() {
422   if (!Materializer)
423     return std::error_code();
424   return Materializer->materializeMetadata();
425 }
426 
427 //===----------------------------------------------------------------------===//
428 // Other module related stuff.
429 //
430 
getIdentifiedStructTypes() const431 std::vector<StructType *> Module::getIdentifiedStructTypes() const {
432   // If we have a materializer, it is possible that some unread function
433   // uses a type that is currently not visible to a TypeFinder, so ask
434   // the materializer which types it created.
435   if (Materializer)
436     return Materializer->getIdentifiedStructTypes();
437 
438   std::vector<StructType *> Ret;
439   TypeFinder SrcStructTypes;
440   SrcStructTypes.run(*this, true);
441   Ret.assign(SrcStructTypes.begin(), SrcStructTypes.end());
442   return Ret;
443 }
444 
445 // dropAllReferences() - This function causes all the subelements to "let go"
446 // of all references that they are maintaining.  This allows one to 'delete' a
447 // whole module at a time, even though there may be circular references... first
448 // all references are dropped, and all use counts go to zero.  Then everything
449 // is deleted for real.  Note that no operations are valid on an object that
450 // has "dropped all references", except operator delete.
451 //
dropAllReferences()452 void Module::dropAllReferences() {
453   for (Function &F : *this)
454     F.dropAllReferences();
455 
456   for (GlobalVariable &GV : globals())
457     GV.dropAllReferences();
458 
459   for (GlobalAlias &GA : aliases())
460     GA.dropAllReferences();
461 
462   for (GlobalIFunc &GIF : ifuncs())
463     GIF.dropAllReferences();
464 }
465 
getDwarfVersion() const466 unsigned Module::getDwarfVersion() const {
467   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("Dwarf Version"));
468   if (!Val)
469     return 0;
470   return cast<ConstantInt>(Val->getValue())->getZExtValue();
471 }
472 
getCodeViewFlag() const473 unsigned Module::getCodeViewFlag() const {
474   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("CodeView"));
475   if (!Val)
476     return 0;
477   return cast<ConstantInt>(Val->getValue())->getZExtValue();
478 }
479 
getOrInsertComdat(StringRef Name)480 Comdat *Module::getOrInsertComdat(StringRef Name) {
481   auto &Entry = *ComdatSymTab.insert(std::make_pair(Name, Comdat())).first;
482   Entry.second.Name = &Entry;
483   return &Entry.second;
484 }
485 
getPICLevel() const486 PICLevel::Level Module::getPICLevel() const {
487   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("PIC Level"));
488 
489   if (!Val)
490     return PICLevel::NotPIC;
491 
492   return static_cast<PICLevel::Level>(
493       cast<ConstantInt>(Val->getValue())->getZExtValue());
494 }
495 
setPICLevel(PICLevel::Level PL)496 void Module::setPICLevel(PICLevel::Level PL) {
497   addModuleFlag(ModFlagBehavior::Error, "PIC Level", PL);
498 }
499 
getPIELevel() const500 PIELevel::Level Module::getPIELevel() const {
501   auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("PIE Level"));
502 
503   if (!Val)
504     return PIELevel::Default;
505 
506   return static_cast<PIELevel::Level>(
507       cast<ConstantInt>(Val->getValue())->getZExtValue());
508 }
509 
setPIELevel(PIELevel::Level PL)510 void Module::setPIELevel(PIELevel::Level PL) {
511   addModuleFlag(ModFlagBehavior::Error, "PIE Level", PL);
512 }
513 
setProfileSummary(Metadata * M)514 void Module::setProfileSummary(Metadata *M) {
515   addModuleFlag(ModFlagBehavior::Error, "ProfileSummary", M);
516 }
517 
getProfileSummary()518 Metadata *Module::getProfileSummary() {
519   return getModuleFlag("ProfileSummary");
520 }
521 
collectUsedGlobalVariables(const Module & M,SmallPtrSetImpl<GlobalValue * > & Set,bool CompilerUsed)522 GlobalVariable *llvm::collectUsedGlobalVariables(
523     const Module &M, SmallPtrSetImpl<GlobalValue *> &Set, bool CompilerUsed) {
524   const char *Name = CompilerUsed ? "llvm.compiler.used" : "llvm.used";
525   GlobalVariable *GV = M.getGlobalVariable(Name);
526   if (!GV || !GV->hasInitializer())
527     return GV;
528 
529   const ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
530   for (Value *Op : Init->operands()) {
531     GlobalValue *G = cast<GlobalValue>(Op->stripPointerCastsNoFollowAliases());
532     Set.insert(G);
533   }
534   return GV;
535 }
536