LLVM 19.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"
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;
27
28//===----------------------------------------------------------------------===//
29// GlobalValue Class
30//===----------------------------------------------------------------------===//
31
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");
38
39// GlobalObject adds a comdat.
40static_assert(sizeof(GlobalObject) == sizeof(GlobalValue) + sizeof(void *),
41 "unexpected GlobalObject size growth");
42
44 if (const Function *F = dyn_cast<Function>(this))
45 return F->isMaterializable();
46 return false;
47}
49
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()!");
54}
55
56Value *GlobalValue::handleOperandChangeImpl(Value *From, Value *To) {
57 llvm_unreachable("Unsupported class for handleOperandChange()!");
58}
59
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
73}
74
76 return MD5Hash(GlobalName);
77}
78
80 switch (getValueID()) {
81#define HANDLE_GLOBAL_VALUE(NAME) \
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");
89}
90
92 switch (getValueID()) {
93#define HANDLE_GLOBAL_VALUE(NAME) \
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");
101}
102
104
107 return true;
109 !isDSOLocal();
110}
111
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());
122}
123
125 return getParent()->getDataLayout();
126}
127
130 "Alignment is greater than MaximumAlignment!");
131 unsigned AlignmentData = encode(Align);
132 unsigned OldData = getGlobalValueSubClassData();
133 setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData);
134 assert(getAlign() == Align && "Alignment representation error!");
135}
136
139 "Alignment is greater than MaximumAlignment!");
140 unsigned AlignmentData = encode(Align);
141 unsigned OldData = getGlobalValueSubClassData();
142 setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData);
143 assert(getAlign() && *getAlign() == Align &&
144 "Alignment representation error!");
145}
146
149 setAlignment(Src->getAlign());
150 setSection(Src->getSection());
151}
152
155 StringRef FileName) {
156 // Value names may be prefixed with a binary '1' to indicate
157 // that the backend should not modify the symbols due to any platform
158 // naming convention. Do not include that '1' in the PGO profile name.
159 Name.consume_front("\1");
160
161 std::string GlobalName;
163 // For local symbols, prepend the main file name to distinguish them.
164 // Do not include the full path in the file name since there's no guarantee
165 // that it will stay the same, e.g., if the files are checked out from
166 // version control in different locations.
167 if (FileName.empty())
168 GlobalName += "<unknown>";
169 else
170 GlobalName += FileName;
171
172 GlobalName += GlobalIdentifierDelimiter;
173 }
174 GlobalName += Name;
175 return GlobalName;
176}
177
180 getParent()->getSourceFileName());
181}
182
184 if (auto *GA = dyn_cast<GlobalAlias>(this)) {
185 // In general we cannot compute this at the IR level, but we try.
186 if (const GlobalObject *GO = GA->getAliaseeObject())
187 return GO->getSection();
188 return "";
189 }
190 return cast<GlobalObject>(this)->getSection();
191}
192
194 if (auto *GA = dyn_cast<GlobalAlias>(this)) {
195 // In general we cannot compute this at the IR level, but we try.
196 if (const GlobalObject *GO = GA->getAliaseeObject())
197 return const_cast<GlobalObject *>(GO)->getComdat();
198 return nullptr;
199 }
200 // ifunc and its resolver are separate things so don't use resolver comdat.
201 if (isa<GlobalIFunc>(this))
202 return nullptr;
203 return cast<GlobalObject>(this)->getComdat();
204}
205
207 if (ObjComdat)
208 ObjComdat->removeUser(this);
209 ObjComdat = C;
210 if (C)
211 C->addUser(this);
212}
213
215 if (!hasPartition())
216 return "";
217 return getContext().pImpl->GlobalValuePartitions[this];
218}
219
221 // Do nothing if we're clearing the partition and it is already empty.
222 if (!hasPartition() && S.empty())
223 return;
224
225 // Get or create a stable partition name string and put it in the table in the
226 // context.
227 if (!S.empty())
228 S = getContext().pImpl->Saver.save(S);
230
231 // Update the HasPartition field. Setting the partition to the empty string
232 // means this global no longer has a partition.
233 HasPartition = !S.empty();
234}
235
239 assert(getContext().pImpl->GlobalValueSanitizerMetadata.count(this));
241}
242
246}
247
251 MetadataMap.erase(this);
252 HasSanitizerMetadata = false;
253}
254
257 Meta.NoAddress = true;
258 Meta.NoHWAddress = true;
260}
261
262StringRef GlobalObject::getSectionImpl() const {
264 return getContext().pImpl->GlobalObjectSections[this];
265}
266
268 // Do nothing if we're clearing the section and it is already empty.
269 if (!hasSection() && S.empty())
270 return;
271
272 // Get or create a stable section name string and put it in the table in the
273 // context.
274 if (!S.empty())
275 S = getContext().pImpl->Saver.save(S);
277
278 // Update the HasSectionHashEntryBit. Setting the section to the empty string
279 // means this global no longer has a section.
280 setGlobalObjectFlag(HasSectionHashEntryBit, !S.empty());
281}
282
283bool GlobalValue::isNobuiltinFnDef() const {
284 const Function *F = dyn_cast<Function>(this);
285 if (!F || F->empty())
286 return false;
287 return F->hasFnAttribute(Attribute::NoBuiltin);
288}
289
291 // Globals are definitions if they have an initializer.
292 if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(this))
293 return GV->getNumOperands() == 0;
294
295 // Functions are definitions if they have a body.
296 if (const Function *F = dyn_cast<Function>(this))
297 return F->empty() && !F->isMaterializable();
298
299 // Aliases and ifuncs are always definitions.
300 assert(isa<GlobalAlias>(this) || isa<GlobalIFunc>(this));
301 return false;
302}
303
305 // Firstly, can only increase the alignment of a global if it
306 // is a strong definition.
308 return false;
309
310 // It also has to either not have a section defined, or, not have
311 // alignment specified. (If it is assigned a section, the global
312 // could be densely packed with other objects in the section, and
313 // increasing the alignment could cause padding issues.)
314 if (hasSection() && getAlign())
315 return false;
316
317 // On ELF platforms, we're further restricted in that we can't
318 // increase the alignment of any variable which might be emitted
319 // into a shared library, and which is exported. If the main
320 // executable accesses a variable found in a shared-lib, the main
321 // exe actually allocates memory for and exports the symbol ITSELF,
322 // overriding the symbol found in the library. That is, at link
323 // time, the observed alignment of the variable is copied into the
324 // executable binary. (A COPY relocation is also generated, to copy
325 // the initial data from the shadowed variable in the shared-lib
326 // into the location in the main binary, before running code.)
327 //
328 // And thus, even though you might think you are defining the
329 // global, and allocating the memory for the global in your object
330 // file, and thus should be able to set the alignment arbitrarily,
331 // that's not actually true. Doing so can cause an ABI breakage; an
332 // executable might have already been built with the previous
333 // alignment of the variable, and then assuming an increased
334 // alignment will be incorrect.
335
336 // Conservatively assume ELF if there's no parent pointer.
337 bool isELF =
339 if (isELF && !isDSOLocal())
340 return false;
341
342 // GV with toc-data attribute is defined in a TOC entry. To mitigate TOC
343 // overflow, the alignment of such symbol should not be increased. Otherwise,
344 // padding is needed thus more TOC entries are wasted.
345 bool isXCOFF =
347 if (isXCOFF)
348 if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(this))
349 if (GV->hasAttribute("toc-data"))
350 return false;
351
352 return true;
353}
354
355template <typename Operation>
356static const GlobalObject *
358 const Operation &Op) {
359 if (auto *GO = dyn_cast<GlobalObject>(C)) {
360 Op(*GO);
361 return GO;
362 }
363 if (auto *GA = dyn_cast<GlobalAlias>(C)) {
364 Op(*GA);
365 if (Aliases.insert(GA).second)
366 return findBaseObject(GA->getOperand(0), Aliases, Op);
367 }
368 if (auto *CE = dyn_cast<ConstantExpr>(C)) {
369 switch (CE->getOpcode()) {
370 case Instruction::Add: {
371 auto *LHS = findBaseObject(CE->getOperand(0), Aliases, Op);
372 auto *RHS = findBaseObject(CE->getOperand(1), Aliases, Op);
373 if (LHS && RHS)
374 return nullptr;
375 return LHS ? LHS : RHS;
376 }
377 case Instruction::Sub: {
378 if (findBaseObject(CE->getOperand(1), Aliases, Op))
379 return nullptr;
380 return findBaseObject(CE->getOperand(0), Aliases, Op);
381 }
382 case Instruction::IntToPtr:
383 case Instruction::PtrToInt:
384 case Instruction::BitCast:
385 case Instruction::GetElementPtr:
386 return findBaseObject(CE->getOperand(0), Aliases, Op);
387 default:
388 break;
389 }
390 }
391 return nullptr;
392}
393
396 return findBaseObject(this, Aliases, [](const GlobalValue &) {});
397}
398
400 auto *GO = dyn_cast<GlobalObject>(this);
401 if (!GO)
402 return false;
403
404 return GO->getMetadata(LLVMContext::MD_absolute_symbol);
405}
406
407std::optional<ConstantRange> GlobalValue::getAbsoluteSymbolRange() const {
408 auto *GO = dyn_cast<GlobalObject>(this);
409 if (!GO)
410 return std::nullopt;
411
412 MDNode *MD = GO->getMetadata(LLVMContext::MD_absolute_symbol);
413 if (!MD)
414 return std::nullopt;
415
417}
418
421 return false;
422
423 // We assume that anyone who sets global unnamed_addr on a non-constant
424 // knows what they're doing.
426 return true;
427
428 // If it is a non constant variable, it needs to be uniqued across shared
429 // objects.
430 if (auto *Var = dyn_cast<GlobalVariable>(this))
431 if (!Var->isConstant())
432 return false;
433
435}
436
437//===----------------------------------------------------------------------===//
438// GlobalVariable Implementation
439//===----------------------------------------------------------------------===//
440
442 Constant *InitVal, const Twine &Name,
443 ThreadLocalMode TLMode, unsigned AddressSpace,
444 bool isExternallyInitialized)
445 : GlobalObject(Ty, Value::GlobalVariableVal,
446 OperandTraits<GlobalVariable>::op_begin(this),
447 InitVal != nullptr, Link, Name, AddressSpace),
448 isConstantGlobal(constant),
449 isExternallyInitializedConstant(isExternallyInitialized) {
451 "invalid type for global variable");
452 setThreadLocalMode(TLMode);
453 if (InitVal) {
454 assert(InitVal->getType() == Ty &&
455 "Initializer should be the same type as the GlobalVariable!");
456 Op<0>() = InitVal;
457 }
458}
459
461 LinkageTypes Link, Constant *InitVal,
463 ThreadLocalMode TLMode,
464 std::optional<unsigned> AddressSpace,
465 bool isExternallyInitialized)
466 : GlobalVariable(Ty, constant, Link, InitVal, Name, TLMode,
468 ? *AddressSpace
469 : M.getDataLayout().getDefaultGlobalsAddressSpace(),
470 isExternallyInitialized) {
471 if (Before)
472 Before->getParent()->insertGlobalVariable(Before->getIterator(), this);
473 else
474 M.insertGlobalVariable(this);
475}
476
479}
480
483}
484
486 if (!InitVal) {
487 if (hasInitializer()) {
488 // Note, the num operands is used to compute the offset of the operand, so
489 // the order here matters. Clearing the operand then clearing the num
490 // operands ensures we have the correct offset to the operand.
491 Op<0>().set(nullptr);
493 }
494 } else {
495 assert(InitVal->getType() == getValueType() &&
496 "Initializer type must match GlobalVariable type");
497 // Note, the num operands is used to compute the offset of the operand, so
498 // the order here matters. We need to set num operands to 1 first so that
499 // we get the correct offset to the first operand when we set it.
500 if (!hasInitializer())
502 Op<0>().set(InitVal);
503 }
504}
505
506/// Copy all additional attributes (those not needed to create a GlobalVariable)
507/// from the GlobalVariable Src to this one.
510 setExternallyInitialized(Src->isExternallyInitialized());
511 setAttributes(Src->getAttributes());
512 if (auto CM = Src->getCodeModel())
513 setCodeModel(*CM);
514}
515
519}
520
522 unsigned CodeModelData = static_cast<unsigned>(CM) + 1;
523 unsigned OldData = getGlobalValueSubClassData();
524 unsigned NewData = (OldData & ~(CodeModelMask << CodeModelShift)) |
525 (CodeModelData << CodeModelShift);
527 assert(getCodeModel() == CM && "Code model representation error!");
528}
529
530//===----------------------------------------------------------------------===//
531// GlobalAlias Implementation
532//===----------------------------------------------------------------------===//
533
534GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
535 const Twine &Name, Constant *Aliasee,
536 Module *ParentModule)
537 : GlobalValue(Ty, Value::GlobalAliasVal, &Op<0>(), 1, Link, Name,
538 AddressSpace) {
539 setAliasee(Aliasee);
540 if (ParentModule)
541 ParentModule->insertAlias(this);
542}
543
545 LinkageTypes Link, const Twine &Name,
546 Constant *Aliasee, Module *ParentModule) {
547 return new GlobalAlias(Ty, AddressSpace, Link, Name, Aliasee, ParentModule);
548}
549
551 LinkageTypes Linkage, const Twine &Name,
552 Module *Parent) {
553 return create(Ty, AddressSpace, Linkage, Name, nullptr, Parent);
554}
555
557 LinkageTypes Linkage, const Twine &Name,
558 GlobalValue *Aliasee) {
559 return create(Ty, AddressSpace, Linkage, Name, Aliasee, Aliasee->getParent());
560}
561
563 GlobalValue *Aliasee) {
564 return create(Aliasee->getValueType(), Aliasee->getAddressSpace(), Link, Name,
565 Aliasee);
566}
567
569 return create(Aliasee->getLinkage(), Name, Aliasee);
570}
571
573
575
577 assert((!Aliasee || Aliasee->getType() == getType()) &&
578 "Alias and aliasee types should match!");
579 Op<0>().set(Aliasee);
580}
581
584 return findBaseObject(getOperand(0), Aliases, [](const GlobalValue &) {});
585}
586
587//===----------------------------------------------------------------------===//
588// GlobalIFunc Implementation
589//===----------------------------------------------------------------------===//
590
591GlobalIFunc::GlobalIFunc(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
592 const Twine &Name, Constant *Resolver,
593 Module *ParentModule)
594 : GlobalObject(Ty, Value::GlobalIFuncVal, &Op<0>(), 1, Link, Name,
595 AddressSpace) {
596 setResolver(Resolver);
597 if (ParentModule)
598 ParentModule->insertIFunc(this);
599}
600
602 LinkageTypes Link, const Twine &Name,
603 Constant *Resolver, Module *ParentModule) {
604 return new GlobalIFunc(Ty, AddressSpace, Link, Name, Resolver, ParentModule);
605}
606
608
610
612 return dyn_cast<Function>(getResolver()->stripPointerCastsAndAliases());
613}
614
616 function_ref<void(const GlobalValue &)> Op) const {
618 findBaseObject(getResolver(), Aliases, Op);
619}
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:357
#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:42
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
bool erase(const KeyT &Val)
Definition: DenseMap.h:345
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:574
const GlobalObject * getAliaseeObject() const
Definition: Globals.cpp:582
void setAliasee(Constant *Aliasee)
These methods retrieve and set alias target.
Definition: Globals.cpp:576
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:544
void removeFromParent()
removeFromParent - This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:572
void applyAlongResolverPath(function_ref< void(const GlobalValue &)> Op) const
Definition: Globals.cpp:615
const Function * getResolverFunction() const
Definition: Globals.cpp:611
void removeFromParent()
This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:607
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:601
void eraseFromParent()
This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:609
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:137
void setComdat(Comdat *C)
Definition: Globals.cpp:206
void copyAttributesFrom(const GlobalObject *Src)
Definition: Globals.cpp:147
void setSection(StringRef S)
Change the section for this global.
Definition: Globals.cpp:267
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:304
unsigned HasSanitizerMetadata
True if this symbol has sanitizer metadata available.
Definition: GlobalValue.h:122
bool hasPartition() const
Definition: GlobalValue.h:309
const SanitizerMetadata & getSanitizerMetadata() const
Definition: Globals.cpp:237
bool isDSOLocal() const
Definition: GlobalValue.h:305
unsigned HasPartition
True if this symbol has a partition name assigned (see https://lld.llvm.org/Partitions....
Definition: GlobalValue.h:117
void removeSanitizerMetadata()
Definition: Globals.cpp:248
static bool isLocalLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:409
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:290
LinkageTypes getLinkage() const
Definition: GlobalValue.h:546
void setUnnamedAddr(UnnamedAddr Val)
Definition: GlobalValue.h:231
bool hasDefaultVisibility() const
Definition: GlobalValue.h:249
bool isAbsoluteSymbolRef() const
Returns whether this is a reference to an absolute symbol.
Definition: Globals.cpp:399
void setDLLStorageClass(DLLStorageClassTypes C)
Definition: GlobalValue.h:284
const Comdat * getComdat() const
Definition: Globals.cpp:193
void setThreadLocalMode(ThreadLocalMode Val)
Definition: GlobalValue.h:267
bool hasSanitizerMetadata() const
Definition: GlobalValue.h:355
unsigned getAddressSpace() const
Definition: GlobalValue.h:205
GUID getGUID() const
Return a 64-bit global unique ID constructed from global value name (i.e.
Definition: GlobalValue.h:595
StringRef getSection() const
Definition: Globals.cpp:183
StringRef getPartition() const
Definition: Globals.cpp:214
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:656
const GlobalObject * getAliaseeObject() const
Definition: Globals.cpp:394
void setDSOLocal(bool Local)
Definition: GlobalValue.h:303
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:407
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:376
bool isStrongDefinitionForLinker() const
Returns true if this global's definition will be the one chosen by the linker.
Definition: GlobalValue.h:631
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:294
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:255
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:254
const DataLayout & getDataLayout() const
Get the data layout of the module this global belongs to.
Definition: Globals.cpp:124
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:425
bool hasAtLeastLocalUnnamedAddr() const
Returns true if this value's address is not significant in this module.
Definition: GlobalValue.h:224
unsigned getGlobalValueSubClassData() const
Definition: GlobalValue.h:175
void setGlobalValueSubClassData(unsigned V)
Definition: GlobalValue.h:178
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:215
Error materialize()
Make sure this GlobalValue is fully read.
Definition: Globals.cpp:48
unsigned Linkage
Definition: GlobalValue.h:98
void setSanitizerMetadata(SanitizerMetadata Meta)
Definition: Globals.cpp:243
bool hasLinkOnceODRLinkage() const
Definition: GlobalValue.h:519
bool canBeOmittedFromSymbolTable() const
True if GV can be left out of the object symbol table.
Definition: Globals.cpp:419
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:178
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:51
Type * getValueType() const
Definition: GlobalValue.h:296
void setPartition(StringRef Part)
Definition: Globals.cpp:220
void setInitializer(Constant *InitVal)
setInitializer - Sets the initializer for this global variable, removing any existing initializer if ...
Definition: Globals.cpp:485
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:477
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:508
void setCodeModel(CodeModel::Model CM)
Change the code model for this global.
Definition: Globals.cpp:521
void setExternallyInitialized(bool Val)
void eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:481
void dropAllReferences()
Drop all references in preparation to destroy the GlobalVariable.
Definition: Globals.cpp:516
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:441
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:630
void insertIFunc(GlobalIFunc *IFunc)
Insert IFunc at the end of the alias list and take ownership.
Definition: Module.h:634
llvm::Error materialize(GlobalValue *GV)
Make sure the GlobalValue is fully read.
Definition: Module.cpp:456
bool getSemanticInterposition() const
Returns whether semantic interposition is to be respected.
Definition: Module.cpp:682
void removeAlias(GlobalAlias *Alias)
Detach Alias from the list but don't delete it.
Definition: Module.h:621
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:632
void eraseAlias(GlobalAlias *Alias)
Remove Alias from the list and delete it.
Definition: Module.h:623
void eraseGlobalVariable(GlobalVariable *GV)
Remove global variable GV from the list and delete it.
Definition: Module.h:582
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.h:293
void insertAlias(GlobalAlias *Alias)
Insert Alias at the end of the alias list and take ownership.
Definition: Module.h:625
void removeGlobalVariable(GlobalVariable *GV)
Detach global variable GV from the list but don't delete it.
Definition: Module.h:580
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 isOSBinFormatXCOFF() const
Tests whether the OS uses the XCOFF binary format.
Definition: Triple.h:742
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:698
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:1075
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
AddressSpace
Definition: NVPTXBaseInfo.h:21
ConstantRange getConstantRangeFromMetadata(const MDNode &RangeMD)
Parse out a conservative ConstantRange from !range metadata.
DWARFExpression::Operation Op
constexpr char GlobalIdentifierDelimiter
Definition: GlobalValue.h:46
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