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/ADT/SmallPtrSet.h" 160b57cec5SDimitry Andric #include "llvm/ADT/Triple.h" 170b57cec5SDimitry Andric #include "llvm/IR/ConstantRange.h" 180b57cec5SDimitry Andric #include "llvm/IR/Constants.h" 190b57cec5SDimitry Andric #include "llvm/IR/DerivedTypes.h" 200b57cec5SDimitry Andric #include "llvm/IR/GlobalAlias.h" 210b57cec5SDimitry Andric #include "llvm/IR/GlobalValue.h" 220b57cec5SDimitry Andric #include "llvm/IR/GlobalVariable.h" 230b57cec5SDimitry Andric #include "llvm/IR/Module.h" 240b57cec5SDimitry Andric #include "llvm/IR/Operator.h" 250b57cec5SDimitry Andric #include "llvm/Support/Error.h" 260b57cec5SDimitry Andric #include "llvm/Support/ErrorHandling.h" 270b57cec5SDimitry Andric using namespace llvm; 280b57cec5SDimitry Andric 290b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 300b57cec5SDimitry Andric // GlobalValue Class 310b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 320b57cec5SDimitry Andric 330b57cec5SDimitry Andric // GlobalValue should be a Constant, plus a type, a module, some flags, and an 340b57cec5SDimitry Andric // intrinsic ID. Add an assert to prevent people from accidentally growing 350b57cec5SDimitry Andric // GlobalValue while adding flags. 360b57cec5SDimitry Andric static_assert(sizeof(GlobalValue) == 370b57cec5SDimitry Andric sizeof(Constant) + 2 * sizeof(void *) + 2 * sizeof(unsigned), 380b57cec5SDimitry Andric "unexpected GlobalValue size growth"); 390b57cec5SDimitry Andric 400b57cec5SDimitry Andric // GlobalObject adds a comdat. 410b57cec5SDimitry Andric static_assert(sizeof(GlobalObject) == sizeof(GlobalValue) + sizeof(void *), 420b57cec5SDimitry Andric "unexpected GlobalObject size growth"); 430b57cec5SDimitry Andric 440b57cec5SDimitry Andric bool GlobalValue::isMaterializable() const { 450b57cec5SDimitry Andric if (const Function *F = dyn_cast<Function>(this)) 460b57cec5SDimitry Andric return F->isMaterializable(); 470b57cec5SDimitry Andric return false; 480b57cec5SDimitry Andric } 490b57cec5SDimitry Andric Error GlobalValue::materialize() { 500b57cec5SDimitry Andric return getParent()->materialize(this); 510b57cec5SDimitry Andric } 520b57cec5SDimitry Andric 530b57cec5SDimitry Andric /// Override destroyConstantImpl to make sure it doesn't get called on 540b57cec5SDimitry Andric /// GlobalValue's because they shouldn't be treated like other constants. 550b57cec5SDimitry Andric void GlobalValue::destroyConstantImpl() { 560b57cec5SDimitry Andric llvm_unreachable("You can't GV->destroyConstantImpl()!"); 570b57cec5SDimitry Andric } 580b57cec5SDimitry Andric 590b57cec5SDimitry Andric Value *GlobalValue::handleOperandChangeImpl(Value *From, Value *To) { 600b57cec5SDimitry Andric llvm_unreachable("Unsupported class for handleOperandChange()!"); 610b57cec5SDimitry Andric } 620b57cec5SDimitry Andric 630b57cec5SDimitry Andric /// copyAttributesFrom - copy all additional attributes (those not needed to 640b57cec5SDimitry Andric /// create a GlobalValue) from the GlobalValue Src to this one. 650b57cec5SDimitry Andric void GlobalValue::copyAttributesFrom(const GlobalValue *Src) { 660b57cec5SDimitry Andric setVisibility(Src->getVisibility()); 670b57cec5SDimitry Andric setUnnamedAddr(Src->getUnnamedAddr()); 685ffd83dbSDimitry Andric setThreadLocalMode(Src->getThreadLocalMode()); 690b57cec5SDimitry Andric setDLLStorageClass(Src->getDLLStorageClass()); 700b57cec5SDimitry Andric setDSOLocal(Src->isDSOLocal()); 710b57cec5SDimitry Andric setPartition(Src->getPartition()); 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 98*04eeddc0SDimitry Andric GlobalObject::~GlobalObject() { setComdat(nullptr); } 99*04eeddc0SDimitry 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 { 108*04eeddc0SDimitry Andric // See AsmPrinter::getSymbolPreferLocal(). For a deduplicate comdat kind, 109*04eeddc0SDimitry Andric // references to a discarded local symbol from outside the group are not 110*04eeddc0SDimitry Andric // allowed, so avoid the local alias. 111*04eeddc0SDimitry Andric auto isDeduplicateComdat = [](const Comdat *C) { 112*04eeddc0SDimitry Andric return C && C->getSelectionKind() != Comdat::NoDeduplicate; 113*04eeddc0SDimitry Andric }; 1148833aad7SDimitry Andric return hasDefaultVisibility() && 1158833aad7SDimitry Andric GlobalObject::isExternalLinkage(getLinkage()) && !isDeclaration() && 116*04eeddc0SDimitry Andric !isa<GlobalIFunc>(this) && !isDeduplicateComdat(getComdat()); 1170b57cec5SDimitry Andric } 1180b57cec5SDimitry Andric 1190b57cec5SDimitry Andric unsigned GlobalValue::getAddressSpace() const { 1200b57cec5SDimitry Andric PointerType *PtrTy = getType(); 1210b57cec5SDimitry Andric return PtrTy->getAddressSpace(); 1220b57cec5SDimitry Andric } 1230b57cec5SDimitry Andric 1248bcb0991SDimitry Andric void GlobalObject::setAlignment(MaybeAlign Align) { 1255ffd83dbSDimitry Andric assert((!Align || *Align <= MaximumAlignment) && 1260b57cec5SDimitry Andric "Alignment is greater than MaximumAlignment!"); 1278bcb0991SDimitry Andric unsigned AlignmentData = encode(Align); 1280b57cec5SDimitry Andric unsigned OldData = getGlobalValueSubClassData(); 1290b57cec5SDimitry Andric setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData); 1308bcb0991SDimitry Andric assert(MaybeAlign(getAlignment()) == Align && 1318bcb0991SDimitry Andric "Alignment representation error!"); 1320b57cec5SDimitry Andric } 1330b57cec5SDimitry Andric 1340b57cec5SDimitry Andric void GlobalObject::copyAttributesFrom(const GlobalObject *Src) { 1350b57cec5SDimitry Andric GlobalValue::copyAttributesFrom(Src); 1360eae32dcSDimitry Andric setAlignment(Src->getAlign()); 1370b57cec5SDimitry Andric setSection(Src->getSection()); 1380b57cec5SDimitry Andric } 1390b57cec5SDimitry Andric 1400b57cec5SDimitry Andric std::string GlobalValue::getGlobalIdentifier(StringRef Name, 1410b57cec5SDimitry Andric GlobalValue::LinkageTypes Linkage, 1420b57cec5SDimitry Andric StringRef FileName) { 1430b57cec5SDimitry Andric 1440b57cec5SDimitry Andric // Value names may be prefixed with a binary '1' to indicate 1450b57cec5SDimitry Andric // that the backend should not modify the symbols due to any platform 1460b57cec5SDimitry Andric // naming convention. Do not include that '1' in the PGO profile name. 1470b57cec5SDimitry Andric if (Name[0] == '\1') 1480b57cec5SDimitry Andric Name = Name.substr(1); 1490b57cec5SDimitry Andric 1505ffd83dbSDimitry Andric std::string NewName = std::string(Name); 1510b57cec5SDimitry Andric if (llvm::GlobalValue::isLocalLinkage(Linkage)) { 1520b57cec5SDimitry Andric // For local symbols, prepend the main file name to distinguish them. 1530b57cec5SDimitry Andric // Do not include the full path in the file name since there's no guarantee 1540b57cec5SDimitry Andric // that it will stay the same, e.g., if the files are checked out from 1550b57cec5SDimitry Andric // version control in different locations. 1560b57cec5SDimitry Andric if (FileName.empty()) 1570b57cec5SDimitry Andric NewName = NewName.insert(0, "<unknown>:"); 1580b57cec5SDimitry Andric else 1590b57cec5SDimitry Andric NewName = NewName.insert(0, FileName.str() + ":"); 1600b57cec5SDimitry Andric } 1610b57cec5SDimitry Andric return NewName; 1620b57cec5SDimitry Andric } 1630b57cec5SDimitry Andric 1640b57cec5SDimitry Andric std::string GlobalValue::getGlobalIdentifier() const { 1650b57cec5SDimitry Andric return getGlobalIdentifier(getName(), getLinkage(), 1660b57cec5SDimitry Andric getParent()->getSourceFileName()); 1670b57cec5SDimitry Andric } 1680b57cec5SDimitry Andric 1690b57cec5SDimitry Andric StringRef GlobalValue::getSection() const { 1700b57cec5SDimitry Andric if (auto *GA = dyn_cast<GlobalAlias>(this)) { 1710b57cec5SDimitry Andric // In general we cannot compute this at the IR level, but we try. 172349cc55cSDimitry Andric if (const GlobalObject *GO = GA->getAliaseeObject()) 1730b57cec5SDimitry Andric return GO->getSection(); 1740b57cec5SDimitry Andric return ""; 1750b57cec5SDimitry Andric } 1760b57cec5SDimitry Andric return cast<GlobalObject>(this)->getSection(); 1770b57cec5SDimitry Andric } 1780b57cec5SDimitry Andric 1790b57cec5SDimitry Andric const Comdat *GlobalValue::getComdat() const { 1800b57cec5SDimitry Andric if (auto *GA = dyn_cast<GlobalAlias>(this)) { 1810b57cec5SDimitry Andric // In general we cannot compute this at the IR level, but we try. 182349cc55cSDimitry Andric if (const GlobalObject *GO = GA->getAliaseeObject()) 1830b57cec5SDimitry Andric return const_cast<GlobalObject *>(GO)->getComdat(); 1840b57cec5SDimitry Andric return nullptr; 1850b57cec5SDimitry Andric } 1860b57cec5SDimitry Andric // ifunc and its resolver are separate things so don't use resolver comdat. 1870b57cec5SDimitry Andric if (isa<GlobalIFunc>(this)) 1880b57cec5SDimitry Andric return nullptr; 1890b57cec5SDimitry Andric return cast<GlobalObject>(this)->getComdat(); 1900b57cec5SDimitry Andric } 1910b57cec5SDimitry Andric 192*04eeddc0SDimitry Andric void GlobalObject::setComdat(Comdat *C) { 193*04eeddc0SDimitry Andric if (ObjComdat) 194*04eeddc0SDimitry Andric ObjComdat->removeUser(this); 195*04eeddc0SDimitry Andric ObjComdat = C; 196*04eeddc0SDimitry Andric if (C) 197*04eeddc0SDimitry Andric C->addUser(this); 198*04eeddc0SDimitry Andric } 199*04eeddc0SDimitry Andric 2000b57cec5SDimitry Andric StringRef GlobalValue::getPartition() const { 2010b57cec5SDimitry Andric if (!hasPartition()) 2020b57cec5SDimitry Andric return ""; 2030b57cec5SDimitry Andric return getContext().pImpl->GlobalValuePartitions[this]; 2040b57cec5SDimitry Andric } 2050b57cec5SDimitry Andric 2060b57cec5SDimitry Andric void GlobalValue::setPartition(StringRef S) { 2070b57cec5SDimitry Andric // Do nothing if we're clearing the partition and it is already empty. 2080b57cec5SDimitry Andric if (!hasPartition() && S.empty()) 2090b57cec5SDimitry Andric return; 2100b57cec5SDimitry Andric 2110b57cec5SDimitry Andric // Get or create a stable partition name string and put it in the table in the 2120b57cec5SDimitry Andric // context. 2130b57cec5SDimitry Andric if (!S.empty()) 2140b57cec5SDimitry Andric S = getContext().pImpl->Saver.save(S); 2150b57cec5SDimitry Andric getContext().pImpl->GlobalValuePartitions[this] = S; 2160b57cec5SDimitry Andric 2170b57cec5SDimitry Andric // Update the HasPartition field. Setting the partition to the empty string 2180b57cec5SDimitry Andric // means this global no longer has a partition. 2190b57cec5SDimitry Andric HasPartition = !S.empty(); 2200b57cec5SDimitry Andric } 2210b57cec5SDimitry Andric 2220b57cec5SDimitry Andric StringRef GlobalObject::getSectionImpl() const { 2230b57cec5SDimitry Andric assert(hasSection()); 2240b57cec5SDimitry Andric return getContext().pImpl->GlobalObjectSections[this]; 2250b57cec5SDimitry Andric } 2260b57cec5SDimitry Andric 2270b57cec5SDimitry Andric void GlobalObject::setSection(StringRef S) { 2280b57cec5SDimitry Andric // Do nothing if we're clearing the section and it is already empty. 2290b57cec5SDimitry Andric if (!hasSection() && S.empty()) 2300b57cec5SDimitry Andric return; 2310b57cec5SDimitry Andric 2320b57cec5SDimitry Andric // Get or create a stable section name string and put it in the table in the 2330b57cec5SDimitry Andric // context. 2340b57cec5SDimitry Andric if (!S.empty()) 2350b57cec5SDimitry Andric S = getContext().pImpl->Saver.save(S); 2360b57cec5SDimitry Andric getContext().pImpl->GlobalObjectSections[this] = S; 2370b57cec5SDimitry Andric 2380b57cec5SDimitry Andric // Update the HasSectionHashEntryBit. Setting the section to the empty string 2390b57cec5SDimitry Andric // means this global no longer has a section. 2400b57cec5SDimitry Andric setGlobalObjectFlag(HasSectionHashEntryBit, !S.empty()); 2410b57cec5SDimitry Andric } 2420b57cec5SDimitry Andric 2430b57cec5SDimitry Andric bool GlobalValue::isDeclaration() const { 2440b57cec5SDimitry Andric // Globals are definitions if they have an initializer. 2450b57cec5SDimitry Andric if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(this)) 2460b57cec5SDimitry Andric return GV->getNumOperands() == 0; 2470b57cec5SDimitry Andric 2480b57cec5SDimitry Andric // Functions are definitions if they have a body. 2490b57cec5SDimitry Andric if (const Function *F = dyn_cast<Function>(this)) 2500b57cec5SDimitry Andric return F->empty() && !F->isMaterializable(); 2510b57cec5SDimitry Andric 2520b57cec5SDimitry Andric // Aliases and ifuncs are always definitions. 253349cc55cSDimitry Andric assert(isa<GlobalAlias>(this) || isa<GlobalIFunc>(this)); 2540b57cec5SDimitry Andric return false; 2550b57cec5SDimitry Andric } 2560b57cec5SDimitry Andric 2575ffd83dbSDimitry Andric bool GlobalObject::canIncreaseAlignment() const { 2580b57cec5SDimitry Andric // Firstly, can only increase the alignment of a global if it 2590b57cec5SDimitry Andric // is a strong definition. 2600b57cec5SDimitry Andric if (!isStrongDefinitionForLinker()) 2610b57cec5SDimitry Andric return false; 2620b57cec5SDimitry Andric 2630b57cec5SDimitry Andric // It also has to either not have a section defined, or, not have 2640b57cec5SDimitry Andric // alignment specified. (If it is assigned a section, the global 2650b57cec5SDimitry Andric // could be densely packed with other objects in the section, and 2660b57cec5SDimitry Andric // increasing the alignment could cause padding issues.) 2670eae32dcSDimitry Andric if (hasSection() && getAlign().hasValue()) 2680b57cec5SDimitry Andric return false; 2690b57cec5SDimitry Andric 2700b57cec5SDimitry Andric // On ELF platforms, we're further restricted in that we can't 2710b57cec5SDimitry Andric // increase the alignment of any variable which might be emitted 2720b57cec5SDimitry Andric // into a shared library, and which is exported. If the main 2730b57cec5SDimitry Andric // executable accesses a variable found in a shared-lib, the main 2740b57cec5SDimitry Andric // exe actually allocates memory for and exports the symbol ITSELF, 2750b57cec5SDimitry Andric // overriding the symbol found in the library. That is, at link 2760b57cec5SDimitry Andric // time, the observed alignment of the variable is copied into the 2770b57cec5SDimitry Andric // executable binary. (A COPY relocation is also generated, to copy 2780b57cec5SDimitry Andric // the initial data from the shadowed variable in the shared-lib 2790b57cec5SDimitry Andric // into the location in the main binary, before running code.) 2800b57cec5SDimitry Andric // 2810b57cec5SDimitry Andric // And thus, even though you might think you are defining the 2820b57cec5SDimitry Andric // global, and allocating the memory for the global in your object 2830b57cec5SDimitry Andric // file, and thus should be able to set the alignment arbitrarily, 2840b57cec5SDimitry Andric // that's not actually true. Doing so can cause an ABI breakage; an 2850b57cec5SDimitry Andric // executable might have already been built with the previous 2860b57cec5SDimitry Andric // alignment of the variable, and then assuming an increased 2870b57cec5SDimitry Andric // alignment will be incorrect. 2880b57cec5SDimitry Andric 2890b57cec5SDimitry Andric // Conservatively assume ELF if there's no parent pointer. 2900b57cec5SDimitry Andric bool isELF = 2910b57cec5SDimitry Andric (!Parent || Triple(Parent->getTargetTriple()).isOSBinFormatELF()); 2920b57cec5SDimitry Andric if (isELF && !isDSOLocal()) 2930b57cec5SDimitry Andric return false; 2940b57cec5SDimitry Andric 2950b57cec5SDimitry Andric return true; 2960b57cec5SDimitry Andric } 2970b57cec5SDimitry Andric 298349cc55cSDimitry Andric static const GlobalObject * 299349cc55cSDimitry Andric findBaseObject(const Constant *C, DenseSet<const GlobalAlias *> &Aliases) { 300349cc55cSDimitry Andric if (auto *GO = dyn_cast<GlobalObject>(C)) 3010b57cec5SDimitry Andric return GO; 302349cc55cSDimitry Andric if (auto *GA = dyn_cast<GlobalAlias>(C)) 303349cc55cSDimitry Andric if (Aliases.insert(GA).second) 304349cc55cSDimitry Andric return findBaseObject(GA->getOperand(0), Aliases); 305349cc55cSDimitry Andric if (auto *CE = dyn_cast<ConstantExpr>(C)) { 306349cc55cSDimitry Andric switch (CE->getOpcode()) { 307349cc55cSDimitry Andric case Instruction::Add: { 308349cc55cSDimitry Andric auto *LHS = findBaseObject(CE->getOperand(0), Aliases); 309349cc55cSDimitry Andric auto *RHS = findBaseObject(CE->getOperand(1), Aliases); 310349cc55cSDimitry Andric if (LHS && RHS) 3110b57cec5SDimitry Andric return nullptr; 312349cc55cSDimitry Andric return LHS ? LHS : RHS; 313349cc55cSDimitry Andric } 314349cc55cSDimitry Andric case Instruction::Sub: { 315349cc55cSDimitry Andric if (findBaseObject(CE->getOperand(1), Aliases)) 316349cc55cSDimitry Andric return nullptr; 317349cc55cSDimitry Andric return findBaseObject(CE->getOperand(0), Aliases); 318349cc55cSDimitry Andric } 319349cc55cSDimitry Andric case Instruction::IntToPtr: 320349cc55cSDimitry Andric case Instruction::PtrToInt: 321349cc55cSDimitry Andric case Instruction::BitCast: 322349cc55cSDimitry Andric case Instruction::GetElementPtr: 323349cc55cSDimitry Andric return findBaseObject(CE->getOperand(0), Aliases); 324349cc55cSDimitry Andric default: 325349cc55cSDimitry Andric break; 326349cc55cSDimitry Andric } 327349cc55cSDimitry Andric } 328349cc55cSDimitry Andric return nullptr; 329349cc55cSDimitry Andric } 330349cc55cSDimitry Andric 331349cc55cSDimitry Andric const GlobalObject *GlobalValue::getAliaseeObject() const { 332349cc55cSDimitry Andric DenseSet<const GlobalAlias *> Aliases; 333349cc55cSDimitry Andric return findBaseObject(this, Aliases); 3340b57cec5SDimitry Andric } 3350b57cec5SDimitry Andric 3360b57cec5SDimitry Andric bool GlobalValue::isAbsoluteSymbolRef() const { 3370b57cec5SDimitry Andric auto *GO = dyn_cast<GlobalObject>(this); 3380b57cec5SDimitry Andric if (!GO) 3390b57cec5SDimitry Andric return false; 3400b57cec5SDimitry Andric 3410b57cec5SDimitry Andric return GO->getMetadata(LLVMContext::MD_absolute_symbol); 3420b57cec5SDimitry Andric } 3430b57cec5SDimitry Andric 3440b57cec5SDimitry Andric Optional<ConstantRange> GlobalValue::getAbsoluteSymbolRange() const { 3450b57cec5SDimitry Andric auto *GO = dyn_cast<GlobalObject>(this); 3460b57cec5SDimitry Andric if (!GO) 3470b57cec5SDimitry Andric return None; 3480b57cec5SDimitry Andric 3490b57cec5SDimitry Andric MDNode *MD = GO->getMetadata(LLVMContext::MD_absolute_symbol); 3500b57cec5SDimitry Andric if (!MD) 3510b57cec5SDimitry Andric return None; 3520b57cec5SDimitry Andric 3530b57cec5SDimitry Andric return getConstantRangeFromMetadata(*MD); 3540b57cec5SDimitry Andric } 3550b57cec5SDimitry Andric 3560b57cec5SDimitry Andric bool GlobalValue::canBeOmittedFromSymbolTable() const { 3570b57cec5SDimitry Andric if (!hasLinkOnceODRLinkage()) 3580b57cec5SDimitry Andric return false; 3590b57cec5SDimitry Andric 3600b57cec5SDimitry Andric // We assume that anyone who sets global unnamed_addr on a non-constant 3610b57cec5SDimitry Andric // knows what they're doing. 3620b57cec5SDimitry Andric if (hasGlobalUnnamedAddr()) 3630b57cec5SDimitry Andric return true; 3640b57cec5SDimitry Andric 3650b57cec5SDimitry Andric // If it is a non constant variable, it needs to be uniqued across shared 3660b57cec5SDimitry Andric // objects. 3670b57cec5SDimitry Andric if (auto *Var = dyn_cast<GlobalVariable>(this)) 3680b57cec5SDimitry Andric if (!Var->isConstant()) 3690b57cec5SDimitry Andric return false; 3700b57cec5SDimitry Andric 3710b57cec5SDimitry Andric return hasAtLeastLocalUnnamedAddr(); 3720b57cec5SDimitry Andric } 3730b57cec5SDimitry Andric 3740b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 3750b57cec5SDimitry Andric // GlobalVariable Implementation 3760b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 3770b57cec5SDimitry Andric 3780b57cec5SDimitry Andric GlobalVariable::GlobalVariable(Type *Ty, bool constant, LinkageTypes Link, 3790b57cec5SDimitry Andric Constant *InitVal, const Twine &Name, 3800b57cec5SDimitry Andric ThreadLocalMode TLMode, unsigned AddressSpace, 3810b57cec5SDimitry Andric bool isExternallyInitialized) 3820b57cec5SDimitry Andric : GlobalObject(Ty, Value::GlobalVariableVal, 3830b57cec5SDimitry Andric OperandTraits<GlobalVariable>::op_begin(this), 3840b57cec5SDimitry Andric InitVal != nullptr, Link, Name, AddressSpace), 3850b57cec5SDimitry Andric isConstantGlobal(constant), 3860b57cec5SDimitry Andric isExternallyInitializedConstant(isExternallyInitialized) { 3870b57cec5SDimitry Andric assert(!Ty->isFunctionTy() && PointerType::isValidElementType(Ty) && 3880b57cec5SDimitry Andric "invalid type for global variable"); 3890b57cec5SDimitry Andric setThreadLocalMode(TLMode); 3900b57cec5SDimitry Andric if (InitVal) { 3910b57cec5SDimitry Andric assert(InitVal->getType() == Ty && 3920b57cec5SDimitry Andric "Initializer should be the same type as the GlobalVariable!"); 3930b57cec5SDimitry Andric Op<0>() = InitVal; 3940b57cec5SDimitry Andric } 3950b57cec5SDimitry Andric } 3960b57cec5SDimitry Andric 3970b57cec5SDimitry Andric GlobalVariable::GlobalVariable(Module &M, Type *Ty, bool constant, 3980b57cec5SDimitry Andric LinkageTypes Link, Constant *InitVal, 3990b57cec5SDimitry Andric const Twine &Name, GlobalVariable *Before, 400e8d8bef9SDimitry Andric ThreadLocalMode TLMode, 401e8d8bef9SDimitry Andric Optional<unsigned> AddressSpace, 4020b57cec5SDimitry Andric bool isExternallyInitialized) 4030b57cec5SDimitry Andric : GlobalObject(Ty, Value::GlobalVariableVal, 4040b57cec5SDimitry Andric OperandTraits<GlobalVariable>::op_begin(this), 405e8d8bef9SDimitry Andric InitVal != nullptr, Link, Name, 406e8d8bef9SDimitry Andric AddressSpace 407e8d8bef9SDimitry Andric ? *AddressSpace 408e8d8bef9SDimitry Andric : M.getDataLayout().getDefaultGlobalsAddressSpace()), 4090b57cec5SDimitry Andric isConstantGlobal(constant), 4100b57cec5SDimitry Andric isExternallyInitializedConstant(isExternallyInitialized) { 4110b57cec5SDimitry Andric assert(!Ty->isFunctionTy() && PointerType::isValidElementType(Ty) && 4120b57cec5SDimitry Andric "invalid type for global variable"); 4130b57cec5SDimitry Andric setThreadLocalMode(TLMode); 4140b57cec5SDimitry Andric if (InitVal) { 4150b57cec5SDimitry Andric assert(InitVal->getType() == Ty && 4160b57cec5SDimitry Andric "Initializer should be the same type as the GlobalVariable!"); 4170b57cec5SDimitry Andric Op<0>() = InitVal; 4180b57cec5SDimitry Andric } 4190b57cec5SDimitry Andric 4200b57cec5SDimitry Andric if (Before) 4210b57cec5SDimitry Andric Before->getParent()->getGlobalList().insert(Before->getIterator(), this); 4220b57cec5SDimitry Andric else 4230b57cec5SDimitry Andric M.getGlobalList().push_back(this); 4240b57cec5SDimitry Andric } 4250b57cec5SDimitry Andric 4260b57cec5SDimitry Andric void GlobalVariable::removeFromParent() { 4270b57cec5SDimitry Andric getParent()->getGlobalList().remove(getIterator()); 4280b57cec5SDimitry Andric } 4290b57cec5SDimitry Andric 4300b57cec5SDimitry Andric void GlobalVariable::eraseFromParent() { 4310b57cec5SDimitry Andric getParent()->getGlobalList().erase(getIterator()); 4320b57cec5SDimitry Andric } 4330b57cec5SDimitry Andric 4340b57cec5SDimitry Andric void GlobalVariable::setInitializer(Constant *InitVal) { 4350b57cec5SDimitry Andric if (!InitVal) { 4360b57cec5SDimitry Andric if (hasInitializer()) { 4370b57cec5SDimitry Andric // Note, the num operands is used to compute the offset of the operand, so 4380b57cec5SDimitry Andric // the order here matters. Clearing the operand then clearing the num 4390b57cec5SDimitry Andric // operands ensures we have the correct offset to the operand. 4400b57cec5SDimitry Andric Op<0>().set(nullptr); 4410b57cec5SDimitry Andric setGlobalVariableNumOperands(0); 4420b57cec5SDimitry Andric } 4430b57cec5SDimitry Andric } else { 4440b57cec5SDimitry Andric assert(InitVal->getType() == getValueType() && 4450b57cec5SDimitry Andric "Initializer type must match GlobalVariable type"); 4460b57cec5SDimitry Andric // Note, the num operands is used to compute the offset of the operand, so 4470b57cec5SDimitry Andric // the order here matters. We need to set num operands to 1 first so that 4480b57cec5SDimitry Andric // we get the correct offset to the first operand when we set it. 4490b57cec5SDimitry Andric if (!hasInitializer()) 4500b57cec5SDimitry Andric setGlobalVariableNumOperands(1); 4510b57cec5SDimitry Andric Op<0>().set(InitVal); 4520b57cec5SDimitry Andric } 4530b57cec5SDimitry Andric } 4540b57cec5SDimitry Andric 4550b57cec5SDimitry Andric /// Copy all additional attributes (those not needed to create a GlobalVariable) 4560b57cec5SDimitry Andric /// from the GlobalVariable Src to this one. 4570b57cec5SDimitry Andric void GlobalVariable::copyAttributesFrom(const GlobalVariable *Src) { 4580b57cec5SDimitry Andric GlobalObject::copyAttributesFrom(Src); 4590b57cec5SDimitry Andric setExternallyInitialized(Src->isExternallyInitialized()); 4600b57cec5SDimitry Andric setAttributes(Src->getAttributes()); 4610b57cec5SDimitry Andric } 4620b57cec5SDimitry Andric 4630b57cec5SDimitry Andric void GlobalVariable::dropAllReferences() { 4640b57cec5SDimitry Andric User::dropAllReferences(); 4650b57cec5SDimitry Andric clearMetadata(); 4660b57cec5SDimitry Andric } 4670b57cec5SDimitry Andric 4680b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 4690b57cec5SDimitry Andric // GlobalAlias Implementation 4700b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 4710b57cec5SDimitry Andric 4720b57cec5SDimitry Andric GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Link, 4730b57cec5SDimitry Andric const Twine &Name, Constant *Aliasee, 4740b57cec5SDimitry Andric Module *ParentModule) 475349cc55cSDimitry Andric : GlobalValue(Ty, Value::GlobalAliasVal, &Op<0>(), 1, Link, Name, 476349cc55cSDimitry Andric AddressSpace) { 477349cc55cSDimitry Andric setAliasee(Aliasee); 4780b57cec5SDimitry Andric if (ParentModule) 4790b57cec5SDimitry Andric ParentModule->getAliasList().push_back(this); 4800b57cec5SDimitry Andric } 4810b57cec5SDimitry Andric 4820b57cec5SDimitry Andric GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace, 4830b57cec5SDimitry Andric LinkageTypes Link, const Twine &Name, 4840b57cec5SDimitry Andric Constant *Aliasee, Module *ParentModule) { 4850b57cec5SDimitry Andric return new GlobalAlias(Ty, AddressSpace, Link, Name, Aliasee, ParentModule); 4860b57cec5SDimitry Andric } 4870b57cec5SDimitry Andric 4880b57cec5SDimitry Andric GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace, 4890b57cec5SDimitry Andric LinkageTypes Linkage, const Twine &Name, 4900b57cec5SDimitry Andric Module *Parent) { 4910b57cec5SDimitry Andric return create(Ty, AddressSpace, Linkage, Name, nullptr, Parent); 4920b57cec5SDimitry Andric } 4930b57cec5SDimitry Andric 4940b57cec5SDimitry Andric GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace, 4950b57cec5SDimitry Andric LinkageTypes Linkage, const Twine &Name, 4960b57cec5SDimitry Andric GlobalValue *Aliasee) { 4970b57cec5SDimitry Andric return create(Ty, AddressSpace, Linkage, Name, Aliasee, Aliasee->getParent()); 4980b57cec5SDimitry Andric } 4990b57cec5SDimitry Andric 5000b57cec5SDimitry Andric GlobalAlias *GlobalAlias::create(LinkageTypes Link, const Twine &Name, 5010b57cec5SDimitry Andric GlobalValue *Aliasee) { 502fe6060f1SDimitry Andric return create(Aliasee->getValueType(), Aliasee->getAddressSpace(), Link, Name, 5030b57cec5SDimitry Andric Aliasee); 5040b57cec5SDimitry Andric } 5050b57cec5SDimitry Andric 5060b57cec5SDimitry Andric GlobalAlias *GlobalAlias::create(const Twine &Name, GlobalValue *Aliasee) { 5070b57cec5SDimitry Andric return create(Aliasee->getLinkage(), Name, Aliasee); 5080b57cec5SDimitry Andric } 5090b57cec5SDimitry Andric 5100b57cec5SDimitry Andric void GlobalAlias::removeFromParent() { 5110b57cec5SDimitry Andric getParent()->getAliasList().remove(getIterator()); 5120b57cec5SDimitry Andric } 5130b57cec5SDimitry Andric 5140b57cec5SDimitry Andric void GlobalAlias::eraseFromParent() { 5150b57cec5SDimitry Andric getParent()->getAliasList().erase(getIterator()); 5160b57cec5SDimitry Andric } 5170b57cec5SDimitry Andric 5180b57cec5SDimitry Andric void GlobalAlias::setAliasee(Constant *Aliasee) { 5190b57cec5SDimitry Andric assert((!Aliasee || Aliasee->getType() == getType()) && 5200b57cec5SDimitry Andric "Alias and aliasee types should match!"); 521349cc55cSDimitry Andric Op<0>().set(Aliasee); 522349cc55cSDimitry Andric } 523349cc55cSDimitry Andric 524349cc55cSDimitry Andric const GlobalObject *GlobalAlias::getAliaseeObject() const { 525349cc55cSDimitry Andric DenseSet<const GlobalAlias *> Aliases; 526349cc55cSDimitry Andric return findBaseObject(getOperand(0), Aliases); 5270b57cec5SDimitry Andric } 5280b57cec5SDimitry Andric 5290b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 5300b57cec5SDimitry Andric // GlobalIFunc Implementation 5310b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 5320b57cec5SDimitry Andric 5330b57cec5SDimitry Andric GlobalIFunc::GlobalIFunc(Type *Ty, unsigned AddressSpace, LinkageTypes Link, 5340b57cec5SDimitry Andric const Twine &Name, Constant *Resolver, 5350b57cec5SDimitry Andric Module *ParentModule) 536349cc55cSDimitry Andric : GlobalObject(Ty, Value::GlobalIFuncVal, &Op<0>(), 1, Link, Name, 537349cc55cSDimitry Andric AddressSpace) { 538349cc55cSDimitry Andric setResolver(Resolver); 5390b57cec5SDimitry Andric if (ParentModule) 5400b57cec5SDimitry Andric ParentModule->getIFuncList().push_back(this); 5410b57cec5SDimitry Andric } 5420b57cec5SDimitry Andric 5430b57cec5SDimitry Andric GlobalIFunc *GlobalIFunc::create(Type *Ty, unsigned AddressSpace, 5440b57cec5SDimitry Andric LinkageTypes Link, const Twine &Name, 5450b57cec5SDimitry Andric Constant *Resolver, Module *ParentModule) { 5460b57cec5SDimitry Andric return new GlobalIFunc(Ty, AddressSpace, Link, Name, Resolver, ParentModule); 5470b57cec5SDimitry Andric } 5480b57cec5SDimitry Andric 5490b57cec5SDimitry Andric void GlobalIFunc::removeFromParent() { 5500b57cec5SDimitry Andric getParent()->getIFuncList().remove(getIterator()); 5510b57cec5SDimitry Andric } 5520b57cec5SDimitry Andric 5530b57cec5SDimitry Andric void GlobalIFunc::eraseFromParent() { 5540b57cec5SDimitry Andric getParent()->getIFuncList().erase(getIterator()); 5550b57cec5SDimitry Andric } 556349cc55cSDimitry Andric 557349cc55cSDimitry Andric const Function *GlobalIFunc::getResolverFunction() const { 558349cc55cSDimitry Andric DenseSet<const GlobalAlias *> Aliases; 559349cc55cSDimitry Andric return dyn_cast<Function>(findBaseObject(getResolver(), Aliases)); 560349cc55cSDimitry Andric } 561