LCOV - code coverage report
Current view: top level - lib/IR - Globals.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 131 144 91.0 %
Date: 2018-02-23 15:42:53 Functions: 38 42 90.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- Globals.cpp - Implement the GlobalValue & GlobalVariable class ----===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file implements the GlobalValue & GlobalVariable classes for the IR
      11             : // library.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #include "LLVMContextImpl.h"
      16             : #include "llvm/ADT/SmallPtrSet.h"
      17             : #include "llvm/ADT/Triple.h"
      18             : #include "llvm/IR/ConstantRange.h"
      19             : #include "llvm/IR/Constants.h"
      20             : #include "llvm/IR/DerivedTypes.h"
      21             : #include "llvm/IR/GlobalAlias.h"
      22             : #include "llvm/IR/GlobalValue.h"
      23             : #include "llvm/IR/GlobalVariable.h"
      24             : #include "llvm/IR/Module.h"
      25             : #include "llvm/IR/Operator.h"
      26             : #include "llvm/Support/Error.h"
      27             : #include "llvm/Support/ErrorHandling.h"
      28             : using namespace llvm;
      29             : 
      30             : //===----------------------------------------------------------------------===//
      31             : //                            GlobalValue Class
      32             : //===----------------------------------------------------------------------===//
      33             : 
      34             : // GlobalValue should be a Constant, plus a type, a module, some flags, and an
      35             : // intrinsic ID. Add an assert to prevent people from accidentally growing
      36             : // GlobalValue while adding flags.
      37             : static_assert(sizeof(GlobalValue) ==
      38             :                   sizeof(Constant) + 2 * sizeof(void *) + 2 * sizeof(unsigned),
      39             :               "unexpected GlobalValue size growth");
      40             : 
      41             : // GlobalObject adds a comdat.
      42             : static_assert(sizeof(GlobalObject) == sizeof(GlobalValue) + sizeof(void *),
      43             :               "unexpected GlobalObject size growth");
      44             : 
      45       80699 : bool GlobalValue::isMaterializable() const {
      46             :   if (const Function *F = dyn_cast<Function>(this))
      47           0 :     return F->isMaterializable();
      48             :   return false;
      49             : }
      50      136855 : Error GlobalValue::materialize() {
      51      136855 :   return getParent()->materialize(this);
      52             : }
      53             : 
      54             : /// Override destroyConstantImpl to make sure it doesn't get called on
      55             : /// GlobalValue's because they shouldn't be treated like other constants.
      56           0 : void GlobalValue::destroyConstantImpl() {
      57           0 :   llvm_unreachable("You can't GV->destroyConstantImpl()!");
      58             : }
      59             : 
      60           0 : Value *GlobalValue::handleOperandChangeImpl(Value *From, Value *To) {
      61           0 :   llvm_unreachable("Unsupported class for handleOperandChange()!");
      62             : }
      63             : 
      64             : /// copyAttributesFrom - copy all additional attributes (those not needed to
      65             : /// create a GlobalValue) from the GlobalValue Src to this one.
      66        3890 : void GlobalValue::copyAttributesFrom(const GlobalValue *Src) {
      67             :   setVisibility(Src->getVisibility());
      68             :   setUnnamedAddr(Src->getUnnamedAddr());
      69             :   setDLLStorageClass(Src->getDLLStorageClass());
      70             :   setDSOLocal(Src->isDSOLocal());
      71        3890 : }
      72             : 
      73           0 : void GlobalValue::removeFromParent() {
      74           0 :   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           0 :   llvm_unreachable("not a global");
      83             : }
      84             : 
      85        5828 : void GlobalValue::eraseFromParent() {
      86       11656 :   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           0 :   llvm_unreachable("not a global");
      95             : }
      96             : 
      97     1455951 : unsigned 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        2825 :     if (const GlobalObject *GO = GA->getBaseObject())
     101        2734 :       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     1453126 :   return cast<GlobalObject>(this)->getAlignment();
     109             : }
     110             : 
     111      441002 : void GlobalObject::setAlignment(unsigned Align) {
     112             :   assert((Align & (Align-1)) == 0 && "Alignment is not a power of 2!");
     113             :   assert(Align <= MaximumAlignment &&
     114             :          "Alignment is greater than MaximumAlignment!");
     115      441002 :   unsigned AlignmentData = Log2_32(Align) + 1;
     116             :   unsigned OldData = getGlobalValueSubClassData();
     117      441002 :   setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData);
     118             :   assert(getAlignment() == Align && "Alignment representation error!");
     119      441002 : }
     120             : 
     121        3779 : void GlobalObject::copyAttributesFrom(const GlobalObject *Src) {
     122        3779 :   GlobalValue::copyAttributesFrom(Src);
     123        3779 :   setAlignment(Src->getAlignment());
     124        3779 :   setSection(Src->getSection());
     125        3779 : }
     126             : 
     127        8094 : std::string GlobalValue::getGlobalIdentifier(StringRef Name,
     128             :                                              GlobalValue::LinkageTypes Linkage,
     129             :                                              StringRef FileName) {
     130             : 
     131             :   // Value names may be prefixed with a binary '1' to indicate
     132             :   // that the backend should not modify the symbols due to any platform
     133             :   // naming convention. Do not include that '1' in the PGO profile name.
     134       16188 :   if (Name[0] == '\1')
     135          46 :     Name = Name.substr(1);
     136             : 
     137             :   std::string NewName = Name;
     138             :   if (llvm::GlobalValue::isLocalLinkage(Linkage)) {
     139             :     // For local symbols, prepend the main file name to distinguish them.
     140             :     // Do not include the full path in the file name since there's no guarantee
     141             :     // that it will stay the same, e.g., if the files are checked out from
     142             :     // version control in different locations.
     143         603 :     if (FileName.empty())
     144           1 :       NewName = NewName.insert(0, "<unknown>:");
     145             :     else
     146        1806 :       NewName = NewName.insert(0, FileName.str() + ":");
     147             :   }
     148        8094 :   return NewName;
     149             : }
     150             : 
     151        4615 : std::string GlobalValue::getGlobalIdentifier() const {
     152             :   return getGlobalIdentifier(getName(), getLinkage(),
     153        9230 :                              getParent()->getSourceFileName());
     154             : }
     155             : 
     156       81279 : StringRef GlobalValue::getSection() const {
     157             :   if (auto *GA = dyn_cast<GlobalAlias>(this)) {
     158             :     // In general we cannot compute this at the IR level, but we try.
     159         132 :     if (const GlobalObject *GO = GA->getBaseObject())
     160             :       return GO->getSection();
     161           0 :     return "";
     162             :   }
     163             :   return cast<GlobalObject>(this)->getSection();
     164             : }
     165             : 
     166     1187025 : const Comdat *GlobalValue::getComdat() const {
     167             :   if (auto *GA = dyn_cast<GlobalAlias>(this)) {
     168             :     // In general we cannot compute this at the IR level, but we try.
     169        1615 :     if (const GlobalObject *GO = GA->getBaseObject())
     170        1599 :       return const_cast<GlobalObject *>(GO)->getComdat();
     171             :     return nullptr;
     172             :   }
     173             :   // ifunc and its resolver are separate things so don't use resolver comdat.
     174     1185410 :   if (isa<GlobalIFunc>(this))
     175             :     return nullptr;
     176     1185403 :   return cast<GlobalObject>(this)->getComdat();
     177             : }
     178             : 
     179       23838 : StringRef GlobalObject::getSectionImpl() const {
     180             :   assert(hasSection());
     181       47676 :   return getContext().pImpl->GlobalObjectSections[this];
     182             : }
     183             : 
     184      288467 : void GlobalObject::setSection(StringRef S) {
     185             :   // Do nothing if we're clearing the section and it is already empty.
     186      288467 :   if (!hasSection() && S.empty())
     187             :     return;
     188             : 
     189             :   // Get or create a stable section name string and put it in the table in the
     190             :   // context.
     191       19317 :   if (!S.empty()) {
     192       19316 :     S = getContext().pImpl->SectionStrings.insert(S).first->first();
     193             :   }
     194       38634 :   getContext().pImpl->GlobalObjectSections[this] = S;
     195             : 
     196             :   // Update the HasSectionHashEntryBit. Setting the section to the empty string
     197             :   // means this global no longer has a section.
     198             :   setGlobalObjectFlag(HasSectionHashEntryBit, !S.empty());
     199             : }
     200             : 
     201    35429742 : bool GlobalValue::isDeclaration() const {
     202             :   // Globals are definitions if they have an initializer.
     203             :   if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(this))
     204    24285892 :     return GV->getNumOperands() == 0;
     205             : 
     206             :   // Functions are definitions if they have a body.
     207             :   if (const Function *F = dyn_cast<Function>(this))
     208    15199848 :     return F->empty() && !F->isMaterializable();
     209             : 
     210             :   // Aliases and ifuncs are always definitions.
     211             :   assert(isa<GlobalIndirectSymbol>(this));
     212             :   return false;
     213             : }
     214             : 
     215       12621 : bool GlobalValue::canIncreaseAlignment() const {
     216             :   // Firstly, can only increase the alignment of a global if it
     217             :   // is a strong definition.
     218       12621 :   if (!isStrongDefinitionForLinker())
     219             :     return false;
     220             : 
     221             :   // It also has to either not have a section defined, or, not have
     222             :   // alignment specified. (If it is assigned a section, the global
     223             :   // could be densely packed with other objects in the section, and
     224             :   // increasing the alignment could cause padding issues.)
     225       12499 :   if (hasSection() && getAlignment() > 0)
     226             :     return false;
     227             : 
     228             :   // On ELF platforms, we're further restricted in that we can't
     229             :   // increase the alignment of any variable which might be emitted
     230             :   // into a shared library, and which is exported. If the main
     231             :   // executable accesses a variable found in a shared-lib, the main
     232             :   // exe actually allocates memory for and exports the symbol ITSELF,
     233             :   // overriding the symbol found in the library. That is, at link
     234             :   // time, the observed alignment of the variable is copied into the
     235             :   // executable binary. (A COPY relocation is also generated, to copy
     236             :   // the initial data from the shadowed variable in the shared-lib
     237             :   // into the location in the main binary, before running code.)
     238             :   //
     239             :   // And thus, even though you might think you are defining the
     240             :   // global, and allocating the memory for the global in your object
     241             :   // file, and thus should be able to set the alignment arbitrarily,
     242             :   // that's not actually true. Doing so can cause an ABI breakage; an
     243             :   // executable might have already been built with the previous
     244             :   // alignment of the variable, and then assuming an increased
     245             :   // alignment will be incorrect.
     246             : 
     247             :   // Conservatively assume ELF if there's no parent pointer.
     248             :   bool isELF =
     249       49924 :       (!Parent || Triple(Parent->getTargetTriple()).isOSBinFormatELF());
     250       24939 :   if (isELF && hasDefaultVisibility() && !hasLocalLinkage())
     251             :     return false;
     252             : 
     253             :   return true;
     254             : }
     255             : 
     256       39445 : const GlobalObject *GlobalValue::getBaseObject() const {
     257             :   if (auto *GO = dyn_cast<GlobalObject>(this))
     258             :     return GO;
     259             :   if (auto *GA = dyn_cast<GlobalIndirectSymbol>(this))
     260         632 :     return GA->getBaseObject();
     261             :   return nullptr;
     262             : }
     263             : 
     264      487142 : bool GlobalValue::isAbsoluteSymbolRef() const {
     265             :   auto *GO = dyn_cast<GlobalObject>(this);
     266             :   if (!GO)
     267             :     return false;
     268             : 
     269      487034 :   return GO->getMetadata(LLVMContext::MD_absolute_symbol);
     270             : }
     271             : 
     272     1514551 : Optional<ConstantRange> GlobalValue::getAbsoluteSymbolRange() const {
     273             :   auto *GO = dyn_cast<GlobalObject>(this);
     274             :   if (!GO)
     275             :     return None;
     276             : 
     277     1514422 :   MDNode *MD = GO->getMetadata(LLVMContext::MD_absolute_symbol);
     278     1514422 :   if (!MD)
     279             :     return None;
     280             : 
     281          84 :   return getConstantRangeFromMetadata(*MD);
     282             : }
     283             : 
     284             : //===----------------------------------------------------------------------===//
     285             : // GlobalVariable Implementation
     286             : //===----------------------------------------------------------------------===//
     287             : 
     288         122 : GlobalVariable::GlobalVariable(Type *Ty, bool constant, LinkageTypes Link,
     289             :                                Constant *InitVal, const Twine &Name,
     290             :                                ThreadLocalMode TLMode, unsigned AddressSpace,
     291         122 :                                bool isExternallyInitialized)
     292             :     : GlobalObject(Ty, Value::GlobalVariableVal,
     293             :                    OperandTraits<GlobalVariable>::op_begin(this),
     294             :                    InitVal != nullptr, Link, Name, AddressSpace),
     295             :       isConstantGlobal(constant),
     296         244 :       isExternallyInitializedConstant(isExternallyInitialized) {
     297             :   assert(!Ty->isFunctionTy() && PointerType::isValidElementType(Ty) &&
     298             :          "invalid type for global variable");
     299             :   setThreadLocalMode(TLMode);
     300         122 :   if (InitVal) {
     301             :     assert(InitVal->getType() == Ty &&
     302             :            "Initializer should be the same type as the GlobalVariable!");
     303             :     Op<0>() = InitVal;
     304             :   }
     305         122 : }
     306             : 
     307      180264 : GlobalVariable::GlobalVariable(Module &M, Type *Ty, bool constant,
     308             :                                LinkageTypes Link, Constant *InitVal,
     309             :                                const Twine &Name, GlobalVariable *Before,
     310             :                                ThreadLocalMode TLMode, unsigned AddressSpace,
     311      180264 :                                bool isExternallyInitialized)
     312             :     : GlobalObject(Ty, Value::GlobalVariableVal,
     313             :                    OperandTraits<GlobalVariable>::op_begin(this),
     314             :                    InitVal != nullptr, Link, Name, AddressSpace),
     315             :       isConstantGlobal(constant),
     316      360528 :       isExternallyInitializedConstant(isExternallyInitialized) {
     317             :   assert(!Ty->isFunctionTy() && PointerType::isValidElementType(Ty) &&
     318             :          "invalid type for global variable");
     319             :   setThreadLocalMode(TLMode);
     320      180264 :   if (InitVal) {
     321             :     assert(InitVal->getType() == Ty &&
     322             :            "Initializer should be the same type as the GlobalVariable!");
     323             :     Op<0>() = InitVal;
     324             :   }
     325             : 
     326      180264 :   if (Before)
     327         332 :     Before->getParent()->getGlobalList().insert(Before->getIterator(), this);
     328             :   else
     329      179932 :     M.getGlobalList().push_back(this);
     330      180264 : }
     331             : 
     332         126 : void GlobalVariable::removeFromParent() {
     333         126 :   getParent()->getGlobalList().remove(getIterator());
     334         126 : }
     335             : 
     336        3992 : void GlobalVariable::eraseFromParent() {
     337        3992 :   getParent()->getGlobalList().erase(getIterator());
     338        3992 : }
     339             : 
     340       50570 : void GlobalVariable::setInitializer(Constant *InitVal) {
     341       50570 :   if (!InitVal) {
     342          99 :     if (hasInitializer()) {
     343             :       // Note, the num operands is used to compute the offset of the operand, so
     344             :       // the order here matters.  Clearing the operand then clearing the num
     345             :       // operands ensures we have the correct offset to the operand.
     346             :       Op<0>().set(nullptr);
     347             :       setGlobalVariableNumOperands(0);
     348             :     }
     349             :   } else {
     350             :     assert(InitVal->getType() == getValueType() &&
     351             :            "Initializer type must match GlobalVariable type");
     352             :     // Note, the num operands is used to compute the offset of the operand, so
     353             :     // the order here matters.  We need to set num operands to 1 first so that
     354             :     // we get the correct offset to the first operand when we set it.
     355       50471 :     if (!hasInitializer())
     356             :       setGlobalVariableNumOperands(1);
     357       50471 :     Op<0>().set(InitVal);
     358             :   }
     359       50570 : }
     360             : 
     361             : /// Copy all additional attributes (those not needed to create a GlobalVariable)
     362             : /// from the GlobalVariable Src to this one.
     363         994 : void GlobalVariable::copyAttributesFrom(const GlobalVariable *Src) {
     364         994 :   GlobalObject::copyAttributesFrom(Src);
     365             :   setThreadLocalMode(Src->getThreadLocalMode());
     366             :   setExternallyInitialized(Src->isExternallyInitialized());
     367             :   setAttributes(Src->getAttributes());
     368         994 : }
     369             : 
     370      238436 : void GlobalVariable::dropAllReferences() {
     371      238436 :   User::dropAllReferences();
     372      238436 :   clearMetadata();
     373      238436 : }
     374             : 
     375             : //===----------------------------------------------------------------------===//
     376             : // GlobalIndirectSymbol Implementation
     377             : //===----------------------------------------------------------------------===//
     378             : 
     379        2613 : GlobalIndirectSymbol::GlobalIndirectSymbol(Type *Ty, ValueTy VTy,
     380             :     unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name,
     381        2613 :     Constant *Symbol)
     382        5226 :     : GlobalValue(Ty, VTy, &Op<0>(), 1, Linkage, Name, AddressSpace) {
     383             :     Op<0>() = Symbol;
     384        2613 : }
     385             : 
     386             : 
     387             : //===----------------------------------------------------------------------===//
     388             : // GlobalAlias Implementation
     389             : //===----------------------------------------------------------------------===//
     390             : 
     391        2498 : GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
     392             :                          const Twine &Name, Constant *Aliasee,
     393        2498 :                          Module *ParentModule)
     394             :     : GlobalIndirectSymbol(Ty, Value::GlobalAliasVal, AddressSpace, Link, Name,
     395        2498 :                            Aliasee) {
     396        2498 :   if (ParentModule)
     397        1565 :     ParentModule->getAliasList().push_back(this);
     398        2498 : }
     399             : 
     400        2498 : GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace,
     401             :                                  LinkageTypes Link, const Twine &Name,
     402             :                                  Constant *Aliasee, Module *ParentModule) {
     403        2498 :   return new GlobalAlias(Ty, AddressSpace, Link, Name, Aliasee, ParentModule);
     404             : }
     405             : 
     406         896 : GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace,
     407             :                                  LinkageTypes Linkage, const Twine &Name,
     408             :                                  Module *Parent) {
     409         896 :   return create(Ty, AddressSpace, Linkage, Name, nullptr, Parent);
     410             : }
     411             : 
     412         184 : GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace,
     413             :                                  LinkageTypes Linkage, const Twine &Name,
     414             :                                  GlobalValue *Aliasee) {
     415         184 :   return create(Ty, AddressSpace, Linkage, Name, Aliasee, Aliasee->getParent());
     416             : }
     417             : 
     418         184 : GlobalAlias *GlobalAlias::create(LinkageTypes Link, const Twine &Name,
     419             :                                  GlobalValue *Aliasee) {
     420             :   PointerType *PTy = Aliasee->getType();
     421         184 :   return create(PTy->getElementType(), PTy->getAddressSpace(), Link, Name,
     422         184 :                 Aliasee);
     423             : }
     424             : 
     425           4 : GlobalAlias *GlobalAlias::create(const Twine &Name, GlobalValue *Aliasee) {
     426           4 :   return create(Aliasee->getLinkage(), Name, Aliasee);
     427             : }
     428             : 
     429           9 : void GlobalAlias::removeFromParent() {
     430           9 :   getParent()->getAliasList().remove(getIterator());
     431           9 : }
     432             : 
     433          83 : void GlobalAlias::eraseFromParent() {
     434          83 :   getParent()->getAliasList().erase(getIterator());
     435          83 : }
     436             : 
     437         114 : void GlobalAlias::setAliasee(Constant *Aliasee) {
     438             :   assert((!Aliasee || Aliasee->getType() == getType()) &&
     439             :          "Alias and aliasee types should match!");
     440             :   setIndirectSymbol(Aliasee);
     441         114 : }
     442             : 
     443             : //===----------------------------------------------------------------------===//
     444             : // GlobalIFunc Implementation
     445             : //===----------------------------------------------------------------------===//
     446             : 
     447         115 : GlobalIFunc::GlobalIFunc(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
     448             :                          const Twine &Name, Constant *Resolver,
     449         115 :                          Module *ParentModule)
     450             :     : GlobalIndirectSymbol(Ty, Value::GlobalIFuncVal, AddressSpace, Link, Name,
     451         115 :                            Resolver) {
     452         115 :   if (ParentModule)
     453          78 :     ParentModule->getIFuncList().push_back(this);
     454         115 : }
     455             : 
     456         115 : GlobalIFunc *GlobalIFunc::create(Type *Ty, unsigned AddressSpace,
     457             :                                  LinkageTypes Link, const Twine &Name,
     458             :                                  Constant *Resolver, Module *ParentModule) {
     459         115 :   return new GlobalIFunc(Ty, AddressSpace, Link, Name, Resolver, ParentModule);
     460             : }
     461             : 
     462           0 : void GlobalIFunc::removeFromParent() {
     463           0 :   getParent()->getIFuncList().remove(getIterator());
     464           0 : }
     465             : 
     466           7 : void GlobalIFunc::eraseFromParent() {
     467           7 :   getParent()->getIFuncList().erase(getIterator());
     468           7 : }

Generated by: LCOV version 1.13