LLVM  14.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/SmallPtrSet.h"
16 #include "llvm/ADT/Triple.h"
17 #include "llvm/IR/ConstantRange.h"
18 #include "llvm/IR/Constants.h"
19 #include "llvm/IR/DerivedTypes.h"
20 #include "llvm/IR/GlobalAlias.h"
21 #include "llvm/IR/GlobalValue.h"
22 #include "llvm/IR/GlobalVariable.h"
23 #include "llvm/IR/Module.h"
24 #include "llvm/IR/Operator.h"
25 #include "llvm/Support/Error.h"
27 using namespace llvm;
28 
29 //===----------------------------------------------------------------------===//
30 // GlobalValue Class
31 //===----------------------------------------------------------------------===//
32 
33 // GlobalValue should be a Constant, plus a type, a module, some flags, and an
34 // intrinsic ID. Add an assert to prevent people from accidentally growing
35 // GlobalValue while adding flags.
36 static_assert(sizeof(GlobalValue) ==
37  sizeof(Constant) + 2 * sizeof(void *) + 2 * sizeof(unsigned),
38  "unexpected GlobalValue size growth");
39 
40 // GlobalObject adds a comdat.
41 static_assert(sizeof(GlobalObject) == sizeof(GlobalValue) + sizeof(void *),
42  "unexpected GlobalObject size growth");
43 
45  if (const Function *F = dyn_cast<Function>(this))
46  return F->isMaterializable();
47  return false;
48 }
50  return getParent()->materialize(this);
51 }
52 
53 /// Override destroyConstantImpl to make sure it doesn't get called on
54 /// GlobalValue's because they shouldn't be treated like other constants.
55 void GlobalValue::destroyConstantImpl() {
56  llvm_unreachable("You can't GV->destroyConstantImpl()!");
57 }
58 
59 Value *GlobalValue::handleOperandChangeImpl(Value *From, Value *To) {
60  llvm_unreachable("Unsupported class for handleOperandChange()!");
61 }
62 
63 /// copyAttributesFrom - copy all additional attributes (those not needed to
64 /// create a GlobalValue) from the GlobalValue Src to this one.
66  setVisibility(Src->getVisibility());
67  setUnnamedAddr(Src->getUnnamedAddr());
68  setThreadLocalMode(Src->getThreadLocalMode());
69  setDLLStorageClass(Src->getDLLStorageClass());
70  setDSOLocal(Src->isDSOLocal());
71  setPartition(Src->getPartition());
72 }
73 
75  switch (getValueID()) {
76 #define HANDLE_GLOBAL_VALUE(NAME) \
77  case Value::NAME##Val: \
78  return static_cast<NAME *>(this)->removeFromParent();
79 #include "llvm/IR/Value.def"
80  default:
81  break;
82  }
83  llvm_unreachable("not a global");
84 }
85 
87  switch (getValueID()) {
88 #define HANDLE_GLOBAL_VALUE(NAME) \
89  case Value::NAME##Val: \
90  return static_cast<NAME *>(this)->eraseFromParent();
91 #include "llvm/IR/Value.def"
92  default:
93  break;
94  }
95  llvm_unreachable("not a global");
96 }
97 
99 
102  return true;
103  return getParent() && getParent()->getSemanticInterposition() &&
104  !isDSOLocal();
105 }
106 
108  // See AsmPrinter::getSymbolPreferLocal(). For a deduplicate comdat kind,
109  // references to a discarded local symbol from outside the group are not
110  // allowed, so avoid the local alias.
111  auto isDeduplicateComdat = [](const Comdat *C) {
112  return C && C->getSelectionKind() != Comdat::NoDeduplicate;
113  };
114  return hasDefaultVisibility() &&
116  !isa<GlobalIFunc>(this) && !isDeduplicateComdat(getComdat());
117 }
118 
120  PointerType *PtrTy = getType();
121  return PtrTy->getAddressSpace();
122 }
123 
125  assert((!Align || *Align <= MaximumAlignment) &&
126  "Alignment is greater than MaximumAlignment!");
127  unsigned AlignmentData = encode(Align);
128  unsigned OldData = getGlobalValueSubClassData();
129  setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData);
131  "Alignment representation error!");
132 }
133 
136  setAlignment(Src->getAlign());
137  setSection(Src->getSection());
138 }
139 
142  StringRef FileName) {
143 
144  // Value names may be prefixed with a binary '1' to indicate
145  // that the backend should not modify the symbols due to any platform
146  // naming convention. Do not include that '1' in the PGO profile name.
147  if (Name[0] == '\1')
148  Name = Name.substr(1);
149 
150  std::string NewName = std::string(Name);
152  // For local symbols, prepend the main file name to distinguish them.
153  // Do not include the full path in the file name since there's no guarantee
154  // that it will stay the same, e.g., if the files are checked out from
155  // version control in different locations.
156  if (FileName.empty())
157  NewName = NewName.insert(0, "<unknown>:");
158  else
159  NewName = NewName.insert(0, FileName.str() + ":");
160  }
161  return NewName;
162 }
163 
164 std::string GlobalValue::getGlobalIdentifier() const {
166  getParent()->getSourceFileName());
167 }
168 
170  if (auto *GA = dyn_cast<GlobalAlias>(this)) {
171  // In general we cannot compute this at the IR level, but we try.
172  if (const GlobalObject *GO = GA->getAliaseeObject())
173  return GO->getSection();
174  return "";
175  }
176  return cast<GlobalObject>(this)->getSection();
177 }
178 
180  if (auto *GA = dyn_cast<GlobalAlias>(this)) {
181  // In general we cannot compute this at the IR level, but we try.
182  if (const GlobalObject *GO = GA->getAliaseeObject())
183  return const_cast<GlobalObject *>(GO)->getComdat();
184  return nullptr;
185  }
186  // ifunc and its resolver are separate things so don't use resolver comdat.
187  if (isa<GlobalIFunc>(this))
188  return nullptr;
189  return cast<GlobalObject>(this)->getComdat();
190 }
191 
193  if (ObjComdat)
194  ObjComdat->removeUser(this);
195  ObjComdat = C;
196  if (C)
197  C->addUser(this);
198 }
199 
201  if (!hasPartition())
202  return "";
203  return getContext().pImpl->GlobalValuePartitions[this];
204 }
205 
207  // Do nothing if we're clearing the partition and it is already empty.
208  if (!hasPartition() && S.empty())
209  return;
210 
211  // Get or create a stable partition name string and put it in the table in the
212  // context.
213  if (!S.empty())
214  S = getContext().pImpl->Saver.save(S);
216 
217  // Update the HasPartition field. Setting the partition to the empty string
218  // means this global no longer has a partition.
219  HasPartition = !S.empty();
220 }
221 
222 StringRef GlobalObject::getSectionImpl() const {
223  assert(hasSection());
224  return getContext().pImpl->GlobalObjectSections[this];
225 }
226 
228  // Do nothing if we're clearing the section and it is already empty.
229  if (!hasSection() && S.empty())
230  return;
231 
232  // Get or create a stable section name string and put it in the table in the
233  // context.
234  if (!S.empty())
235  S = getContext().pImpl->Saver.save(S);
237 
238  // Update the HasSectionHashEntryBit. Setting the section to the empty string
239  // means this global no longer has a section.
240  setGlobalObjectFlag(HasSectionHashEntryBit, !S.empty());
241 }
242 
244  // Globals are definitions if they have an initializer.
245  if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(this))
246  return GV->getNumOperands() == 0;
247 
248  // Functions are definitions if they have a body.
249  if (const Function *F = dyn_cast<Function>(this))
250  return F->empty() && !F->isMaterializable();
251 
252  // Aliases and ifuncs are always definitions.
253  assert(isa<GlobalAlias>(this) || isa<GlobalIFunc>(this));
254  return false;
255 }
256 
258  // Firstly, can only increase the alignment of a global if it
259  // is a strong definition.
261  return false;
262 
263  // It also has to either not have a section defined, or, not have
264  // alignment specified. (If it is assigned a section, the global
265  // could be densely packed with other objects in the section, and
266  // increasing the alignment could cause padding issues.)
267  if (hasSection() && getAlign().hasValue())
268  return false;
269 
270  // On ELF platforms, we're further restricted in that we can't
271  // increase the alignment of any variable which might be emitted
272  // into a shared library, and which is exported. If the main
273  // executable accesses a variable found in a shared-lib, the main
274  // exe actually allocates memory for and exports the symbol ITSELF,
275  // overriding the symbol found in the library. That is, at link
276  // time, the observed alignment of the variable is copied into the
277  // executable binary. (A COPY relocation is also generated, to copy
278  // the initial data from the shadowed variable in the shared-lib
279  // into the location in the main binary, before running code.)
280  //
281  // And thus, even though you might think you are defining the
282  // global, and allocating the memory for the global in your object
283  // file, and thus should be able to set the alignment arbitrarily,
284  // that's not actually true. Doing so can cause an ABI breakage; an
285  // executable might have already been built with the previous
286  // alignment of the variable, and then assuming an increased
287  // alignment will be incorrect.
288 
289  // Conservatively assume ELF if there's no parent pointer.
290  bool isELF =
292  if (isELF && !isDSOLocal())
293  return false;
294 
295  return true;
296 }
297 
298 static const GlobalObject *
300  if (auto *GO = dyn_cast<GlobalObject>(C))
301  return GO;
302  if (auto *GA = dyn_cast<GlobalAlias>(C))
303  if (Aliases.insert(GA).second)
304  return findBaseObject(GA->getOperand(0), Aliases);
305  if (auto *CE = dyn_cast<ConstantExpr>(C)) {
306  switch (CE->getOpcode()) {
307  case Instruction::Add: {
308  auto *LHS = findBaseObject(CE->getOperand(0), Aliases);
309  auto *RHS = findBaseObject(CE->getOperand(1), Aliases);
310  if (LHS && RHS)
311  return nullptr;
312  return LHS ? LHS : RHS;
313  }
314  case Instruction::Sub: {
315  if (findBaseObject(CE->getOperand(1), Aliases))
316  return nullptr;
317  return findBaseObject(CE->getOperand(0), Aliases);
318  }
319  case Instruction::IntToPtr:
320  case Instruction::PtrToInt:
321  case Instruction::BitCast:
322  case Instruction::GetElementPtr:
323  return findBaseObject(CE->getOperand(0), Aliases);
324  default:
325  break;
326  }
327  }
328  return nullptr;
329 }
330 
333  return findBaseObject(this, Aliases);
334 }
335 
337  auto *GO = dyn_cast<GlobalObject>(this);
338  if (!GO)
339  return false;
340 
341  return GO->getMetadata(LLVMContext::MD_absolute_symbol);
342 }
343 
345  auto *GO = dyn_cast<GlobalObject>(this);
346  if (!GO)
347  return None;
348 
349  MDNode *MD = GO->getMetadata(LLVMContext::MD_absolute_symbol);
350  if (!MD)
351  return None;
352 
353  return getConstantRangeFromMetadata(*MD);
354 }
355 
357  if (!hasLinkOnceODRLinkage())
358  return false;
359 
360  // We assume that anyone who sets global unnamed_addr on a non-constant
361  // knows what they're doing.
362  if (hasGlobalUnnamedAddr())
363  return true;
364 
365  // If it is a non constant variable, it needs to be uniqued across shared
366  // objects.
367  if (auto *Var = dyn_cast<GlobalVariable>(this))
368  if (!Var->isConstant())
369  return false;
370 
372 }
373 
374 //===----------------------------------------------------------------------===//
375 // GlobalVariable Implementation
376 //===----------------------------------------------------------------------===//
377 
379  Constant *InitVal, const Twine &Name,
380  ThreadLocalMode TLMode, unsigned AddressSpace,
381  bool isExternallyInitialized)
382  : GlobalObject(Ty, Value::GlobalVariableVal,
383  OperandTraits<GlobalVariable>::op_begin(this),
384  InitVal != nullptr, Link, Name, AddressSpace),
385  isConstantGlobal(constant),
386  isExternallyInitializedConstant(isExternallyInitialized) {
388  "invalid type for global variable");
389  setThreadLocalMode(TLMode);
390  if (InitVal) {
391  assert(InitVal->getType() == Ty &&
392  "Initializer should be the same type as the GlobalVariable!");
393  Op<0>() = InitVal;
394  }
395 }
396 
398  LinkageTypes Link, Constant *InitVal,
399  const Twine &Name, GlobalVariable *Before,
400  ThreadLocalMode TLMode,
402  bool isExternallyInitialized)
403  : GlobalObject(Ty, Value::GlobalVariableVal,
404  OperandTraits<GlobalVariable>::op_begin(this),
405  InitVal != nullptr, Link, Name,
407  ? *AddressSpace
408  : M.getDataLayout().getDefaultGlobalsAddressSpace()),
409  isConstantGlobal(constant),
410  isExternallyInitializedConstant(isExternallyInitialized) {
412  "invalid type for global variable");
413  setThreadLocalMode(TLMode);
414  if (InitVal) {
415  assert(InitVal->getType() == Ty &&
416  "Initializer should be the same type as the GlobalVariable!");
417  Op<0>() = InitVal;
418  }
419 
420  if (Before)
421  Before->getParent()->getGlobalList().insert(Before->getIterator(), this);
422  else
423  M.getGlobalList().push_back(this);
424 }
425 
427  getParent()->getGlobalList().remove(getIterator());
428 }
429 
431  getParent()->getGlobalList().erase(getIterator());
432 }
433 
435  if (!InitVal) {
436  if (hasInitializer()) {
437  // Note, the num operands is used to compute the offset of the operand, so
438  // the order here matters. Clearing the operand then clearing the num
439  // operands ensures we have the correct offset to the operand.
440  Op<0>().set(nullptr);
442  }
443  } else {
444  assert(InitVal->getType() == getValueType() &&
445  "Initializer type must match GlobalVariable type");
446  // Note, the num operands is used to compute the offset of the operand, so
447  // the order here matters. We need to set num operands to 1 first so that
448  // we get the correct offset to the first operand when we set it.
449  if (!hasInitializer())
451  Op<0>().set(InitVal);
452  }
453 }
454 
455 /// Copy all additional attributes (those not needed to create a GlobalVariable)
456 /// from the GlobalVariable Src to this one.
459  setExternallyInitialized(Src->isExternallyInitialized());
460  setAttributes(Src->getAttributes());
461 }
462 
465  clearMetadata();
466 }
467 
468 //===----------------------------------------------------------------------===//
469 // GlobalAlias Implementation
470 //===----------------------------------------------------------------------===//
471 
472 GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
473  const Twine &Name, Constant *Aliasee,
474  Module *ParentModule)
475  : GlobalValue(Ty, Value::GlobalAliasVal, &Op<0>(), 1, Link, Name,
476  AddressSpace) {
477  setAliasee(Aliasee);
478  if (ParentModule)
479  ParentModule->getAliasList().push_back(this);
480 }
481 
483  LinkageTypes Link, const Twine &Name,
484  Constant *Aliasee, Module *ParentModule) {
485  return new GlobalAlias(Ty, AddressSpace, Link, Name, Aliasee, ParentModule);
486 }
487 
489  LinkageTypes Linkage, const Twine &Name,
490  Module *Parent) {
491  return create(Ty, AddressSpace, Linkage, Name, nullptr, Parent);
492 }
493 
495  LinkageTypes Linkage, const Twine &Name,
496  GlobalValue *Aliasee) {
497  return create(Ty, AddressSpace, Linkage, Name, Aliasee, Aliasee->getParent());
498 }
499 
501  GlobalValue *Aliasee) {
502  return create(Aliasee->getValueType(), Aliasee->getAddressSpace(), Link, Name,
503  Aliasee);
504 }
505 
507  return create(Aliasee->getLinkage(), Name, Aliasee);
508 }
509 
511  getParent()->getAliasList().remove(getIterator());
512 }
513 
515  getParent()->getAliasList().erase(getIterator());
516 }
517 
519  assert((!Aliasee || Aliasee->getType() == getType()) &&
520  "Alias and aliasee types should match!");
521  Op<0>().set(Aliasee);
522 }
523 
526  return findBaseObject(getOperand(0), Aliases);
527 }
528 
529 //===----------------------------------------------------------------------===//
530 // GlobalIFunc Implementation
531 //===----------------------------------------------------------------------===//
532 
533 GlobalIFunc::GlobalIFunc(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
534  const Twine &Name, Constant *Resolver,
535  Module *ParentModule)
536  : GlobalObject(Ty, Value::GlobalIFuncVal, &Op<0>(), 1, Link, Name,
537  AddressSpace) {
538  setResolver(Resolver);
539  if (ParentModule)
540  ParentModule->getIFuncList().push_back(this);
541 }
542 
544  LinkageTypes Link, const Twine &Name,
545  Constant *Resolver, Module *ParentModule) {
546  return new GlobalIFunc(Ty, AddressSpace, Link, Name, Resolver, ParentModule);
547 }
548 
550  getParent()->getIFuncList().remove(getIterator());
551 }
552 
554  getParent()->getIFuncList().erase(getIterator());
555 }
556 
559  return dyn_cast<Function>(findBaseObject(getResolver(), Aliases));
560 }
llvm::GlobalVariable::setExternallyInitialized
void setExternallyInitialized(bool Val)
Definition: GlobalVariable.h:158
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:430
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:192
llvm::GlobalValue::removeFromParent
void removeFromParent()
This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:74
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:23
llvm::PointerType::isValidElementType
static bool isValidElementType(Type *ElemTy)
Return true if the specified type is valid as a element type.
Definition: Type.cpp:780
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:98
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:164
llvm::Value::MaximumAlignment
static constexpr uint64_t MaximumAlignment
Definition: Value.h:793
llvm::GlobalVariable::copyAttributesFrom
void copyAttributesFrom(const GlobalVariable *Src)
copyAttributesFrom - copy all additional attributes (those not needed to create a GlobalVariable) fro...
Definition: Globals.cpp:457
llvm::GlobalValue::getLinkage
LinkageTypes getLinkage() const
Definition: GlobalValue.h:467
llvm::Function
Definition: Function.h:62
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:80
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:332
llvm::GlobalValue::materialize
Error materialize()
Make sure this GlobalValue is fully read.
Definition: Globals.cpp:49
ErrorHandling.h
llvm::GlobalVariable
Definition: GlobalVariable.h:39
llvm::PointerType::getAddressSpace
unsigned getAddressSpace() const
Return the address space of the Pointer type.
Definition: DerivedTypes.h:687
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:248
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
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::Optional
Definition: APInt.h:33
Operator.h
llvm::codeview::Link
@ Link
Definition: CodeView.h:154
llvm::GlobalValue::setUnnamedAddr
void setUnnamedAddr(UnnamedAddr Val)
Definition: GlobalValue.h:212
RHS
Value * RHS
Definition: X86PartialReduction.cpp:74
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:1777
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:545
llvm::GlobalValue::setDSOLocal
void setDSOLocal(bool Local)
Definition: GlobalValue.h:280
llvm::LLVMContextImpl::GlobalValuePartitions
DenseMap< const GlobalValue *, StringRef > GlobalValuePartitions
Collection of per-GlobalValue partitions used in this context.
Definition: LLVMContextImpl.h:1478
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:169
llvm::Resolver
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:2012
LHS
Value * LHS
Definition: X86PartialReduction.cpp:73
llvm::Triple::isOSBinFormatELF
bool isOSBinFormatELF() const
Tests whether the OS uses the ELF binary format.
Definition: Triple.h:616
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:243
Constants.h
llvm::GlobalObject::setSection
void setSection(StringRef S)
Change the section for this global.
Definition: Globals.cpp:227
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::GlobalObject
Definition: GlobalObject.h:27
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:65
llvm::GlobalValue::hasAtLeastLocalUnnamedAddr
bool hasAtLeastLocalUnnamedAddr() const
Returns true if this value's address is not significant in this module.
Definition: GlobalValue.h:205
llvm::MaybeAlign
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:109
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:562
LLVMContextImpl.h
findBaseObject
static const GlobalObject * findBaseObject(const Constant *C, DenseSet< const GlobalAlias * > &Aliases)
Definition: Globals.cpp:299
llvm::encode
unsigned encode(MaybeAlign A)
Returns a representation of the alignment that encodes undefined as 0.
Definition: Alignment.h:232
llvm::GlobalIFunc::removeFromParent
void removeFromParent()
This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:549
SmallPtrSet.h
llvm::GlobalValue::hasGlobalUnnamedAddr
bool hasGlobalUnnamedAddr() const
Definition: GlobalValue.h:196
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:208
llvm::AddressSpace
AddressSpace
Definition: NVPTXBaseInfo.h:21
llvm::StringRef::str
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:244
llvm::None
const NoneType None
Definition: None.h:23
llvm::GlobalValue::hasDefaultVisibility
bool hasDefaultVisibility() const
Definition: GlobalValue.h:230
llvm::GlobalVariable::dropAllReferences
void dropAllReferences()
Drop all references in preparation to destroy the GlobalVariable.
Definition: Globals.cpp:463
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:104
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::GlobalValue::canBenefitFromLocalAlias
bool canBenefitFromLocalAlias() const
Definition: Globals.cpp:107
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::StringRef::empty
constexpr LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:152
llvm::GlobalObject::canIncreaseAlignment
bool canIncreaseAlignment() const
Returns true if the alignment of the value can be unilaterally increased.
Definition: Globals.cpp:257
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:578
llvm::LLVMContextImpl::GlobalObjectSections
DenseMap< const GlobalObject *, StringRef > GlobalObjectSections
Collection of per-GlobalObject sections used in this context.
Definition: LLVMContextImpl.h:1475
llvm::GlobalValue::getPartition
StringRef getPartition() const
Definition: Globals.cpp:200
llvm::GlobalObject::HasSectionHashEntryBit
@ HasSectionHashEntryBit
Definition: GlobalObject.h:55
llvm::PointerType
Class to represent pointers.
Definition: DerivedTypes.h:632
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:299
llvm::UniqueStringSaver::save
StringRef save(const char *S)
Definition: StringSaver.h:50
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:906
llvm::Value::clearMetadata
void clearMetadata()
Erase all metadata attached to this Value.
Definition: Metadata.cpp:1291
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:44
llvm::GlobalValue::canBeOmittedFromSymbolTable
bool canBeOmittedFromSymbolTable() const
True if GV can be left out of the object symbol table.
Definition: Globals.cpp:356
llvm::GlobalValue::getGlobalValueSubClassData
unsigned getGlobalValueSubClassData() const
Definition: GlobalValue.h:158
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
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:134
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:265
llvm::Value::getContext
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:991
llvm::ilist_node_impl::getIterator
self_iterator getIterator()
Definition: ilist_node.h:81
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:331
llvm::Value::getName
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
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:543
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:378
llvm::GlobalValue::eraseFromParent
void eraseFromParent()
This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:86
llvm::GlobalObject::getAlignment
uint64_t getAlignment() const
FIXME: Remove this function once transition to Align is over.
Definition: GlobalObject.h:71
llvm::GlobalValue::isStrongDefinitionForLinker
bool isStrongDefinitionForLinker() const
Returns true if this global's definition will be the one chosen by the linker.
Definition: GlobalValue.h:553
llvm::Module::getSemanticInterposition
bool getSemanticInterposition() const
Returns whether semantic interposition is to be respected.
Definition: Module.cpp:649
llvm::Module::materialize
llvm::Error materialize(GlobalValue *GV)
Make sure the GlobalValue is fully read.
Definition: Module.cpp:442
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:100
llvm::Module::getIFuncList
const IFuncListType & getIFuncList() const
Get the Module's list of ifuncs (constant).
Definition: Module.h:571
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::GlobalValue::hasLinkOnceODRLinkage
bool hasLinkOnceODRLinkage() const
Definition: GlobalValue.h:442
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::GlobalValue::ThreadLocalMode
ThreadLocalMode
Definition: GlobalValue.h:178
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:482
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:348
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:325
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
GlobalVariable.h
llvm::GlobalValue::getComdat
const Comdat * getComdat() const
Definition: Globals.cpp:179
llvm::MCID::Add
@ Add
Definition: MCInstrDesc.h:183
GlobalAlias.h
llvm::GlobalValue::getAddressSpace
unsigned getAddressSpace() const
Definition: Globals.cpp:119
llvm::GlobalValue::setGlobalValueSubClassData
void setGlobalValueSubClassData(unsigned V)
Definition: GlobalValue.h:161
llvm::GlobalValue::isAbsoluteSymbolRef
bool isAbsoluteSymbolRef() const
Returns whether this is a reference to an absolute symbol.
Definition: Globals.cpp:336
llvm::GlobalValue::getAbsoluteSymbolRange
Optional< ConstantRange > getAbsoluteSymbolRange() const
If this is an absolute symbol reference, returns the range of the symbol, otherwise returns None.
Definition: Globals.cpp:344
llvm::GlobalAlias::getAliaseeObject
const GlobalObject * getAliaseeObject() const
Definition: Globals.cpp:524
llvm::LLVMContextImpl::Saver
UniqueStringSaver Saver
Definition: LLVMContextImpl.h:1446
llvm::Module::getTargetTriple
const std::string & getTargetTriple() const
Get the target triple which is a string describing the target host.
Definition: Module.h:255
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:134
llvm::GlobalValue::setPartition
void setPartition(StringRef Part)
Definition: Globals.cpp:206
llvm::GlobalValue::getType
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:271
DerivedTypes.h
llvm::GlobalValue::getValueType
Type * getValueType() const
Definition: GlobalValue.h:273
llvm::GlobalValue::hasPartition
bool hasPartition() const
Definition: GlobalValue.h:286
llvm::GlobalObject::ObjComdat
Comdat * ObjComdat
Definition: GlobalObject.h:52
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:514
llvm::User::getOperand
Value * getOperand(unsigned i) const
Definition: User.h:169
llvm::GlobalObject::setAlignment
void setAlignment(MaybeAlign Align)
Definition: Globals.cpp:124
llvm::GlobalVariable::removeFromParent
void removeFromParent()
removeFromParent - This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:426
llvm::GlobalIFunc::getResolverFunction
const Function * getResolverFunction() const
Definition: Globals.cpp:557
llvm::GlobalValue::isDSOLocal
bool isDSOLocal() const
Definition: GlobalValue.h:282
llvm::GlobalIFunc
Definition: GlobalIFunc.h:34
llvm::GlobalValue::setVisibility
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:235
llvm::GlobalValue::Parent
Module * Parent
Definition: GlobalValue.h:166
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:553
llvm::GlobalAlias::removeFromParent
void removeFromParent()
removeFromParent - This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:510
llvm::GlobalAlias::setAliasee
void setAliasee(Constant *Aliasee)
These methods retrieve and set alias target.
Definition: Globals.cpp:518
llvm::GlobalVariable::setInitializer
void setInitializer(Constant *InitVal)
setInitializer - Sets the initializer for this global variable, removing any existing initializer if ...
Definition: Globals.cpp:434