xref: /freebsd/contrib/llvm-project/llvm/lib/IR/Globals.cpp (revision 04eeddc0aa8e0a417a16eaf9d7d095207f4a8623)
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