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"
25using 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.
34static_assert(sizeof(GlobalValue) ==
35 sizeof(Constant) + 2 * sizeof(void *) + 2 * sizeof(unsigned),
36 "unexpected GlobalValue size growth");
37
38// GlobalObject adds a comdat.
39static_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
49/// Override destroyConstantImpl to make sure it doesn't get called on
50/// GlobalValue's because they shouldn't be treated like other constants.
51void GlobalValue::destroyConstantImpl() {
52 llvm_unreachable("You can't GV->destroyConstantImpl()!");
53}
54
55Value *GlobalValue::handleOperandChangeImpl(Value *From, Value *To) {
56 llvm_unreachable("Unsupported class for handleOperandChange()!");
57}
58
59/// copyAttributesFrom - copy all additional attributes (those not needed to
60/// create a GlobalValue) from the GlobalValue Src to this one.
62 setVisibility(Src->getVisibility());
63 setUnnamedAddr(Src->getUnnamedAddr());
64 setThreadLocalMode(Src->getThreadLocalMode());
65 setDLLStorageClass(Src->getDLLStorageClass());
66 setDSOLocal(Src->isDSOLocal());
67 setPartition(Src->getPartition());
68 if (Src->hasSanitizerMetadata())
69 setSanitizerMetadata(Src->getSanitizerMetadata());
70 else
72}
73
75 switch (getValueID()) {
76#define HANDLE_GLOBAL_VALUE(NAME) \
77 case Value::NAME##Val: \
78 return static_cast<NAME *>(this)->removeFromParent();
79#include "llvm/IR/Value.def"
80 default:
81 break;
82 }
83 llvm_unreachable("not a global");
84}
85
87 switch (getValueID()) {
88#define HANDLE_GLOBAL_VALUE(NAME) \
89 case Value::NAME##Val: \
90 return static_cast<NAME *>(this)->eraseFromParent();
91#include "llvm/IR/Value.def"
92 default:
93 break;
94 }
95 llvm_unreachable("not a global");
96}
97
99
102 return true;
104 !isDSOLocal();
105}
106
108 // See AsmPrinter::getSymbolPreferLocal(). For a deduplicate comdat kind,
109 // references to a discarded local symbol from outside the group are not
110 // allowed, so avoid the local alias.
111 auto isDeduplicateComdat = [](const Comdat *C) {
112 return C && C->getSelectionKind() != Comdat::NoDeduplicate;
113 };
114 return hasDefaultVisibility() &&
116 !isa<GlobalIFunc>(this) && !isDeduplicateComdat(getComdat());
117}
118
121 "Alignment is greater than MaximumAlignment!");
122 unsigned AlignmentData = encode(Align);
123 unsigned OldData = getGlobalValueSubClassData();
124 setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData);
125 assert(getAlign() == Align && "Alignment representation error!");
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() && *getAlign() == Align &&
135 "Alignment representation error!");
136}
137
140 setAlignment(Src->getAlign());
141 setSection(Src->getSection());
142}
143
146 StringRef FileName) {
147 // Value names may be prefixed with a binary '1' to indicate
148 // that the backend should not modify the symbols due to any platform
149 // naming convention. Do not include that '1' in the PGO profile name.
150 Name.consume_front("\1");
151
152 std::string GlobalName;
154 // For local symbols, prepend the main file name to distinguish them.
155 // Do not include the full path in the file name since there's no guarantee
156 // that it will stay the same, e.g., if the files are checked out from
157 // version control in different locations.
158 if (FileName.empty())
159 GlobalName += "<unknown>";
160 else
161 GlobalName += FileName;
162
163 GlobalName += kGlobalIdentifierDelimiter;
164 }
165 GlobalName += Name;
166 return GlobalName;
167}
168
171 getParent()->getSourceFileName());
172}
173
175 if (auto *GA = dyn_cast<GlobalAlias>(this)) {
176 // In general we cannot compute this at the IR level, but we try.
177 if (const GlobalObject *GO = GA->getAliaseeObject())
178 return GO->getSection();
179 return "";
180 }
181 return cast<GlobalObject>(this)->getSection();
182}
183
185 if (auto *GA = dyn_cast<GlobalAlias>(this)) {
186 // In general we cannot compute this at the IR level, but we try.
187 if (const GlobalObject *GO = GA->getAliaseeObject())
188 return const_cast<GlobalObject *>(GO)->getComdat();
189 return nullptr;
190 }
191 // ifunc and its resolver are separate things so don't use resolver comdat.
192 if (isa<GlobalIFunc>(this))
193 return nullptr;
194 return cast<GlobalObject>(this)->getComdat();
195}
196
198 if (ObjComdat)
199 ObjComdat->removeUser(this);
200 ObjComdat = C;
201 if (C)
202 C->addUser(this);
203}
204
206 if (!hasPartition())
207 return "";
208 return getContext().pImpl->GlobalValuePartitions[this];
209}
210
212 // Do nothing if we're clearing the partition and it is already empty.
213 if (!hasPartition() && S.empty())
214 return;
215
216 // Get or create a stable partition name string and put it in the table in the
217 // context.
218 if (!S.empty())
219 S = getContext().pImpl->Saver.save(S);
221
222 // Update the HasPartition field. Setting the partition to the empty string
223 // means this global no longer has a partition.
224 HasPartition = !S.empty();
225}
226
230 assert(getContext().pImpl->GlobalValueSanitizerMetadata.count(this));
232}
233
237}
238
242 MetadataMap.erase(this);
243 HasSanitizerMetadata = false;
244}
245
246StringRef GlobalObject::getSectionImpl() const {
248 return getContext().pImpl->GlobalObjectSections[this];
249}
250
252 // Do nothing if we're clearing the section and it is already empty.
253 if (!hasSection() && S.empty())
254 return;
255
256 // Get or create a stable section name string and put it in the table in the
257 // context.
258 if (!S.empty())
259 S = getContext().pImpl->Saver.save(S);
261
262 // Update the HasSectionHashEntryBit. Setting the section to the empty string
263 // means this global no longer has a section.
264 setGlobalObjectFlag(HasSectionHashEntryBit, !S.empty());
265}
266
267bool GlobalValue::isNobuiltinFnDef() const {
268 const Function *F = dyn_cast<Function>(this);
269 if (!F || F->empty())
270 return false;
271 return F->hasFnAttribute(Attribute::NoBuiltin);
272}
273
275 // Globals are definitions if they have an initializer.
276 if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(this))
277 return GV->getNumOperands() == 0;
278
279 // Functions are definitions if they have a body.
280 if (const Function *F = dyn_cast<Function>(this))
281 return F->empty() && !F->isMaterializable();
282
283 // Aliases and ifuncs are always definitions.
284 assert(isa<GlobalAlias>(this) || isa<GlobalIFunc>(this));
285 return false;
286}
287
289 // Firstly, can only increase the alignment of a global if it
290 // is a strong definition.
292 return false;
293
294 // It also has to either not have a section defined, or, not have
295 // alignment specified. (If it is assigned a section, the global
296 // could be densely packed with other objects in the section, and
297 // increasing the alignment could cause padding issues.)
298 if (hasSection() && getAlign())
299 return false;
300
301 // On ELF platforms, we're further restricted in that we can't
302 // increase the alignment of any variable which might be emitted
303 // into a shared library, and which is exported. If the main
304 // executable accesses a variable found in a shared-lib, the main
305 // exe actually allocates memory for and exports the symbol ITSELF,
306 // overriding the symbol found in the library. That is, at link
307 // time, the observed alignment of the variable is copied into the
308 // executable binary. (A COPY relocation is also generated, to copy
309 // the initial data from the shadowed variable in the shared-lib
310 // into the location in the main binary, before running code.)
311 //
312 // And thus, even though you might think you are defining the
313 // global, and allocating the memory for the global in your object
314 // file, and thus should be able to set the alignment arbitrarily,
315 // that's not actually true. Doing so can cause an ABI breakage; an
316 // executable might have already been built with the previous
317 // alignment of the variable, and then assuming an increased
318 // alignment will be incorrect.
319
320 // Conservatively assume ELF if there's no parent pointer.
321 bool isELF =
323 if (isELF && !isDSOLocal())
324 return false;
325
326 return true;
327}
328
329template <typename Operation>
330static const GlobalObject *
332 const Operation &Op) {
333 if (auto *GO = dyn_cast<GlobalObject>(C)) {
334 Op(*GO);
335 return GO;
336 }
337 if (auto *GA = dyn_cast<GlobalAlias>(C)) {
338 Op(*GA);
339 if (Aliases.insert(GA).second)
340 return findBaseObject(GA->getOperand(0), Aliases, Op);
341 }
342 if (auto *CE = dyn_cast<ConstantExpr>(C)) {
343 switch (CE->getOpcode()) {
344 case Instruction::Add: {
345 auto *LHS = findBaseObject(CE->getOperand(0), Aliases, Op);
346 auto *RHS = findBaseObject(CE->getOperand(1), Aliases, Op);
347 if (LHS && RHS)
348 return nullptr;
349 return LHS ? LHS : RHS;
350 }
351 case Instruction::Sub: {
352 if (findBaseObject(CE->getOperand(1), Aliases, Op))
353 return nullptr;
354 return findBaseObject(CE->getOperand(0), Aliases, Op);
355 }
356 case Instruction::IntToPtr:
357 case Instruction::PtrToInt:
358 case Instruction::BitCast:
359 case Instruction::GetElementPtr:
360 return findBaseObject(CE->getOperand(0), Aliases, Op);
361 default:
362 break;
363 }
364 }
365 return nullptr;
366}
367
370 return findBaseObject(this, Aliases, [](const GlobalValue &) {});
371}
372
374 auto *GO = dyn_cast<GlobalObject>(this);
375 if (!GO)
376 return false;
377
378 return GO->getMetadata(LLVMContext::MD_absolute_symbol);
379}
380
381std::optional<ConstantRange> GlobalValue::getAbsoluteSymbolRange() const {
382 auto *GO = dyn_cast<GlobalObject>(this);
383 if (!GO)
384 return std::nullopt;
385
386 MDNode *MD = GO->getMetadata(LLVMContext::MD_absolute_symbol);
387 if (!MD)
388 return std::nullopt;
389
391}
392
395 return false;
396
397 // We assume that anyone who sets global unnamed_addr on a non-constant
398 // knows what they're doing.
400 return true;
401
402 // If it is a non constant variable, it needs to be uniqued across shared
403 // objects.
404 if (auto *Var = dyn_cast<GlobalVariable>(this))
405 if (!Var->isConstant())
406 return false;
407
409}
410
411//===----------------------------------------------------------------------===//
412// GlobalVariable Implementation
413//===----------------------------------------------------------------------===//
414
416 Constant *InitVal, const Twine &Name,
417 ThreadLocalMode TLMode, unsigned AddressSpace,
418 bool isExternallyInitialized)
419 : GlobalObject(Ty, Value::GlobalVariableVal,
420 OperandTraits<GlobalVariable>::op_begin(this),
421 InitVal != nullptr, Link, Name, AddressSpace),
422 isConstantGlobal(constant),
423 isExternallyInitializedConstant(isExternallyInitialized) {
425 "invalid type for global variable");
426 setThreadLocalMode(TLMode);
427 if (InitVal) {
428 assert(InitVal->getType() == Ty &&
429 "Initializer should be the same type as the GlobalVariable!");
430 Op<0>() = InitVal;
431 }
432}
433
435 LinkageTypes Link, Constant *InitVal,
437 ThreadLocalMode TLMode,
438 std::optional<unsigned> AddressSpace,
439 bool isExternallyInitialized)
440 : GlobalVariable(Ty, constant, Link, InitVal, Name, TLMode,
442 ? *AddressSpace
443 : M.getDataLayout().getDefaultGlobalsAddressSpace(),
444 isExternallyInitialized) {
445 if (Before)
446 Before->getParent()->insertGlobalVariable(Before->getIterator(), this);
447 else
448 M.insertGlobalVariable(this);
449}
450
453}
454
457}
458
460 if (!InitVal) {
461 if (hasInitializer()) {
462 // Note, the num operands is used to compute the offset of the operand, so
463 // the order here matters. Clearing the operand then clearing the num
464 // operands ensures we have the correct offset to the operand.
465 Op<0>().set(nullptr);
467 }
468 } else {
469 assert(InitVal->getType() == getValueType() &&
470 "Initializer type must match GlobalVariable type");
471 // Note, the num operands is used to compute the offset of the operand, so
472 // the order here matters. We need to set num operands to 1 first so that
473 // we get the correct offset to the first operand when we set it.
474 if (!hasInitializer())
476 Op<0>().set(InitVal);
477 }
478}
479
480/// Copy all additional attributes (those not needed to create a GlobalVariable)
481/// from the GlobalVariable Src to this one.
484 setExternallyInitialized(Src->isExternallyInitialized());
485 setAttributes(Src->getAttributes());
486 if (auto CM = Src->getCodeModel())
487 setCodeModel(*CM);
488}
489
493}
494
496 unsigned CodeModelData = static_cast<unsigned>(CM) + 1;
497 unsigned OldData = getGlobalValueSubClassData();
498 unsigned NewData = (OldData & ~(CodeModelMask << CodeModelShift)) |
499 (CodeModelData << CodeModelShift);
501 assert(getCodeModel() == CM && "Code model representation error!");
502}
503
504//===----------------------------------------------------------------------===//
505// GlobalAlias Implementation
506//===----------------------------------------------------------------------===//
507
508GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
509 const Twine &Name, Constant *Aliasee,
510 Module *ParentModule)
511 : GlobalValue(Ty, Value::GlobalAliasVal, &Op<0>(), 1, Link, Name,
512 AddressSpace) {
513 setAliasee(Aliasee);
514 if (ParentModule)
515 ParentModule->insertAlias(this);
516}
517
519 LinkageTypes Link, const Twine &Name,
520 Constant *Aliasee, Module *ParentModule) {
521 return new GlobalAlias(Ty, AddressSpace, Link, Name, Aliasee, ParentModule);
522}
523
525 LinkageTypes Linkage, const Twine &Name,
526 Module *Parent) {
527 return create(Ty, AddressSpace, Linkage, Name, nullptr, Parent);
528}
529
531 LinkageTypes Linkage, const Twine &Name,
532 GlobalValue *Aliasee) {
533 return create(Ty, AddressSpace, Linkage, Name, Aliasee, Aliasee->getParent());
534}
535
537 GlobalValue *Aliasee) {
538 return create(Aliasee->getValueType(), Aliasee->getAddressSpace(), Link, Name,
539 Aliasee);
540}
541
543 return create(Aliasee->getLinkage(), Name, Aliasee);
544}
545
547
549
551 assert((!Aliasee || Aliasee->getType() == getType()) &&
552 "Alias and aliasee types should match!");
553 Op<0>().set(Aliasee);
554}
555
558 return findBaseObject(getOperand(0), Aliases, [](const GlobalValue &) {});
559}
560
561//===----------------------------------------------------------------------===//
562// GlobalIFunc Implementation
563//===----------------------------------------------------------------------===//
564
565GlobalIFunc::GlobalIFunc(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
566 const Twine &Name, Constant *Resolver,
567 Module *ParentModule)
568 : GlobalObject(Ty, Value::GlobalIFuncVal, &Op<0>(), 1, Link, Name,
569 AddressSpace) {
570 setResolver(Resolver);
571 if (ParentModule)
572 ParentModule->insertIFunc(this);
573}
574
576 LinkageTypes Link, const Twine &Name,
577 Constant *Resolver, Module *ParentModule) {
578 return new GlobalIFunc(Ty, AddressSpace, Link, Name, Resolver, ParentModule);
579}
580
582
584
586 return dyn_cast<Function>(getResolver()->stripPointerCastsAndAliases());
587}
588
590 function_ref<void(const GlobalValue &)> Op) const {
592 findBaseObject(getResolver(), Aliases, Op);
593}
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:331
#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:548
const GlobalObject * getAliaseeObject() const
Definition: Globals.cpp:556
void setAliasee(Constant *Aliasee)
These methods retrieve and set alias target.
Definition: Globals.cpp:550
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:518
void removeFromParent()
removeFromParent - This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:546
void applyAlongResolverPath(function_ref< void(const GlobalValue &)> Op) const
Definition: Globals.cpp:589
const Function * getResolverFunction() const
Definition: Globals.cpp:585
void removeFromParent()
This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:581
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:575
void eraseFromParent()
This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:583
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:128
void setComdat(Comdat *C)
Definition: Globals.cpp:197
void copyAttributesFrom(const GlobalObject *Src)
Definition: Globals.cpp:138
void setSection(StringRef S)
Change the section for this global.
Definition: Globals.cpp:251
void clearMetadata()
Erase all metadata attached to this Value.
Definition: Metadata.cpp:1557
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:288
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:228
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:239
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:274
LinkageTypes getLinkage() const
Definition: GlobalValue.h:545
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:373
void setDLLStorageClass(DLLStorageClassTypes C)
Definition: GlobalValue.h:284
const Comdat * getComdat() const
Definition: Globals.cpp:184
void setThreadLocalMode(ThreadLocalMode Val)
Definition: GlobalValue.h:267
bool hasSanitizerMetadata() const
Definition: GlobalValue.h:355
unsigned getAddressSpace() const
Definition: GlobalValue.h:205
StringRef getSection() const
Definition: Globals.cpp:174
StringRef getPartition() const
Definition: Globals.cpp:205
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:655
const GlobalObject * getAliaseeObject() const
Definition: Globals.cpp:368
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:381
void eraseFromParent()
This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:86
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: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:61
bool isInterposable() const
Return true if this global's definition can be substituted with an arbitrary definition at link time ...
Definition: Globals.cpp:100
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:254
bool canBenefitFromLocalAlias() const
Definition: Globals.cpp:107
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: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:42
bool hasGlobalUnnamedAddr() const
Definition: GlobalValue.h:215
Error materialize()
Make sure this GlobalValue is fully read.
Definition: Globals.cpp:47
unsigned Linkage
Definition: GlobalValue.h:98
void setSanitizerMetadata(SanitizerMetadata Meta)
Definition: Globals.cpp:234
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:393
void removeFromParent()
This method unlinks 'this' from the containing module, but does not delete it.
Definition: Globals.cpp:74
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:169
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:211
void setInitializer(Constant *InitVal)
setInitializer - Sets the initializer for this global variable, removing any existing initializer if ...
Definition: Globals.cpp:459
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:451
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:482
void setCodeModel(CodeModel::Model CM)
Change the code model for this global.
Definition: Globals.cpp:495
void setExternallyInitialized(bool Val)
void eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:455
void dropAllReferences()
Drop all references in preparation to destroy the GlobalVariable.
Definition: Globals.cpp:490
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:415
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:629
void insertIFunc(GlobalIFunc *IFunc)
Insert IFunc at the end of the alias list and take ownership.
Definition: Module.h:633
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:620
const std::string & getTargetTriple() const
Get the target triple which is a string describing the target host.
Definition: Module.h:291
void eraseIFunc(GlobalIFunc *IFunc)
Remove IFunc from the list and delete it.
Definition: Module.h:631
void eraseAlias(GlobalAlias *Alias)
Remove Alias from the list and delete it.
Definition: Module.h:622
void eraseGlobalVariable(GlobalVariable *GV)
Remove global variable GV from the list and delete it.
Definition: Module.h:581
void insertAlias(GlobalAlias *Alias)
Insert Alias at the end of the alias list and take ownership.
Definition: Module.h:624
void removeGlobalVariable(GlobalVariable *GV)
Detach global variable GV from the list but don't delete it.
Definition: Module.h:579
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:703
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
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.
constexpr char kGlobalIdentifierDelimiter
Definition: GlobalValue.h:46
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