LLVM  8.0.0svn
Module.cpp
Go to the documentation of this file.
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"
16 #include "llvm/ADT/Optional.h"
17 #include "llvm/ADT/SmallPtrSet.h"
18 #include "llvm/ADT/SmallString.h"
19 #include "llvm/ADT/SmallVector.h"
20 #include "llvm/ADT/StringMap.h"
21 #include "llvm/ADT/StringRef.h"
22 #include "llvm/ADT/Twine.h"
23 #include "llvm/IR/Attributes.h"
24 #include "llvm/IR/Comdat.h"
25 #include "llvm/IR/Constants.h"
26 #include "llvm/IR/DataLayout.h"
28 #include "llvm/IR/DerivedTypes.h"
29 #include "llvm/IR/Function.h"
30 #include "llvm/IR/GVMaterializer.h"
31 #include "llvm/IR/GlobalAlias.h"
32 #include "llvm/IR/GlobalIFunc.h"
33 #include "llvm/IR/GlobalValue.h"
34 #include "llvm/IR/GlobalVariable.h"
35 #include "llvm/IR/LLVMContext.h"
36 #include "llvm/IR/Metadata.h"
38 #include "llvm/IR/Type.h"
39 #include "llvm/IR/TypeFinder.h"
40 #include "llvm/IR/Value.h"
42 #include "llvm/Pass.h"
43 #include "llvm/Support/Casting.h"
44 #include "llvm/Support/CodeGen.h"
45 #include "llvm/Support/Error.h"
47 #include "llvm/Support/Path.h"
49 #include <algorithm>
50 #include <cassert>
51 #include <cstdint>
52 #include <memory>
53 #include <utility>
54 #include <vector>
55 
56 using namespace llvm;
57 
58 //===----------------------------------------------------------------------===//
59 // Methods to implement the globals and functions lists.
60 //
61 
62 // Explicit instantiations of SymbolTableListTraits since some of the methods
63 // are not in the public header file.
68 
69 //===----------------------------------------------------------------------===//
70 // Primitive Module methods.
71 //
72 
74  : Context(C), Materializer(), ModuleID(MID), SourceFileName(MID), DL("") {
75  ValSymTab = new ValueSymbolTable();
76  NamedMDSymTab = new StringMap<NamedMDNode *>();
77  Context.addModule(this);
78 }
79 
81  Context.removeModule(this);
83  GlobalList.clear();
84  FunctionList.clear();
85  AliasList.clear();
86  IFuncList.clear();
87  NamedMDList.clear();
88  delete ValSymTab;
89  delete static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab);
90 }
91 
92 std::unique_ptr<RandomNumberGenerator> Module::createRNG(const Pass* P) const {
93  SmallString<32> Salt(P->getPassName());
94 
95  // This RNG is guaranteed to produce the same random stream only
96  // when the Module ID and thus the input filename is the same. This
97  // might be problematic if the input filename extension changes
98  // (e.g. from .c to .bc or .ll).
99  //
100  // We could store this salt in NamedMetadata, but this would make
101  // the parameter non-const. This would unfortunately make this
102  // interface unusable by any Machine passes, since they only have a
103  // const reference to their IR Module. Alternatively we can always
104  // store salt metadata from the Module constructor.
106 
107  return std::unique_ptr<RandomNumberGenerator>(new RandomNumberGenerator(Salt));
108 }
109 
110 /// getNamedValue - Return the first global value in the module with
111 /// the specified name, of arbitrary type. This method returns null
112 /// if a global with the specified name is not found.
114  return cast_or_null<GlobalValue>(getValueSymbolTable().lookup(Name));
115 }
116 
117 /// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
118 /// This ID is uniqued across modules in the current LLVMContext.
120  return Context.getMDKindID(Name);
121 }
122 
123 /// getMDKindNames - Populate client supplied SmallVector with the name for
124 /// custom metadata IDs registered in this LLVMContext. ID #0 is not used,
125 /// so it is filled in as an empty string.
127  return Context.getMDKindNames(Result);
128 }
129 
131  return Context.getOperandBundleTags(Result);
132 }
133 
134 //===----------------------------------------------------------------------===//
135 // Methods for easy access to the functions in the module.
136 //
137 
138 // getOrInsertFunction - Look up the specified function in the module symbol
139 // table. If it does not exist, add a prototype for the function and return
140 // it. This is nice because it allows most passes to get away with not handling
141 // the symbol table directly for this common task.
142 //
145  // See if we have a definition for the specified function already.
146  GlobalValue *F = getNamedValue(Name);
147  if (!F) {
148  // Nope, add it
151  if (!New->isIntrinsic()) // Intrinsics get attrs set on construction
152  New->setAttributes(AttributeList);
153  FunctionList.push_back(New);
154  return New; // Return the new prototype.
155  }
156 
157  // If the function exists but has the wrong type, return a bitcast to the
158  // right type.
159  auto *PTy = PointerType::get(Ty, F->getAddressSpace());
160  if (F->getType() != PTy)
161  return ConstantExpr::getBitCast(F, PTy);
162 
163  // Otherwise, we just found the existing function or a prototype.
164  return F;
165 }
166 
168  FunctionType *Ty) {
169  return getOrInsertFunction(Name, Ty, AttributeList());
170 }
171 
172 // getFunction - Look up the specified function in the module symbol table.
173 // If it does not exist, return null.
174 //
176  return dyn_cast_or_null<Function>(getNamedValue(Name));
177 }
178 
179 //===----------------------------------------------------------------------===//
180 // Methods for easy access to the global variables in the module.
181 //
182 
183 /// getGlobalVariable - Look up the specified global variable in the module
184 /// symbol table. If it does not exist, return null. The type argument
185 /// should be the underlying type of the global, i.e., it should not have
186 /// the top-level PointerType, which represents the address of the global.
187 /// If AllowLocal is set to true, this function will return types that
188 /// have an local. By default, these types are not returned.
189 ///
191  bool AllowLocal) const {
192  if (GlobalVariable *Result =
193  dyn_cast_or_null<GlobalVariable>(getNamedValue(Name)))
194  if (AllowLocal || !Result->hasLocalLinkage())
195  return Result;
196  return nullptr;
197 }
198 
199 /// getOrInsertGlobal - Look up the specified global in the module symbol table.
200 /// 1. If it does not exist, add a declaration of the global and return it.
201 /// 2. Else, the global exists but has the wrong type: return the function
202 /// with a constantexpr cast to the right type.
203 /// 3. Finally, if the existing global is the correct declaration, return the
204 /// existing global.
206  // See if we have a definition for the specified global already.
207  GlobalVariable *GV = dyn_cast_or_null<GlobalVariable>(getNamedValue(Name));
208  if (!GV) {
209  // Nope, add it
210  GlobalVariable *New =
211  new GlobalVariable(*this, Ty, false, GlobalVariable::ExternalLinkage,
212  nullptr, Name);
213  return New; // Return the new declaration.
214  }
215 
216  // If the variable exists but has the wrong type, return a bitcast to the
217  // right type.
218  Type *GVTy = GV->getType();
220  if (GVTy != PTy)
221  return ConstantExpr::getBitCast(GV, PTy);
222 
223  // Otherwise, we just found the existing function or a prototype.
224  return GV;
225 }
226 
227 //===----------------------------------------------------------------------===//
228 // Methods for easy access to the global variables in the module.
229 //
230 
231 // getNamedAlias - Look up the specified global in the module symbol table.
232 // If it does not exist, return null.
233 //
235  return dyn_cast_or_null<GlobalAlias>(getNamedValue(Name));
236 }
237 
239  return dyn_cast_or_null<GlobalIFunc>(getNamedValue(Name));
240 }
241 
242 /// getNamedMetadata - Return the first NamedMDNode in the module with the
243 /// specified name. This method returns null if a NamedMDNode with the
244 /// specified name is not found.
246  SmallString<256> NameData;
247  StringRef NameRef = Name.toStringRef(NameData);
248  return static_cast<StringMap<NamedMDNode*> *>(NamedMDSymTab)->lookup(NameRef);
249 }
250 
251 /// getOrInsertNamedMetadata - Return the first named MDNode in the module
252 /// with the specified name. This method returns a new NamedMDNode if a
253 /// NamedMDNode with the specified name is not found.
255  NamedMDNode *&NMD =
256  (*static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab))[Name];
257  if (!NMD) {
258  NMD = new NamedMDNode(Name);
259  NMD->setParent(this);
260  NamedMDList.push_back(NMD);
261  }
262  return NMD;
263 }
264 
265 /// eraseNamedMetadata - Remove the given NamedMDNode from this module and
266 /// delete it.
268  static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab)->erase(NMD->getName());
269  NamedMDList.erase(NMD->getIterator());
270 }
271 
273  if (ConstantInt *Behavior = mdconst::dyn_extract_or_null<ConstantInt>(MD)) {
274  uint64_t Val = Behavior->getLimitedValue();
275  if (Val >= ModFlagBehaviorFirstVal && Val <= ModFlagBehaviorLastVal) {
276  MFB = static_cast<ModFlagBehavior>(Val);
277  return true;
278  }
279  }
280  return false;
281 }
282 
283 /// getModuleFlagsMetadata - Returns the module flags in the provided vector.
284 void Module::
286  const NamedMDNode *ModFlags = getModuleFlagsMetadata();
287  if (!ModFlags) return;
288 
289  for (const MDNode *Flag : ModFlags->operands()) {
290  ModFlagBehavior MFB;
291  if (Flag->getNumOperands() >= 3 &&
292  isValidModFlagBehavior(Flag->getOperand(0), MFB) &&
293  dyn_cast_or_null<MDString>(Flag->getOperand(1))) {
294  // Check the operands of the MDNode before accessing the operands.
295  // The verifier will actually catch these failures.
296  MDString *Key = cast<MDString>(Flag->getOperand(1));
297  Metadata *Val = Flag->getOperand(2);
298  Flags.push_back(ModuleFlagEntry(MFB, Key, Val));
299  }
300  }
301 }
302 
303 /// Return the corresponding value if Key appears in module flags, otherwise
304 /// return null.
307  getModuleFlagsMetadata(ModuleFlags);
308  for (const ModuleFlagEntry &MFE : ModuleFlags) {
309  if (Key == MFE.Key->getString())
310  return MFE.Val;
311  }
312  return nullptr;
313 }
314 
315 /// getModuleFlagsMetadata - Returns the NamedMDNode in the module that
316 /// represents module-level flags. This method returns null if there are no
317 /// module-level flags.
319  return getNamedMetadata("llvm.module.flags");
320 }
321 
322 /// getOrInsertModuleFlagsMetadata - Returns the NamedMDNode in the module that
323 /// represents module-level flags. If module-level flags aren't found, it
324 /// creates the named metadata that contains them.
326  return getOrInsertNamedMetadata("llvm.module.flags");
327 }
328 
329 /// addModuleFlag - Add a module-level flag to the module-level flags
330 /// metadata. It will create the module-level flags named metadata if it doesn't
331 /// already exist.
333  Metadata *Val) {
334  Type *Int32Ty = Type::getInt32Ty(Context);
335  Metadata *Ops[3] = {
336  ConstantAsMetadata::get(ConstantInt::get(Int32Ty, Behavior)),
337  MDString::get(Context, Key), Val};
339 }
341  Constant *Val) {
342  addModuleFlag(Behavior, Key, ConstantAsMetadata::get(Val));
343 }
345  uint32_t Val) {
346  Type *Int32Ty = Type::getInt32Ty(Context);
347  addModuleFlag(Behavior, Key, ConstantInt::get(Int32Ty, Val));
348 }
350  assert(Node->getNumOperands() == 3 &&
351  "Invalid number of operands for module flag!");
352  assert(mdconst::hasa<ConstantInt>(Node->getOperand(0)) &&
353  isa<MDString>(Node->getOperand(1)) &&
354  "Invalid operand types for module flag!");
356 }
357 
359  DL.reset(Desc);
360 }
361 
362 void Module::setDataLayout(const DataLayout &Other) { DL = Other; }
363 
364 const DataLayout &Module::getDataLayout() const { return DL; }
365 
367  return cast<DICompileUnit>(CUs->getOperand(Idx));
368 }
370  return cast<DICompileUnit>(CUs->getOperand(Idx));
371 }
372 
373 void Module::debug_compile_units_iterator::SkipNoDebugCUs() {
374  while (CUs && (Idx < CUs->getNumOperands()) &&
375  ((*this)->getEmissionKind() == DICompileUnit::NoDebug))
376  ++Idx;
377 }
378 
379 //===----------------------------------------------------------------------===//
380 // Methods to control the materialization of GlobalValues in the Module.
381 //
383  assert(!Materializer &&
384  "Module already has a GVMaterializer. Call materializeAll"
385  " to clear it out before setting another one.");
386  Materializer.reset(GVM);
387 }
388 
390  if (!Materializer)
391  return Error::success();
392 
393  return Materializer->materialize(GV);
394 }
395 
397  if (!Materializer)
398  return Error::success();
399  std::unique_ptr<GVMaterializer> M = std::move(Materializer);
400  return M->materializeModule();
401 }
402 
404  if (!Materializer)
405  return Error::success();
406  return Materializer->materializeMetadata();
407 }
408 
409 //===----------------------------------------------------------------------===//
410 // Other module related stuff.
411 //
412 
413 std::vector<StructType *> Module::getIdentifiedStructTypes() const {
414  // If we have a materializer, it is possible that some unread function
415  // uses a type that is currently not visible to a TypeFinder, so ask
416  // the materializer which types it created.
417  if (Materializer)
418  return Materializer->getIdentifiedStructTypes();
419 
420  std::vector<StructType *> Ret;
421  TypeFinder SrcStructTypes;
422  SrcStructTypes.run(*this, true);
423  Ret.assign(SrcStructTypes.begin(), SrcStructTypes.end());
424  return Ret;
425 }
426 
427 // dropAllReferences() - This function causes all the subelements to "let go"
428 // of all references that they are maintaining. This allows one to 'delete' a
429 // whole module at a time, even though there may be circular references... first
430 // all references are dropped, and all use counts go to zero. Then everything
431 // is deleted for real. Note that no operations are valid on an object that
432 // has "dropped all references", except operator delete.
433 //
435  for (Function &F : *this)
436  F.dropAllReferences();
437 
438  for (GlobalVariable &GV : globals())
439  GV.dropAllReferences();
440 
441  for (GlobalAlias &GA : aliases())
442  GA.dropAllReferences();
443 
444  for (GlobalIFunc &GIF : ifuncs())
445  GIF.dropAllReferences();
446 }
447 
449  auto *Val =
450  cast_or_null<ConstantAsMetadata>(getModuleFlag("NumRegisterParameters"));
451  if (!Val)
452  return 0;
453  return cast<ConstantInt>(Val->getValue())->getZExtValue();
454 }
455 
456 unsigned Module::getDwarfVersion() const {
457  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("Dwarf Version"));
458  if (!Val)
459  return 0;
460  return cast<ConstantInt>(Val->getValue())->getZExtValue();
461 }
462 
463 unsigned Module::getCodeViewFlag() const {
464  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("CodeView"));
465  if (!Val)
466  return 0;
467  return cast<ConstantInt>(Val->getValue())->getZExtValue();
468 }
469 
471  unsigned NumInstrs = 0;
472  for (Function &F : FunctionList)
473  NumInstrs += F.getInstructionCount();
474  return NumInstrs;
475 }
476 
478  auto &Entry = *ComdatSymTab.insert(std::make_pair(Name, Comdat())).first;
479  Entry.second.Name = &Entry;
480  return &Entry.second;
481 }
482 
484  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("PIC Level"));
485 
486  if (!Val)
487  return PICLevel::NotPIC;
488 
489  return static_cast<PICLevel::Level>(
490  cast<ConstantInt>(Val->getValue())->getZExtValue());
491 }
492 
494  addModuleFlag(ModFlagBehavior::Max, "PIC Level", PL);
495 }
496 
498  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("PIE Level"));
499 
500  if (!Val)
501  return PIELevel::Default;
502 
503  return static_cast<PIELevel::Level>(
504  cast<ConstantInt>(Val->getValue())->getZExtValue());
505 }
506 
508  addModuleFlag(ModFlagBehavior::Max, "PIE Level", PL);
509 }
510 
512  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("Code Model"));
513 
514  if (!Val)
515  return None;
516 
517  return static_cast<CodeModel::Model>(
518  cast<ConstantInt>(Val->getValue())->getZExtValue());
519 }
520 
522  // Linking object files with different code models is undefined behavior
523  // because the compiler would have to generate additional code (to span
524  // longer jumps) if a larger code model is used with a smaller one.
525  // Therefore we will treat attempts to mix code models as an error.
526  addModuleFlag(ModFlagBehavior::Error, "Code Model", CL);
527 }
528 
530  addModuleFlag(ModFlagBehavior::Error, "ProfileSummary", M);
531 }
532 
534  return getModuleFlag("ProfileSummary");
535 }
536 
537 void Module::setOwnedMemoryBuffer(std::unique_ptr<MemoryBuffer> MB) {
538  OwnedMemoryBuffer = std::move(MB);
539 }
540 
542  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("RtLibUseGOT"));
543  return Val && (cast<ConstantInt>(Val->getValue())->getZExtValue() > 0);
544 }
545 
547  addModuleFlag(ModFlagBehavior::Max, "RtLibUseGOT", 1);
548 }
549 
551  const Module &M, SmallPtrSetImpl<GlobalValue *> &Set, bool CompilerUsed) {
552  const char *Name = CompilerUsed ? "llvm.compiler.used" : "llvm.used";
553  GlobalVariable *GV = M.getGlobalVariable(Name);
554  if (!GV || !GV->hasInitializer())
555  return GV;
556 
557  const ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
558  for (Value *Op : Init->operands()) {
559  GlobalValue *G = cast<GlobalValue>(Op->stripPointerCastsNoFollowAliases());
560  Set.insert(G);
561  }
562  return GV;
563 }
Pass interface - Implemented by all &#39;passes&#39;.
Definition: Pass.h:81
uint64_t CallInst * C
bool isIntrinsic() const
isIntrinsic - Returns true if the function&#39;s name starts with "llvm.".
Definition: Function.h:199
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:111
This class provides a symbol table of name/value pairs.
llvm::Error materializeAll()
Make sure all GlobalValues in this Module are fully read and clear the Materializer.
Definition: Module.cpp:396
void reset(StringRef LayoutDescription)
Parse a data layout string (with fallback to default values).
Definition: DataLayout.cpp:180
LLVMContext & Context
iterator erase(iterator where)
Definition: ilist.h:267
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
Constant * getOrInsertFunction(StringRef Name, FunctionType *T, AttributeList AttributeList)
Look up the specified function in the module symbol table.
Definition: Module.cpp:143
NamedMDNode * getModuleFlagsMetadata() const
Returns the NamedMDNode in the module that represents module-level flags.
Definition: Module.cpp:318
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:64
static MDString * get(LLVMContext &Context, StringRef Str)
Definition: Metadata.cpp:454
const ValueSymbolTable & getValueSymbolTable() const
Get the symbol table of global variable and function identifiers.
Definition: Module.h:555
void setMaterializer(GVMaterializer *GVM)
Sets the GVMaterializer to GVM.
Definition: Module.cpp:382
StringRef toStringRef(SmallVectorImpl< char > &Out) const
This returns the twine as a single StringRef if it can be represented as such.
Definition: Twine.h:453
void addOperand(MDNode *M)
Definition: Metadata.cpp:1087
DICompileUnit * operator->() const
Definition: Module.cpp:369
This file contains the declarations for metadata subclasses.
static PointerType * get(Type *ElementType, unsigned AddressSpace)
This constructs a pointer to an object of the specified type in a numbered address space...
Definition: Type.cpp:617
This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM...
NamedMDNode * getOrInsertNamedMetadata(StringRef Name)
Return the named MDNode in the module with the specified name.
Definition: Module.cpp:254
Externally visible function.
Definition: GlobalValue.h:49
void setDataLayout(StringRef Desc)
Set the data layout.
Definition: Module.cpp:358
Optional< CodeModel::Model > getCodeModel() const
Returns the code model (tiny, small, kernel, medium or large model)
Definition: Module.cpp:511
GlobalVariable * getGlobalVariable(StringRef Name) const
Look up the specified global variable in the module symbol table.
Definition: Module.h:381
Metadata node.
Definition: Metadata.h:864
F(f)
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1069
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: DerivedTypes.h:503
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
Definition: Pass.cpp:75
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:344
unsigned getMDKindID(StringRef Name) const
getMDKindID - Return a unique non-zero ID for the specified metadata kind.
GlobalAlias * getNamedAlias(StringRef Name) const
Return the global alias in the module with the specified name, of arbitrary type. ...
Definition: Module.cpp:234
A tuple of MDNodes.
Definition: Metadata.h:1326
amdgpu Simplify well known AMD library false Value Value const Twine & Name
const DataLayout & getDataLayout() const
Get the data layout for the module&#39;s target platform.
Definition: Module.cpp:364
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
void getMDKindNames(SmallVectorImpl< StringRef > &Result) const
getMDKindNames - Populate client supplied SmallVector with the name for custom metadata IDs registere...
void eraseNamedMetadata(NamedMDNode *NMD)
Remove the given NamedMDNode from this module and delete it.
Definition: Module.cpp:267
unsigned getInstructionCount()
Returns the number of non-debug IR instructions in the module.
Definition: Module.cpp:470
This file contains the simple types necessary to represent the attributes associated with functions a...
Metadata * getProfileSummary()
Returns profile summary metadata.
Definition: Module.cpp:533
static const uint16_t * lookup(unsigned opcode, unsigned domain, ArrayRef< uint16_t[3]> Table)
Key
PAL metadata keys.
Class to represent function types.
Definition: DerivedTypes.h:103
void setRtLibUseGOT()
Set that PLT should be avoid for RTLib calls.
Definition: Module.cpp:546
NamedMDNode * getNamedMetadata(const Twine &Name) const
Return the first NamedMDNode in the module with the specified name.
Definition: Module.cpp:245
GlobalValue * getNamedValue(StringRef Name) const
Return the global value in the module with the specified name, of arbitrary type. ...
Definition: Module.cpp:113
void dropAllReferences()
This function causes all the subinstructions to "let go" of all references that they are maintaining...
Definition: Module.cpp:434
static ConstantAsMetadata * get(Constant *C)
Definition: Metadata.h:410
iterator_range< op_iterator > operands()
Definition: Metadata.h:1418
Class to represent pointers.
Definition: DerivedTypes.h:467
unsigned getCodeViewFlag() const
Returns the CodeView Version by checking module flags.
Definition: Module.cpp:463
Flag
These should be considered private to the implementation of the MCInstrDesc class.
Definition: MCInstrDesc.h:118
void getOperandBundleTags(SmallVectorImpl< StringRef > &Result) const
Populate client supplied SmallVector with the bundle tags registered in this LLVMContext.
Definition: Module.cpp:130
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1750
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1166
#define P(N)
Module(StringRef ModuleID, LLVMContext &C)
The Module constructor.
Definition: Module.cpp:73
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:136
PIELevel::Level getPIELevel() const
Returns the PIE level (small or large model)
Definition: Module.cpp:497
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:69
Constant * getOrInsertGlobal(StringRef Name, Type *Ty)
Look up the specified global in the module symbol table.
Definition: Module.cpp:205
Metadata * getModuleFlag(StringRef Key) const
Return the corresponding value if Key appears in module flags, otherwise return null.
Definition: Module.cpp:305
This is an important base class in LLVM.
Definition: Constant.h:42
This file contains the declarations for the subclasses of Constant, which represent the different fla...
void getOperandBundleTags(SmallVectorImpl< StringRef > &Result) const
getOperandBundleTags - Populate client supplied SmallVector with the bundle tags registered in this L...
ModFlagBehavior
This enumeration defines the supported behaviors of module flags.
Definition: Module.h:112
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:371
void addModuleFlag(ModFlagBehavior Behavior, StringRef Key, Metadata *Val)
Add a module-level flag to the module-level flags metadata.
Definition: Module.cpp:332
unsigned getAddressSpace() const
Definition: Globals.cpp:111
void setCodeModel(CodeModel::Model CL)
Set the code model (tiny, small, kernel, medium or large)
Definition: Module.cpp:521
op_range operands()
Definition: User.h:238
self_iterator getIterator()
Definition: ilist_node.h:82
Comdat * getOrInsertComdat(StringRef Name)
Return the Comdat in the module with the specified name.
Definition: Module.cpp:477
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
Definition: Module.h:209
unsigned getDwarfVersion() const
Returns the Dwarf Version by checking module flags.
Definition: Module.cpp:456
std::vector< StructType * > getIdentifiedStructTypes() const
Definition: Module.cpp:413
GlobalVariable * collectUsedGlobalVariables(const Module &M, SmallPtrSetImpl< GlobalValue *> &Set, bool CompilerUsed)
Given "llvm.used" or "llvm.compiler.used" as a global name, collect the initializer elements of that ...
Definition: Module.cpp:550
static ErrorSuccess success()
Create a success value.
Definition: Error.h:327
This is the shared class of boolean and integer constants.
Definition: Constants.h:84
void run(const Module &M, bool onlyNamed)
Definition: TypeFinder.cpp:32
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:847
Module.h This file contains the declarations for the Module class.
static bool isValidModFlagBehavior(Metadata *MD, ModFlagBehavior &MFB)
Checks if Metadata represents a valid ModFlagBehavior, and stores the converted result in MFB...
Definition: Module.cpp:272
const DataFlowGraph & G
Definition: RDFGraph.cpp:211
NamedMDNode * getOrInsertModuleFlagsMetadata()
Returns the NamedMDNode in the module that represents module-level flags.
Definition: Module.cpp:325
void dropAllReferences()
dropAllReferences() - This method causes all the subinstructions to "let go" of all references that t...
Definition: Function.cpp:347
unsigned getProgramAddressSpace() const
Definition: DataLayout.h:260
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:621
iterator end()
Definition: TypeFinder.h:51
void setAttributes(AttributeList Attrs)
Set the attribute list for this Function.
Definition: Function.h:227
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
Definition: StringMap.h:366
Function * getFunction(StringRef Name) const
Look up the specified function in the module symbol table.
Definition: Module.cpp:175
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:220
ConstantArray - Constant Array Declarations.
Definition: Constants.h:410
void push_back(pointer val)
Definition: ilist.h:313
StringRef getName() const
Definition: Metadata.cpp:1098
bool getRtLibUseGOT() const
Returns true if PLT should be avoided for RTLib calls.
Definition: Module.cpp:541
DICompileUnit * operator*() const
Definition: Module.cpp:366
A random number generator.
void setProfileSummary(Metadata *M)
Attach profile summary metadata to this module.
Definition: Module.cpp:529
StringRef filename(StringRef path, Style style=Style::native)
Get filename.
Definition: Path.cpp:590
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:176
void clear()
Definition: ilist.h:309
std::unique_ptr< RandomNumberGenerator > createRNG(const Pass *P) const
Get a RandomNumberGenerator salted for use with this module.
Definition: Module.cpp:92
llvm::Error materialize(GlobalValue *GV)
Make sure the GlobalValue is fully read.
Definition: Module.cpp:389
~Module()
The module destructor. This will dropAllReferences.
Definition: Module.cpp:80
void setPIELevel(PIELevel::Level PL)
Set the PIE level (small or large model)
Definition: Module.cpp:507
iterator_range< ifunc_iterator > ifuncs()
Definition: Module.h:632
void setOwnedMemoryBuffer(std::unique_ptr< MemoryBuffer > MB)
Take ownership of the given memory buffer.
Definition: Module.cpp:537
Value * lookup(StringRef Name) const
This method finds the value with the given Name in the the symbol table.
void getMDKindNames(SmallVectorImpl< StringRef > &Result) const
Populate client supplied SmallVector with the name for custom metadata IDs registered in this LLVMCon...
Definition: Module.cpp:126
unsigned getMDKindID(StringRef Name) const
Return a unique non-zero ID for the specified metadata kind.
Definition: Module.cpp:119
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:73
unsigned getNumberRegisterParameters() const
Returns the Number of Register ParametersDwarf Version by checking module flags.
Definition: Module.cpp:448
bool hasInitializer() const
Definitions have initializers, declarations don&#39;t.
Lightweight error class with error context and mandatory checking.
Definition: Error.h:158
iterator begin()
Definition: TypeFinder.h:50
void setPICLevel(PICLevel::Level PL)
Set the PIC level (small or large model)
Definition: Module.cpp:493
PICLevel::Level getPICLevel() const
Returns the PIC level (small or large model)
Definition: Module.cpp:483
iterator_range< global_iterator > globals()
Definition: Module.h:574
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
A single uniqued string.
Definition: Metadata.h:604
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1075
GlobalIFunc * getNamedIFunc(StringRef Name) const
Return the global ifunc in the module with the specified name, of arbitrary type. ...
Definition: Module.cpp:238
TypeFinder - Walk over a module, identifying all of the types that are used by the module...
Definition: TypeFinder.h:31
Root of the metadata hierarchy.
Definition: Metadata.h:58
llvm::Error materializeMetadata()
Definition: Module.cpp:403
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:274
IntegerType * Int32Ty
iterator_range< alias_iterator > aliases()
Definition: Module.h:614