1 //===-- Module.cpp - Implement the Module class ---------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the Module class for the IR library.
12 //===----------------------------------------------------------------------===//
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/Error.h"
29 #include "llvm/Support/MemoryBuffer.h"
30 #include "llvm/Support/Path.h"
31 #include "llvm/Support/RandomNumberGenerator.h"
38 //===----------------------------------------------------------------------===//
39 // Methods to implement the globals and functions lists.
42 // Explicit instantiations of SymbolTableListTraits since some of the methods
43 // are not in the public header file.
44 template class llvm::SymbolTableListTraits
<Function
>;
45 template class llvm::SymbolTableListTraits
<GlobalVariable
>;
46 template class llvm::SymbolTableListTraits
<GlobalAlias
>;
47 template class llvm::SymbolTableListTraits
<GlobalIFunc
>;
49 //===----------------------------------------------------------------------===//
50 // Primitive Module methods.
53 Module::Module(StringRef MID
, LLVMContext
&C
)
54 : Context(C
), Materializer(), ModuleID(MID
), SourceFileName(MID
), DL("") {
55 ValSymTab
= new ValueSymbolTable();
56 NamedMDSymTab
= new StringMap
<NamedMDNode
*>();
57 Context
.addModule(this);
61 Context
.removeModule(this);
69 delete static_cast<StringMap
<NamedMDNode
*> *>(NamedMDSymTab
);
72 RandomNumberGenerator
*Module::createRNG(const Pass
* P
) const {
73 SmallString
<32> Salt(P
->getPassName());
75 // This RNG is guaranteed to produce the same random stream only
76 // when the Module ID and thus the input filename is the same. This
77 // might be problematic if the input filename extension changes
78 // (e.g. from .c to .bc or .ll).
80 // We could store this salt in NamedMetadata, but this would make
81 // the parameter non-const. This would unfortunately make this
82 // interface unusable by any Machine passes, since they only have a
83 // const reference to their IR Module. Alternatively we can always
84 // store salt metadata from the Module constructor.
85 Salt
+= sys::path::filename(getModuleIdentifier());
87 return new RandomNumberGenerator(Salt
);
90 /// getNamedValue - Return the first global value in the module with
91 /// the specified name, of arbitrary type. This method returns null
92 /// if a global with the specified name is not found.
93 GlobalValue
*Module::getNamedValue(StringRef Name
) const {
94 return cast_or_null
<GlobalValue
>(getValueSymbolTable().lookup(Name
));
97 /// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
98 /// This ID is uniqued across modules in the current LLVMContext.
99 unsigned Module::getMDKindID(StringRef Name
) const {
100 return Context
.getMDKindID(Name
);
103 /// getMDKindNames - Populate client supplied SmallVector with the name for
104 /// custom metadata IDs registered in this LLVMContext. ID #0 is not used,
105 /// so it is filled in as an empty string.
106 void Module::getMDKindNames(SmallVectorImpl
<StringRef
> &Result
) const {
107 return Context
.getMDKindNames(Result
);
110 void Module::getOperandBundleTags(SmallVectorImpl
<StringRef
> &Result
) const {
111 return Context
.getOperandBundleTags(Result
);
114 //===----------------------------------------------------------------------===//
115 // Methods for easy access to the functions in the module.
118 // getOrInsertFunction - Look up the specified function in the module symbol
119 // table. If it does not exist, add a prototype for the function and return
120 // it. This is nice because it allows most passes to get away with not handling
121 // the symbol table directly for this common task.
123 Constant
*Module::getOrInsertFunction(StringRef Name
, FunctionType
*Ty
,
124 AttributeList AttributeList
) {
125 // See if we have a definition for the specified function already.
126 GlobalValue
*F
= getNamedValue(Name
);
129 Function
*New
= Function::Create(Ty
, GlobalVariable::ExternalLinkage
, Name
);
130 if (!New
->isIntrinsic()) // Intrinsics get attrs set on construction
131 New
->setAttributes(AttributeList
);
132 FunctionList
.push_back(New
);
133 return New
; // Return the new prototype.
136 // If the function exists but has the wrong type, return a bitcast to the
138 if (F
->getType() != PointerType::getUnqual(Ty
))
139 return ConstantExpr::getBitCast(F
, PointerType::getUnqual(Ty
));
141 // Otherwise, we just found the existing function or a prototype.
145 Constant
*Module::getOrInsertFunction(StringRef Name
,
147 return getOrInsertFunction(Name
, Ty
, AttributeList());
150 // getOrInsertFunction - Look up the specified function in the module symbol
151 // table. If it does not exist, add a prototype for the function and return it.
152 // This version of the method takes a null terminated list of function
153 // arguments, which makes it easier for clients to use.
155 Constant
*Module::getOrInsertFunction(StringRef Name
,
156 AttributeList AttributeList
, Type
*RetTy
,
159 va_start(Args
, RetTy
);
161 // Build the list of argument types...
162 std::vector
<Type
*> ArgTys
;
163 while (Type
*ArgTy
= va_arg(Args
, Type
*))
164 ArgTys
.push_back(ArgTy
);
168 // Build the function type and chain to the other getOrInsertFunction...
169 return getOrInsertFunction(Name
,
170 FunctionType::get(RetTy
, ArgTys
, false),
174 Constant
*Module::getOrInsertFunction(StringRef Name
,
177 va_start(Args
, RetTy
);
179 // Build the list of argument types...
180 std::vector
<Type
*> ArgTys
;
181 while (Type
*ArgTy
= va_arg(Args
, Type
*))
182 ArgTys
.push_back(ArgTy
);
186 // Build the function type and chain to the other getOrInsertFunction...
187 return getOrInsertFunction(Name
, FunctionType::get(RetTy
, ArgTys
, false),
191 // getFunction - Look up the specified function in the module symbol table.
192 // If it does not exist, return null.
194 Function
*Module::getFunction(StringRef Name
) const {
195 return dyn_cast_or_null
<Function
>(getNamedValue(Name
));
198 //===----------------------------------------------------------------------===//
199 // Methods for easy access to the global variables in the module.
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.
209 GlobalVariable
*Module::getGlobalVariable(StringRef Name
,
210 bool AllowLocal
) const {
211 if (GlobalVariable
*Result
=
212 dyn_cast_or_null
<GlobalVariable
>(getNamedValue(Name
)))
213 if (AllowLocal
|| !Result
->hasLocalLinkage())
218 /// getOrInsertGlobal - Look up the specified global in the module symbol table.
219 /// 1. If it does not exist, add a declaration of the global and return it.
220 /// 2. Else, the global exists but has the wrong type: return the function
221 /// with a constantexpr cast to the right type.
222 /// 3. Finally, if the existing global is the correct declaration, return the
224 Constant
*Module::getOrInsertGlobal(StringRef Name
, Type
*Ty
) {
225 // See if we have a definition for the specified global already.
226 GlobalVariable
*GV
= dyn_cast_or_null
<GlobalVariable
>(getNamedValue(Name
));
229 GlobalVariable
*New
=
230 new GlobalVariable(*this, Ty
, false, GlobalVariable::ExternalLinkage
,
232 return New
; // Return the new declaration.
235 // If the variable exists but has the wrong type, return a bitcast to the
237 Type
*GVTy
= GV
->getType();
238 PointerType
*PTy
= PointerType::get(Ty
, GVTy
->getPointerAddressSpace());
240 return ConstantExpr::getBitCast(GV
, PTy
);
242 // Otherwise, we just found the existing function or a prototype.
246 //===----------------------------------------------------------------------===//
247 // Methods for easy access to the global variables in the module.
250 // getNamedAlias - Look up the specified global in the module symbol table.
251 // If it does not exist, return null.
253 GlobalAlias
*Module::getNamedAlias(StringRef Name
) const {
254 return dyn_cast_or_null
<GlobalAlias
>(getNamedValue(Name
));
257 GlobalIFunc
*Module::getNamedIFunc(StringRef Name
) const {
258 return dyn_cast_or_null
<GlobalIFunc
>(getNamedValue(Name
));
261 /// getNamedMetadata - Return the first NamedMDNode in the module with the
262 /// specified name. This method returns null if a NamedMDNode with the
263 /// specified name is not found.
264 NamedMDNode
*Module::getNamedMetadata(const Twine
&Name
) const {
265 SmallString
<256> NameData
;
266 StringRef NameRef
= Name
.toStringRef(NameData
);
267 return static_cast<StringMap
<NamedMDNode
*> *>(NamedMDSymTab
)->lookup(NameRef
);
270 /// getOrInsertNamedMetadata - Return the first named MDNode in the module
271 /// with the specified name. This method returns a new NamedMDNode if a
272 /// NamedMDNode with the specified name is not found.
273 NamedMDNode
*Module::getOrInsertNamedMetadata(StringRef Name
) {
275 (*static_cast<StringMap
<NamedMDNode
*> *>(NamedMDSymTab
))[Name
];
277 NMD
= new NamedMDNode(Name
);
278 NMD
->setParent(this);
279 NamedMDList
.push_back(NMD
);
284 /// eraseNamedMetadata - Remove the given NamedMDNode from this module and
286 void Module::eraseNamedMetadata(NamedMDNode
*NMD
) {
287 static_cast<StringMap
<NamedMDNode
*> *>(NamedMDSymTab
)->erase(NMD
->getName());
288 NamedMDList
.erase(NMD
->getIterator());
291 bool Module::isValidModFlagBehavior(Metadata
*MD
, ModFlagBehavior
&MFB
) {
292 if (ConstantInt
*Behavior
= mdconst::dyn_extract_or_null
<ConstantInt
>(MD
)) {
293 uint64_t Val
= Behavior
->getLimitedValue();
294 if (Val
>= ModFlagBehaviorFirstVal
&& Val
<= ModFlagBehaviorLastVal
) {
295 MFB
= static_cast<ModFlagBehavior
>(Val
);
302 /// getModuleFlagsMetadata - Returns the module flags in the provided vector.
304 getModuleFlagsMetadata(SmallVectorImpl
<ModuleFlagEntry
> &Flags
) const {
305 const NamedMDNode
*ModFlags
= getModuleFlagsMetadata();
306 if (!ModFlags
) return;
308 for (const MDNode
*Flag
: ModFlags
->operands()) {
310 if (Flag
->getNumOperands() >= 3 &&
311 isValidModFlagBehavior(Flag
->getOperand(0), MFB
) &&
312 dyn_cast_or_null
<MDString
>(Flag
->getOperand(1))) {
313 // Check the operands of the MDNode before accessing the operands.
314 // The verifier will actually catch these failures.
315 MDString
*Key
= cast
<MDString
>(Flag
->getOperand(1));
316 Metadata
*Val
= Flag
->getOperand(2);
317 Flags
.push_back(ModuleFlagEntry(MFB
, Key
, Val
));
322 /// Return the corresponding value if Key appears in module flags, otherwise
324 Metadata
*Module::getModuleFlag(StringRef Key
) const {
325 SmallVector
<Module::ModuleFlagEntry
, 8> ModuleFlags
;
326 getModuleFlagsMetadata(ModuleFlags
);
327 for (const ModuleFlagEntry
&MFE
: ModuleFlags
) {
328 if (Key
== MFE
.Key
->getString())
334 /// getModuleFlagsMetadata - Returns the NamedMDNode in the module that
335 /// represents module-level flags. This method returns null if there are no
336 /// module-level flags.
337 NamedMDNode
*Module::getModuleFlagsMetadata() const {
338 return getNamedMetadata("llvm.module.flags");
341 /// getOrInsertModuleFlagsMetadata - Returns the NamedMDNode in the module that
342 /// represents module-level flags. If module-level flags aren't found, it
343 /// creates the named metadata that contains them.
344 NamedMDNode
*Module::getOrInsertModuleFlagsMetadata() {
345 return getOrInsertNamedMetadata("llvm.module.flags");
348 /// addModuleFlag - Add a module-level flag to the module-level flags
349 /// metadata. It will create the module-level flags named metadata if it doesn't
351 void Module::addModuleFlag(ModFlagBehavior Behavior
, StringRef Key
,
353 Type
*Int32Ty
= Type::getInt32Ty(Context
);
355 ConstantAsMetadata::get(ConstantInt::get(Int32Ty
, Behavior
)),
356 MDString::get(Context
, Key
), Val
};
357 getOrInsertModuleFlagsMetadata()->addOperand(MDNode::get(Context
, Ops
));
359 void Module::addModuleFlag(ModFlagBehavior Behavior
, StringRef Key
,
361 addModuleFlag(Behavior
, Key
, ConstantAsMetadata::get(Val
));
363 void Module::addModuleFlag(ModFlagBehavior Behavior
, StringRef Key
,
365 Type
*Int32Ty
= Type::getInt32Ty(Context
);
366 addModuleFlag(Behavior
, Key
, ConstantInt::get(Int32Ty
, Val
));
368 void Module::addModuleFlag(MDNode
*Node
) {
369 assert(Node
->getNumOperands() == 3 &&
370 "Invalid number of operands for module flag!");
371 assert(mdconst::hasa
<ConstantInt
>(Node
->getOperand(0)) &&
372 isa
<MDString
>(Node
->getOperand(1)) &&
373 "Invalid operand types for module flag!");
374 getOrInsertModuleFlagsMetadata()->addOperand(Node
);
377 void Module::setDataLayout(StringRef Desc
) {
381 void Module::setDataLayout(const DataLayout
&Other
) { DL
= Other
; }
383 const DataLayout
&Module::getDataLayout() const { return DL
; }
385 DICompileUnit
*Module::debug_compile_units_iterator::operator*() const {
386 return cast
<DICompileUnit
>(CUs
->getOperand(Idx
));
388 DICompileUnit
*Module::debug_compile_units_iterator::operator->() const {
389 return cast
<DICompileUnit
>(CUs
->getOperand(Idx
));
392 void Module::debug_compile_units_iterator::SkipNoDebugCUs() {
393 while (CUs
&& (Idx
< CUs
->getNumOperands()) &&
394 ((*this)->getEmissionKind() == DICompileUnit::NoDebug
))
398 //===----------------------------------------------------------------------===//
399 // Methods to control the materialization of GlobalValues in the Module.
401 void Module::setMaterializer(GVMaterializer
*GVM
) {
402 assert(!Materializer
&&
403 "Module already has a GVMaterializer. Call materializeAll"
404 " to clear it out before setting another one.");
405 Materializer
.reset(GVM
);
408 Error
Module::materialize(GlobalValue
*GV
) {
410 return Error::success();
412 return Materializer
->materialize(GV
);
415 Error
Module::materializeAll() {
417 return Error::success();
418 std::unique_ptr
<GVMaterializer
> M
= std::move(Materializer
);
419 return M
->materializeModule();
422 Error
Module::materializeMetadata() {
424 return Error::success();
425 return Materializer
->materializeMetadata();
428 //===----------------------------------------------------------------------===//
429 // Other module related stuff.
432 std::vector
<StructType
*> Module::getIdentifiedStructTypes() const {
433 // If we have a materializer, it is possible that some unread function
434 // uses a type that is currently not visible to a TypeFinder, so ask
435 // the materializer which types it created.
437 return Materializer
->getIdentifiedStructTypes();
439 std::vector
<StructType
*> Ret
;
440 TypeFinder SrcStructTypes
;
441 SrcStructTypes
.run(*this, true);
442 Ret
.assign(SrcStructTypes
.begin(), SrcStructTypes
.end());
446 // dropAllReferences() - This function causes all the subelements to "let go"
447 // of all references that they are maintaining. This allows one to 'delete' a
448 // whole module at a time, even though there may be circular references... first
449 // all references are dropped, and all use counts go to zero. Then everything
450 // is deleted for real. Note that no operations are valid on an object that
451 // has "dropped all references", except operator delete.
453 void Module::dropAllReferences() {
454 for (Function
&F
: *this)
455 F
.dropAllReferences();
457 for (GlobalVariable
&GV
: globals())
458 GV
.dropAllReferences();
460 for (GlobalAlias
&GA
: aliases())
461 GA
.dropAllReferences();
463 for (GlobalIFunc
&GIF
: ifuncs())
464 GIF
.dropAllReferences();
467 unsigned Module::getNumberRegisterParameters() const {
469 cast_or_null
<ConstantAsMetadata
>(getModuleFlag("NumRegisterParameters"));
472 return cast
<ConstantInt
>(Val
->getValue())->getZExtValue();
475 unsigned Module::getDwarfVersion() const {
476 auto *Val
= cast_or_null
<ConstantAsMetadata
>(getModuleFlag("Dwarf Version"));
479 return cast
<ConstantInt
>(Val
->getValue())->getZExtValue();
482 unsigned Module::getCodeViewFlag() const {
483 auto *Val
= cast_or_null
<ConstantAsMetadata
>(getModuleFlag("CodeView"));
486 return cast
<ConstantInt
>(Val
->getValue())->getZExtValue();
489 Comdat
*Module::getOrInsertComdat(StringRef Name
) {
490 auto &Entry
= *ComdatSymTab
.insert(std::make_pair(Name
, Comdat())).first
;
491 Entry
.second
.Name
= &Entry
;
492 return &Entry
.second
;
495 PICLevel::Level
Module::getPICLevel() const {
496 auto *Val
= cast_or_null
<ConstantAsMetadata
>(getModuleFlag("PIC Level"));
499 return PICLevel::NotPIC
;
501 return static_cast<PICLevel::Level
>(
502 cast
<ConstantInt
>(Val
->getValue())->getZExtValue());
505 void Module::setPICLevel(PICLevel::Level PL
) {
506 addModuleFlag(ModFlagBehavior::Error
, "PIC Level", PL
);
509 PIELevel::Level
Module::getPIELevel() const {
510 auto *Val
= cast_or_null
<ConstantAsMetadata
>(getModuleFlag("PIE Level"));
513 return PIELevel::Default
;
515 return static_cast<PIELevel::Level
>(
516 cast
<ConstantInt
>(Val
->getValue())->getZExtValue());
519 void Module::setPIELevel(PIELevel::Level PL
) {
520 addModuleFlag(ModFlagBehavior::Error
, "PIE Level", PL
);
523 void Module::setProfileSummary(Metadata
*M
) {
524 addModuleFlag(ModFlagBehavior::Error
, "ProfileSummary", M
);
527 Metadata
*Module::getProfileSummary() {
528 return getModuleFlag("ProfileSummary");
531 void Module::setOwnedMemoryBuffer(std::unique_ptr
<MemoryBuffer
> MB
) {
532 OwnedMemoryBuffer
= std::move(MB
);
535 GlobalVariable
*llvm::collectUsedGlobalVariables(
536 const Module
&M
, SmallPtrSetImpl
<GlobalValue
*> &Set
, bool CompilerUsed
) {
537 const char *Name
= CompilerUsed
? "llvm.compiler.used" : "llvm.used";
538 GlobalVariable
*GV
= M
.getGlobalVariable(Name
);
539 if (!GV
|| !GV
->hasInitializer())
542 const ConstantArray
*Init
= cast
<ConstantArray
>(GV
->getInitializer());
543 for (Value
*Op
: Init
->operands()) {
544 GlobalValue
*G
= cast
<GlobalValue
>(Op
->stripPointerCastsNoFollowAliases());