LLVM 19.0.0git
Go to the documentation of this file.
1//===-- Globals.cpp - Implement the GlobalValue & GlobalVariable class ----===//
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
9// This file implements the GlobalValue & GlobalVariable classes for the IR
10// library.
14#include "LLVMContextImpl.h"
16#include "llvm/IR/Constants.h"
18#include "llvm/IR/GlobalAlias.h"
19#include "llvm/IR/GlobalValue.h"
21#include "llvm/IR/Module.h"
22#include "llvm/Support/Error.h"
24#include "llvm/Support/MD5.h"
26using namespace llvm;
29// GlobalValue Class
32// GlobalValue should be a Constant, plus a type, a module, some flags, and an
33// intrinsic ID. Add an assert to prevent people from accidentally growing
34// GlobalValue while adding flags.
35static_assert(sizeof(GlobalValue) ==
36 sizeof(Constant) + 2 * sizeof(void *) + 2 * sizeof(unsigned),
37 "unexpected GlobalValue size growth");
39// GlobalObject adds a comdat.
40static_assert(sizeof(GlobalObject) == sizeof(GlobalValue) + sizeof(void *),
41 "unexpected GlobalObject size growth");
44 if (const Function *F = dyn_cast<Function>(this))
45 return F->isMaterializable();
46 return false;
50/// Override destroyConstantImpl to make sure it doesn't get called on
51/// GlobalValue's because they shouldn't be treated like other constants.
52void GlobalValue::destroyConstantImpl() {
53 llvm_unreachable("You can't GV->destroyConstantImpl()!");
56Value *GlobalValue::handleOperandChangeImpl(Value *From, Value *To) {
57 llvm_unreachable("Unsupported class for handleOperandChange()!");
60/// copyAttributesFrom - copy all additional attributes (those not needed to
61/// create a GlobalValue) from the GlobalValue Src to this one.
63 setVisibility(Src->getVisibility());
64 setUnnamedAddr(Src->getUnnamedAddr());
65 setThreadLocalMode(Src->getThreadLocalMode());
66 setDLLStorageClass(Src->getDLLStorageClass());
67 setDSOLocal(Src->isDSOLocal());
68 setPartition(Src->getPartition());
69 if (Src->hasSanitizerMetadata())
70 setSanitizerMetadata(Src->getSanitizerMetadata());
71 else
76 return MD5Hash(GlobalName);
80 switch (getValueID()) {
82 case Value::NAME##Val: \
83 return static_cast<NAME *>(this)->removeFromParent();
84#include "llvm/IR/Value.def"
85 default:
86 break;
87 }
88 llvm_unreachable("not a global");
92 switch (getValueID()) {
94 case Value::NAME##Val: \
95 return static_cast<NAME *>(this)->eraseFromParent();
96#include "llvm/IR/Value.def"
97 default:
98 break;
99 }
100 llvm_unreachable("not a global");
107 return true;
109 !isDSOLocal();
113 // See AsmPrinter::getSymbolPreferLocal(). For a deduplicate comdat kind,
114 // references to a discarded local symbol from outside the group are not
115 // allowed, so avoid the local alias.
116 auto isDeduplicateComdat = [](const Comdat *C) {
117 return C && C->getSelectionKind() != Comdat::NoDeduplicate;
118 };
119 return hasDefaultVisibility() &&
121 !isa<GlobalIFunc>(this) && !isDeduplicateComdat(getComdat());
126 "Alignment is greater than MaximumAlignment!");
127 unsigned AlignmentData = encode(Align);
128 unsigned OldData = getGlobalValueSubClassData();
129 setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData);
130 assert(getAlign() == Align && "Alignment representation error!");
135 "Alignment is greater than MaximumAlignment!");
136 unsigned AlignmentData = encode(Align);
137 unsigned OldData = getGlobalValueSubClassData();
138 setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData);
139 assert(getAlign() && *getAlign() == Align &&
140 "Alignment representation error!");
145 setAlignment(Src->getAlign());
146 setSection(Src->getSection());
151 StringRef FileName) {
152 // Value names may be prefixed with a binary '1' to indicate
153 // that the backend should not modify the symbols due to any platform
154 // naming convention. Do not include that '1' in the PGO profile name.
155 Name.consume_front("\1");
157 std::string GlobalName;
159 // For local symbols, prepend the main file name to distinguish them.
160 // Do not include the full path in the file name since there's no guarantee
161 // that it will stay the same, e.g., if the files are checked out from
162 // version control in different locations.
163 if (FileName.empty())
164 GlobalName += "<unknown>";
165 else
166 GlobalName += FileName;
168 GlobalName += kGlobalIdentifierDelimiter;
169 }
170 GlobalName += Name;
171 return GlobalName;
176 getParent()->getSourceFileName());
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 GO->getSection();
184 return "";
185 }
186 return cast<GlobalObject>(this)->getSection();
190 if (auto *GA = dyn_cast<GlobalAlias>(this)) {
191 // In general we cannot compute this at the IR level, but we try.
192 if (const GlobalObject *GO = GA->getAliaseeObject())
193 return const_cast<GlobalObject *>(GO)->getComdat();
194 return nullptr;
195 }
196 // ifunc and its resolver are separate things so don't use resolver comdat.
197 if (isa<GlobalIFunc>(this))
198 return nullptr;
199 return cast<GlobalObject>(this)->getComdat();
203 if (ObjComdat)
204 ObjComdat->removeUser(this);
205 ObjComdat = C;
206 if (C)
207 C->addUser(this);
211 if (!hasPartition())
212 return "";
213 return getContext().pImpl->GlobalValuePartitions[this];
217 // Do nothing if we're clearing the partition and it is already empty.
218 if (!hasPartition() && S.empty())
219 return;
221 // Get or create a stable partition name string and put it in the table in the
222 // context.
223 if (!S.empty())
224 S = getContext().pImpl->Saver.save(S);
227 // Update the HasPartition field. Setting the partition to the empty string
228 // means this global no longer has a partition.
229 HasPartition = !S.empty();
235 assert(getContext().pImpl->GlobalValueSanitizerMetadata.count(this));
247 MetadataMap.erase(this);
248 HasSanitizerMetadata = false;
253 Meta.NoAddress = true;
254 Meta.NoHWAddress = true;
258StringRef GlobalObject::getSectionImpl() const {
260 return getContext().pImpl->GlobalObjectSections[this];
264 // Do nothing if we're clearing the section and it is already empty.
265 if (!hasSection() && S.empty())
266 return;
268 // Get or create a stable section name string and put it in the table in the
269 // context.
270 if (!S.empty())
271 S = getContext().pImpl->Saver.save(S);
274 // Update the HasSectionHashEntryBit. Setting the section to the empty string
275 // means this global no longer has a section.
276 setGlobalObjectFlag(HasSectionHashEntryBit, !S.empty());
279bool GlobalValue::isNobuiltinFnDef() const {
280 const Function *F = dyn_cast<Function>(this);
281 if (!F || F->empty())
282 return false;
283 return F->hasFnAttribute(Attribute::NoBuiltin);
287 // Globals are definitions if they have an initializer.
288 if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(this))
289 return GV->getNumOperands() == 0;
291 // Functions are definitions if they have a body.
292 if (const Function *F = dyn_cast<Function>(this))
293 return F->empty() && !F->isMaterializable();
295 // Aliases and ifuncs are always definitions.
296 assert(isa<GlobalAlias>(this) || isa<GlobalIFunc>(this));
297 return false;
301 // Firstly, can only increase the alignment of a global if it
302 // is a strong definition.
304 return false;
306 // It also has to either not have a section defined, or, not have
307 // alignment specified. (If it is assigned a section, the global
308 // could be densely packed with other objects in the section, and
309 // increasing the alignment could cause padding issues.)
310 if (hasSection() && getAlign())
311 return false;
313 // On ELF platforms, we're further restricted in that we can't
314 // increase the alignment of any variable which might be emitted
315 // into a shared library, and which is exported. If the main
316 // executable accesses a variable found in a shared-lib, the main
317 // exe actually allocates memory for and exports the symbol ITSELF,
318 // overriding the symbol found in the library. That is, at link
319 // time, the observed alignment of the variable is copied into the
320 // executable binary. (A COPY relocation is also generated, to copy
321 // the initial data from the shadowed variable in the shared-lib
322 // into the location in the main binary, before running code.)
323 //
324 // And thus, even though you might think you are defining the
325 // global, and allocating the memory for the global in your object
326 // file, and thus should be able to set the alignment arbitrarily,
327 // that's not actually true. Doing so can cause an ABI breakage; an
328 // executable might have already been built with the previous
329 // alignment of the variable, and then assuming an increased
330 // alignment will be incorrect.
332 // Conservatively assume ELF if there's no parent pointer.
333 bool isELF =
335 if (isELF && !isDSOLocal())
336 return false;
338 return true;
341template <typename Operation>
342static const GlobalObject *
344 const Operation &Op) {
345 if (auto *GO = dyn_cast<GlobalObject>(C)) {
346 Op(*GO);
347 return GO;
348 }
349 if (auto *GA = dyn_cast<GlobalAlias>(C)) {
350 Op(*GA);
351 if (Aliases.insert(GA).second)
352 return findBaseObject(GA->getOperand(0), Aliases, Op);
353 }
354 if (auto *CE = dyn_cast<ConstantExpr>(C)) {
355 switch (CE->getOpcode()) {
356 case Instruction::Add: {
357 auto *LHS = findBaseObject(CE->getOperand(0), Aliases, Op);
358 auto *RHS = findBaseObject(CE->getOperand(1), Aliases, Op);
359 if (LHS && RHS)
360 return nullptr;
361 return LHS ? LHS : RHS;
362 }
363 case Instruction::Sub: {
364 if (findBaseObject(CE->getOperand(1), Aliases, Op))
365 return nullptr;
366 return findBaseObject(CE->getOperand(0), Aliases, Op);
367 }
368 case Instruction::IntToPtr:
369 case Instruction::PtrToInt:
370 case Instruction::BitCast:
371 case Instruction::GetElementPtr:
372 return findBaseObject(CE->getOperand(0), Aliases, Op);
373 default:
374 break;
375 }
376 }
377 return nullptr;
382 return findBaseObject(this, Aliases, [](const GlobalValue &) {});
386 auto *GO = dyn_cast<GlobalObject>(this);
387 if (!GO)
388 return false;
390 return GO->getMetadata(LLVMContext::MD_absolute_symbol);
393std::optional<ConstantRange> GlobalValue::getAbsoluteSymbolRange() const {
394 auto *GO = dyn_cast<GlobalObject>(this);
395 if (!GO)
396 return std::nullopt;
398 MDNode *MD = GO->getMetadata(LLVMContext::MD_absolute_symbol);
399 if (!MD)
400 return std::nullopt;
407 return false;
409 // We assume that anyone who sets global unnamed_addr on a non-constant
410 // knows what they're doing.
412 return true;
414 // If it is a non constant variable, it needs to be uniqued across shared
415 // objects.
416 if (auto *Var = dyn_cast<GlobalVariable>(this))
417 if (!Var->isConstant())
418 return false;
424// GlobalVariable Implementation
428 Constant *InitVal, const Twine &Name,
429 ThreadLocalMode TLMode, unsigned AddressSpace,
430 bool isExternallyInitialized)
431 : GlobalObject(Ty, Value::GlobalVariableVal,
432 OperandTraits<GlobalVariable>::op_begin(this),
433 InitVal != nullptr, Link, Name, AddressSpace),
434 isConstantGlobal(constant),
435 isExternallyInitializedConstant(isExternallyInitialized) {
437 "invalid type for global variable");
438 setThreadLocalMode(TLMode);
439 if (InitVal) {
440 assert(InitVal->getType() == Ty &&
441 "Initializer should be the same type as the GlobalVariable!");
442 Op<0>() = InitVal;
443 }
447 LinkageTypes Link, Constant *InitVal,
449 ThreadLocalMode TLMode,
450 std::optional<unsigned> AddressSpace,
451 bool isExternallyInitialized)
452 : GlobalVariable(Ty, constant, Link, InitVal, Name, TLMode,
454 ? *AddressSpace
455 : M.getDataLayout().getDefaultGlobalsAddressSpace(),
456 isExternallyInitialized) {
457 if (Before)
458 Before->getParent()->insertGlobalVariable(Before->getIterator(), this);
459 else
460 M.insertGlobalVariable(this);
472 if (!InitVal) {
473 if (hasInitializer()) {
474 // Note, the num operands is used to compute the offset of the operand, so
475 // the order here matters. Clearing the operand then clearing the num
476 // operands ensures we have the correct offset to the operand.
477 Op<0>().set(nullptr);
479 }
480 } else {
481 assert(InitVal->getType() == getValueType() &&
482 "Initializer type must match GlobalVariable type");
483 // Note, the num operands is used to compute the offset of the operand, so
484 // the order here matters. We need to set num operands to 1 first so that
485 // we get the correct offset to the first operand when we set it.
486 if (!hasInitializer())
488 Op<0>().set(InitVal);
489 }
492/// Copy all additional attributes (those not needed to create a GlobalVariable)
493/// from the GlobalVariable Src to this one.
496 setExternallyInitialized(Src->isExternallyInitialized());
497 setAttributes(Src->getAttributes());
498 if (auto CM = Src->getCodeModel())
499 setCodeModel(*CM);
508 unsigned CodeModelData = static_cast<unsigned>(CM) + 1;
509 unsigned OldData = getGlobalValueSubClassData();
510 unsigned NewData = (OldData & ~(CodeModelMask << CodeModelShift)) |
511 (CodeModelData << CodeModelShift);
513 assert(getCodeModel() == CM && "Code model representation error!");
517// GlobalAlias Implementation
520GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
521 const Twine &Name, Constant *Aliasee,
522 Module *ParentModule)
523 : GlobalValue(Ty, Value::GlobalAliasVal, &Op<0>(), 1, Link, Name,
524 AddressSpace) {
525 setAliasee(Aliasee);
526 if (ParentModule)
527 ParentModule->insertAlias(this);
531 LinkageTypes Link, const Twine &Name,
532 Constant *Aliasee, Module *ParentModule) {
533 return new GlobalAlias(Ty, AddressSpace, Link, Name, Aliasee, ParentModule);
537 LinkageTypes Linkage, const Twine &Name,
538 Module *Parent) {
539 return create(Ty, AddressSpace, Linkage, Name, nullptr, Parent);
543 LinkageTypes Linkage, const Twine &Name,
544 GlobalValue *Aliasee) {
545 return create(Ty, AddressSpace, Linkage, Name, Aliasee, Aliasee->getParent());
549 GlobalValue *Aliasee) {
550 return create(Aliasee->getValueType(), Aliasee->getAddressSpace(), Link, Name,
551 Aliasee);
555 return create(Aliasee->getLinkage(), Name, Aliasee);
563 assert((!Aliasee || Aliasee->getType() == getType()) &&
564 "Alias and aliasee types should match!");
565 Op<0>().set(Aliasee);
570 return findBaseObject(getOperand(0), Aliases, [](const GlobalValue &) {});
574// GlobalIFunc Implementation
577GlobalIFunc::GlobalIFunc(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
578 const Twine &Name, Constant *Resolver,
579 Module *ParentModule)
580 : GlobalObject(Ty, Value::GlobalIFuncVal, &Op<0>(), 1, Link, Name,
581 AddressSpace) {
582 setResolver(Resolver);
583 if (ParentModule)
584 ParentModule->insertIFunc(this);
588 LinkageTypes Link, const Twine &Name,
589 Constant *Resolver, Module *ParentModule) {
590 return new GlobalIFunc(Ty, AddressSpace, Link, Name, Resolver, ParentModule);
598 return dyn_cast<Function>(getResolver()->stripPointerCastsAndAliases());
602 function_ref<void(const GlobalValue &)> Op) const {
604 findBaseObject(getResolver(), Aliases, Op);
BlockVerifier::State From
This file contains the declarations for the subclasses of Constant, which represent the different fla...
std::string Name
static const GlobalObject * findBaseObject(const Constant *C, DenseSet< const GlobalAlias * > &Aliases, const Operation &Op)
Definition: Globals.cpp:343
#define F(x, y, z)
Definition: MD5.cpp:55
Module.h This file contains the declarations for the Module class.
PowerPC Reduce CR logical Operation
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Value * RHS
Value * LHS
@ NoDeduplicate
No deduplication is performed.
Definition: Comdat.h:39
This is an important base class in LLVM.
Definition: Constant.h:41
This class represents an Operation in the Expression.
bool erase(const KeyT &Val)
Definition: DenseMap.h:329
Implements a dense probed hash-table based set.
Definition: DenseSet.h:271
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
void eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:560
const GlobalObject * getAliaseeObject() const
Definition: Globals.cpp:568
void setAliasee(Constant *Aliasee)
These methods retrieve and set alias target.
Definition: Globals.cpp:562
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:530
void removeFromParent()
removeFromParent - This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:558
void applyAlongResolverPath(function_ref< void(const GlobalValue &)> Op) const
Definition: Globals.cpp:601
const Function * getResolverFunction() const
Definition: Globals.cpp:597
void removeFromParent()
This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:593
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:587
void eraseFromParent()
This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:595
const Constant * getResolver() const
Definition: GlobalIFunc.h:70
MaybeAlign getAlign() const
Returns the alignment of the given variable or function.
Definition: GlobalObject.h:80
void setAlignment(Align Align)
Sets the alignment attribute of the GlobalObject.
Definition: Globals.cpp:133
void setComdat(Comdat *C)
Definition: Globals.cpp:202
void copyAttributesFrom(const GlobalObject *Src)
Definition: Globals.cpp:143
void setSection(StringRef S)
Change the section for this global.
Definition: Globals.cpp:263
void clearMetadata()
Erase all metadata attached to this Value.
Definition: Metadata.cpp:1559
bool hasSection() const
Check if this global has a custom object file section.
Definition: GlobalObject.h:110
bool canIncreaseAlignment() const
Returns true if the alignment of the value can be unilaterally increased.
Definition: Globals.cpp:300
unsigned HasSanitizerMetadata
True if this symbol has sanitizer metadata available.
Definition: GlobalValue.h:121
bool hasPartition() const
Definition: GlobalValue.h:308
const SanitizerMetadata & getSanitizerMetadata() const
Definition: Globals.cpp:233
bool isDSOLocal() const
Definition: GlobalValue.h:304
unsigned HasPartition
True if this symbol has a partition name assigned (see https://lld.llvm.org/Partitions....
Definition: GlobalValue.h:116
void removeSanitizerMetadata()
Definition: Globals.cpp:244
static bool isLocalLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:408
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:286
LinkageTypes getLinkage() const
Definition: GlobalValue.h:545
void setUnnamedAddr(UnnamedAddr Val)
Definition: GlobalValue.h:230
bool hasDefaultVisibility() const
Definition: GlobalValue.h:248
bool isAbsoluteSymbolRef() const
Returns whether this is a reference to an absolute symbol.
Definition: Globals.cpp:385
void setDLLStorageClass(DLLStorageClassTypes C)
Definition: GlobalValue.h:283
const Comdat * getComdat() const
Definition: Globals.cpp:189
void setThreadLocalMode(ThreadLocalMode Val)
Definition: GlobalValue.h:266
bool hasSanitizerMetadata() const
Definition: GlobalValue.h:354
unsigned getAddressSpace() const
Definition: GlobalValue.h:204
GUID getGUID() const
Return a 64-bit global unique ID constructed from global value name (i.e.
Definition: GlobalValue.h:594
StringRef getSection() const
Definition: Globals.cpp:179
StringRef getPartition() const
Definition: Globals.cpp:210
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:655
const GlobalObject * getAliaseeObject() const
Definition: Globals.cpp:380
void setDSOLocal(bool Local)
Definition: GlobalValue.h:302
std::optional< ConstantRange > getAbsoluteSymbolRange() const
If this is an absolute symbol reference, returns the range of the symbol, otherwise returns std::null...
Definition: Globals.cpp:393
void eraseFromParent()
This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:91
static bool isExternalLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:375
bool isStrongDefinitionForLinker() const
Returns true if this global's definition will be the one chosen by the linker.
Definition: GlobalValue.h:630
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:293
void copyAttributesFrom(const GlobalValue *Src)
Copy all additional attributes (those not needed to create a GlobalValue) from the GlobalValue Src to...
Definition: Globals.cpp:62
void setNoSanitizeMetadata()
Definition: Globals.cpp:251
bool isInterposable() const
Return true if this global's definition can be substituted with an arbitrary definition at link time ...
Definition: Globals.cpp:105
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:253
bool canBenefitFromLocalAlias() const
Definition: Globals.cpp:112
static bool isInterposableLinkage(LinkageTypes Linkage)
Whether the definition of this global may be replaced by something non-equivalent at link time.
Definition: GlobalValue.h:424
bool hasAtLeastLocalUnnamedAddr() const
Returns true if this value's address is not significant in this module.
Definition: GlobalValue.h:223
unsigned getGlobalValueSubClassData() const
Definition: GlobalValue.h:174
void setGlobalValueSubClassData(unsigned V)
Definition: GlobalValue.h:177
bool isMaterializable() const
If this function's Module is being lazily streamed in functions from disk or some other source,...
Definition: Globals.cpp:43
bool hasGlobalUnnamedAddr() const
Definition: GlobalValue.h:214
Error materialize()
Make sure this GlobalValue is fully read.
Definition: Globals.cpp:48
unsigned Linkage
Definition: GlobalValue.h:97
void setSanitizerMetadata(SanitizerMetadata Meta)
Definition: Globals.cpp:239
bool hasLinkOnceODRLinkage() const
Definition: GlobalValue.h:518
bool canBeOmittedFromSymbolTable() const
True if GV can be left out of the object symbol table.
Definition: Globals.cpp:405
void removeFromParent()
This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:79
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:174
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:50
Type * getValueType() const
Definition: GlobalValue.h:295
void setPartition(StringRef Part)
Definition: Globals.cpp:216
void setInitializer(Constant *InitVal)
setInitializer - Sets the initializer for this global variable, removing any existing initializer if ...
Definition: Globals.cpp:471
bool hasInitializer() const
Definitions have initializers, declarations don't.
void removeFromParent()
removeFromParent - This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:463
std::optional< CodeModel::Model > getCodeModel() const
Get the custom code model of this global if it has one.
void setAttributes(AttributeSet A)
Set attribute list for this global.
void copyAttributesFrom(const GlobalVariable *Src)
copyAttributesFrom - copy all additional attributes (those not needed to create a GlobalVariable) fro...
Definition: Globals.cpp:494
void setCodeModel(CodeModel::Model CM)
Change the code model for this global.
Definition: Globals.cpp:507
void setExternallyInitialized(bool Val)
void eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:467
void dropAllReferences()
Drop all references in preparation to destroy the GlobalVariable.
Definition: Globals.cpp:502
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:427
DenseMap< const GlobalValue *, StringRef > GlobalValuePartitions
Collection of per-GlobalValue partitions used in this context.
DenseMap< const GlobalValue *, GlobalValue::SanitizerMetadata > GlobalValueSanitizerMetadata
DenseMap< const GlobalObject *, StringRef > GlobalObjectSections
Collection of per-GlobalObject sections used in this context.
UniqueStringSaver Saver
LLVMContextImpl *const pImpl
Definition: LLVMContext.h:69
Metadata node.
Definition: Metadata.h:1067
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
void removeIFunc(GlobalIFunc *IFunc)
Detach IFunc from the list but don't delete it.
Definition: Module.h:628
void insertIFunc(GlobalIFunc *IFunc)
Insert IFunc at the end of the alias list and take ownership.
Definition: Module.h:632
llvm::Error materialize(GlobalValue *GV)
Make sure the GlobalValue is fully read.
Definition: Module.cpp:446
bool getSemanticInterposition() const
Returns whether semantic interposition is to be respected.
Definition: Module.cpp:672
void removeAlias(GlobalAlias *Alias)
Detach Alias from the list but don't delete it.
Definition: Module.h:619
const std::string & getTargetTriple() const
Get the target triple which is a string describing the target host.
Definition: Module.h:297
void eraseIFunc(GlobalIFunc *IFunc)
Remove IFunc from the list and delete it.
Definition: Module.h:630
void eraseAlias(GlobalAlias *Alias)
Remove Alias from the list and delete it.
Definition: Module.h:621
void eraseGlobalVariable(GlobalVariable *GV)
Remove global variable GV from the list and delete it.
Definition: Module.h:580
void insertAlias(GlobalAlias *Alias)
Insert Alias at the end of the alias list and take ownership.
Definition: Module.h:623
void removeGlobalVariable(GlobalVariable *GV)
Detach global variable GV from the list but don't delete it.
Definition: Module.h:578
static bool isValidElementType(Type *ElemTy)
Return true if the specified type is valid as a element type.
Definition: Type.cpp:764
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:2213
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
bool isOSBinFormatELF() const
Tests whether the OS uses the ELF binary format.
Definition: Triple.h:719
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
bool isFunctionTy() const
True if this is an instance of FunctionType.
Definition: Type.h:246
StringRef save(const char *S)
Definition: StringSaver.h:52
void dropAllReferences()
Drop all references to operands.
Definition: User.h:299
void setGlobalVariableNumOperands(unsigned NumOps)
Set the number of operands on a GlobalVariable.
Definition: User.h:207
Value * getOperand(unsigned i) const
Definition: User.h:169
LLVM Value Representation.
Definition: Value.h:74
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
static constexpr uint64_t MaximumAlignment
Definition: Value.h:807
const Value * stripPointerCastsAndAliases() const
Strip off pointer casts, all-zero GEPs, address space casts, and aliases.
Definition: Value.cpp:697
unsigned getValueID() const
Return an ID for the concrete type of this object.
Definition: Value.h:532
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:1074
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
std::pair< iterator, bool > insert(const ValueT &V)
Definition: DenseSet.h:206
An efficient, type-erasing, non-owning reference to a callable.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
uint64_t MD5Hash(const FunctionId &Obj)
Definition: FunctionId.h:167
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
unsigned encode(MaybeAlign A)
Returns a representation of the alignment that encodes undefined as 0.
Definition: Alignment.h:217
Definition: NVPTXBaseInfo.h:21
ConstantRange getConstantRangeFromMetadata(const MDNode &RangeMD)
Parse out a conservative ConstantRange from !range metadata.
constexpr char kGlobalIdentifierDelimiter
Definition: GlobalValue.h:45
DWARFExpression::Operation Op
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:117
Compile-time customization of User operands.
Definition: User.h:42