10b57cec5SDimitry Andric //===-- Globals.cpp - Implement the GlobalValue & GlobalVariable class ----===// 20b57cec5SDimitry Andric // 30b57cec5SDimitry Andric // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 40b57cec5SDimitry Andric // See https://llvm.org/LICENSE.txt for license information. 50b57cec5SDimitry Andric // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 60b57cec5SDimitry Andric // 70b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 80b57cec5SDimitry Andric // 90b57cec5SDimitry Andric // This file implements the GlobalValue & GlobalVariable classes for the IR 100b57cec5SDimitry Andric // library. 110b57cec5SDimitry Andric // 120b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 130b57cec5SDimitry Andric 140b57cec5SDimitry Andric #include "LLVMContextImpl.h" 150b57cec5SDimitry Andric #include "llvm/IR/ConstantRange.h" 160b57cec5SDimitry Andric #include "llvm/IR/Constants.h" 170b57cec5SDimitry Andric #include "llvm/IR/DerivedTypes.h" 180b57cec5SDimitry Andric #include "llvm/IR/GlobalAlias.h" 190b57cec5SDimitry Andric #include "llvm/IR/GlobalValue.h" 200b57cec5SDimitry Andric #include "llvm/IR/GlobalVariable.h" 210b57cec5SDimitry Andric #include "llvm/IR/Module.h" 220b57cec5SDimitry Andric #include "llvm/Support/Error.h" 230b57cec5SDimitry Andric #include "llvm/Support/ErrorHandling.h" 2406c3fb27SDimitry Andric #include "llvm/TargetParser/Triple.h" 250b57cec5SDimitry Andric using namespace llvm; 260b57cec5SDimitry Andric 270b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 280b57cec5SDimitry Andric // GlobalValue Class 290b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 300b57cec5SDimitry Andric 310b57cec5SDimitry Andric // GlobalValue should be a Constant, plus a type, a module, some flags, and an 320b57cec5SDimitry Andric // intrinsic ID. Add an assert to prevent people from accidentally growing 330b57cec5SDimitry Andric // GlobalValue while adding flags. 340b57cec5SDimitry Andric static_assert(sizeof(GlobalValue) == 350b57cec5SDimitry Andric sizeof(Constant) + 2 * sizeof(void *) + 2 * sizeof(unsigned), 360b57cec5SDimitry Andric "unexpected GlobalValue size growth"); 370b57cec5SDimitry Andric 380b57cec5SDimitry Andric // GlobalObject adds a comdat. 390b57cec5SDimitry Andric static_assert(sizeof(GlobalObject) == sizeof(GlobalValue) + sizeof(void *), 400b57cec5SDimitry Andric "unexpected GlobalObject size growth"); 410b57cec5SDimitry Andric 420b57cec5SDimitry Andric bool GlobalValue::isMaterializable() const { 430b57cec5SDimitry Andric if (const Function *F = dyn_cast<Function>(this)) 440b57cec5SDimitry Andric return F->isMaterializable(); 450b57cec5SDimitry Andric return false; 460b57cec5SDimitry Andric } 4706c3fb27SDimitry Andric Error GlobalValue::materialize() { return getParent()->materialize(this); } 480b57cec5SDimitry Andric 490b57cec5SDimitry Andric /// Override destroyConstantImpl to make sure it doesn't get called on 500b57cec5SDimitry Andric /// GlobalValue's because they shouldn't be treated like other constants. 510b57cec5SDimitry Andric void GlobalValue::destroyConstantImpl() { 520b57cec5SDimitry Andric llvm_unreachable("You can't GV->destroyConstantImpl()!"); 530b57cec5SDimitry Andric } 540b57cec5SDimitry Andric 550b57cec5SDimitry Andric Value *GlobalValue::handleOperandChangeImpl(Value *From, Value *To) { 560b57cec5SDimitry Andric llvm_unreachable("Unsupported class for handleOperandChange()!"); 570b57cec5SDimitry Andric } 580b57cec5SDimitry Andric 590b57cec5SDimitry Andric /// copyAttributesFrom - copy all additional attributes (those not needed to 600b57cec5SDimitry Andric /// create a GlobalValue) from the GlobalValue Src to this one. 610b57cec5SDimitry Andric void GlobalValue::copyAttributesFrom(const GlobalValue *Src) { 620b57cec5SDimitry Andric setVisibility(Src->getVisibility()); 630b57cec5SDimitry Andric setUnnamedAddr(Src->getUnnamedAddr()); 645ffd83dbSDimitry Andric setThreadLocalMode(Src->getThreadLocalMode()); 650b57cec5SDimitry Andric setDLLStorageClass(Src->getDLLStorageClass()); 660b57cec5SDimitry Andric setDSOLocal(Src->isDSOLocal()); 670b57cec5SDimitry Andric setPartition(Src->getPartition()); 6881ad6265SDimitry Andric if (Src->hasSanitizerMetadata()) 6981ad6265SDimitry Andric setSanitizerMetadata(Src->getSanitizerMetadata()); 7081ad6265SDimitry Andric else 7181ad6265SDimitry Andric removeSanitizerMetadata(); 720b57cec5SDimitry Andric } 730b57cec5SDimitry Andric 740b57cec5SDimitry Andric void GlobalValue::removeFromParent() { 750b57cec5SDimitry Andric switch (getValueID()) { 760b57cec5SDimitry Andric #define HANDLE_GLOBAL_VALUE(NAME) \ 770b57cec5SDimitry Andric case Value::NAME##Val: \ 780b57cec5SDimitry Andric return static_cast<NAME *>(this)->removeFromParent(); 790b57cec5SDimitry Andric #include "llvm/IR/Value.def" 800b57cec5SDimitry Andric default: 810b57cec5SDimitry Andric break; 820b57cec5SDimitry Andric } 830b57cec5SDimitry Andric llvm_unreachable("not a global"); 840b57cec5SDimitry Andric } 850b57cec5SDimitry Andric 860b57cec5SDimitry Andric void GlobalValue::eraseFromParent() { 870b57cec5SDimitry Andric switch (getValueID()) { 880b57cec5SDimitry Andric #define HANDLE_GLOBAL_VALUE(NAME) \ 890b57cec5SDimitry Andric case Value::NAME##Val: \ 900b57cec5SDimitry Andric return static_cast<NAME *>(this)->eraseFromParent(); 910b57cec5SDimitry Andric #include "llvm/IR/Value.def" 920b57cec5SDimitry Andric default: 930b57cec5SDimitry Andric break; 940b57cec5SDimitry Andric } 950b57cec5SDimitry Andric llvm_unreachable("not a global"); 960b57cec5SDimitry Andric } 970b57cec5SDimitry Andric 9804eeddc0SDimitry Andric GlobalObject::~GlobalObject() { setComdat(nullptr); } 9904eeddc0SDimitry Andric 1005ffd83dbSDimitry Andric bool GlobalValue::isInterposable() const { 1015ffd83dbSDimitry Andric if (isInterposableLinkage(getLinkage())) 1025ffd83dbSDimitry Andric return true; 1035ffd83dbSDimitry Andric return getParent() && getParent()->getSemanticInterposition() && 1045ffd83dbSDimitry Andric !isDSOLocal(); 1050b57cec5SDimitry Andric } 1065ffd83dbSDimitry Andric 1075ffd83dbSDimitry Andric bool GlobalValue::canBenefitFromLocalAlias() const { 10804eeddc0SDimitry Andric // See AsmPrinter::getSymbolPreferLocal(). For a deduplicate comdat kind, 10904eeddc0SDimitry Andric // references to a discarded local symbol from outside the group are not 11004eeddc0SDimitry Andric // allowed, so avoid the local alias. 11104eeddc0SDimitry Andric auto isDeduplicateComdat = [](const Comdat *C) { 11204eeddc0SDimitry Andric return C && C->getSelectionKind() != Comdat::NoDeduplicate; 11304eeddc0SDimitry Andric }; 1148833aad7SDimitry Andric return hasDefaultVisibility() && 1158833aad7SDimitry Andric GlobalObject::isExternalLinkage(getLinkage()) && !isDeclaration() && 11604eeddc0SDimitry Andric !isa<GlobalIFunc>(this) && !isDeduplicateComdat(getComdat()); 1170b57cec5SDimitry Andric } 1180b57cec5SDimitry Andric 1198bcb0991SDimitry Andric void GlobalObject::setAlignment(MaybeAlign Align) { 1205ffd83dbSDimitry Andric assert((!Align || *Align <= MaximumAlignment) && 1210b57cec5SDimitry Andric "Alignment is greater than MaximumAlignment!"); 1228bcb0991SDimitry Andric unsigned AlignmentData = encode(Align); 1230b57cec5SDimitry Andric unsigned OldData = getGlobalValueSubClassData(); 1240b57cec5SDimitry Andric setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData); 125bdd1243dSDimitry Andric assert(getAlign() == Align && "Alignment representation error!"); 1260b57cec5SDimitry Andric } 1270b57cec5SDimitry Andric 12806c3fb27SDimitry Andric void GlobalObject::setAlignment(Align Align) { 12906c3fb27SDimitry Andric assert(Align <= MaximumAlignment && 13006c3fb27SDimitry Andric "Alignment is greater than MaximumAlignment!"); 13106c3fb27SDimitry Andric unsigned AlignmentData = encode(Align); 13206c3fb27SDimitry Andric unsigned OldData = getGlobalValueSubClassData(); 13306c3fb27SDimitry Andric setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData); 13406c3fb27SDimitry Andric assert(getAlign() && *getAlign() == Align && 13506c3fb27SDimitry Andric "Alignment representation error!"); 13606c3fb27SDimitry Andric } 13706c3fb27SDimitry Andric 1380b57cec5SDimitry Andric void GlobalObject::copyAttributesFrom(const GlobalObject *Src) { 1390b57cec5SDimitry Andric GlobalValue::copyAttributesFrom(Src); 1400eae32dcSDimitry Andric setAlignment(Src->getAlign()); 1410b57cec5SDimitry Andric setSection(Src->getSection()); 1420b57cec5SDimitry Andric } 1430b57cec5SDimitry Andric 1440b57cec5SDimitry Andric std::string GlobalValue::getGlobalIdentifier(StringRef Name, 1450b57cec5SDimitry Andric GlobalValue::LinkageTypes Linkage, 1460b57cec5SDimitry Andric StringRef FileName) { 1470b57cec5SDimitry Andric // Value names may be prefixed with a binary '1' to indicate 1480b57cec5SDimitry Andric // that the backend should not modify the symbols due to any platform 1490b57cec5SDimitry Andric // naming convention. Do not include that '1' in the PGO profile name. 150*7a6dacacSDimitry Andric Name.consume_front("\1"); 1510b57cec5SDimitry Andric 152cb14a3feSDimitry Andric std::string GlobalName; 1530b57cec5SDimitry Andric if (llvm::GlobalValue::isLocalLinkage(Linkage)) { 1540b57cec5SDimitry Andric // For local symbols, prepend the main file name to distinguish them. 1550b57cec5SDimitry Andric // Do not include the full path in the file name since there's no guarantee 1560b57cec5SDimitry Andric // that it will stay the same, e.g., if the files are checked out from 1570b57cec5SDimitry Andric // version control in different locations. 1580b57cec5SDimitry Andric if (FileName.empty()) 159cb14a3feSDimitry Andric GlobalName += "<unknown>"; 1600b57cec5SDimitry Andric else 161cb14a3feSDimitry Andric GlobalName += FileName; 162cb14a3feSDimitry Andric 163cb14a3feSDimitry Andric GlobalName += kGlobalIdentifierDelimiter; 1640b57cec5SDimitry Andric } 165cb14a3feSDimitry Andric GlobalName += Name; 166cb14a3feSDimitry Andric return GlobalName; 1670b57cec5SDimitry Andric } 1680b57cec5SDimitry Andric 1690b57cec5SDimitry Andric std::string GlobalValue::getGlobalIdentifier() const { 1700b57cec5SDimitry Andric return getGlobalIdentifier(getName(), getLinkage(), 1710b57cec5SDimitry Andric getParent()->getSourceFileName()); 1720b57cec5SDimitry Andric } 1730b57cec5SDimitry Andric 1740b57cec5SDimitry Andric StringRef GlobalValue::getSection() const { 1750b57cec5SDimitry Andric if (auto *GA = dyn_cast<GlobalAlias>(this)) { 1760b57cec5SDimitry Andric // In general we cannot compute this at the IR level, but we try. 177349cc55cSDimitry Andric if (const GlobalObject *GO = GA->getAliaseeObject()) 1780b57cec5SDimitry Andric return GO->getSection(); 1790b57cec5SDimitry Andric return ""; 1800b57cec5SDimitry Andric } 1810b57cec5SDimitry Andric return cast<GlobalObject>(this)->getSection(); 1820b57cec5SDimitry Andric } 1830b57cec5SDimitry Andric 1840b57cec5SDimitry Andric const Comdat *GlobalValue::getComdat() const { 1850b57cec5SDimitry Andric if (auto *GA = dyn_cast<GlobalAlias>(this)) { 1860b57cec5SDimitry Andric // In general we cannot compute this at the IR level, but we try. 187349cc55cSDimitry Andric if (const GlobalObject *GO = GA->getAliaseeObject()) 1880b57cec5SDimitry Andric return const_cast<GlobalObject *>(GO)->getComdat(); 1890b57cec5SDimitry Andric return nullptr; 1900b57cec5SDimitry Andric } 1910b57cec5SDimitry Andric // ifunc and its resolver are separate things so don't use resolver comdat. 1920b57cec5SDimitry Andric if (isa<GlobalIFunc>(this)) 1930b57cec5SDimitry Andric return nullptr; 1940b57cec5SDimitry Andric return cast<GlobalObject>(this)->getComdat(); 1950b57cec5SDimitry Andric } 1960b57cec5SDimitry Andric 19704eeddc0SDimitry Andric void GlobalObject::setComdat(Comdat *C) { 19804eeddc0SDimitry Andric if (ObjComdat) 19904eeddc0SDimitry Andric ObjComdat->removeUser(this); 20004eeddc0SDimitry Andric ObjComdat = C; 20104eeddc0SDimitry Andric if (C) 20204eeddc0SDimitry Andric C->addUser(this); 20304eeddc0SDimitry Andric } 20404eeddc0SDimitry Andric 2050b57cec5SDimitry Andric StringRef GlobalValue::getPartition() const { 2060b57cec5SDimitry Andric if (!hasPartition()) 2070b57cec5SDimitry Andric return ""; 2080b57cec5SDimitry Andric return getContext().pImpl->GlobalValuePartitions[this]; 2090b57cec5SDimitry Andric } 2100b57cec5SDimitry Andric 2110b57cec5SDimitry Andric void GlobalValue::setPartition(StringRef S) { 2120b57cec5SDimitry Andric // Do nothing if we're clearing the partition and it is already empty. 2130b57cec5SDimitry Andric if (!hasPartition() && S.empty()) 2140b57cec5SDimitry Andric return; 2150b57cec5SDimitry Andric 2160b57cec5SDimitry Andric // Get or create a stable partition name string and put it in the table in the 2170b57cec5SDimitry Andric // context. 2180b57cec5SDimitry Andric if (!S.empty()) 2190b57cec5SDimitry Andric S = getContext().pImpl->Saver.save(S); 2200b57cec5SDimitry Andric getContext().pImpl->GlobalValuePartitions[this] = S; 2210b57cec5SDimitry Andric 2220b57cec5SDimitry Andric // Update the HasPartition field. Setting the partition to the empty string 2230b57cec5SDimitry Andric // means this global no longer has a partition. 2240b57cec5SDimitry Andric HasPartition = !S.empty(); 2250b57cec5SDimitry Andric } 2260b57cec5SDimitry Andric 22781ad6265SDimitry Andric using SanitizerMetadata = GlobalValue::SanitizerMetadata; 22881ad6265SDimitry Andric const SanitizerMetadata &GlobalValue::getSanitizerMetadata() const { 22981ad6265SDimitry Andric assert(hasSanitizerMetadata()); 23081ad6265SDimitry Andric assert(getContext().pImpl->GlobalValueSanitizerMetadata.count(this)); 23181ad6265SDimitry Andric return getContext().pImpl->GlobalValueSanitizerMetadata[this]; 23281ad6265SDimitry Andric } 23381ad6265SDimitry Andric 23481ad6265SDimitry Andric void GlobalValue::setSanitizerMetadata(SanitizerMetadata Meta) { 23581ad6265SDimitry Andric getContext().pImpl->GlobalValueSanitizerMetadata[this] = Meta; 23681ad6265SDimitry Andric HasSanitizerMetadata = true; 23781ad6265SDimitry Andric } 23881ad6265SDimitry Andric 23981ad6265SDimitry Andric void GlobalValue::removeSanitizerMetadata() { 24081ad6265SDimitry Andric DenseMap<const GlobalValue *, SanitizerMetadata> &MetadataMap = 24181ad6265SDimitry Andric getContext().pImpl->GlobalValueSanitizerMetadata; 24281ad6265SDimitry Andric MetadataMap.erase(this); 24381ad6265SDimitry Andric HasSanitizerMetadata = false; 24481ad6265SDimitry Andric } 24581ad6265SDimitry Andric 2460b57cec5SDimitry Andric StringRef GlobalObject::getSectionImpl() const { 2470b57cec5SDimitry Andric assert(hasSection()); 2480b57cec5SDimitry Andric return getContext().pImpl->GlobalObjectSections[this]; 2490b57cec5SDimitry Andric } 2500b57cec5SDimitry Andric 2510b57cec5SDimitry Andric void GlobalObject::setSection(StringRef S) { 2520b57cec5SDimitry Andric // Do nothing if we're clearing the section and it is already empty. 2530b57cec5SDimitry Andric if (!hasSection() && S.empty()) 2540b57cec5SDimitry Andric return; 2550b57cec5SDimitry Andric 2560b57cec5SDimitry Andric // Get or create a stable section name string and put it in the table in the 2570b57cec5SDimitry Andric // context. 2580b57cec5SDimitry Andric if (!S.empty()) 2590b57cec5SDimitry Andric S = getContext().pImpl->Saver.save(S); 2600b57cec5SDimitry Andric getContext().pImpl->GlobalObjectSections[this] = S; 2610b57cec5SDimitry Andric 2620b57cec5SDimitry Andric // Update the HasSectionHashEntryBit. Setting the section to the empty string 2630b57cec5SDimitry Andric // means this global no longer has a section. 2640b57cec5SDimitry Andric setGlobalObjectFlag(HasSectionHashEntryBit, !S.empty()); 2650b57cec5SDimitry Andric } 2660b57cec5SDimitry Andric 267bdd1243dSDimitry Andric bool GlobalValue::isNobuiltinFnDef() const { 268bdd1243dSDimitry Andric const Function *F = dyn_cast<Function>(this); 269bdd1243dSDimitry Andric if (!F || F->empty()) 270bdd1243dSDimitry Andric return false; 271bdd1243dSDimitry Andric return F->hasFnAttribute(Attribute::NoBuiltin); 272bdd1243dSDimitry Andric } 273bdd1243dSDimitry Andric 2740b57cec5SDimitry Andric bool GlobalValue::isDeclaration() const { 2750b57cec5SDimitry Andric // Globals are definitions if they have an initializer. 2760b57cec5SDimitry Andric if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(this)) 2770b57cec5SDimitry Andric return GV->getNumOperands() == 0; 2780b57cec5SDimitry Andric 2790b57cec5SDimitry Andric // Functions are definitions if they have a body. 2800b57cec5SDimitry Andric if (const Function *F = dyn_cast<Function>(this)) 2810b57cec5SDimitry Andric return F->empty() && !F->isMaterializable(); 2820b57cec5SDimitry Andric 2830b57cec5SDimitry Andric // Aliases and ifuncs are always definitions. 284349cc55cSDimitry Andric assert(isa<GlobalAlias>(this) || isa<GlobalIFunc>(this)); 2850b57cec5SDimitry Andric return false; 2860b57cec5SDimitry Andric } 2870b57cec5SDimitry Andric 2885ffd83dbSDimitry Andric bool GlobalObject::canIncreaseAlignment() const { 2890b57cec5SDimitry Andric // Firstly, can only increase the alignment of a global if it 2900b57cec5SDimitry Andric // is a strong definition. 2910b57cec5SDimitry Andric if (!isStrongDefinitionForLinker()) 2920b57cec5SDimitry Andric return false; 2930b57cec5SDimitry Andric 2940b57cec5SDimitry Andric // It also has to either not have a section defined, or, not have 2950b57cec5SDimitry Andric // alignment specified. (If it is assigned a section, the global 2960b57cec5SDimitry Andric // could be densely packed with other objects in the section, and 2970b57cec5SDimitry Andric // increasing the alignment could cause padding issues.) 29881ad6265SDimitry Andric if (hasSection() && getAlign()) 2990b57cec5SDimitry Andric return false; 3000b57cec5SDimitry Andric 3010b57cec5SDimitry Andric // On ELF platforms, we're further restricted in that we can't 3020b57cec5SDimitry Andric // increase the alignment of any variable which might be emitted 3030b57cec5SDimitry Andric // into a shared library, and which is exported. If the main 3040b57cec5SDimitry Andric // executable accesses a variable found in a shared-lib, the main 3050b57cec5SDimitry Andric // exe actually allocates memory for and exports the symbol ITSELF, 3060b57cec5SDimitry Andric // overriding the symbol found in the library. That is, at link 3070b57cec5SDimitry Andric // time, the observed alignment of the variable is copied into the 3080b57cec5SDimitry Andric // executable binary. (A COPY relocation is also generated, to copy 3090b57cec5SDimitry Andric // the initial data from the shadowed variable in the shared-lib 3100b57cec5SDimitry Andric // into the location in the main binary, before running code.) 3110b57cec5SDimitry Andric // 3120b57cec5SDimitry Andric // And thus, even though you might think you are defining the 3130b57cec5SDimitry Andric // global, and allocating the memory for the global in your object 3140b57cec5SDimitry Andric // file, and thus should be able to set the alignment arbitrarily, 3150b57cec5SDimitry Andric // that's not actually true. Doing so can cause an ABI breakage; an 3160b57cec5SDimitry Andric // executable might have already been built with the previous 3170b57cec5SDimitry Andric // alignment of the variable, and then assuming an increased 3180b57cec5SDimitry Andric // alignment will be incorrect. 3190b57cec5SDimitry Andric 3200b57cec5SDimitry Andric // Conservatively assume ELF if there's no parent pointer. 3210b57cec5SDimitry Andric bool isELF = 3220b57cec5SDimitry Andric (!Parent || Triple(Parent->getTargetTriple()).isOSBinFormatELF()); 3230b57cec5SDimitry Andric if (isELF && !isDSOLocal()) 3240b57cec5SDimitry Andric return false; 3250b57cec5SDimitry Andric 3260b57cec5SDimitry Andric return true; 3270b57cec5SDimitry Andric } 3280b57cec5SDimitry Andric 329fcaf7f86SDimitry Andric template <typename Operation> 330349cc55cSDimitry Andric static const GlobalObject * 331fcaf7f86SDimitry Andric findBaseObject(const Constant *C, DenseSet<const GlobalAlias *> &Aliases, 332fcaf7f86SDimitry Andric const Operation &Op) { 333fcaf7f86SDimitry Andric if (auto *GO = dyn_cast<GlobalObject>(C)) { 334fcaf7f86SDimitry Andric Op(*GO); 3350b57cec5SDimitry Andric return GO; 336fcaf7f86SDimitry Andric } 337fcaf7f86SDimitry Andric if (auto *GA = dyn_cast<GlobalAlias>(C)) { 338fcaf7f86SDimitry Andric Op(*GA); 339349cc55cSDimitry Andric if (Aliases.insert(GA).second) 340fcaf7f86SDimitry Andric return findBaseObject(GA->getOperand(0), Aliases, Op); 341fcaf7f86SDimitry Andric } 342349cc55cSDimitry Andric if (auto *CE = dyn_cast<ConstantExpr>(C)) { 343349cc55cSDimitry Andric switch (CE->getOpcode()) { 344349cc55cSDimitry Andric case Instruction::Add: { 345fcaf7f86SDimitry Andric auto *LHS = findBaseObject(CE->getOperand(0), Aliases, Op); 346fcaf7f86SDimitry Andric auto *RHS = findBaseObject(CE->getOperand(1), Aliases, Op); 347349cc55cSDimitry Andric if (LHS && RHS) 3480b57cec5SDimitry Andric return nullptr; 349349cc55cSDimitry Andric return LHS ? LHS : RHS; 350349cc55cSDimitry Andric } 351349cc55cSDimitry Andric case Instruction::Sub: { 352fcaf7f86SDimitry Andric if (findBaseObject(CE->getOperand(1), Aliases, Op)) 353349cc55cSDimitry Andric return nullptr; 354fcaf7f86SDimitry Andric return findBaseObject(CE->getOperand(0), Aliases, Op); 355349cc55cSDimitry Andric } 356349cc55cSDimitry Andric case Instruction::IntToPtr: 357349cc55cSDimitry Andric case Instruction::PtrToInt: 358349cc55cSDimitry Andric case Instruction::BitCast: 359349cc55cSDimitry Andric case Instruction::GetElementPtr: 360fcaf7f86SDimitry Andric return findBaseObject(CE->getOperand(0), Aliases, Op); 361349cc55cSDimitry Andric default: 362349cc55cSDimitry Andric break; 363349cc55cSDimitry Andric } 364349cc55cSDimitry Andric } 365349cc55cSDimitry Andric return nullptr; 366349cc55cSDimitry Andric } 367349cc55cSDimitry Andric 368349cc55cSDimitry Andric const GlobalObject *GlobalValue::getAliaseeObject() const { 369349cc55cSDimitry Andric DenseSet<const GlobalAlias *> Aliases; 370fcaf7f86SDimitry Andric return findBaseObject(this, Aliases, [](const GlobalValue &) {}); 3710b57cec5SDimitry Andric } 3720b57cec5SDimitry Andric 3730b57cec5SDimitry Andric bool GlobalValue::isAbsoluteSymbolRef() const { 3740b57cec5SDimitry Andric auto *GO = dyn_cast<GlobalObject>(this); 3750b57cec5SDimitry Andric if (!GO) 3760b57cec5SDimitry Andric return false; 3770b57cec5SDimitry Andric 3780b57cec5SDimitry Andric return GO->getMetadata(LLVMContext::MD_absolute_symbol); 3790b57cec5SDimitry Andric } 3800b57cec5SDimitry Andric 381bdd1243dSDimitry Andric std::optional<ConstantRange> GlobalValue::getAbsoluteSymbolRange() const { 3820b57cec5SDimitry Andric auto *GO = dyn_cast<GlobalObject>(this); 3830b57cec5SDimitry Andric if (!GO) 384bdd1243dSDimitry Andric return std::nullopt; 3850b57cec5SDimitry Andric 3860b57cec5SDimitry Andric MDNode *MD = GO->getMetadata(LLVMContext::MD_absolute_symbol); 3870b57cec5SDimitry Andric if (!MD) 388bdd1243dSDimitry Andric return std::nullopt; 3890b57cec5SDimitry Andric 3900b57cec5SDimitry Andric return getConstantRangeFromMetadata(*MD); 3910b57cec5SDimitry Andric } 3920b57cec5SDimitry Andric 3930b57cec5SDimitry Andric bool GlobalValue::canBeOmittedFromSymbolTable() const { 3940b57cec5SDimitry Andric if (!hasLinkOnceODRLinkage()) 3950b57cec5SDimitry Andric return false; 3960b57cec5SDimitry Andric 3970b57cec5SDimitry Andric // We assume that anyone who sets global unnamed_addr on a non-constant 3980b57cec5SDimitry Andric // knows what they're doing. 3990b57cec5SDimitry Andric if (hasGlobalUnnamedAddr()) 4000b57cec5SDimitry Andric return true; 4010b57cec5SDimitry Andric 4020b57cec5SDimitry Andric // If it is a non constant variable, it needs to be uniqued across shared 4030b57cec5SDimitry Andric // objects. 4040b57cec5SDimitry Andric if (auto *Var = dyn_cast<GlobalVariable>(this)) 4050b57cec5SDimitry Andric if (!Var->isConstant()) 4060b57cec5SDimitry Andric return false; 4070b57cec5SDimitry Andric 4080b57cec5SDimitry Andric return hasAtLeastLocalUnnamedAddr(); 4090b57cec5SDimitry Andric } 4100b57cec5SDimitry Andric 4110b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 4120b57cec5SDimitry Andric // GlobalVariable Implementation 4130b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 4140b57cec5SDimitry Andric 4150b57cec5SDimitry Andric GlobalVariable::GlobalVariable(Type *Ty, bool constant, LinkageTypes Link, 4160b57cec5SDimitry Andric Constant *InitVal, const Twine &Name, 4170b57cec5SDimitry Andric ThreadLocalMode TLMode, unsigned AddressSpace, 4180b57cec5SDimitry Andric bool isExternallyInitialized) 4190b57cec5SDimitry Andric : GlobalObject(Ty, Value::GlobalVariableVal, 4200b57cec5SDimitry Andric OperandTraits<GlobalVariable>::op_begin(this), 4210b57cec5SDimitry Andric InitVal != nullptr, Link, Name, AddressSpace), 4220b57cec5SDimitry Andric isConstantGlobal(constant), 4230b57cec5SDimitry Andric isExternallyInitializedConstant(isExternallyInitialized) { 4240b57cec5SDimitry Andric assert(!Ty->isFunctionTy() && PointerType::isValidElementType(Ty) && 4250b57cec5SDimitry Andric "invalid type for global variable"); 4260b57cec5SDimitry Andric setThreadLocalMode(TLMode); 4270b57cec5SDimitry Andric if (InitVal) { 4280b57cec5SDimitry Andric assert(InitVal->getType() == Ty && 4290b57cec5SDimitry Andric "Initializer should be the same type as the GlobalVariable!"); 4300b57cec5SDimitry Andric Op<0>() = InitVal; 4310b57cec5SDimitry Andric } 4320b57cec5SDimitry Andric } 4330b57cec5SDimitry Andric 4340b57cec5SDimitry Andric GlobalVariable::GlobalVariable(Module &M, Type *Ty, bool constant, 4350b57cec5SDimitry Andric LinkageTypes Link, Constant *InitVal, 4360b57cec5SDimitry Andric const Twine &Name, GlobalVariable *Before, 437e8d8bef9SDimitry Andric ThreadLocalMode TLMode, 438bdd1243dSDimitry Andric std::optional<unsigned> AddressSpace, 4390b57cec5SDimitry Andric bool isExternallyInitialized) 44006c3fb27SDimitry Andric : GlobalVariable(Ty, constant, Link, InitVal, Name, TLMode, 441e8d8bef9SDimitry Andric AddressSpace 442e8d8bef9SDimitry Andric ? *AddressSpace 44306c3fb27SDimitry Andric : M.getDataLayout().getDefaultGlobalsAddressSpace(), 44406c3fb27SDimitry Andric isExternallyInitialized) { 4450b57cec5SDimitry Andric if (Before) 44606c3fb27SDimitry Andric Before->getParent()->insertGlobalVariable(Before->getIterator(), this); 4470b57cec5SDimitry Andric else 44806c3fb27SDimitry Andric M.insertGlobalVariable(this); 4490b57cec5SDimitry Andric } 4500b57cec5SDimitry Andric 4510b57cec5SDimitry Andric void GlobalVariable::removeFromParent() { 45206c3fb27SDimitry Andric getParent()->removeGlobalVariable(this); 4530b57cec5SDimitry Andric } 4540b57cec5SDimitry Andric 4550b57cec5SDimitry Andric void GlobalVariable::eraseFromParent() { 45606c3fb27SDimitry Andric getParent()->eraseGlobalVariable(this); 4570b57cec5SDimitry Andric } 4580b57cec5SDimitry Andric 4590b57cec5SDimitry Andric void GlobalVariable::setInitializer(Constant *InitVal) { 4600b57cec5SDimitry Andric if (!InitVal) { 4610b57cec5SDimitry Andric if (hasInitializer()) { 4620b57cec5SDimitry Andric // Note, the num operands is used to compute the offset of the operand, so 4630b57cec5SDimitry Andric // the order here matters. Clearing the operand then clearing the num 4640b57cec5SDimitry Andric // operands ensures we have the correct offset to the operand. 4650b57cec5SDimitry Andric Op<0>().set(nullptr); 4660b57cec5SDimitry Andric setGlobalVariableNumOperands(0); 4670b57cec5SDimitry Andric } 4680b57cec5SDimitry Andric } else { 4690b57cec5SDimitry Andric assert(InitVal->getType() == getValueType() && 4700b57cec5SDimitry Andric "Initializer type must match GlobalVariable type"); 4710b57cec5SDimitry Andric // Note, the num operands is used to compute the offset of the operand, so 4720b57cec5SDimitry Andric // the order here matters. We need to set num operands to 1 first so that 4730b57cec5SDimitry Andric // we get the correct offset to the first operand when we set it. 4740b57cec5SDimitry Andric if (!hasInitializer()) 4750b57cec5SDimitry Andric setGlobalVariableNumOperands(1); 4760b57cec5SDimitry Andric Op<0>().set(InitVal); 4770b57cec5SDimitry Andric } 4780b57cec5SDimitry Andric } 4790b57cec5SDimitry Andric 4800b57cec5SDimitry Andric /// Copy all additional attributes (those not needed to create a GlobalVariable) 4810b57cec5SDimitry Andric /// from the GlobalVariable Src to this one. 4820b57cec5SDimitry Andric void GlobalVariable::copyAttributesFrom(const GlobalVariable *Src) { 4830b57cec5SDimitry Andric GlobalObject::copyAttributesFrom(Src); 4840b57cec5SDimitry Andric setExternallyInitialized(Src->isExternallyInitialized()); 4850b57cec5SDimitry Andric setAttributes(Src->getAttributes()); 4865f757f3fSDimitry Andric if (auto CM = Src->getCodeModel()) 4875f757f3fSDimitry Andric setCodeModel(*CM); 4880b57cec5SDimitry Andric } 4890b57cec5SDimitry Andric 4900b57cec5SDimitry Andric void GlobalVariable::dropAllReferences() { 4910b57cec5SDimitry Andric User::dropAllReferences(); 4920b57cec5SDimitry Andric clearMetadata(); 4930b57cec5SDimitry Andric } 4940b57cec5SDimitry Andric 4955f757f3fSDimitry Andric void GlobalVariable::setCodeModel(CodeModel::Model CM) { 4965f757f3fSDimitry Andric unsigned CodeModelData = static_cast<unsigned>(CM) + 1; 4975f757f3fSDimitry Andric unsigned OldData = getGlobalValueSubClassData(); 4985f757f3fSDimitry Andric unsigned NewData = (OldData & ~(CodeModelMask << CodeModelShift)) | 4995f757f3fSDimitry Andric (CodeModelData << CodeModelShift); 5005f757f3fSDimitry Andric setGlobalValueSubClassData(NewData); 5015f757f3fSDimitry Andric assert(getCodeModel() == CM && "Code model representation error!"); 5025f757f3fSDimitry Andric } 5035f757f3fSDimitry Andric 5040b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 5050b57cec5SDimitry Andric // GlobalAlias Implementation 5060b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 5070b57cec5SDimitry Andric 5080b57cec5SDimitry Andric GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Link, 5090b57cec5SDimitry Andric const Twine &Name, Constant *Aliasee, 5100b57cec5SDimitry Andric Module *ParentModule) 511349cc55cSDimitry Andric : GlobalValue(Ty, Value::GlobalAliasVal, &Op<0>(), 1, Link, Name, 512349cc55cSDimitry Andric AddressSpace) { 513349cc55cSDimitry Andric setAliasee(Aliasee); 5140b57cec5SDimitry Andric if (ParentModule) 51506c3fb27SDimitry Andric ParentModule->insertAlias(this); 5160b57cec5SDimitry Andric } 5170b57cec5SDimitry Andric 5180b57cec5SDimitry Andric GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace, 5190b57cec5SDimitry Andric LinkageTypes Link, const Twine &Name, 5200b57cec5SDimitry Andric Constant *Aliasee, Module *ParentModule) { 5210b57cec5SDimitry Andric return new GlobalAlias(Ty, AddressSpace, Link, Name, Aliasee, ParentModule); 5220b57cec5SDimitry Andric } 5230b57cec5SDimitry Andric 5240b57cec5SDimitry Andric GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace, 5250b57cec5SDimitry Andric LinkageTypes Linkage, const Twine &Name, 5260b57cec5SDimitry Andric Module *Parent) { 5270b57cec5SDimitry Andric return create(Ty, AddressSpace, Linkage, Name, nullptr, Parent); 5280b57cec5SDimitry Andric } 5290b57cec5SDimitry Andric 5300b57cec5SDimitry Andric GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace, 5310b57cec5SDimitry Andric LinkageTypes Linkage, const Twine &Name, 5320b57cec5SDimitry Andric GlobalValue *Aliasee) { 5330b57cec5SDimitry Andric return create(Ty, AddressSpace, Linkage, Name, Aliasee, Aliasee->getParent()); 5340b57cec5SDimitry Andric } 5350b57cec5SDimitry Andric 5360b57cec5SDimitry Andric GlobalAlias *GlobalAlias::create(LinkageTypes Link, const Twine &Name, 5370b57cec5SDimitry Andric GlobalValue *Aliasee) { 538fe6060f1SDimitry Andric return create(Aliasee->getValueType(), Aliasee->getAddressSpace(), Link, Name, 5390b57cec5SDimitry Andric Aliasee); 5400b57cec5SDimitry Andric } 5410b57cec5SDimitry Andric 5420b57cec5SDimitry Andric GlobalAlias *GlobalAlias::create(const Twine &Name, GlobalValue *Aliasee) { 5430b57cec5SDimitry Andric return create(Aliasee->getLinkage(), Name, Aliasee); 5440b57cec5SDimitry Andric } 5450b57cec5SDimitry Andric 54606c3fb27SDimitry Andric void GlobalAlias::removeFromParent() { getParent()->removeAlias(this); } 5470b57cec5SDimitry Andric 54806c3fb27SDimitry Andric void GlobalAlias::eraseFromParent() { getParent()->eraseAlias(this); } 5490b57cec5SDimitry Andric 5500b57cec5SDimitry Andric void GlobalAlias::setAliasee(Constant *Aliasee) { 5510b57cec5SDimitry Andric assert((!Aliasee || Aliasee->getType() == getType()) && 5520b57cec5SDimitry Andric "Alias and aliasee types should match!"); 553349cc55cSDimitry Andric Op<0>().set(Aliasee); 554349cc55cSDimitry Andric } 555349cc55cSDimitry Andric 556349cc55cSDimitry Andric const GlobalObject *GlobalAlias::getAliaseeObject() const { 557349cc55cSDimitry Andric DenseSet<const GlobalAlias *> Aliases; 558fcaf7f86SDimitry Andric return findBaseObject(getOperand(0), Aliases, [](const GlobalValue &) {}); 5590b57cec5SDimitry Andric } 5600b57cec5SDimitry Andric 5610b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 5620b57cec5SDimitry Andric // GlobalIFunc Implementation 5630b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 5640b57cec5SDimitry Andric 5650b57cec5SDimitry Andric GlobalIFunc::GlobalIFunc(Type *Ty, unsigned AddressSpace, LinkageTypes Link, 5660b57cec5SDimitry Andric const Twine &Name, Constant *Resolver, 5670b57cec5SDimitry Andric Module *ParentModule) 568349cc55cSDimitry Andric : GlobalObject(Ty, Value::GlobalIFuncVal, &Op<0>(), 1, Link, Name, 569349cc55cSDimitry Andric AddressSpace) { 570349cc55cSDimitry Andric setResolver(Resolver); 5710b57cec5SDimitry Andric if (ParentModule) 57206c3fb27SDimitry Andric ParentModule->insertIFunc(this); 5730b57cec5SDimitry Andric } 5740b57cec5SDimitry Andric 5750b57cec5SDimitry Andric GlobalIFunc *GlobalIFunc::create(Type *Ty, unsigned AddressSpace, 5760b57cec5SDimitry Andric LinkageTypes Link, const Twine &Name, 5770b57cec5SDimitry Andric Constant *Resolver, Module *ParentModule) { 5780b57cec5SDimitry Andric return new GlobalIFunc(Ty, AddressSpace, Link, Name, Resolver, ParentModule); 5790b57cec5SDimitry Andric } 5800b57cec5SDimitry Andric 58106c3fb27SDimitry Andric void GlobalIFunc::removeFromParent() { getParent()->removeIFunc(this); } 5820b57cec5SDimitry Andric 58306c3fb27SDimitry Andric void GlobalIFunc::eraseFromParent() { getParent()->eraseIFunc(this); } 584349cc55cSDimitry Andric 585349cc55cSDimitry Andric const Function *GlobalIFunc::getResolverFunction() const { 586bdd1243dSDimitry Andric return dyn_cast<Function>(getResolver()->stripPointerCastsAndAliases()); 587fcaf7f86SDimitry Andric } 588fcaf7f86SDimitry Andric 589fcaf7f86SDimitry Andric void GlobalIFunc::applyAlongResolverPath( 590fcaf7f86SDimitry Andric function_ref<void(const GlobalValue &)> Op) const { 591fcaf7f86SDimitry Andric DenseSet<const GlobalAlias *> Aliases; 592fcaf7f86SDimitry Andric findBaseObject(getResolver(), Aliases, Op); 593349cc55cSDimitry Andric } 594