1//===-- Globals.cpp - Implement the GlobalValue & GlobalVariable class ----===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// This file implements the GlobalValue & GlobalVariable classes for the IR 10// library. 11// 12//===----------------------------------------------------------------------===// 13 14#include "LLVMContextImpl.h" 15#include "llvm/ADT/SmallPtrSet.h" 16#include "llvm/ADT/Triple.h" 17#include "llvm/IR/ConstantRange.h" 18#include "llvm/IR/Constants.h" 19#include "llvm/IR/DerivedTypes.h" 20#include "llvm/IR/GlobalAlias.h" 21#include "llvm/IR/GlobalValue.h" 22#include "llvm/IR/GlobalVariable.h" 23#include "llvm/IR/Module.h" 24#include "llvm/IR/Operator.h" 25#include "llvm/Support/Error.h" 26#include "llvm/Support/ErrorHandling.h" 27using namespace llvm; 28 29//===----------------------------------------------------------------------===// 30// GlobalValue Class 31//===----------------------------------------------------------------------===// 32 33// GlobalValue should be a Constant, plus a type, a module, some flags, and an 34// intrinsic ID. Add an assert to prevent people from accidentally growing 35// GlobalValue while adding flags. 36static_assert(sizeof(GlobalValue) == 37 sizeof(Constant) + 2 * sizeof(void *) + 2 * sizeof(unsigned), 38 "unexpected GlobalValue size growth"); 39 40// GlobalObject adds a comdat. 41static_assert(sizeof(GlobalObject) == sizeof(GlobalValue) + sizeof(void *), 42 "unexpected GlobalObject size growth"); 43 44bool GlobalValue::isMaterializable() const { 45 if (const Function *F = dyn_cast<Function>(this)) 46 return F->isMaterializable(); 47 return false; 48} 49Error GlobalValue::materialize() { 50 return getParent()->materialize(this); 51} 52 53/// Override destroyConstantImpl to make sure it doesn't get called on 54/// GlobalValue's because they shouldn't be treated like other constants. 55void GlobalValue::destroyConstantImpl() { 56 llvm_unreachable("You can't GV->destroyConstantImpl()!"); 57} 58 59Value *GlobalValue::handleOperandChangeImpl(Value *From, Value *To) { 60 llvm_unreachable("Unsupported class for handleOperandChange()!"); 61} 62 63/// copyAttributesFrom - copy all additional attributes (those not needed to 64/// create a GlobalValue) from the GlobalValue Src to this one. 65void GlobalValue::copyAttributesFrom(const GlobalValue *Src) { 66 setVisibility(Src->getVisibility()); 67 setUnnamedAddr(Src->getUnnamedAddr()); 68 setDLLStorageClass(Src->getDLLStorageClass()); 69 setDSOLocal(Src->isDSOLocal()); 70 setPartition(Src->getPartition()); 71} 72 73void GlobalValue::removeFromParent() { 74 switch (getValueID()) { 75#define HANDLE_GLOBAL_VALUE(NAME) \ 76 case Value::NAME##Val: \ 77 return static_cast<NAME *>(this)->removeFromParent(); 78#include "llvm/IR/Value.def" 79 default: 80 break; 81 } 82 llvm_unreachable("not a global"); 83} 84 85void GlobalValue::eraseFromParent() { 86 switch (getValueID()) { 87#define HANDLE_GLOBAL_VALUE(NAME) \ 88 case Value::NAME##Val: \ 89 return static_cast<NAME *>(this)->eraseFromParent(); 90#include "llvm/IR/Value.def" 91 default: 92 break; 93 } 94 llvm_unreachable("not a global"); 95} 96 97unsigned GlobalValue::getAlignment() const { 98 if (auto *GA = dyn_cast<GlobalAlias>(this)) { 99 // In general we cannot compute this at the IR level, but we try. 100 if (const GlobalObject *GO = GA->getBaseObject()) 101 return GO->getAlignment(); 102 103 // FIXME: we should also be able to handle: 104 // Alias = Global + Offset 105 // Alias = Absolute 106 return 0; 107 } 108 return cast<GlobalObject>(this)->getAlignment(); 109} 110 111unsigned GlobalValue::getAddressSpace() const { 112 PointerType *PtrTy = getType(); 113 return PtrTy->getAddressSpace(); 114} 115 116void GlobalObject::setAlignment(unsigned Align) { 117 setAlignment(MaybeAlign(Align)); 118} 119 120void GlobalObject::setAlignment(MaybeAlign Align) { 121 assert((!Align || Align <= MaximumAlignment) && 122 "Alignment is greater than MaximumAlignment!"); 123 unsigned AlignmentData = encode(Align); 124 unsigned OldData = getGlobalValueSubClassData(); 125 setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData); 126 assert(MaybeAlign(getAlignment()) == Align && 127 "Alignment representation error!"); 128} 129 130void GlobalObject::copyAttributesFrom(const GlobalObject *Src) { 131 GlobalValue::copyAttributesFrom(Src); 132 setAlignment(MaybeAlign(Src->getAlignment())); 133 setSection(Src->getSection()); 134} 135 136std::string GlobalValue::getGlobalIdentifier(StringRef Name, 137 GlobalValue::LinkageTypes Linkage, 138 StringRef FileName) { 139 140 // Value names may be prefixed with a binary '1' to indicate 141 // that the backend should not modify the symbols due to any platform 142 // naming convention. Do not include that '1' in the PGO profile name. 143 if (Name[0] == '\1') 144 Name = Name.substr(1); 145 146 std::string NewName = Name; 147 if (llvm::GlobalValue::isLocalLinkage(Linkage)) { 148 // For local symbols, prepend the main file name to distinguish them. 149 // Do not include the full path in the file name since there's no guarantee 150 // that it will stay the same, e.g., if the files are checked out from 151 // version control in different locations. 152 if (FileName.empty()) 153 NewName = NewName.insert(0, "<unknown>:"); 154 else 155 NewName = NewName.insert(0, FileName.str() + ":"); 156 } 157 return NewName; 158} 159 160std::string GlobalValue::getGlobalIdentifier() const { 161 return getGlobalIdentifier(getName(), getLinkage(), 162 getParent()->getSourceFileName()); 163} 164 165StringRef GlobalValue::getSection() const { 166 if (auto *GA = dyn_cast<GlobalAlias>(this)) { 167 // In general we cannot compute this at the IR level, but we try. 168 if (const GlobalObject *GO = GA->getBaseObject()) 169 return GO->getSection(); 170 return ""; 171 } 172 return cast<GlobalObject>(this)->getSection(); 173} 174 175const Comdat *GlobalValue::getComdat() const { 176 if (auto *GA = dyn_cast<GlobalAlias>(this)) { 177 // In general we cannot compute this at the IR level, but we try. 178 if (const GlobalObject *GO = GA->getBaseObject()) 179 return const_cast<GlobalObject *>(GO)->getComdat(); 180 return nullptr; 181 } 182 // ifunc and its resolver are separate things so don't use resolver comdat. 183 if (isa<GlobalIFunc>(this)) 184 return nullptr; 185 return cast<GlobalObject>(this)->getComdat(); 186} 187 188StringRef GlobalValue::getPartition() const { 189 if (!hasPartition()) 190 return ""; 191 return getContext().pImpl->GlobalValuePartitions[this]; 192} 193 194void GlobalValue::setPartition(StringRef S) { 195 // Do nothing if we're clearing the partition and it is already empty. 196 if (!hasPartition() && S.empty()) 197 return; 198 199 // Get or create a stable partition name string and put it in the table in the 200 // context. 201 if (!S.empty()) 202 S = getContext().pImpl->Saver.save(S); 203 getContext().pImpl->GlobalValuePartitions[this] = S; 204 205 // Update the HasPartition field. Setting the partition to the empty string 206 // means this global no longer has a partition. 207 HasPartition = !S.empty(); 208} 209 210StringRef GlobalObject::getSectionImpl() const { 211 assert(hasSection()); 212 return getContext().pImpl->GlobalObjectSections[this]; 213} 214 215void GlobalObject::setSection(StringRef S) { 216 // Do nothing if we're clearing the section and it is already empty. 217 if (!hasSection() && S.empty()) 218 return; 219 220 // Get or create a stable section name string and put it in the table in the 221 // context. 222 if (!S.empty()) 223 S = getContext().pImpl->Saver.save(S); 224 getContext().pImpl->GlobalObjectSections[this] = S; 225 226 // Update the HasSectionHashEntryBit. Setting the section to the empty string 227 // means this global no longer has a section. 228 setGlobalObjectFlag(HasSectionHashEntryBit, !S.empty()); 229} 230 231bool GlobalValue::isDeclaration() const { 232 // Globals are definitions if they have an initializer. 233 if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(this)) 234 return GV->getNumOperands() == 0; 235 236 // Functions are definitions if they have a body. 237 if (const Function *F = dyn_cast<Function>(this)) 238 return F->empty() && !F->isMaterializable(); 239 240 // Aliases and ifuncs are always definitions. 241 assert(isa<GlobalIndirectSymbol>(this)); 242 return false; 243} 244 245bool GlobalValue::canIncreaseAlignment() const { 246 // Firstly, can only increase the alignment of a global if it 247 // is a strong definition. 248 if (!isStrongDefinitionForLinker()) 249 return false; 250 251 // It also has to either not have a section defined, or, not have 252 // alignment specified. (If it is assigned a section, the global 253 // could be densely packed with other objects in the section, and 254 // increasing the alignment could cause padding issues.) 255 if (hasSection() && getAlignment() > 0) 256 return false; 257 258 // On ELF platforms, we're further restricted in that we can't 259 // increase the alignment of any variable which might be emitted 260 // into a shared library, and which is exported. If the main 261 // executable accesses a variable found in a shared-lib, the main 262 // exe actually allocates memory for and exports the symbol ITSELF, 263 // overriding the symbol found in the library. That is, at link 264 // time, the observed alignment of the variable is copied into the 265 // executable binary. (A COPY relocation is also generated, to copy 266 // the initial data from the shadowed variable in the shared-lib 267 // into the location in the main binary, before running code.) 268 // 269 // And thus, even though you might think you are defining the 270 // global, and allocating the memory for the global in your object 271 // file, and thus should be able to set the alignment arbitrarily, 272 // that's not actually true. Doing so can cause an ABI breakage; an 273 // executable might have already been built with the previous 274 // alignment of the variable, and then assuming an increased 275 // alignment will be incorrect. 276 277 // Conservatively assume ELF if there's no parent pointer. 278 bool isELF = 279 (!Parent || Triple(Parent->getTargetTriple()).isOSBinFormatELF()); 280 if (isELF && !isDSOLocal()) 281 return false; 282 283 return true; 284} 285 286const GlobalObject *GlobalValue::getBaseObject() const { 287 if (auto *GO = dyn_cast<GlobalObject>(this)) 288 return GO; 289 if (auto *GA = dyn_cast<GlobalIndirectSymbol>(this)) 290 return GA->getBaseObject(); 291 return nullptr; 292} 293 294bool GlobalValue::isAbsoluteSymbolRef() const { 295 auto *GO = dyn_cast<GlobalObject>(this); 296 if (!GO) 297 return false; 298 299 return GO->getMetadata(LLVMContext::MD_absolute_symbol); 300} 301 302Optional<ConstantRange> GlobalValue::getAbsoluteSymbolRange() const { 303 auto *GO = dyn_cast<GlobalObject>(this); 304 if (!GO) 305 return None; 306 307 MDNode *MD = GO->getMetadata(LLVMContext::MD_absolute_symbol); 308 if (!MD) 309 return None; 310 311 return getConstantRangeFromMetadata(*MD); 312} 313 314bool GlobalValue::canBeOmittedFromSymbolTable() const { 315 if (!hasLinkOnceODRLinkage()) 316 return false; 317 318 // We assume that anyone who sets global unnamed_addr on a non-constant 319 // knows what they're doing. 320 if (hasGlobalUnnamedAddr()) 321 return true; 322 323 // If it is a non constant variable, it needs to be uniqued across shared 324 // objects. 325 if (auto *Var = dyn_cast<GlobalVariable>(this)) 326 if (!Var->isConstant()) 327 return false; 328 329 return hasAtLeastLocalUnnamedAddr(); 330} 331 332//===----------------------------------------------------------------------===// 333// GlobalVariable Implementation 334//===----------------------------------------------------------------------===// 335 336GlobalVariable::GlobalVariable(Type *Ty, bool constant, LinkageTypes Link, 337 Constant *InitVal, const Twine &Name, 338 ThreadLocalMode TLMode, unsigned AddressSpace, 339 bool isExternallyInitialized) 340 : GlobalObject(Ty, Value::GlobalVariableVal, 341 OperandTraits<GlobalVariable>::op_begin(this), 342 InitVal != nullptr, Link, Name, AddressSpace), 343 isConstantGlobal(constant), 344 isExternallyInitializedConstant(isExternallyInitialized) { 345 assert(!Ty->isFunctionTy() && PointerType::isValidElementType(Ty) && 346 "invalid type for global variable"); 347 setThreadLocalMode(TLMode); 348 if (InitVal) { 349 assert(InitVal->getType() == Ty && 350 "Initializer should be the same type as the GlobalVariable!"); 351 Op<0>() = InitVal; 352 } 353} 354 355GlobalVariable::GlobalVariable(Module &M, Type *Ty, bool constant, 356 LinkageTypes Link, Constant *InitVal, 357 const Twine &Name, GlobalVariable *Before, 358 ThreadLocalMode TLMode, unsigned AddressSpace, 359 bool isExternallyInitialized) 360 : GlobalObject(Ty, Value::GlobalVariableVal, 361 OperandTraits<GlobalVariable>::op_begin(this), 362 InitVal != nullptr, Link, Name, AddressSpace), 363 isConstantGlobal(constant), 364 isExternallyInitializedConstant(isExternallyInitialized) { 365 assert(!Ty->isFunctionTy() && PointerType::isValidElementType(Ty) && 366 "invalid type for global variable"); 367 setThreadLocalMode(TLMode); 368 if (InitVal) { 369 assert(InitVal->getType() == Ty && 370 "Initializer should be the same type as the GlobalVariable!"); 371 Op<0>() = InitVal; 372 } 373 374 if (Before) 375 Before->getParent()->getGlobalList().insert(Before->getIterator(), this); 376 else 377 M.getGlobalList().push_back(this); 378} 379 380void GlobalVariable::removeFromParent() { 381 getParent()->getGlobalList().remove(getIterator()); 382} 383 384void GlobalVariable::eraseFromParent() { 385 getParent()->getGlobalList().erase(getIterator()); 386} 387 388void GlobalVariable::setInitializer(Constant *InitVal) { 389 if (!InitVal) { 390 if (hasInitializer()) { 391 // Note, the num operands is used to compute the offset of the operand, so 392 // the order here matters. Clearing the operand then clearing the num 393 // operands ensures we have the correct offset to the operand. 394 Op<0>().set(nullptr); 395 setGlobalVariableNumOperands(0); 396 } 397 } else { 398 assert(InitVal->getType() == getValueType() && 399 "Initializer type must match GlobalVariable type"); 400 // Note, the num operands is used to compute the offset of the operand, so 401 // the order here matters. We need to set num operands to 1 first so that 402 // we get the correct offset to the first operand when we set it. 403 if (!hasInitializer()) 404 setGlobalVariableNumOperands(1); 405 Op<0>().set(InitVal); 406 } 407} 408 409/// Copy all additional attributes (those not needed to create a GlobalVariable) 410/// from the GlobalVariable Src to this one. 411void GlobalVariable::copyAttributesFrom(const GlobalVariable *Src) { 412 GlobalObject::copyAttributesFrom(Src); 413 setThreadLocalMode(Src->getThreadLocalMode()); 414 setExternallyInitialized(Src->isExternallyInitialized()); 415 setAttributes(Src->getAttributes()); 416} 417 418void GlobalVariable::dropAllReferences() { 419 User::dropAllReferences(); 420 clearMetadata(); 421} 422 423//===----------------------------------------------------------------------===// 424// GlobalIndirectSymbol Implementation 425//===----------------------------------------------------------------------===// 426 427GlobalIndirectSymbol::GlobalIndirectSymbol(Type *Ty, ValueTy VTy, 428 unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, 429 Constant *Symbol) 430 : GlobalValue(Ty, VTy, &Op<0>(), 1, Linkage, Name, AddressSpace) { 431 Op<0>() = Symbol; 432} 433 434static const GlobalObject * 435findBaseObject(const Constant *C, DenseSet<const GlobalAlias *> &Aliases) { 436 if (auto *GO = dyn_cast<GlobalObject>(C)) 437 return GO; 438 if (auto *GA = dyn_cast<GlobalAlias>(C)) 439 if (Aliases.insert(GA).second) 440 return findBaseObject(GA->getOperand(0), Aliases); 441 if (auto *CE = dyn_cast<ConstantExpr>(C)) { 442 switch (CE->getOpcode()) { 443 case Instruction::Add: { 444 auto *LHS = findBaseObject(CE->getOperand(0), Aliases); 445 auto *RHS = findBaseObject(CE->getOperand(1), Aliases); 446 if (LHS && RHS) 447 return nullptr; 448 return LHS ? LHS : RHS; 449 } 450 case Instruction::Sub: { 451 if (findBaseObject(CE->getOperand(1), Aliases)) 452 return nullptr; 453 return findBaseObject(CE->getOperand(0), Aliases); 454 } 455 case Instruction::IntToPtr: 456 case Instruction::PtrToInt: 457 case Instruction::BitCast: 458 case Instruction::GetElementPtr: 459 return findBaseObject(CE->getOperand(0), Aliases); 460 default: 461 break; 462 } 463 } 464 return nullptr; 465} 466 467const GlobalObject *GlobalIndirectSymbol::getBaseObject() const { 468 DenseSet<const GlobalAlias *> Aliases; 469 return findBaseObject(getOperand(0), Aliases); 470} 471 472//===----------------------------------------------------------------------===// 473// GlobalAlias Implementation 474//===----------------------------------------------------------------------===// 475 476GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Link, 477 const Twine &Name, Constant *Aliasee, 478 Module *ParentModule) 479 : GlobalIndirectSymbol(Ty, Value::GlobalAliasVal, AddressSpace, Link, Name, 480 Aliasee) { 481 if (ParentModule) 482 ParentModule->getAliasList().push_back(this); 483} 484 485GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace, 486 LinkageTypes Link, const Twine &Name, 487 Constant *Aliasee, Module *ParentModule) { 488 return new GlobalAlias(Ty, AddressSpace, Link, Name, Aliasee, ParentModule); 489} 490 491GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace, 492 LinkageTypes Linkage, const Twine &Name, 493 Module *Parent) { 494 return create(Ty, AddressSpace, Linkage, Name, nullptr, Parent); 495} 496 497GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace, 498 LinkageTypes Linkage, const Twine &Name, 499 GlobalValue *Aliasee) { 500 return create(Ty, AddressSpace, Linkage, Name, Aliasee, Aliasee->getParent()); 501} 502 503GlobalAlias *GlobalAlias::create(LinkageTypes Link, const Twine &Name, 504 GlobalValue *Aliasee) { 505 PointerType *PTy = Aliasee->getType(); 506 return create(PTy->getElementType(), PTy->getAddressSpace(), Link, Name, 507 Aliasee); 508} 509 510GlobalAlias *GlobalAlias::create(const Twine &Name, GlobalValue *Aliasee) { 511 return create(Aliasee->getLinkage(), Name, Aliasee); 512} 513 514void GlobalAlias::removeFromParent() { 515 getParent()->getAliasList().remove(getIterator()); 516} 517 518void GlobalAlias::eraseFromParent() { 519 getParent()->getAliasList().erase(getIterator()); 520} 521 522void GlobalAlias::setAliasee(Constant *Aliasee) { 523 assert((!Aliasee || Aliasee->getType() == getType()) && 524 "Alias and aliasee types should match!"); 525 setIndirectSymbol(Aliasee); 526} 527 528//===----------------------------------------------------------------------===// 529// GlobalIFunc Implementation 530//===----------------------------------------------------------------------===// 531 532GlobalIFunc::GlobalIFunc(Type *Ty, unsigned AddressSpace, LinkageTypes Link, 533 const Twine &Name, Constant *Resolver, 534 Module *ParentModule) 535 : GlobalIndirectSymbol(Ty, Value::GlobalIFuncVal, AddressSpace, Link, Name, 536 Resolver) { 537 if (ParentModule) 538 ParentModule->getIFuncList().push_back(this); 539} 540 541GlobalIFunc *GlobalIFunc::create(Type *Ty, unsigned AddressSpace, 542 LinkageTypes Link, const Twine &Name, 543 Constant *Resolver, Module *ParentModule) { 544 return new GlobalIFunc(Ty, AddressSpace, Link, Name, Resolver, ParentModule); 545} 546 547void GlobalIFunc::removeFromParent() { 548 getParent()->getIFuncList().remove(getIterator()); 549} 550 551void GlobalIFunc::eraseFromParent() { 552 getParent()->getIFuncList().erase(getIterator()); 553} 554