LLVM  15.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 }
71 
73  switch (getValueID()) {
74 #define HANDLE_GLOBAL_VALUE(NAME) \
75  case Value::NAME##Val: \
76  return static_cast<NAME *>(this)->removeFromParent();
77 #include "llvm/IR/Value.def"
78  default:
79  break;
80  }
81  llvm_unreachable("not a global");
82 }
83 
85  switch (getValueID()) {
86 #define HANDLE_GLOBAL_VALUE(NAME) \
87  case Value::NAME##Val: \
88  return static_cast<NAME *>(this)->eraseFromParent();
89 #include "llvm/IR/Value.def"
90  default:
91  break;
92  }
93  llvm_unreachable("not a global");
94 }
95 
97 
100  return true;
101  return getParent() && getParent()->getSemanticInterposition() &&
102  !isDSOLocal();
103 }
104 
106  // See AsmPrinter::getSymbolPreferLocal(). For a deduplicate comdat kind,
107  // references to a discarded local symbol from outside the group are not
108  // allowed, so avoid the local alias.
109  auto isDeduplicateComdat = [](const Comdat *C) {
110  return C && C->getSelectionKind() != Comdat::NoDeduplicate;
111  };
112  return hasDefaultVisibility() &&
114  !isa<GlobalIFunc>(this) && !isDeduplicateComdat(getComdat());
115 }
116 
118  PointerType *PtrTy = getType();
119  return PtrTy->getAddressSpace();
120 }
121 
123  assert((!Align || *Align <= MaximumAlignment) &&
124  "Alignment is greater than MaximumAlignment!");
125  unsigned AlignmentData = encode(Align);
126  unsigned OldData = getGlobalValueSubClassData();
127  setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData);
129  "Alignment representation error!");
130 }
131 
134  setAlignment(Src->getAlign());
135  setSection(Src->getSection());
136 }
137 
140  StringRef FileName) {
141 
142  // Value names may be prefixed with a binary '1' to indicate
143  // that the backend should not modify the symbols due to any platform
144  // naming convention. Do not include that '1' in the PGO profile name.
145  if (Name[0] == '\1')
146  Name = Name.substr(1);
147 
148  std::string NewName = std::string(Name);
150  // For local symbols, prepend the main file name to distinguish them.
151  // Do not include the full path in the file name since there's no guarantee
152  // that it will stay the same, e.g., if the files are checked out from
153  // version control in different locations.
154  if (FileName.empty())
155  NewName = NewName.insert(0, "<unknown>:");
156  else
157  NewName = NewName.insert(0, FileName.str() + ":");
158  }
159  return NewName;
160 }
161 
162 std::string GlobalValue::getGlobalIdentifier() const {
164  getParent()->getSourceFileName());
165 }
166 
168  if (auto *GA = dyn_cast<GlobalAlias>(this)) {
169  // In general we cannot compute this at the IR level, but we try.
170  if (const GlobalObject *GO = GA->getAliaseeObject())
171  return GO->getSection();
172  return "";
173  }
174  return cast<GlobalObject>(this)->getSection();
175 }
176 
178  if (auto *GA = dyn_cast<GlobalAlias>(this)) {
179  // In general we cannot compute this at the IR level, but we try.
180  if (const GlobalObject *GO = GA->getAliaseeObject())
181  return const_cast<GlobalObject *>(GO)->getComdat();
182  return nullptr;
183  }
184  // ifunc and its resolver are separate things so don't use resolver comdat.
185  if (isa<GlobalIFunc>(this))
186  return nullptr;
187  return cast<GlobalObject>(this)->getComdat();
188 }
189 
191  if (ObjComdat)
192  ObjComdat->removeUser(this);
193  ObjComdat = C;
194  if (C)
195  C->addUser(this);
196 }
197 
199  if (!hasPartition())
200  return "";
201  return getContext().pImpl->GlobalValuePartitions[this];
202 }
203 
205  // Do nothing if we're clearing the partition and it is already empty.
206  if (!hasPartition() && S.empty())
207  return;
208 
209  // Get or create a stable partition name string and put it in the table in the
210  // context.
211  if (!S.empty())
212  S = getContext().pImpl->Saver.save(S);
214 
215  // Update the HasPartition field. Setting the partition to the empty string
216  // means this global no longer has a partition.
217  HasPartition = !S.empty();
218 }
219 
220 StringRef GlobalObject::getSectionImpl() const {
221  assert(hasSection());
222  return getContext().pImpl->GlobalObjectSections[this];
223 }
224 
226  // Do nothing if we're clearing the section and it is already empty.
227  if (!hasSection() && S.empty())
228  return;
229 
230  // Get or create a stable section name string and put it in the table in the
231  // context.
232  if (!S.empty())
233  S = getContext().pImpl->Saver.save(S);
235 
236  // Update the HasSectionHashEntryBit. Setting the section to the empty string
237  // means this global no longer has a section.
238  setGlobalObjectFlag(HasSectionHashEntryBit, !S.empty());
239 }
240 
242  // Globals are definitions if they have an initializer.
243  if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(this))
244  return GV->getNumOperands() == 0;
245 
246  // Functions are definitions if they have a body.
247  if (const Function *F = dyn_cast<Function>(this))
248  return F->empty() && !F->isMaterializable();
249 
250  // Aliases and ifuncs are always definitions.
251  assert(isa<GlobalAlias>(this) || isa<GlobalIFunc>(this));
252  return false;
253 }
254 
256  // Firstly, can only increase the alignment of a global if it
257  // is a strong definition.
259  return false;
260 
261  // It also has to either not have a section defined, or, not have
262  // alignment specified. (If it is assigned a section, the global
263  // could be densely packed with other objects in the section, and
264  // increasing the alignment could cause padding issues.)
265  if (hasSection() && getAlign().hasValue())
266  return false;
267 
268  // On ELF platforms, we're further restricted in that we can't
269  // increase the alignment of any variable which might be emitted
270  // into a shared library, and which is exported. If the main
271  // executable accesses a variable found in a shared-lib, the main
272  // exe actually allocates memory for and exports the symbol ITSELF,
273  // overriding the symbol found in the library. That is, at link
274  // time, the observed alignment of the variable is copied into the
275  // executable binary. (A COPY relocation is also generated, to copy
276  // the initial data from the shadowed variable in the shared-lib
277  // into the location in the main binary, before running code.)
278  //
279  // And thus, even though you might think you are defining the
280  // global, and allocating the memory for the global in your object
281  // file, and thus should be able to set the alignment arbitrarily,
282  // that's not actually true. Doing so can cause an ABI breakage; an
283  // executable might have already been built with the previous
284  // alignment of the variable, and then assuming an increased
285  // alignment will be incorrect.
286 
287  // Conservatively assume ELF if there's no parent pointer.
288  bool isELF =
290  if (isELF && !isDSOLocal())
291  return false;
292 
293  return true;
294 }
295 
296 static const GlobalObject *
298  if (auto *GO = dyn_cast<GlobalObject>(C))
299  return GO;
300  if (auto *GA = dyn_cast<GlobalAlias>(C))
301  if (Aliases.insert(GA).second)
302  return findBaseObject(GA->getOperand(0), Aliases);
303  if (auto *CE = dyn_cast<ConstantExpr>(C)) {
304  switch (CE->getOpcode()) {
305  case Instruction::Add: {
306  auto *LHS = findBaseObject(CE->getOperand(0), Aliases);
307  auto *RHS = findBaseObject(CE->getOperand(1), Aliases);
308  if (LHS && RHS)
309  return nullptr;
310  return LHS ? LHS : RHS;
311  }
312  case Instruction::Sub: {
313  if (findBaseObject(CE->getOperand(1), Aliases))
314  return nullptr;
315  return findBaseObject(CE->getOperand(0), Aliases);
316  }
317  case Instruction::IntToPtr:
318  case Instruction::PtrToInt:
319  case Instruction::BitCast:
320  case Instruction::GetElementPtr:
321  return findBaseObject(CE->getOperand(0), Aliases);
322  default:
323  break;
324  }
325  }
326  return nullptr;
327 }
328 
331  return findBaseObject(this, Aliases);
332 }
333 
335  auto *GO = dyn_cast<GlobalObject>(this);
336  if (!GO)
337  return false;
338 
339  return GO->getMetadata(LLVMContext::MD_absolute_symbol);
340 }
341 
343  auto *GO = dyn_cast<GlobalObject>(this);
344  if (!GO)
345  return None;
346 
347  MDNode *MD = GO->getMetadata(LLVMContext::MD_absolute_symbol);
348  if (!MD)
349  return None;
350 
351  return getConstantRangeFromMetadata(*MD);
352 }
353 
355  if (!hasLinkOnceODRLinkage())
356  return false;
357 
358  // We assume that anyone who sets global unnamed_addr on a non-constant
359  // knows what they're doing.
360  if (hasGlobalUnnamedAddr())
361  return true;
362 
363  // If it is a non constant variable, it needs to be uniqued across shared
364  // objects.
365  if (auto *Var = dyn_cast<GlobalVariable>(this))
366  if (!Var->isConstant())
367  return false;
368 
370 }
371 
372 //===----------------------------------------------------------------------===//
373 // GlobalVariable Implementation
374 //===----------------------------------------------------------------------===//
375 
377  Constant *InitVal, const Twine &Name,
378  ThreadLocalMode TLMode, unsigned AddressSpace,
379  bool isExternallyInitialized)
380  : GlobalObject(Ty, Value::GlobalVariableVal,
381  OperandTraits<GlobalVariable>::op_begin(this),
382  InitVal != nullptr, Link, Name, AddressSpace),
383  isConstantGlobal(constant),
384  isExternallyInitializedConstant(isExternallyInitialized) {
386  "invalid type for global variable");
387  setThreadLocalMode(TLMode);
388  if (InitVal) {
389  assert(InitVal->getType() == Ty &&
390  "Initializer should be the same type as the GlobalVariable!");
391  Op<0>() = InitVal;
392  }
393 }
394 
396  LinkageTypes Link, Constant *InitVal,
397  const Twine &Name, GlobalVariable *Before,
398  ThreadLocalMode TLMode,
400  bool isExternallyInitialized)
401  : GlobalObject(Ty, Value::GlobalVariableVal,
402  OperandTraits<GlobalVariable>::op_begin(this),
403  InitVal != nullptr, Link, Name,
405  ? *AddressSpace
406  : M.getDataLayout().getDefaultGlobalsAddressSpace()),
407  isConstantGlobal(constant),
408  isExternallyInitializedConstant(isExternallyInitialized) {
410  "invalid type for global variable");
411  setThreadLocalMode(TLMode);
412  if (InitVal) {
413  assert(InitVal->getType() == Ty &&
414  "Initializer should be the same type as the GlobalVariable!");
415  Op<0>() = InitVal;
416  }
417 
418  if (Before)
419  Before->getParent()->getGlobalList().insert(Before->getIterator(), this);
420  else
421  M.getGlobalList().push_back(this);
422 }
423 
425  getParent()->getGlobalList().remove(getIterator());
426 }
427 
429  getParent()->getGlobalList().erase(getIterator());
430 }
431 
433  if (!InitVal) {
434  if (hasInitializer()) {
435  // Note, the num operands is used to compute the offset of the operand, so
436  // the order here matters. Clearing the operand then clearing the num
437  // operands ensures we have the correct offset to the operand.
438  Op<0>().set(nullptr);
440  }
441  } else {
442  assert(InitVal->getType() == getValueType() &&
443  "Initializer type must match GlobalVariable type");
444  // Note, the num operands is used to compute the offset of the operand, so
445  // the order here matters. We need to set num operands to 1 first so that
446  // we get the correct offset to the first operand when we set it.
447  if (!hasInitializer())
449  Op<0>().set(InitVal);
450  }
451 }
452 
453 /// Copy all additional attributes (those not needed to create a GlobalVariable)
454 /// from the GlobalVariable Src to this one.
457  setExternallyInitialized(Src->isExternallyInitialized());
458  setAttributes(Src->getAttributes());
459 }
460 
463  clearMetadata();
464 }
465 
466 //===----------------------------------------------------------------------===//
467 // GlobalAlias Implementation
468 //===----------------------------------------------------------------------===//
469 
470 GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
471  const Twine &Name, Constant *Aliasee,
472  Module *ParentModule)
473  : GlobalValue(Ty, Value::GlobalAliasVal, &Op<0>(), 1, Link, Name,
474  AddressSpace) {
475  setAliasee(Aliasee);
476  if (ParentModule)
477  ParentModule->getAliasList().push_back(this);
478 }
479 
481  LinkageTypes Link, const Twine &Name,
482  Constant *Aliasee, Module *ParentModule) {
483  return new GlobalAlias(Ty, AddressSpace, Link, Name, Aliasee, ParentModule);
484 }
485 
487  LinkageTypes Linkage, const Twine &Name,
488  Module *Parent) {
489  return create(Ty, AddressSpace, Linkage, Name, nullptr, Parent);
490 }
491 
493  LinkageTypes Linkage, const Twine &Name,
494  GlobalValue *Aliasee) {
495  return create(Ty, AddressSpace, Linkage, Name, Aliasee, Aliasee->getParent());
496 }
497 
499  GlobalValue *Aliasee) {
500  return create(Aliasee->getValueType(), Aliasee->getAddressSpace(), Link, Name,
501  Aliasee);
502 }
503 
505  return create(Aliasee->getLinkage(), Name, Aliasee);
506 }
507 
509  getParent()->getAliasList().remove(getIterator());
510 }
511 
513  getParent()->getAliasList().erase(getIterator());
514 }
515 
517  assert((!Aliasee || Aliasee->getType() == getType()) &&
518  "Alias and aliasee types should match!");
519  Op<0>().set(Aliasee);
520 }
521 
524  return findBaseObject(getOperand(0), Aliases);
525 }
526 
527 //===----------------------------------------------------------------------===//
528 // GlobalIFunc Implementation
529 //===----------------------------------------------------------------------===//
530 
531 GlobalIFunc::GlobalIFunc(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
532  const Twine &Name, Constant *Resolver,
533  Module *ParentModule)
534  : GlobalObject(Ty, Value::GlobalIFuncVal, &Op<0>(), 1, Link, Name,
535  AddressSpace) {
536  setResolver(Resolver);
537  if (ParentModule)
538  ParentModule->getIFuncList().push_back(this);
539 }
540 
542  LinkageTypes Link, const Twine &Name,
543  Constant *Resolver, Module *ParentModule) {
544  return new GlobalIFunc(Ty, AddressSpace, Link, Name, Resolver, ParentModule);
545 }
546 
548  getParent()->getIFuncList().remove(getIterator());
549 }
550 
552  getParent()->getIFuncList().erase(getIterator());
553 }
554 
557  return dyn_cast<Function>(findBaseObject(getResolver(), Aliases));
558 }
llvm::GlobalVariable::setExternallyInitialized
void setExternallyInitialized(bool Val)
Definition: GlobalVariable.h:158
llvm::LLVMContext::pImpl
LLVMContextImpl *const pImpl
Definition: LLVMContext.h:70
llvm::GlobalVariable::eraseFromParent
void eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:428
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:190
llvm::GlobalValue::removeFromParent
void removeFromParent()
This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:72
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
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:96
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:162
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:455
llvm::GlobalValue::getLinkage
LinkageTypes getLinkage() const
Definition: GlobalValue.h:466
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:331
llvm::GlobalValue::materialize
Error materialize()
Make sure this GlobalValue is fully read.
Definition: Globals.cpp:47
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:682
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:112
Error.h
llvm::GlobalValue::setThreadLocalMode
void setThreadLocalMode(ThreadLocalMode Val)
Definition: GlobalValue.h:247
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
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::Optional
Definition: APInt.h:33
llvm::codeview::Link
@ Link
Definition: CodeView.h:154
llvm::GlobalValue::setUnnamedAddr
void setUnnamedAddr(UnnamedAddr Val)
Definition: GlobalValue.h:211
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:1797
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:279
llvm::LLVMContextImpl::GlobalValuePartitions
DenseMap< const GlobalValue *, StringRef > GlobalValuePartitions
Collection of per-GlobalValue partitions used in this context.
Definition: LLVMContextImpl.h:1504
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:167
llvm::Resolver
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:2052
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:656
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:241
Constants.h
llvm::GlobalObject::setSection
void setSection(StringRef S)
Change the section for this global.
Definition: Globals.cpp:225
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:63
llvm::GlobalValue::hasAtLeastLocalUnnamedAddr
bool hasAtLeastLocalUnnamedAddr() const
Returns true if this value's address is not significant in this module.
Definition: GlobalValue.h:204
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:567
LLVMContextImpl.h
findBaseObject
static const GlobalObject * findBaseObject(const Constant *C, DenseSet< const GlobalAlias * > &Aliases)
Definition: Globals.cpp:297
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:547
llvm::GlobalValue::hasGlobalUnnamedAddr
bool hasGlobalUnnamedAddr() const
Definition: GlobalValue.h:195
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:209
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:245
llvm::None
const NoneType None
Definition: None.h:24
llvm::GlobalValue::hasDefaultVisibility
bool hasDefaultVisibility() const
Definition: GlobalValue.h:229
llvm::GlobalVariable::dropAllReferences
void dropAllReferences()
Drop all references in preparation to destroy the GlobalVariable.
Definition: Globals.cpp:461
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:105
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:153
llvm::GlobalObject::canIncreaseAlignment
bool canIncreaseAlignment() const
Returns true if the alignment of the value can be unilaterally increased.
Definition: Globals.cpp:255
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:577
llvm::LLVMContextImpl::GlobalObjectSections
DenseMap< const GlobalObject *, StringRef > GlobalObjectSections
Collection of per-GlobalObject sections used in this context.
Definition: LLVMContextImpl.h:1501
llvm::GlobalValue::getPartition
StringRef getPartition() const
Definition: Globals.cpp:198
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:93
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::GlobalValue::isExternalLinkage
static bool isExternalLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:298
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:937
llvm::Value::clearMetadata
void clearMetadata()
Erase all metadata attached to this Value.
Definition: Metadata.cpp:1323
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:354
llvm::GlobalValue::getGlobalValueSubClassData
unsigned getGlobalValueSubClassData() const
Definition: GlobalValue.h:157
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
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:264
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: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:329
llvm::Value::getName
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:305
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:541
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:376
llvm::GlobalValue::eraseFromParent
void eraseFromParent()
This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:84
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:552
llvm::Module::getSemanticInterposition
bool getSemanticInterposition() const
Returns whether semantic interposition is to be respected.
Definition: Module.cpp:646
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:98
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:83
llvm::GlobalValue::hasLinkOnceODRLinkage
bool hasLinkOnceODRLinkage() const
Definition: GlobalValue.h:441
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
llvm::GlobalValue::ThreadLocalMode
ThreadLocalMode
Definition: GlobalValue.h:177
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:480
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:347
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:344
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:177
llvm::MCID::Add
@ Add
Definition: MCInstrDesc.h:185
GlobalAlias.h
llvm::GlobalValue::getAddressSpace
unsigned getAddressSpace() const
Definition: Globals.cpp:117
llvm::GlobalValue::setGlobalValueSubClassData
void setGlobalValueSubClassData(unsigned V)
Definition: GlobalValue.h:160
llvm::GlobalValue::isAbsoluteSymbolRef
bool isAbsoluteSymbolRef() const
Returns whether this is a reference to an absolute symbol.
Definition: Globals.cpp:334
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:342
llvm::GlobalAlias::getAliaseeObject
const GlobalObject * getAliaseeObject() const
Definition: Globals.cpp:522
llvm::LLVMContextImpl::Saver
UniqueStringSaver Saver
Definition: LLVMContextImpl.h:1472
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:132
llvm::GlobalValue::setPartition
void setPartition(StringRef Part)
Definition: Globals.cpp:204
llvm::GlobalValue::getType
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:270
DerivedTypes.h
llvm::GlobalValue::getValueType
Type * getValueType() const
Definition: GlobalValue.h:272
llvm::GlobalValue::hasPartition
bool hasPartition() const
Definition: GlobalValue.h:285
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:512
llvm::User::getOperand
Value * getOperand(unsigned i) const
Definition: User.h:169
llvm::GlobalObject::setAlignment
void setAlignment(MaybeAlign Align)
Definition: Globals.cpp:122
llvm::GlobalVariable::removeFromParent
void removeFromParent()
removeFromParent - This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:424
llvm::GlobalIFunc::getResolverFunction
const Function * getResolverFunction() const
Definition: Globals.cpp:555
llvm::GlobalValue::isDSOLocal
bool isDSOLocal() const
Definition: GlobalValue.h:281
llvm::GlobalIFunc
Definition: GlobalIFunc.h:34
llvm::GlobalValue::setVisibility
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:234
llvm::GlobalValue::Parent
Module * Parent
Definition: GlobalValue.h:165
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:551
llvm::GlobalAlias::removeFromParent
void removeFromParent()
removeFromParent - This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:508
llvm::GlobalAlias::setAliasee
void setAliasee(Constant *Aliasee)
These methods retrieve and set alias target.
Definition: Globals.cpp:516
llvm::GlobalVariable::setInitializer
void setInitializer(Constant *InitVal)
setInitializer - Sets the initializer for this global variable, removing any existing initializer if ...
Definition: Globals.cpp:432