1//===-- Globals.cpp - Implement the GlobalValue & GlobalVariable class ----===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the GlobalValue & GlobalVariable classes for the IR
10// library.
11//
12//===----------------------------------------------------------------------===//
13
14#include "LLVMContextImpl.h"
15#include "llvm/IR/ConstantRange.h"
16#include "llvm/IR/Constants.h"
17#include "llvm/IR/DataLayout.h"
18#include "llvm/IR/DerivedTypes.h"
19#include "llvm/IR/GlobalAlias.h"
20#include "llvm/IR/GlobalValue.h"
21#include "llvm/IR/GlobalVariable.h"
22#include "llvm/IR/MDBuilder.h"
23#include "llvm/IR/Module.h"
24#include "llvm/Support/Error.h"
25#include "llvm/Support/ErrorHandling.h"
26#include "llvm/Support/MD5.h"
27#include "llvm/TargetParser/Triple.h"
28using namespace llvm;
29
30//===----------------------------------------------------------------------===//
31// GlobalValue Class
32//===----------------------------------------------------------------------===//
33
34// GlobalValue should be a Constant, plus a type, a module, some flags, and an
35// intrinsic ID. Add an assert to prevent people from accidentally growing
36// GlobalValue while adding flags.
37static_assert(sizeof(GlobalValue) ==
38 sizeof(Constant) + 2 * sizeof(void *) + 2 * sizeof(unsigned),
39 "unexpected GlobalValue size growth");
40
41// GlobalObject adds a comdat and metadata index.
42static_assert(sizeof(GlobalObject) ==
43 sizeof(GlobalValue) + sizeof(void *) +
44 alignTo(Value: sizeof(unsigned), Align: alignof(void *)),
45 "unexpected GlobalObject size growth");
46
47bool GlobalValue::isMaterializable() const {
48 if (const Function *F = dyn_cast<Function>(Val: this))
49 return F->isMaterializable();
50 return false;
51}
52Error GlobalValue::materialize() { return getParent()->materialize(GV: this); }
53
54/// Override destroyConstantImpl to make sure it doesn't get called on
55/// GlobalValue's because they shouldn't be treated like other constants.
56void GlobalValue::destroyConstantImpl() {
57 llvm_unreachable("You can't GV->destroyConstantImpl()!");
58}
59
60Value *GlobalValue::handleOperandChangeImpl(Value *From, Value *To) {
61 llvm_unreachable("Unsupported class for handleOperandChange()!");
62}
63
64/// copyAttributesFrom - copy all additional attributes (those not needed to
65/// create a GlobalValue) from the GlobalValue Src to this one.
66void GlobalValue::copyAttributesFrom(const GlobalValue *Src) {
67 setVisibility(Src->getVisibility());
68 setUnnamedAddr(Src->getUnnamedAddr());
69 setThreadLocalMode(Src->getThreadLocalMode());
70 setDLLStorageClass(Src->getDLLStorageClass());
71 setDSOLocal(Src->isDSOLocal());
72 setPartition(Src->getPartition());
73 if (Src->hasSanitizerMetadata())
74 setSanitizerMetadata(Src->getSanitizerMetadata());
75 else
76 removeSanitizerMetadata();
77}
78
79GlobalValue::GUID
80GlobalValue::getGUIDAssumingExternalLinkage(StringRef GlobalIdentifier) {
81 return MD5Hash(Str: GlobalIdentifier);
82}
83
84void GlobalValue::assignGUID() {
85 if (getGUIDMetadata() != nullptr)
86 return;
87
88 const GUID G =
89 GlobalValue::getGUIDAssumingExternalLinkage(GlobalIdentifier: getGlobalIdentifier());
90 setMetadata(
91 KindID: LLVMContext::MD_guid,
92 Node: MDNode::get(Context&: getContext(), MDs: {ConstantAsMetadata::get(C: ConstantInt::get(
93 Ty: Type::getInt64Ty(C&: getContext()), V: G))}));
94}
95
96void GlobalValue::reassignGUID() {
97 if (!getGUIDMetadata())
98 return;
99 eraseMetadata(KindID: LLVMContext::MD_guid);
100 assignGUID();
101}
102
103GlobalValue::GUID GlobalValue::getGUID() const {
104 auto MaybeGUID = getGUIDIfAssigned();
105 assert(MaybeGUID.has_value() &&
106 "GUID was not assigned before calling GetGUID()");
107 return *MaybeGUID;
108}
109
110GlobalValue::GUID GlobalValue::getGUIDOrFallback() const {
111 if (auto MaybeGUID = getGUIDIfAssigned(); MaybeGUID)
112 return *MaybeGUID;
113 return getGUIDAssumingExternalLinkage(GlobalIdentifier: getGlobalIdentifier());
114}
115
116std::optional<GlobalValue::GUID> GlobalValue::getGUIDIfAssigned() const {
117 // First check the metadata.
118 auto *MD = getGUIDMetadata();
119 if (MD != nullptr)
120 return cast<ConstantInt>(Val: cast<ConstantAsMetadata>(Val: MD->getOperand(I: 0))
121 ->getValue()
122 ->stripPointerCasts())
123 ->getZExtValue();
124
125 // Handle a few special cases where we just want to compute it based on the
126 // current properties.
127 // TODO: Maybe we should use a more robust check for intrinsics than just
128 // matching on the name?
129 if (isDeclaration() || isa<GlobalAlias>(Val: this) ||
130 getName().starts_with(Prefix: "llvm.")) {
131 return GlobalValue::getGUIDAssumingExternalLinkage(GlobalIdentifier: getGlobalIdentifier());
132 }
133
134 // Otherwise we try to look it up in the module, for cases where we've read
135 // the GUID table but not the metadata. This happens when lazy-loading a
136 // module.
137 return getParent()->getGUID(V: this);
138}
139
140MDNode *GlobalValue::getGUIDMetadata() const {
141 if (auto *GO = dyn_cast<GlobalObject>(Val: this))
142 return GO->getMetadata(KindID: LLVMContext::MD_guid);
143 return nullptr;
144}
145
146void GlobalValue::removeFromParent() {
147 switch (getValueID()) {
148#define HANDLE_GLOBAL_VALUE(NAME) \
149 case Value::NAME##Val: \
150 return static_cast<NAME *>(this)->removeFromParent();
151#include "llvm/IR/Value.def"
152 default:
153 break;
154 }
155 llvm_unreachable("not a global");
156}
157
158void GlobalValue::eraseFromParent() {
159 switch (getValueID()) {
160#define HANDLE_GLOBAL_VALUE(NAME) \
161 case Value::NAME##Val: \
162 return static_cast<NAME *>(this)->eraseFromParent();
163#include "llvm/IR/Value.def"
164 default:
165 break;
166 }
167 llvm_unreachable("not a global");
168}
169
170GlobalObject::~GlobalObject() {
171 // Remove associated metadata from context.
172 if (hasMetadata())
173 clearMetadata();
174
175 setComdat(nullptr);
176}
177
178bool GlobalValue::isInterposable(bool CheckNoIPA) const {
179 if (CheckNoIPA && isNoipaFnDef())
180 return true;
181 if (isInterposableLinkage(Linkage: getLinkage()))
182 return true;
183 return !isDSOLocal() && getParent() &&
184 getParent()->getSemanticInterposition();
185}
186
187bool GlobalValue::canBenefitFromLocalAlias() const {
188 if (isTagged()) {
189 // Cannot create local aliases to MTE tagged globals. The address of a
190 // tagged global includes a tag that is assigned by the loader in the
191 // GOT.
192 return false;
193 }
194 // See AsmPrinter::getSymbolPreferLocal(). For a deduplicate comdat kind,
195 // references to a discarded local symbol from outside the group are not
196 // allowed, so avoid the local alias.
197 auto isDeduplicateComdat = [](const Comdat *C) {
198 return C && C->getSelectionKind() != Comdat::NoDeduplicate;
199 };
200 return hasDefaultVisibility() &&
201 GlobalObject::isExternalLinkage(Linkage: getLinkage()) && !isDeclaration() &&
202 !isa<GlobalIFunc>(Val: this) && !isDeduplicateComdat(getComdat());
203}
204
205const DataLayout &GlobalValue::getDataLayout() const {
206 return getParent()->getDataLayout();
207}
208
209void GlobalObject::setAlignment(MaybeAlign Align) {
210 assert((!Align || *Align <= MaximumAlignment) &&
211 "Alignment is greater than MaximumAlignment!");
212 unsigned AlignmentData = encode(A: Align);
213 unsigned OldData = getGlobalValueSubClassData();
214 setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData);
215 assert(getAlign() == Align && "Alignment representation error!");
216}
217
218void GlobalObject::setAlignment(Align Align) {
219 assert(Align <= MaximumAlignment &&
220 "Alignment is greater than MaximumAlignment!");
221 unsigned AlignmentData = encode(A: Align);
222 unsigned OldData = getGlobalValueSubClassData();
223 setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData);
224 assert(getAlign() && *getAlign() == Align &&
225 "Alignment representation error!");
226}
227
228void GlobalObject::copyAttributesFrom(const GlobalObject *Src) {
229 GlobalValue::copyAttributesFrom(Src);
230 setAlignment(Src->getAlign());
231 setSection(Src->getSection());
232}
233
234std::string GlobalValue::getGlobalIdentifier(StringRef Name,
235 GlobalValue::LinkageTypes Linkage,
236 StringRef FileName) {
237 // Value names may be prefixed with a binary '1' to indicate
238 // that the backend should not modify the symbols due to any platform
239 // naming convention. Do not include that '1' in the PGO profile name.
240 Name.consume_front(Prefix: "\1");
241
242 std::string GlobalName;
243 if (llvm::GlobalValue::isLocalLinkage(Linkage)) {
244 // For local symbols, prepend the main file name to distinguish them.
245 // Do not include the full path in the file name since there's no guarantee
246 // that it will stay the same, e.g., if the files are checked out from
247 // version control in different locations.
248 if (FileName.empty())
249 GlobalName += "<unknown>";
250 else
251 GlobalName += FileName;
252
253 GlobalName += GlobalIdentifierDelimiter;
254 }
255 GlobalName += Name;
256 return GlobalName;
257}
258
259std::string GlobalValue::getGlobalIdentifier() const {
260 return getGlobalIdentifier(Name: getName(), Linkage: getLinkage(),
261 FileName: getParent()->getSourceFileName());
262}
263
264StringRef GlobalValue::getSection() const {
265 if (auto *GA = dyn_cast<GlobalAlias>(Val: this)) {
266 // In general we cannot compute this at the IR level, but we try.
267 if (const GlobalObject *GO = GA->getAliaseeObject())
268 return GO->getSection();
269 return "";
270 }
271 return cast<GlobalObject>(Val: this)->getSection();
272}
273
274const Comdat *GlobalValue::getComdat() const {
275 if (auto *GA = dyn_cast<GlobalAlias>(Val: this)) {
276 // In general we cannot compute this at the IR level, but we try.
277 if (const GlobalObject *GO = GA->getAliaseeObject())
278 return const_cast<GlobalObject *>(GO)->getComdat();
279 return nullptr;
280 }
281 // ifunc and its resolver are separate things so don't use resolver comdat.
282 if (isa<GlobalIFunc>(Val: this))
283 return nullptr;
284 return cast<GlobalObject>(Val: this)->getComdat();
285}
286
287void GlobalObject::setComdat(Comdat *C) {
288 if (ObjComdat)
289 ObjComdat->removeUser(GO: this);
290 ObjComdat = C;
291 if (C)
292 C->addUser(GO: this);
293}
294
295StringRef GlobalValue::getPartition() const {
296 if (!hasPartition())
297 return "";
298 return getContext().pImpl->GlobalValuePartitions[this];
299}
300
301void GlobalValue::setPartition(StringRef S) {
302 // Do nothing if we're clearing the partition and it is already empty.
303 if (!hasPartition() && S.empty())
304 return;
305
306 // Get or create a stable partition name string and put it in the table in the
307 // context.
308 if (!S.empty())
309 S = getContext().pImpl->Saver.save(S);
310 getContext().pImpl->GlobalValuePartitions[this] = S;
311
312 // Update the HasPartition field. Setting the partition to the empty string
313 // means this global no longer has a partition.
314 HasPartition = !S.empty();
315}
316
317using SanitizerMetadata = GlobalValue::SanitizerMetadata;
318const SanitizerMetadata &GlobalValue::getSanitizerMetadata() const {
319 assert(hasSanitizerMetadata());
320 assert(getContext().pImpl->GlobalValueSanitizerMetadata.count(this));
321 return getContext().pImpl->GlobalValueSanitizerMetadata[this];
322}
323
324void GlobalValue::setSanitizerMetadata(SanitizerMetadata Meta) {
325 getContext().pImpl->GlobalValueSanitizerMetadata[this] = Meta;
326 HasSanitizerMetadata = true;
327}
328
329void GlobalValue::removeSanitizerMetadata() {
330 DenseMap<const GlobalValue *, SanitizerMetadata> &MetadataMap =
331 getContext().pImpl->GlobalValueSanitizerMetadata;
332 MetadataMap.erase(Val: this);
333 HasSanitizerMetadata = false;
334}
335
336void GlobalValue::setNoSanitizeMetadata() {
337 SanitizerMetadata Meta;
338 Meta.NoAddress = true;
339 Meta.NoHWAddress = true;
340 setSanitizerMetadata(Meta);
341}
342
343StringRef GlobalObject::getSectionImpl() const {
344 assert(hasSection());
345 return getContext().pImpl->GlobalObjectSections[this];
346}
347
348void GlobalObject::setSection(StringRef S) {
349 // Do nothing if we're clearing the section and it is already empty.
350 if (!hasSection() && S.empty())
351 return;
352
353 // Get or create a stable section name string and put it in the table in the
354 // context.
355 if (!S.empty())
356 S = getContext().pImpl->Saver.save(S);
357 getContext().pImpl->GlobalObjectSections[this] = S;
358
359 // Update the HasSectionHashEntryBit. Setting the section to the empty string
360 // means this global no longer has a section.
361 setGlobalObjectFlag(Bit: HasSectionHashEntryBit, Val: !S.empty());
362}
363
364bool GlobalObject::setSectionPrefix(StringRef Prefix) {
365 StringRef ExistingPrefix;
366 if (std::optional<StringRef> MaybePrefix = getSectionPrefix())
367 ExistingPrefix = *MaybePrefix;
368
369 if (ExistingPrefix == Prefix)
370 return false;
371
372 if (Prefix.empty()) {
373 setMetadata(KindID: LLVMContext::MD_section_prefix, Node: nullptr);
374 return true;
375 }
376 MDBuilder MDB(getContext());
377 setMetadata(KindID: LLVMContext::MD_section_prefix,
378 Node: MDB.createGlobalObjectSectionPrefix(Prefix));
379 return true;
380}
381
382std::optional<StringRef> GlobalObject::getSectionPrefix() const {
383 if (MDNode *MD = getMetadata(KindID: LLVMContext::MD_section_prefix)) {
384 [[maybe_unused]] StringRef MDName =
385 cast<MDString>(Val: MD->getOperand(I: 0))->getString();
386 assert((MDName == "section_prefix" ||
387 (isa<Function>(this) && MDName == "function_section_prefix")) &&
388 "Metadata not match");
389 return cast<MDString>(Val: MD->getOperand(I: 1))->getString();
390 }
391 return std::nullopt;
392}
393
394bool GlobalValue::isNobuiltinFnDef() const {
395 const Function *F = dyn_cast<Function>(Val: this);
396 if (!F || F->empty())
397 return false;
398 return F->hasFnAttribute(Kind: Attribute::NoBuiltin);
399}
400
401bool GlobalValue::isNoipaFnDef() const {
402 const Function *F = dyn_cast<Function>(Val: this);
403 if (!F || F->isDeclaration())
404 return false;
405 return F->hasFnAttribute(Kind: Attribute::NoIPA);
406}
407
408bool GlobalValue::isDeclaration() const {
409 // Globals are definitions if they have an initializer.
410 if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(Val: this))
411 return GV->getNumOperands() == 0;
412
413 // Functions are definitions if they have a body.
414 if (const Function *F = dyn_cast<Function>(Val: this))
415 return F->empty() && !F->isMaterializable();
416
417 // Aliases and ifuncs are always definitions.
418 assert(isa<GlobalAlias>(this) || isa<GlobalIFunc>(this));
419 return false;
420}
421
422bool GlobalObject::canIncreaseAlignment() const {
423 // Firstly, can only increase the alignment of a global if it
424 // is a strong definition.
425 if (!isStrongDefinitionForLinker())
426 return false;
427
428 // It also has to either not have a section defined, or, not have
429 // alignment specified. (If it is assigned a section, the global
430 // could be densely packed with other objects in the section, and
431 // increasing the alignment could cause padding issues.)
432 if (hasSection() && getAlign())
433 return false;
434
435 // On ELF platforms, we're further restricted in that we can't
436 // increase the alignment of any variable which might be emitted
437 // into a shared library, and which is exported. If the main
438 // executable accesses a variable found in a shared-lib, the main
439 // exe actually allocates memory for and exports the symbol ITSELF,
440 // overriding the symbol found in the library. That is, at link
441 // time, the observed alignment of the variable is copied into the
442 // executable binary. (A COPY relocation is also generated, to copy
443 // the initial data from the shadowed variable in the shared-lib
444 // into the location in the main binary, before running code.)
445 //
446 // And thus, even though you might think you are defining the
447 // global, and allocating the memory for the global in your object
448 // file, and thus should be able to set the alignment arbitrarily,
449 // that's not actually true. Doing so can cause an ABI breakage; an
450 // executable might have already been built with the previous
451 // alignment of the variable, and then assuming an increased
452 // alignment will be incorrect.
453
454 // Conservatively assume ELF if there's no parent pointer.
455 bool isELF = (!Parent || Parent->getTargetTriple().isOSBinFormatELF());
456 if (isELF && !isDSOLocal())
457 return false;
458
459 // GV with toc-data attribute is defined in a TOC entry. To mitigate TOC
460 // overflow, the alignment of such symbol should not be increased. Otherwise,
461 // padding is needed thus more TOC entries are wasted.
462 bool isXCOFF = (!Parent || Parent->getTargetTriple().isOSBinFormatXCOFF());
463 if (isXCOFF)
464 if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(Val: this))
465 if (GV->hasAttribute(Kind: "toc-data"))
466 return false;
467
468 return true;
469}
470
471bool GlobalObject::hasMetadataOtherThanDebugLocAndGuid() const {
472 SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
473 getAllMetadata(MDs);
474 for (const auto &V : MDs)
475 if (V.first != LLVMContext::MD_dbg && V.first != LLVMContext::MD_guid)
476 return true;
477 return false;
478}
479
480template <typename Operation>
481static const GlobalObject *
482findBaseObject(const Constant *C, DenseSet<const GlobalAlias *> &Aliases,
483 const Operation &Op) {
484 if (auto *GO = dyn_cast<GlobalObject>(Val: C)) {
485 Op(*GO);
486 return GO;
487 }
488 if (auto *GA = dyn_cast<GlobalAlias>(Val: C)) {
489 Op(*GA);
490 if (Aliases.insert(V: GA).second)
491 return findBaseObject(GA->getOperand(i_nocapture: 0), Aliases, Op);
492 }
493 if (auto *CE = dyn_cast<ConstantExpr>(Val: C)) {
494 switch (CE->getOpcode()) {
495 case Instruction::Add: {
496 auto *LHS = findBaseObject(CE->getOperand(i_nocapture: 0), Aliases, Op);
497 auto *RHS = findBaseObject(CE->getOperand(i_nocapture: 1), Aliases, Op);
498 if (LHS && RHS)
499 return nullptr;
500 return LHS ? LHS : RHS;
501 }
502 case Instruction::Sub: {
503 if (findBaseObject(CE->getOperand(i_nocapture: 1), Aliases, Op))
504 return nullptr;
505 return findBaseObject(CE->getOperand(i_nocapture: 0), Aliases, Op);
506 }
507 case Instruction::IntToPtr:
508 case Instruction::PtrToAddr:
509 case Instruction::PtrToInt:
510 case Instruction::BitCast:
511 case Instruction::AddrSpaceCast:
512 case Instruction::GetElementPtr:
513 return findBaseObject(CE->getOperand(i_nocapture: 0), Aliases, Op);
514 default:
515 break;
516 }
517 }
518 return nullptr;
519}
520
521const GlobalObject *GlobalValue::getAliaseeObject() const {
522 DenseSet<const GlobalAlias *> Aliases;
523 return findBaseObject(C: this, Aliases, Op: [](const GlobalValue &) {});
524}
525
526bool GlobalValue::isAbsoluteSymbolRef() const {
527 auto *GO = dyn_cast<GlobalObject>(Val: this);
528 if (!GO)
529 return false;
530
531 return GO->getMetadata(KindID: LLVMContext::MD_absolute_symbol);
532}
533
534std::optional<ConstantRange> GlobalValue::getAbsoluteSymbolRange() const {
535 auto *GO = dyn_cast<GlobalObject>(Val: this);
536 if (!GO)
537 return std::nullopt;
538
539 MDNode *MD = GO->getMetadata(KindID: LLVMContext::MD_absolute_symbol);
540 if (!MD)
541 return std::nullopt;
542
543 return getConstantRangeFromMetadata(RangeMD: *MD);
544}
545
546bool GlobalValue::canBeOmittedFromSymbolTable() const {
547 if (!hasLinkOnceODRLinkage())
548 return false;
549
550 // We assume that anyone who sets global unnamed_addr on a non-constant
551 // knows what they're doing.
552 if (hasGlobalUnnamedAddr())
553 return true;
554
555 // If it is a non constant variable, it needs to be uniqued across shared
556 // objects.
557 if (auto *Var = dyn_cast<GlobalVariable>(Val: this))
558 if (!Var->isConstant())
559 return false;
560
561 return hasAtLeastLocalUnnamedAddr();
562}
563
564//===----------------------------------------------------------------------===//
565// GlobalVariable Implementation
566//===----------------------------------------------------------------------===//
567
568GlobalVariable::GlobalVariable(Type *Ty, bool constant, LinkageTypes Link,
569 Constant *InitVal, const Twine &Name,
570 ThreadLocalMode TLMode, unsigned AddressSpace,
571 bool isExternallyInitialized)
572 : GlobalObject(Ty, Value::GlobalVariableVal, AllocMarker, Link, Name,
573 AddressSpace),
574 isConstantGlobal(constant),
575 isExternallyInitializedConstant(isExternallyInitialized) {
576 assert(!Ty->isFunctionTy() && PointerType::isValidElementType(Ty) &&
577 "invalid type for global variable");
578 setThreadLocalMode(TLMode);
579 if (InitVal) {
580 assert(InitVal->getType() == Ty &&
581 "Initializer should be the same type as the GlobalVariable!");
582 Op<0>() = InitVal;
583 } else {
584 setGlobalVariableNumOperands(0);
585 }
586}
587
588GlobalVariable::GlobalVariable(Module &M, Type *Ty, bool constant,
589 LinkageTypes Link, Constant *InitVal,
590 const Twine &Name, GlobalVariable *Before,
591 ThreadLocalMode TLMode,
592 std::optional<unsigned> AddressSpace,
593 bool isExternallyInitialized)
594 : GlobalVariable(Ty, constant, Link, InitVal, Name, TLMode,
595 AddressSpace
596 ? *AddressSpace
597 : M.getDataLayout().getDefaultGlobalsAddressSpace(),
598 isExternallyInitialized) {
599 if (Before)
600 Before->getParent()->insertGlobalVariable(Where: Before->getIterator(), GV: this);
601 else
602 M.insertGlobalVariable(GV: this);
603}
604
605void GlobalVariable::removeFromParent() {
606 getParent()->removeGlobalVariable(GV: this);
607}
608
609void GlobalVariable::eraseFromParent() {
610 getParent()->eraseGlobalVariable(GV: this);
611}
612
613void GlobalVariable::setInitializer(Constant *InitVal) {
614 if (!InitVal) {
615 if (hasInitializer()) {
616 // Note, the num operands is used to compute the offset of the operand, so
617 // the order here matters. Clearing the operand then clearing the num
618 // operands ensures we have the correct offset to the operand.
619 Op<0>().set(nullptr);
620 setGlobalVariableNumOperands(0);
621 }
622 } else {
623 assert(InitVal->getType() == getValueType() &&
624 "Initializer type must match GlobalVariable type");
625 // Note, the num operands is used to compute the offset of the operand, so
626 // the order here matters. We need to set num operands to 1 first so that
627 // we get the correct offset to the first operand when we set it.
628 if (!hasInitializer())
629 setGlobalVariableNumOperands(1);
630 Op<0>().set(InitVal);
631 }
632}
633
634void GlobalVariable::replaceInitializer(Constant *InitVal) {
635 assert(InitVal && "Can't compute type of null initializer");
636 ValueType = InitVal->getType();
637 setInitializer(InitVal);
638}
639
640uint64_t GlobalVariable::getGlobalSize(const DataLayout &DL) const {
641 // We don't support scalable global variables.
642 return DL.getTypeAllocSize(Ty: getValueType()).getFixedValue();
643}
644
645/// Copy all additional attributes (those not needed to create a GlobalVariable)
646/// from the GlobalVariable Src to this one.
647void GlobalVariable::copyAttributesFrom(const GlobalVariable *Src) {
648 GlobalObject::copyAttributesFrom(Src);
649 setExternallyInitialized(Src->isExternallyInitialized());
650 setAttributes(Src->getAttributes());
651 if (auto CM = Src->getCodeModel())
652 setCodeModel(*CM);
653}
654
655void GlobalVariable::dropAllReferences() {
656 User::dropAllReferences();
657 clearMetadata();
658}
659
660void GlobalVariable::setCodeModel(CodeModel::Model CM) {
661 unsigned CodeModelData = static_cast<unsigned>(CM) + 1;
662 unsigned OldData = getGlobalValueSubClassData();
663 unsigned NewData = (OldData & ~(CodeModelMask << CodeModelShift)) |
664 (CodeModelData << CodeModelShift);
665 setGlobalValueSubClassData(NewData);
666 assert(getCodeModel() == CM && "Code model representation error!");
667}
668
669void GlobalVariable::clearCodeModel() {
670 unsigned CodeModelData = 0;
671 unsigned OldData = getGlobalValueSubClassData();
672 unsigned NewData = (OldData & ~(CodeModelMask << CodeModelShift)) |
673 (CodeModelData << CodeModelShift);
674 setGlobalValueSubClassData(NewData);
675 assert(getCodeModel() == std::nullopt && "Code model representation error!");
676}
677
678//===----------------------------------------------------------------------===//
679// GlobalAlias Implementation
680//===----------------------------------------------------------------------===//
681
682GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
683 const Twine &Name, Constant *Aliasee,
684 Module *ParentModule)
685 : GlobalValue(Ty, Value::GlobalAliasVal, AllocMarker, Link, Name,
686 AddressSpace) {
687 setAliasee(Aliasee);
688 if (ParentModule)
689 ParentModule->insertAlias(Alias: this);
690}
691
692GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace,
693 LinkageTypes Link, const Twine &Name,
694 Constant *Aliasee, Module *ParentModule) {
695 return new GlobalAlias(Ty, AddressSpace, Link, Name, Aliasee, ParentModule);
696}
697
698GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace,
699 LinkageTypes Linkage, const Twine &Name,
700 Module *Parent) {
701 return create(Ty, AddressSpace, Link: Linkage, Name, Aliasee: nullptr, ParentModule: Parent);
702}
703
704GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace,
705 LinkageTypes Linkage, const Twine &Name,
706 GlobalValue *Aliasee) {
707 return create(Ty, AddressSpace, Link: Linkage, Name, Aliasee, ParentModule: Aliasee->getParent());
708}
709
710GlobalAlias *GlobalAlias::create(LinkageTypes Link, const Twine &Name,
711 GlobalValue *Aliasee) {
712 return create(Ty: Aliasee->getValueType(), AddressSpace: Aliasee->getAddressSpace(), Linkage: Link, Name,
713 Aliasee);
714}
715
716GlobalAlias *GlobalAlias::create(const Twine &Name, GlobalValue *Aliasee) {
717 return create(Link: Aliasee->getLinkage(), Name, Aliasee);
718}
719
720void GlobalAlias::removeFromParent() { getParent()->removeAlias(Alias: this); }
721
722void GlobalAlias::eraseFromParent() { getParent()->eraseAlias(Alias: this); }
723
724void GlobalAlias::setAliasee(Constant *Aliasee) {
725 assert((!Aliasee || Aliasee->getType() == getType()) &&
726 "Alias and aliasee types should match!");
727 Op<0>().set(Aliasee);
728}
729
730const GlobalObject *GlobalAlias::getAliaseeObject() const {
731 DenseSet<const GlobalAlias *> Aliases;
732 return findBaseObject(C: getOperand(i_nocapture: 0), Aliases, Op: [](const GlobalValue &) {});
733}
734
735//===----------------------------------------------------------------------===//
736// GlobalIFunc Implementation
737//===----------------------------------------------------------------------===//
738
739GlobalIFunc::GlobalIFunc(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
740 const Twine &Name, Constant *Resolver,
741 Module *ParentModule)
742 : GlobalObject(Ty, Value::GlobalIFuncVal, AllocMarker, Link, Name,
743 AddressSpace) {
744 setResolver(Resolver);
745 if (ParentModule)
746 ParentModule->insertIFunc(IFunc: this);
747}
748
749GlobalIFunc *GlobalIFunc::create(Type *Ty, unsigned AddressSpace,
750 LinkageTypes Link, const Twine &Name,
751 Constant *Resolver, Module *ParentModule) {
752 return new GlobalIFunc(Ty, AddressSpace, Link, Name, Resolver, ParentModule);
753}
754
755void GlobalIFunc::removeFromParent() { getParent()->removeIFunc(IFunc: this); }
756
757void GlobalIFunc::eraseFromParent() { getParent()->eraseIFunc(IFunc: this); }
758
759const Function *GlobalIFunc::getResolverFunction() const {
760 return dyn_cast<Function>(Val: getResolver()->stripPointerCastsAndAliases());
761}
762
763void GlobalIFunc::applyAlongResolverPath(
764 function_ref<void(const GlobalValue &)> Op) const {
765 DenseSet<const GlobalAlias *> Aliases;
766 findBaseObject(C: getResolver(), Aliases, Op);
767}
768