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"
50 #include <algorithm>
51 #include <cassert>
52 #include <cstdint>
53 #include <memory>
54 #include <utility>
55 #include <vector>
56 
57 using namespace llvm;
58 
59 //===----------------------------------------------------------------------===//
60 // Methods to implement the globals and functions lists.
61 //
62 
63 // Explicit instantiations of SymbolTableListTraits since some of the methods
64 // are not in the public header file.
69 
70 //===----------------------------------------------------------------------===//
71 // Primitive Module methods.
72 //
73 
75  : Context(C), Materializer(), ModuleID(MID), SourceFileName(MID), DL("") {
76  ValSymTab = new ValueSymbolTable();
77  NamedMDSymTab = new StringMap<NamedMDNode *>();
78  Context.addModule(this);
79 }
80 
82  Context.removeModule(this);
84  GlobalList.clear();
85  FunctionList.clear();
86  AliasList.clear();
87  IFuncList.clear();
88  NamedMDList.clear();
89  delete ValSymTab;
90  delete static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab);
91 }
92 
93 std::unique_ptr<RandomNumberGenerator> Module::createRNG(const Pass* P) const {
94  SmallString<32> Salt(P->getPassName());
95 
96  // This RNG is guaranteed to produce the same random stream only
97  // when the Module ID and thus the input filename is the same. This
98  // might be problematic if the input filename extension changes
99  // (e.g. from .c to .bc or .ll).
100  //
101  // We could store this salt in NamedMetadata, but this would make
102  // the parameter non-const. This would unfortunately make this
103  // interface unusable by any Machine passes, since they only have a
104  // const reference to their IR Module. Alternatively we can always
105  // store salt metadata from the Module constructor.
107 
108  return std::unique_ptr<RandomNumberGenerator>(new RandomNumberGenerator(Salt));
109 }
110 
111 /// getNamedValue - Return the first global value in the module with
112 /// the specified name, of arbitrary type. This method returns null
113 /// if a global with the specified name is not found.
115  return cast_or_null<GlobalValue>(getValueSymbolTable().lookup(Name));
116 }
117 
118 /// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
119 /// This ID is uniqued across modules in the current LLVMContext.
121  return Context.getMDKindID(Name);
122 }
123 
124 /// getMDKindNames - Populate client supplied SmallVector with the name for
125 /// custom metadata IDs registered in this LLVMContext. ID #0 is not used,
126 /// so it is filled in as an empty string.
128  return Context.getMDKindNames(Result);
129 }
130 
132  return Context.getOperandBundleTags(Result);
133 }
134 
135 //===----------------------------------------------------------------------===//
136 // Methods for easy access to the functions in the module.
137 //
138 
139 // getOrInsertFunction - Look up the specified function in the module symbol
140 // table. If it does not exist, add a prototype for the function and return
141 // it. This is nice because it allows most passes to get away with not handling
142 // the symbol table directly for this common task.
143 //
146  // See if we have a definition for the specified function already.
147  GlobalValue *F = getNamedValue(Name);
148  if (!F) {
149  // Nope, add it
152  if (!New->isIntrinsic()) // Intrinsics get attrs set on construction
153  New->setAttributes(AttributeList);
154  FunctionList.push_back(New);
155  return New; // Return the new prototype.
156  }
157 
158  // If the function exists but has the wrong type, return a bitcast to the
159  // right type.
160  auto *PTy = PointerType::get(Ty, F->getAddressSpace());
161  if (F->getType() != PTy)
162  return ConstantExpr::getBitCast(F, PTy);
163 
164  // Otherwise, we just found the existing function or a prototype.
165  return F;
166 }
167 
169  FunctionType *Ty) {
170  return getOrInsertFunction(Name, Ty, AttributeList());
171 }
172 
173 // getFunction - Look up the specified function in the module symbol table.
174 // If it does not exist, return null.
175 //
177  return dyn_cast_or_null<Function>(getNamedValue(Name));
178 }
179 
180 //===----------------------------------------------------------------------===//
181 // Methods for easy access to the global variables in the module.
182 //
183 
184 /// getGlobalVariable - Look up the specified global variable in the module
185 /// symbol table. If it does not exist, return null. The type argument
186 /// should be the underlying type of the global, i.e., it should not have
187 /// the top-level PointerType, which represents the address of the global.
188 /// If AllowLocal is set to true, this function will return types that
189 /// have an local. By default, these types are not returned.
190 ///
192  bool AllowLocal) const {
193  if (GlobalVariable *Result =
194  dyn_cast_or_null<GlobalVariable>(getNamedValue(Name)))
195  if (AllowLocal || !Result->hasLocalLinkage())
196  return Result;
197  return nullptr;
198 }
199 
200 /// getOrInsertGlobal - Look up the specified global in the module symbol table.
201 /// 1. If it does not exist, add a declaration of the global and return it.
202 /// 2. Else, the global exists but has the wrong type: return the function
203 /// with a constantexpr cast to the right type.
204 /// 3. Finally, if the existing global is the correct declaration, return the
205 /// existing global.
207  // See if we have a definition for the specified global already.
208  GlobalVariable *GV = dyn_cast_or_null<GlobalVariable>(getNamedValue(Name));
209  if (!GV) {
210  // Nope, add it
211  GlobalVariable *New =
212  new GlobalVariable(*this, Ty, false, GlobalVariable::ExternalLinkage,
213  nullptr, Name);
214  return New; // Return the new declaration.
215  }
216 
217  // If the variable exists but has the wrong type, return a bitcast to the
218  // right type.
219  Type *GVTy = GV->getType();
221  if (GVTy != PTy)
222  return ConstantExpr::getBitCast(GV, PTy);
223 
224  // Otherwise, we just found the existing function or a prototype.
225  return GV;
226 }
227 
228 //===----------------------------------------------------------------------===//
229 // Methods for easy access to the global variables in the module.
230 //
231 
232 // getNamedAlias - Look up the specified global in the module symbol table.
233 // If it does not exist, return null.
234 //
236  return dyn_cast_or_null<GlobalAlias>(getNamedValue(Name));
237 }
238 
240  return dyn_cast_or_null<GlobalIFunc>(getNamedValue(Name));
241 }
242 
243 /// getNamedMetadata - Return the first NamedMDNode in the module with the
244 /// specified name. This method returns null if a NamedMDNode with the
245 /// specified name is not found.
247  SmallString<256> NameData;
248  StringRef NameRef = Name.toStringRef(NameData);
249  return static_cast<StringMap<NamedMDNode*> *>(NamedMDSymTab)->lookup(NameRef);
250 }
251 
252 /// getOrInsertNamedMetadata - Return the first named MDNode in the module
253 /// with the specified name. This method returns a new NamedMDNode if a
254 /// NamedMDNode with the specified name is not found.
256  NamedMDNode *&NMD =
257  (*static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab))[Name];
258  if (!NMD) {
259  NMD = new NamedMDNode(Name);
260  NMD->setParent(this);
261  NamedMDList.push_back(NMD);
262  }
263  return NMD;
264 }
265 
266 /// eraseNamedMetadata - Remove the given NamedMDNode from this module and
267 /// delete it.
269  static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab)->erase(NMD->getName());
270  NamedMDList.erase(NMD->getIterator());
271 }
272 
274  if (ConstantInt *Behavior = mdconst::dyn_extract_or_null<ConstantInt>(MD)) {
275  uint64_t Val = Behavior->getLimitedValue();
276  if (Val >= ModFlagBehaviorFirstVal && Val <= ModFlagBehaviorLastVal) {
277  MFB = static_cast<ModFlagBehavior>(Val);
278  return true;
279  }
280  }
281  return false;
282 }
283 
284 /// getModuleFlagsMetadata - Returns the module flags in the provided vector.
285 void Module::
287  const NamedMDNode *ModFlags = getModuleFlagsMetadata();
288  if (!ModFlags) return;
289 
290  for (const MDNode *Flag : ModFlags->operands()) {
291  ModFlagBehavior MFB;
292  if (Flag->getNumOperands() >= 3 &&
293  isValidModFlagBehavior(Flag->getOperand(0), MFB) &&
294  dyn_cast_or_null<MDString>(Flag->getOperand(1))) {
295  // Check the operands of the MDNode before accessing the operands.
296  // The verifier will actually catch these failures.
297  MDString *Key = cast<MDString>(Flag->getOperand(1));
298  Metadata *Val = Flag->getOperand(2);
299  Flags.push_back(ModuleFlagEntry(MFB, Key, Val));
300  }
301  }
302 }
303 
304 /// Return the corresponding value if Key appears in module flags, otherwise
305 /// return null.
308  getModuleFlagsMetadata(ModuleFlags);
309  for (const ModuleFlagEntry &MFE : ModuleFlags) {
310  if (Key == MFE.Key->getString())
311  return MFE.Val;
312  }
313  return nullptr;
314 }
315 
316 /// getModuleFlagsMetadata - Returns the NamedMDNode in the module that
317 /// represents module-level flags. This method returns null if there are no
318 /// module-level flags.
320  return getNamedMetadata("llvm.module.flags");
321 }
322 
323 /// getOrInsertModuleFlagsMetadata - Returns the NamedMDNode in the module that
324 /// represents module-level flags. If module-level flags aren't found, it
325 /// creates the named metadata that contains them.
327  return getOrInsertNamedMetadata("llvm.module.flags");
328 }
329 
330 /// addModuleFlag - Add a module-level flag to the module-level flags
331 /// metadata. It will create the module-level flags named metadata if it doesn't
332 /// already exist.
334  Metadata *Val) {
335  Type *Int32Ty = Type::getInt32Ty(Context);
336  Metadata *Ops[3] = {
337  ConstantAsMetadata::get(ConstantInt::get(Int32Ty, Behavior)),
338  MDString::get(Context, Key), Val};
340 }
342  Constant *Val) {
343  addModuleFlag(Behavior, Key, ConstantAsMetadata::get(Val));
344 }
346  uint32_t Val) {
347  Type *Int32Ty = Type::getInt32Ty(Context);
348  addModuleFlag(Behavior, Key, ConstantInt::get(Int32Ty, Val));
349 }
351  assert(Node->getNumOperands() == 3 &&
352  "Invalid number of operands for module flag!");
353  assert(mdconst::hasa<ConstantInt>(Node->getOperand(0)) &&
354  isa<MDString>(Node->getOperand(1)) &&
355  "Invalid operand types for module flag!");
357 }
358 
360  DL.reset(Desc);
361 }
362 
363 void Module::setDataLayout(const DataLayout &Other) { DL = Other; }
364 
365 const DataLayout &Module::getDataLayout() const { return DL; }
366 
368  return cast<DICompileUnit>(CUs->getOperand(Idx));
369 }
371  return cast<DICompileUnit>(CUs->getOperand(Idx));
372 }
373 
374 void Module::debug_compile_units_iterator::SkipNoDebugCUs() {
375  while (CUs && (Idx < CUs->getNumOperands()) &&
376  ((*this)->getEmissionKind() == DICompileUnit::NoDebug))
377  ++Idx;
378 }
379 
380 //===----------------------------------------------------------------------===//
381 // Methods to control the materialization of GlobalValues in the Module.
382 //
384  assert(!Materializer &&
385  "Module already has a GVMaterializer. Call materializeAll"
386  " to clear it out before setting another one.");
387  Materializer.reset(GVM);
388 }
389 
391  if (!Materializer)
392  return Error::success();
393 
394  return Materializer->materialize(GV);
395 }
396 
398  if (!Materializer)
399  return Error::success();
400  std::unique_ptr<GVMaterializer> M = std::move(Materializer);
401  return M->materializeModule();
402 }
403 
405  if (!Materializer)
406  return Error::success();
407  return Materializer->materializeMetadata();
408 }
409 
410 //===----------------------------------------------------------------------===//
411 // Other module related stuff.
412 //
413 
414 std::vector<StructType *> Module::getIdentifiedStructTypes() const {
415  // If we have a materializer, it is possible that some unread function
416  // uses a type that is currently not visible to a TypeFinder, so ask
417  // the materializer which types it created.
418  if (Materializer)
419  return Materializer->getIdentifiedStructTypes();
420 
421  std::vector<StructType *> Ret;
422  TypeFinder SrcStructTypes;
423  SrcStructTypes.run(*this, true);
424  Ret.assign(SrcStructTypes.begin(), SrcStructTypes.end());
425  return Ret;
426 }
427 
428 // dropAllReferences() - This function causes all the subelements to "let go"
429 // of all references that they are maintaining. This allows one to 'delete' a
430 // whole module at a time, even though there may be circular references... first
431 // all references are dropped, and all use counts go to zero. Then everything
432 // is deleted for real. Note that no operations are valid on an object that
433 // has "dropped all references", except operator delete.
434 //
436  for (Function &F : *this)
437  F.dropAllReferences();
438 
439  for (GlobalVariable &GV : globals())
440  GV.dropAllReferences();
441 
442  for (GlobalAlias &GA : aliases())
443  GA.dropAllReferences();
444 
445  for (GlobalIFunc &GIF : ifuncs())
446  GIF.dropAllReferences();
447 }
448 
450  auto *Val =
451  cast_or_null<ConstantAsMetadata>(getModuleFlag("NumRegisterParameters"));
452  if (!Val)
453  return 0;
454  return cast<ConstantInt>(Val->getValue())->getZExtValue();
455 }
456 
457 unsigned Module::getDwarfVersion() const {
458  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("Dwarf Version"));
459  if (!Val)
460  return 0;
461  return cast<ConstantInt>(Val->getValue())->getZExtValue();
462 }
463 
464 unsigned Module::getCodeViewFlag() const {
465  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("CodeView"));
466  if (!Val)
467  return 0;
468  return cast<ConstantInt>(Val->getValue())->getZExtValue();
469 }
470 
472  unsigned NumInstrs = 0;
473  for (Function &F : FunctionList)
474  NumInstrs += F.getInstructionCount();
475  return NumInstrs;
476 }
477 
479  auto &Entry = *ComdatSymTab.insert(std::make_pair(Name, Comdat())).first;
480  Entry.second.Name = &Entry;
481  return &Entry.second;
482 }
483 
485  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("PIC Level"));
486 
487  if (!Val)
488  return PICLevel::NotPIC;
489 
490  return static_cast<PICLevel::Level>(
491  cast<ConstantInt>(Val->getValue())->getZExtValue());
492 }
493 
495  addModuleFlag(ModFlagBehavior::Max, "PIC Level", PL);
496 }
497 
499  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("PIE Level"));
500 
501  if (!Val)
502  return PIELevel::Default;
503 
504  return static_cast<PIELevel::Level>(
505  cast<ConstantInt>(Val->getValue())->getZExtValue());
506 }
507 
509  addModuleFlag(ModFlagBehavior::Max, "PIE Level", PL);
510 }
511 
513  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("Code Model"));
514 
515  if (!Val)
516  return None;
517 
518  return static_cast<CodeModel::Model>(
519  cast<ConstantInt>(Val->getValue())->getZExtValue());
520 }
521 
523  // Linking object files with different code models is undefined behavior
524  // because the compiler would have to generate additional code (to span
525  // longer jumps) if a larger code model is used with a smaller one.
526  // Therefore we will treat attempts to mix code models as an error.
527  addModuleFlag(ModFlagBehavior::Error, "Code Model", CL);
528 }
529 
531  addModuleFlag(ModFlagBehavior::Error, "ProfileSummary", M);
532 }
533 
535  return getModuleFlag("ProfileSummary");
536 }
537 
538 void Module::setOwnedMemoryBuffer(std::unique_ptr<MemoryBuffer> MB) {
539  OwnedMemoryBuffer = std::move(MB);
540 }
541 
543  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("RtLibUseGOT"));
544  return Val && (cast<ConstantInt>(Val->getValue())->getZExtValue() > 0);
545 }
546 
548  addModuleFlag(ModFlagBehavior::Max, "RtLibUseGOT", 1);
549 }
550 
552  SmallVector<unsigned, 3> Entries;
553  Entries.push_back(V.getMajor());
554  if (auto Minor = V.getMinor()) {
555  Entries.push_back(*Minor);
556  if (auto Subminor = V.getSubminor())
557  Entries.push_back(*Subminor);
558  // Ignore the 'build' component as it can't be represented in the object
559  // file.
560  }
562  ConstantDataArray::get(Context, Entries));
563 }
564 
566  auto *CM = dyn_cast_or_null<ConstantAsMetadata>(getModuleFlag("SDK Version"));
567  if (!CM)
568  return {};
569  auto *Arr = dyn_cast_or_null<ConstantDataArray>(CM->getValue());
570  if (!Arr)
571  return {};
572  auto getVersionComponent = [&](unsigned Index) -> Optional<unsigned> {
573  if (Index >= Arr->getNumElements())
574  return None;
575  return (unsigned)Arr->getElementAsInteger(Index);
576  };
577  auto Major = getVersionComponent(0);
578  if (!Major)
579  return {};
580  VersionTuple Result = VersionTuple(*Major);
581  if (auto Minor = getVersionComponent(1)) {
582  Result = VersionTuple(*Major, *Minor);
583  if (auto Subminor = getVersionComponent(2)) {
584  Result = VersionTuple(*Major, *Minor, *Subminor);
585  }
586  }
587  return Result;
588 }
589 
591  const Module &M, SmallPtrSetImpl<GlobalValue *> &Set, bool CompilerUsed) {
592  const char *Name = CompilerUsed ? "llvm.compiler.used" : "llvm.used";
593  GlobalVariable *GV = M.getGlobalVariable(Name);
594  if (!GV || !GV->hasInitializer())
595  return GV;
596 
597  const ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
598  for (Value *Op : Init->operands()) {
599  GlobalValue *G = cast<GlobalValue>(Op->stripPointerCastsNoFollowAliases());
600  Set.insert(G);
601  }
602  return GV;
603 }
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:397
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.
This class represents lattice values for constants.
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:144
NamedMDNode * getModuleFlagsMetadata() const
Returns the NamedMDNode in the module that represents module-level flags.
Definition: Module.cpp:319
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
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:556
void setMaterializer(GVMaterializer *GVM)
Sets the GVMaterializer to GVM.
Definition: Module.cpp:383
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:370
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:630
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:255
Externally visible function.
Definition: GlobalValue.h:49
void setDataLayout(StringRef Desc)
Set the data layout.
Definition: Module.cpp:359
Optional< CodeModel::Model > getCodeModel() const
Returns the code model (tiny, small, kernel, medium or large model)
Definition: Module.cpp:512
GlobalVariable * getGlobalVariable(StringRef Name) const
Look up the specified global variable in the module symbol table.
Definition: Module.h:382
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:235
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:365
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:268
unsigned getInstructionCount()
Returns the number of non-debug IR instructions in the module.
Definition: Module.cpp:471
This file contains the simple types necessary to represent the attributes associated with functions a...
Metadata * getProfileSummary()
Returns profile summary metadata.
Definition: Module.cpp:534
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:547
NamedMDNode * getNamedMetadata(const Twine &Name) const
Return the first NamedMDNode in the module with the specified name.
Definition: Module.cpp:246
GlobalValue * getNamedValue(StringRef Name) const
Return the global value in the module with the specified name, of arbitrary type. ...
Definition: Module.cpp:114
void dropAllReferences()
This function causes all the subinstructions to "let go" of all references that they are maintaining...
Definition: Module.cpp:435
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:464
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:131
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1773
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:74
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:498
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:206
Metadata * getModuleFlag(StringRef Key) const
Return the corresponding value if Key appears in module flags, otherwise return null.
Definition: Module.cpp:306
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:113
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
unsigned getMajor() const
Retrieve the major version number.
Definition: VersionTuple.h:68
void addModuleFlag(ModFlagBehavior Behavior, StringRef Key, Metadata *Val)
Add a module-level flag to the module-level flags metadata.
Definition: Module.cpp:333
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:522
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:478
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
Definition: Module.h:210
unsigned getDwarfVersion() const
Returns the Dwarf Version by checking module flags.
Definition: Module.cpp:457
Optional< unsigned > getMinor() const
Retrieve the minor version number, if provided.
Definition: VersionTuple.h:71
std::vector< StructType * > getIdentifiedStructTypes() const
Definition: Module.cpp:414
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:590
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:273
const DataFlowGraph & G
Definition: RDFGraph.cpp:211
NamedMDNode * getOrInsertModuleFlagsMetadata()
Returns the NamedMDNode in the module that represents module-level flags.
Definition: Module.cpp:326
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:622
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:176
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:414
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:542
DICompileUnit * operator*() const
Definition: Module.cpp:367
A random number generator.
void setProfileSummary(Metadata *M)
Attach profile summary metadata to this module.
Definition: Module.cpp:530
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:27
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
void setSDKVersion(const VersionTuple &V)
Attach a build SDK version metadata to this module.
Definition: Module.cpp:551
std::unique_ptr< RandomNumberGenerator > createRNG(const Pass *P) const
Get a RandomNumberGenerator salted for use with this module.
Definition: Module.cpp:93
llvm::Error materialize(GlobalValue *GV)
Make sure the GlobalValue is fully read.
Definition: Module.cpp:390
~Module()
The module destructor. This will dropAllReferences.
Definition: Module.cpp:81
void setPIELevel(PIELevel::Level PL)
Set the PIE level (small or large model)
Definition: Module.cpp:508
iterator_range< ifunc_iterator > ifuncs()
Definition: Module.h:633
void setOwnedMemoryBuffer(std::unique_ptr< MemoryBuffer > MB)
Take ownership of the given memory buffer.
Definition: Module.cpp:538
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:127
unsigned getMDKindID(StringRef Name) const
Return a unique non-zero ID for the specified metadata kind.
Definition: Module.cpp:120
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:449
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
Defines the llvm::VersionTuple class, which represents a version in the form major[.minor[.subminor]].
static Constant * get(LLVMContext &Context, ArrayRef< ElementTy > Elts)
get() constructor - Return a constant with array type with an element count and element type matching...
Definition: Constants.h:703
void setPICLevel(PICLevel::Level PL)
Set the PIC level (small or large model)
Definition: Module.cpp:494
PICLevel::Level getPICLevel() const
Returns the PIC level (small or large model)
Definition: Module.cpp:484
iterator_range< global_iterator > globals()
Definition: Module.h:575
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
A single uniqued string.
Definition: Metadata.h:604
Optional< unsigned > getSubminor() const
Retrieve the subminor version number, if provided.
Definition: VersionTuple.h:78
VersionTuple getSDKVersion() const
Get the build SDK version metadata.
Definition: Module.cpp:565
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:239
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:404
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:274
IntegerType * Int32Ty
iterator_range< alias_iterator > aliases()
Definition: Module.h:615