LLVM  16.0.0git
Globals.cpp
Go to the documentation of this file.
1 //===-- Globals.cpp - Implement the GlobalValue & GlobalVariable class ----===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the GlobalValue & GlobalVariable classes for the IR
10 // library.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "LLVMContextImpl.h"
15 #include "llvm/ADT/Triple.h"
16 #include "llvm/IR/ConstantRange.h"
17 #include "llvm/IR/Constants.h"
18 #include "llvm/IR/DerivedTypes.h"
19 #include "llvm/IR/GlobalAlias.h"
20 #include "llvm/IR/GlobalValue.h"
21 #include "llvm/IR/GlobalVariable.h"
22 #include "llvm/IR/Module.h"
23 #include "llvm/Support/Error.h"
25 using namespace llvm;
26 
27 //===----------------------------------------------------------------------===//
28 // GlobalValue Class
29 //===----------------------------------------------------------------------===//
30 
31 // GlobalValue should be a Constant, plus a type, a module, some flags, and an
32 // intrinsic ID. Add an assert to prevent people from accidentally growing
33 // GlobalValue while adding flags.
34 static_assert(sizeof(GlobalValue) ==
35  sizeof(Constant) + 2 * sizeof(void *) + 2 * sizeof(unsigned),
36  "unexpected GlobalValue size growth");
37 
38 // GlobalObject adds a comdat.
39 static_assert(sizeof(GlobalObject) == sizeof(GlobalValue) + sizeof(void *),
40  "unexpected GlobalObject size growth");
41 
43  if (const Function *F = dyn_cast<Function>(this))
44  return F->isMaterializable();
45  return false;
46 }
48  return getParent()->materialize(this);
49 }
50 
51 /// Override destroyConstantImpl to make sure it doesn't get called on
52 /// GlobalValue's because they shouldn't be treated like other constants.
53 void GlobalValue::destroyConstantImpl() {
54  llvm_unreachable("You can't GV->destroyConstantImpl()!");
55 }
56 
57 Value *GlobalValue::handleOperandChangeImpl(Value *From, Value *To) {
58  llvm_unreachable("Unsupported class for handleOperandChange()!");
59 }
60 
61 /// copyAttributesFrom - copy all additional attributes (those not needed to
62 /// create a GlobalValue) from the GlobalValue Src to this one.
64  setVisibility(Src->getVisibility());
65  setUnnamedAddr(Src->getUnnamedAddr());
66  setThreadLocalMode(Src->getThreadLocalMode());
67  setDLLStorageClass(Src->getDLLStorageClass());
68  setDSOLocal(Src->isDSOLocal());
69  setPartition(Src->getPartition());
70  if (Src->hasSanitizerMetadata())
71  setSanitizerMetadata(Src->getSanitizerMetadata());
72  else
74 }
75 
77  switch (getValueID()) {
78 #define HANDLE_GLOBAL_VALUE(NAME) \
79  case Value::NAME##Val: \
80  return static_cast<NAME *>(this)->removeFromParent();
81 #include "llvm/IR/Value.def"
82  default:
83  break;
84  }
85  llvm_unreachable("not a global");
86 }
87 
89  switch (getValueID()) {
90 #define HANDLE_GLOBAL_VALUE(NAME) \
91  case Value::NAME##Val: \
92  return static_cast<NAME *>(this)->eraseFromParent();
93 #include "llvm/IR/Value.def"
94  default:
95  break;
96  }
97  llvm_unreachable("not a global");
98 }
99 
101 
104  return true;
105  return getParent() && getParent()->getSemanticInterposition() &&
106  !isDSOLocal();
107 }
108 
110  // See AsmPrinter::getSymbolPreferLocal(). For a deduplicate comdat kind,
111  // references to a discarded local symbol from outside the group are not
112  // allowed, so avoid the local alias.
113  auto isDeduplicateComdat = [](const Comdat *C) {
114  return C && C->getSelectionKind() != Comdat::NoDeduplicate;
115  };
116  return hasDefaultVisibility() &&
118  !isa<GlobalIFunc>(this) && !isDeduplicateComdat(getComdat());
119 }
120 
122  assert((!Align || *Align <= MaximumAlignment) &&
123  "Alignment is greater than MaximumAlignment!");
124  unsigned AlignmentData = encode(Align);
125  unsigned OldData = getGlobalValueSubClassData();
126  setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData);
128  "Alignment representation error!");
129 }
130 
133  setAlignment(Src->getAlign());
134  setSection(Src->getSection());
135 }
136 
139  StringRef FileName) {
140 
141  // Value names may be prefixed with a binary '1' to indicate
142  // that the backend should not modify the symbols due to any platform
143  // naming convention. Do not include that '1' in the PGO profile name.
144  if (Name[0] == '\1')
145  Name = Name.substr(1);
146 
147  std::string NewName = std::string(Name);
149  // For local symbols, prepend the main file name to distinguish them.
150  // Do not include the full path in the file name since there's no guarantee
151  // that it will stay the same, e.g., if the files are checked out from
152  // version control in different locations.
153  if (FileName.empty())
154  NewName = NewName.insert(0, "<unknown>:");
155  else
156  NewName = NewName.insert(0, FileName.str() + ":");
157  }
158  return NewName;
159 }
160 
161 std::string GlobalValue::getGlobalIdentifier() const {
163  getParent()->getSourceFileName());
164 }
165 
167  if (auto *GA = dyn_cast<GlobalAlias>(this)) {
168  // In general we cannot compute this at the IR level, but we try.
169  if (const GlobalObject *GO = GA->getAliaseeObject())
170  return GO->getSection();
171  return "";
172  }
173  return cast<GlobalObject>(this)->getSection();
174 }
175 
177  if (auto *GA = dyn_cast<GlobalAlias>(this)) {
178  // In general we cannot compute this at the IR level, but we try.
179  if (const GlobalObject *GO = GA->getAliaseeObject())
180  return const_cast<GlobalObject *>(GO)->getComdat();
181  return nullptr;
182  }
183  // ifunc and its resolver are separate things so don't use resolver comdat.
184  if (isa<GlobalIFunc>(this))
185  return nullptr;
186  return cast<GlobalObject>(this)->getComdat();
187 }
188 
190  if (ObjComdat)
191  ObjComdat->removeUser(this);
192  ObjComdat = C;
193  if (C)
194  C->addUser(this);
195 }
196 
198  if (!hasPartition())
199  return "";
200  return getContext().pImpl->GlobalValuePartitions[this];
201 }
202 
204  // Do nothing if we're clearing the partition and it is already empty.
205  if (!hasPartition() && S.empty())
206  return;
207 
208  // Get or create a stable partition name string and put it in the table in the
209  // context.
210  if (!S.empty())
211  S = getContext().pImpl->Saver.save(S);
213 
214  // Update the HasPartition field. Setting the partition to the empty string
215  // means this global no longer has a partition.
216  HasPartition = !S.empty();
217 }
218 
222  assert(getContext().pImpl->GlobalValueSanitizerMetadata.count(this));
224 }
225 
228  HasSanitizerMetadata = true;
229 }
230 
234  MetadataMap.erase(this);
235  HasSanitizerMetadata = false;
236 }
237 
238 StringRef GlobalObject::getSectionImpl() const {
239  assert(hasSection());
240  return getContext().pImpl->GlobalObjectSections[this];
241 }
242 
244  // Do nothing if we're clearing the section and it is already empty.
245  if (!hasSection() && S.empty())
246  return;
247 
248  // Get or create a stable section name string and put it in the table in the
249  // context.
250  if (!S.empty())
251  S = getContext().pImpl->Saver.save(S);
253 
254  // Update the HasSectionHashEntryBit. Setting the section to the empty string
255  // means this global no longer has a section.
256  setGlobalObjectFlag(HasSectionHashEntryBit, !S.empty());
257 }
258 
259 bool GlobalValue::isNobuiltinFnDef() const {
260  const Function *F = dyn_cast<Function>(this);
261  if (!F || F->empty())
262  return false;
263  return F->hasFnAttribute(Attribute::NoBuiltin);
264 }
265 
267  // Globals are definitions if they have an initializer.
268  if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(this))
269  return GV->getNumOperands() == 0;
270 
271  // Functions are definitions if they have a body.
272  if (const Function *F = dyn_cast<Function>(this))
273  return F->empty() && !F->isMaterializable();
274 
275  // Aliases and ifuncs are always definitions.
276  assert(isa<GlobalAlias>(this) || isa<GlobalIFunc>(this));
277  return false;
278 }
279 
281  // Firstly, can only increase the alignment of a global if it
282  // is a strong definition.
284  return false;
285 
286  // It also has to either not have a section defined, or, not have
287  // alignment specified. (If it is assigned a section, the global
288  // could be densely packed with other objects in the section, and
289  // increasing the alignment could cause padding issues.)
290  if (hasSection() && getAlign())
291  return false;
292 
293  // On ELF platforms, we're further restricted in that we can't
294  // increase the alignment of any variable which might be emitted
295  // into a shared library, and which is exported. If the main
296  // executable accesses a variable found in a shared-lib, the main
297  // exe actually allocates memory for and exports the symbol ITSELF,
298  // overriding the symbol found in the library. That is, at link
299  // time, the observed alignment of the variable is copied into the
300  // executable binary. (A COPY relocation is also generated, to copy
301  // the initial data from the shadowed variable in the shared-lib
302  // into the location in the main binary, before running code.)
303  //
304  // And thus, even though you might think you are defining the
305  // global, and allocating the memory for the global in your object
306  // file, and thus should be able to set the alignment arbitrarily,
307  // that's not actually true. Doing so can cause an ABI breakage; an
308  // executable might have already been built with the previous
309  // alignment of the variable, and then assuming an increased
310  // alignment will be incorrect.
311 
312  // Conservatively assume ELF if there's no parent pointer.
313  bool isELF =
315  if (isELF && !isDSOLocal())
316  return false;
317 
318  return true;
319 }
320 
321 template <typename Operation>
322 static const GlobalObject *
324  const Operation &Op) {
325  if (auto *GO = dyn_cast<GlobalObject>(C)) {
326  Op(*GO);
327  return GO;
328  }
329  if (auto *GA = dyn_cast<GlobalAlias>(C)) {
330  Op(*GA);
331  if (Aliases.insert(GA).second)
332  return findBaseObject(GA->getOperand(0), Aliases, Op);
333  }
334  if (auto *CE = dyn_cast<ConstantExpr>(C)) {
335  switch (CE->getOpcode()) {
336  case Instruction::Add: {
337  auto *LHS = findBaseObject(CE->getOperand(0), Aliases, Op);
338  auto *RHS = findBaseObject(CE->getOperand(1), Aliases, Op);
339  if (LHS && RHS)
340  return nullptr;
341  return LHS ? LHS : RHS;
342  }
343  case Instruction::Sub: {
344  if (findBaseObject(CE->getOperand(1), Aliases, Op))
345  return nullptr;
346  return findBaseObject(CE->getOperand(0), Aliases, Op);
347  }
348  case Instruction::IntToPtr:
349  case Instruction::PtrToInt:
350  case Instruction::BitCast:
351  case Instruction::GetElementPtr:
352  return findBaseObject(CE->getOperand(0), Aliases, Op);
353  default:
354  break;
355  }
356  }
357  return nullptr;
358 }
359 
362  return findBaseObject(this, Aliases, [](const GlobalValue &) {});
363 }
364 
366  auto *GO = dyn_cast<GlobalObject>(this);
367  if (!GO)
368  return false;
369 
370  return GO->getMetadata(LLVMContext::MD_absolute_symbol);
371 }
372 
373 std::optional<ConstantRange> GlobalValue::getAbsoluteSymbolRange() const {
374  auto *GO = dyn_cast<GlobalObject>(this);
375  if (!GO)
376  return std::nullopt;
377 
378  MDNode *MD = GO->getMetadata(LLVMContext::MD_absolute_symbol);
379  if (!MD)
380  return std::nullopt;
381 
382  return getConstantRangeFromMetadata(*MD);
383 }
384 
386  if (!hasLinkOnceODRLinkage())
387  return false;
388 
389  // We assume that anyone who sets global unnamed_addr on a non-constant
390  // knows what they're doing.
391  if (hasGlobalUnnamedAddr())
392  return true;
393 
394  // If it is a non constant variable, it needs to be uniqued across shared
395  // objects.
396  if (auto *Var = dyn_cast<GlobalVariable>(this))
397  if (!Var->isConstant())
398  return false;
399 
401 }
402 
403 //===----------------------------------------------------------------------===//
404 // GlobalVariable Implementation
405 //===----------------------------------------------------------------------===//
406 
408  Constant *InitVal, const Twine &Name,
409  ThreadLocalMode TLMode, unsigned AddressSpace,
410  bool isExternallyInitialized)
411  : GlobalObject(Ty, Value::GlobalVariableVal,
412  OperandTraits<GlobalVariable>::op_begin(this),
413  InitVal != nullptr, Link, Name, AddressSpace),
414  isConstantGlobal(constant),
415  isExternallyInitializedConstant(isExternallyInitialized) {
417  "invalid type for global variable");
418  setThreadLocalMode(TLMode);
419  if (InitVal) {
420  assert(InitVal->getType() == Ty &&
421  "Initializer should be the same type as the GlobalVariable!");
422  Op<0>() = InitVal;
423  }
424 }
425 
427  LinkageTypes Link, Constant *InitVal,
428  const Twine &Name, GlobalVariable *Before,
429  ThreadLocalMode TLMode,
430  std::optional<unsigned> AddressSpace,
431  bool isExternallyInitialized)
432  : GlobalObject(Ty, Value::GlobalVariableVal,
433  OperandTraits<GlobalVariable>::op_begin(this),
434  InitVal != nullptr, Link, Name,
436  ? *AddressSpace
437  : M.getDataLayout().getDefaultGlobalsAddressSpace()),
438  isConstantGlobal(constant),
439  isExternallyInitializedConstant(isExternallyInitialized) {
441  "invalid type for global variable");
442  setThreadLocalMode(TLMode);
443  if (InitVal) {
444  assert(InitVal->getType() == Ty &&
445  "Initializer should be the same type as the GlobalVariable!");
446  Op<0>() = InitVal;
447  }
448 
449  if (Before)
450  Before->getParent()->getGlobalList().insert(Before->getIterator(), this);
451  else
452  M.getGlobalList().push_back(this);
453 }
454 
456  getParent()->getGlobalList().remove(getIterator());
457 }
458 
460  getParent()->getGlobalList().erase(getIterator());
461 }
462 
464  if (!InitVal) {
465  if (hasInitializer()) {
466  // Note, the num operands is used to compute the offset of the operand, so
467  // the order here matters. Clearing the operand then clearing the num
468  // operands ensures we have the correct offset to the operand.
469  Op<0>().set(nullptr);
471  }
472  } else {
473  assert(InitVal->getType() == getValueType() &&
474  "Initializer type must match GlobalVariable type");
475  // Note, the num operands is used to compute the offset of the operand, so
476  // the order here matters. We need to set num operands to 1 first so that
477  // we get the correct offset to the first operand when we set it.
478  if (!hasInitializer())
480  Op<0>().set(InitVal);
481  }
482 }
483 
484 /// Copy all additional attributes (those not needed to create a GlobalVariable)
485 /// from the GlobalVariable Src to this one.
488  setExternallyInitialized(Src->isExternallyInitialized());
489  setAttributes(Src->getAttributes());
490 }
491 
494  clearMetadata();
495 }
496 
497 //===----------------------------------------------------------------------===//
498 // GlobalAlias Implementation
499 //===----------------------------------------------------------------------===//
500 
501 GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
502  const Twine &Name, Constant *Aliasee,
503  Module *ParentModule)
504  : GlobalValue(Ty, Value::GlobalAliasVal, &Op<0>(), 1, Link, Name,
505  AddressSpace) {
506  setAliasee(Aliasee);
507  if (ParentModule)
508  ParentModule->getAliasList().push_back(this);
509 }
510 
512  LinkageTypes Link, const Twine &Name,
513  Constant *Aliasee, Module *ParentModule) {
514  return new GlobalAlias(Ty, AddressSpace, Link, Name, Aliasee, ParentModule);
515 }
516 
518  LinkageTypes Linkage, const Twine &Name,
519  Module *Parent) {
520  return create(Ty, AddressSpace, Linkage, Name, nullptr, Parent);
521 }
522 
524  LinkageTypes Linkage, const Twine &Name,
525  GlobalValue *Aliasee) {
526  return create(Ty, AddressSpace, Linkage, Name, Aliasee, Aliasee->getParent());
527 }
528 
530  GlobalValue *Aliasee) {
531  return create(Aliasee->getValueType(), Aliasee->getAddressSpace(), Link, Name,
532  Aliasee);
533 }
534 
536  return create(Aliasee->getLinkage(), Name, Aliasee);
537 }
538 
540  getParent()->getAliasList().remove(getIterator());
541 }
542 
544  getParent()->getAliasList().erase(getIterator());
545 }
546 
548  assert((!Aliasee || Aliasee->getType() == getType()) &&
549  "Alias and aliasee types should match!");
550  Op<0>().set(Aliasee);
551 }
552 
555  return findBaseObject(getOperand(0), Aliases, [](const GlobalValue &) {});
556 }
557 
558 //===----------------------------------------------------------------------===//
559 // GlobalIFunc Implementation
560 //===----------------------------------------------------------------------===//
561 
562 GlobalIFunc::GlobalIFunc(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
563  const Twine &Name, Constant *Resolver,
564  Module *ParentModule)
565  : GlobalObject(Ty, Value::GlobalIFuncVal, &Op<0>(), 1, Link, Name,
566  AddressSpace) {
567  setResolver(Resolver);
568  if (ParentModule)
569  ParentModule->getIFuncList().push_back(this);
570 }
571 
573  LinkageTypes Link, const Twine &Name,
574  Constant *Resolver, Module *ParentModule) {
575  return new GlobalIFunc(Ty, AddressSpace, Link, Name, Resolver, ParentModule);
576 }
577 
579  getParent()->getIFuncList().remove(getIterator());
580 }
581 
583  getParent()->getIFuncList().erase(getIterator());
584 }
585 
587  return dyn_cast<Function>(getResolver()->stripPointerCastsAndAliases());
588 }
589 
591  function_ref<void(const GlobalValue &)> Op) const {
593  findBaseObject(getResolver(), Aliases, Op);
594 }
llvm::GlobalVariable::setExternallyInitialized
void setExternallyInitialized(bool Val)
Definition: GlobalVariable.h:158
llvm::GlobalValue::hasSanitizerMetadata
bool hasSanitizerMetadata() const
Definition: GlobalValue.h:351
llvm::LLVMContext::pImpl
LLVMContextImpl *const pImpl
Definition: LLVMContext.h:69
llvm::GlobalVariable::eraseFromParent
void eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:459
llvm::Value::stripPointerCastsAndAliases
const Value * stripPointerCastsAndAliases() const
Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
Definition: Value.cpp:689
constant
we should consider alternate ways to model stack dependencies Lots of things could be done in WebAssemblyTargetTransformInfo cpp there are numerous optimization related hooks that can be overridden in WebAssemblyTargetLowering Instead of the OptimizeReturned which should consider preserving the returned attribute through to MachineInstrs and extending the MemIntrinsicResults pass to do this optimization on calls too That would also let the WebAssemblyPeephole pass clean up dead defs for such as it does for stores Consider implementing and or getMachineCombinerPatterns Find a clean way to fix the problem which leads to the Shrink Wrapping pass being run after the WebAssembly PEI pass When setting multiple variables to the same constant
Definition: README.txt:91
llvm::GlobalObject::setComdat
void setComdat(Comdat *C)
Definition: Globals.cpp:189
llvm::GlobalValue::removeFromParent
void removeFromParent()
This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:76
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::PointerType::isValidElementType
static bool isValidElementType(Type *ElemTy)
Return true if the specified type is valid as a element type.
Definition: Type.cpp:778
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::GlobalObject::~GlobalObject
~GlobalObject()
Definition: Globals.cpp:100
llvm::GlobalValue::getGlobalIdentifier
std::string getGlobalIdentifier() const
Return the modified name for this global value suitable to be used as the key for a global lookup (e....
Definition: Globals.cpp:161
llvm::Value::MaximumAlignment
static constexpr uint64_t MaximumAlignment
Definition: Value.h:790
llvm::GlobalVariable::copyAttributesFrom
void copyAttributesFrom(const GlobalVariable *Src)
copyAttributesFrom - copy all additional attributes (those not needed to create a GlobalVariable) fro...
Definition: Globals.cpp:486
llvm::GlobalValue::getLinkage
LinkageTypes getLinkage() const
Definition: GlobalValue.h:541
llvm::Function
Definition: Function.h:60
llvm::Comdat::NoDeduplicate
@ NoDeduplicate
No deduplication is performed.
Definition: Comdat.h:39
llvm::GlobalObject::getAlign
MaybeAlign getAlign() const
Returns the alignment of the given variable or function.
Definition: GlobalObject.h:79
llvm::User::dropAllReferences
void dropAllReferences()
Drop all references to operands.
Definition: User.h:299
llvm::GlobalValue::isLocalLinkage
static bool isLocalLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:404
llvm::GlobalValue::materialize
Error materialize()
Make sure this GlobalValue is fully read.
Definition: Globals.cpp:47
ErrorHandling.h
llvm::GlobalIFunc::applyAlongResolverPath
void applyAlongResolverPath(function_ref< void(const GlobalValue &)> Op) const
Definition: Globals.cpp:590
llvm::GlobalVariable
Definition: GlobalVariable.h:39
llvm::GlobalAlias
Definition: GlobalAlias.h:28
llvm::GlobalValue::HasPartition
unsigned HasPartition
True if this symbol has a partition name assigned (see https://lld.llvm.org/Partitions....
Definition: GlobalValue.h:113
Error.h
llvm::GlobalValue::setThreadLocalMode
void setThreadLocalMode(ThreadLocalMode Val)
Definition: GlobalValue.h:263
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::erase
bool erase(const KeyT &Val)
Definition: DenseMap.h:302
llvm::GlobalObject::HasSectionHashEntryBit
@ HasSectionHashEntryBit
Definition: GlobalObject.h:54
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
Module.h
llvm::GlobalValue::setSanitizerMetadata
void setSanitizerMetadata(SanitizerMetadata Meta)
Definition: Globals.cpp:226
llvm::codeview::Link
@ Link
Definition: CodeView.h:151
llvm::GlobalValue::setUnnamedAddr
void setUnnamedAddr(UnnamedAddr Val)
Definition: GlobalValue.h:227
RHS
Value * RHS
Definition: X86PartialReduction.cpp:76
llvm::GlobalValue::LinkageTypes
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:47
llvm::getConstantRangeFromMetadata
ConstantRange getConstantRangeFromMetadata(const MDNode &RangeMD)
Parse out a conservative ConstantRange from !range metadata.
Definition: ConstantRange.cpp:1796
llvm::detail::DenseSetImpl< ValueT, DenseMap< ValueT, detail::DenseSetEmpty, DenseMapInfo< ValueT >, detail::DenseSetPair< ValueT > >, DenseMapInfo< ValueT > >::insert
std::pair< iterator, bool > insert(const ValueT &V)
Definition: DenseSet.h:206
llvm::Module::getGlobalList
const GlobalListType & getGlobalList() const
Get the Module's list of global variables (constant).
Definition: Module.h:550
llvm::GlobalValue::setDSOLocal
void setDSOLocal(bool Local)
Definition: GlobalValue.h:299
llvm::LLVMContextImpl::GlobalValuePartitions
DenseMap< const GlobalValue *, StringRef > GlobalValuePartitions
Collection of per-GlobalValue partitions used in this context.
Definition: LLVMContextImpl.h:1511
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::GlobalVariable::hasInitializer
bool hasInitializer() const
Definitions have initializers, declarations don't.
Definition: GlobalVariable.h:91
llvm::User::setGlobalVariableNumOperands
void setGlobalVariableNumOperands(unsigned NumOps)
Set the number of operands on a GlobalVariable.
Definition: User.h:207
llvm::GlobalValue::getSection
StringRef getSection() const
Definition: Globals.cpp:166
llvm::Resolver
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:2134
LHS
Value * LHS
Definition: X86PartialReduction.cpp:75
llvm::Triple::isOSBinFormatELF
bool isOSBinFormatELF() const
Tests whether the OS uses the ELF binary format.
Definition: Triple.h:673
GlobalValue.h
llvm::OperandTraits
Compile-time customization of User operands.
Definition: User.h:42
llvm::GlobalValue::isDeclaration
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:266
Constants.h
llvm::LLVMContextImpl::GlobalValueSanitizerMetadata
DenseMap< const GlobalValue *, GlobalValue::SanitizerMetadata > GlobalValueSanitizerMetadata
Definition: LLVMContextImpl.h:1514
llvm::GlobalObject::setSection
void setSection(StringRef S)
Change the section for this global.
Definition: Globals.cpp:243
Operation
PowerPC Reduce CR logical Operation
Definition: PPCReduceCRLogicals.cpp:735
llvm::GlobalValue::getSanitizerMetadata
const SanitizerMetadata & getSanitizerMetadata() const
Definition: Globals.cpp:220
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::GlobalObject
Definition: GlobalObject.h:27
llvm::GlobalValue::HasSanitizerMetadata
unsigned HasSanitizerMetadata
True if this symbol has sanitizer metadata available.
Definition: GlobalValue.h:118
llvm::GlobalValue::copyAttributesFrom
void copyAttributesFrom(const GlobalValue *Src)
Copy all additional attributes (those not needed to create a GlobalValue) from the GlobalValue Src to...
Definition: Globals.cpp:63
llvm::GlobalValue::hasAtLeastLocalUnnamedAddr
bool hasAtLeastLocalUnnamedAddr() const
Returns true if this value's address is not significant in this module.
Definition: GlobalValue.h:220
llvm::MaybeAlign
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:117
llvm::Value::getValueID
unsigned getValueID() const
Return an ID for the concrete type of this object.
Definition: Value.h:532
llvm::Module::getAliasList
const AliasListType & getAliasList() const
Get the Module's list of aliases (constant).
Definition: Module.h:567
LLVMContextImpl.h
findBaseObject
static const GlobalObject * findBaseObject(const Constant *C, DenseSet< const GlobalAlias * > &Aliases, const Operation &Op)
Definition: Globals.cpp:323
llvm::encode
unsigned encode(MaybeAlign A)
Returns a representation of the alignment that encodes undefined as 0.
Definition: Alignment.h:218
llvm::GlobalIFunc::removeFromParent
void removeFromParent()
This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:578
llvm::GlobalValue::SanitizerMetadata
Definition: GlobalValue.h:313
llvm::GlobalValue::hasGlobalUnnamedAddr
bool hasGlobalUnnamedAddr() const
Definition: GlobalValue.h:211
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::Comdat
Definition: Comdat.h:33
llvm::Type::isFunctionTy
bool isFunctionTy() const
True if this is an instance of FunctionType.
Definition: Type.h:228
llvm::AddressSpace
AddressSpace
Definition: NVPTXBaseInfo.h:21
llvm::GlobalValue::hasDefaultVisibility
bool hasDefaultVisibility() const
Definition: GlobalValue.h:245
llvm::GlobalVariable::dropAllReferences
void dropAllReferences()
Drop all references in preparation to destroy the GlobalVariable.
Definition: Globals.cpp:492
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLFunctionalExtras.h:36
llvm::StringRef::empty
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
llvm::GlobalObject::hasSection
bool hasSection() const
Check if this global has a custom object file section.
Definition: GlobalObject.h:103
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::GlobalValue::canBenefitFromLocalAlias
bool canBenefitFromLocalAlias() const
Definition: Globals.cpp:109
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::GlobalObject::canIncreaseAlignment
bool canIncreaseAlignment() const
Returns true if the alignment of the value can be unilaterally increased.
Definition: Globals.cpp:280
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:652
llvm::DenseMap
Definition: DenseMap.h:714
llvm::LLVMContextImpl::GlobalObjectSections
DenseMap< const GlobalObject *, StringRef > GlobalObjectSections
Collection of per-GlobalObject sections used in this context.
Definition: LLVMContextImpl.h:1508
llvm::GlobalValue::getPartition
StringRef getPartition() const
Definition: Globals.cpp:197
llvm::GlobalIFunc::getResolver
const Constant * getResolver() const
Definition: GlobalIFunc.h:70
llvm::GlobalValue::Linkage
unsigned Linkage
Definition: GlobalValue.h:94
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::GlobalValue::isExternalLinkage
static bool isExternalLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:371
llvm::GlobalValue::getAddressSpace
unsigned getAddressSpace() const
Definition: GlobalValue.h:201
llvm::UniqueStringSaver::save
StringRef save(const char *S)
Definition: StringSaver.h:52
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::MDNode
Metadata node.
Definition: Metadata.h:944
llvm::Value::clearMetadata
void clearMetadata()
Erase all metadata attached to this Value.
Definition: Metadata.cpp:1383
Triple.h
llvm::GlobalValue::isMaterializable
bool isMaterializable() const
If this function's Module is being lazily streamed in functions from disk or some other source,...
Definition: Globals.cpp:42
llvm::GlobalValue::canBeOmittedFromSymbolTable
bool canBeOmittedFromSymbolTable() const
True if GV can be left out of the object symbol table.
Definition: Globals.cpp:385
llvm::GlobalValue::getGlobalValueSubClassData
unsigned getGlobalValueSubClassData() const
Definition: GlobalValue.h:171
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
this
Analysis the ScalarEvolution expression for r is this
Definition: README.txt:8
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::Value::getType
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
llvm::GlobalValue::setDLLStorageClass
void setDLLStorageClass(DLLStorageClassTypes C)
Definition: GlobalValue.h:280
llvm::Value::getContext
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:994
llvm::ilist_node_impl::getIterator
self_iterator getIterator()
Definition: ilist_node.h:82
ConstantRange.h
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::GlobalValue::getAliaseeObject
const GlobalObject * getAliaseeObject() const
Definition: Globals.cpp:360
llvm::Value::getName
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:308
llvm::GlobalIFunc::create
static GlobalIFunc * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Resolver, Module *Parent)
If a parent module is specified, the ifunc is automatically inserted into the end of the specified mo...
Definition: Globals.cpp:572
llvm::GlobalVariable::GlobalVariable
GlobalVariable(Type *Ty, bool isConstant, LinkageTypes Linkage, Constant *Initializer=nullptr, const Twine &Name="", ThreadLocalMode=NotThreadLocal, unsigned AddressSpace=0, bool isExternallyInitialized=false)
GlobalVariable ctor - If a parent module is specified, the global is automatically inserted into the ...
Definition: Globals.cpp:407
llvm::GlobalValue::eraseFromParent
void eraseFromParent()
This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:88
llvm::GlobalObject::getAlignment
uint64_t getAlignment() const
FIXME: Remove this function once transition to Align is over.
Definition: GlobalObject.h:70
llvm::GlobalValue::isStrongDefinitionForLinker
bool isStrongDefinitionForLinker() const
Returns true if this global's definition will be the one chosen by the linker.
Definition: GlobalValue.h:627
llvm::GlobalValue::getAbsoluteSymbolRange
std::optional< ConstantRange > getAbsoluteSymbolRange() const
If this is an absolute symbol reference, returns the range of the symbol, otherwise returns None.
Definition: Globals.cpp:373
llvm::Module::getSemanticInterposition
bool getSemanticInterposition() const
Returns whether semantic interposition is to be respected.
Definition: Module.cpp:648
llvm::Module::materialize
llvm::Error materialize(GlobalValue *GV)
Make sure the GlobalValue is fully read.
Definition: Module.cpp:439
llvm::GlobalValue::isInterposable
bool isInterposable() const
Return true if this global's definition can be substituted with an arbitrary definition at link time ...
Definition: Globals.cpp:102
llvm::Module::getIFuncList
const IFuncListType & getIFuncList() const
Get the Module's list of ifuncs (constant).
Definition: Module.h:576
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
llvm::GlobalValue::hasLinkOnceODRLinkage
bool hasLinkOnceODRLinkage() const
Definition: GlobalValue.h:514
llvm::GlobalValue::ThreadLocalMode
ThreadLocalMode
Definition: GlobalValue.h:191
llvm::GlobalAlias::create
static GlobalAlias * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Aliasee, Module *Parent)
If a parent module is specified, the alias is automatically inserted into the end of the specified mo...
Definition: Globals.cpp:511
llvm::GlobalValue::isInterposableLinkage
static bool isInterposableLinkage(LinkageTypes Linkage)
Whether the definition of this global may be replaced by something non-equivalent at link time.
Definition: GlobalValue.h:420
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:351
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:155
GlobalVariable.h
llvm::GlobalValue::getComdat
const Comdat * getComdat() const
Definition: Globals.cpp:176
SanitizerMetadata
GlobalValue::SanitizerMetadata SanitizerMetadata
Definition: Globals.cpp:219
llvm::MCID::Add
@ Add
Definition: MCInstrDesc.h:185
GlobalAlias.h
llvm::GlobalValue::setGlobalValueSubClassData
void setGlobalValueSubClassData(unsigned V)
Definition: GlobalValue.h:174
llvm::GlobalValue::isAbsoluteSymbolRef
bool isAbsoluteSymbolRef() const
Returns whether this is a reference to an absolute symbol.
Definition: Globals.cpp:365
llvm::GlobalValue::removeSanitizerMetadata
void removeSanitizerMetadata()
Definition: Globals.cpp:231
llvm::GlobalAlias::getAliaseeObject
const GlobalObject * getAliaseeObject() const
Definition: Globals.cpp:553
llvm::LLVMContextImpl::Saver
UniqueStringSaver Saver
Definition: LLVMContextImpl.h:1473
llvm::Module::getTargetTriple
const std::string & getTargetTriple() const
Get the target triple which is a string describing the target host.
Definition: Module.h:258
llvm::GlobalVariable::setAttributes
void setAttributes(AttributeSet A)
Set attribute list for this global.
Definition: GlobalVariable.h:237
llvm::GlobalObject::copyAttributesFrom
void copyAttributesFrom(const GlobalObject *Src)
Definition: Globals.cpp:131
llvm::GlobalValue::setPartition
void setPartition(StringRef Part)
Definition: Globals.cpp:203
llvm::GlobalValue::getType
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:290
DerivedTypes.h
llvm::GlobalValue::getValueType
Type * getValueType() const
Definition: GlobalValue.h:292
llvm::StringRef::str
std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:221
llvm::GlobalValue::hasPartition
bool hasPartition() const
Definition: GlobalValue.h:305
llvm::User::Op
Use & Op()
Definition: User.h:133
llvm::GlobalObject::ObjComdat
Comdat * ObjComdat
Definition: GlobalObject.h:51
From
BlockVerifier::State From
Definition: BlockVerifier.cpp:55
llvm::GlobalAlias::eraseFromParent
void eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:543
llvm::User::getOperand
Value * getOperand(unsigned i) const
Definition: User.h:169
llvm::GlobalObject::setAlignment
void setAlignment(MaybeAlign Align)
Definition: Globals.cpp:121
llvm::GlobalVariable::removeFromParent
void removeFromParent()
removeFromParent - This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:455
llvm::GlobalIFunc::getResolverFunction
const Function * getResolverFunction() const
Definition: Globals.cpp:586
llvm::GlobalValue::isDSOLocal
bool isDSOLocal() const
Definition: GlobalValue.h:301
llvm::GlobalIFunc
Definition: GlobalIFunc.h:34
llvm::GlobalValue::setVisibility
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:250
llvm::GlobalValue::Parent
Module * Parent
Definition: GlobalValue.h:179
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::GlobalIFunc::eraseFromParent
void eraseFromParent()
This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:582
llvm::GlobalAlias::removeFromParent
void removeFromParent()
removeFromParent - This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:539
llvm::GlobalAlias::setAliasee
void setAliasee(Constant *Aliasee)
These methods retrieve and set alias target.
Definition: Globals.cpp:547
llvm::GlobalVariable::setInitializer
void setInitializer(Constant *InitVal)
setInitializer - Sets the initializer for this global variable, removing any existing initializer if ...
Definition: Globals.cpp:463