LCOV - code coverage report
Current view: top level - include/llvm/IR - GlobalValue.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 66 73 90.4 %
Date: 2018-10-20 13:21:21 Functions: 6 10 60.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- llvm/GlobalValue.h - Class to represent a global value --*- C++ -*-===//
       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 is a common base class of all globally definable objects.  As such,
      11             : // it is subclassed by GlobalVariable, GlobalAlias and by Function.  This is
      12             : // used because you can do certain things with these global objects that you
      13             : // can't do to anything else.  For example, use the address of one as a
      14             : // constant.
      15             : //
      16             : //===----------------------------------------------------------------------===//
      17             : 
      18             : #ifndef LLVM_IR_GLOBALVALUE_H
      19             : #define LLVM_IR_GLOBALVALUE_H
      20             : 
      21             : #include "llvm/ADT/StringRef.h"
      22             : #include "llvm/ADT/Twine.h"
      23             : #include "llvm/IR/Constant.h"
      24             : #include "llvm/IR/DerivedTypes.h"
      25             : #include "llvm/IR/Value.h"
      26             : #include "llvm/Support/Casting.h"
      27             : #include "llvm/Support/ErrorHandling.h"
      28             : #include "llvm/Support/MD5.h"
      29             : #include <cassert>
      30             : #include <cstdint>
      31             : #include <string>
      32             : 
      33             : namespace llvm {
      34             : 
      35             : class Comdat;
      36             : class ConstantRange;
      37             : class Error;
      38             : class GlobalObject;
      39             : class Module;
      40             : 
      41             : namespace Intrinsic {
      42             :   enum ID : unsigned;
      43             : } // end namespace Intrinsic
      44             : 
      45             : class GlobalValue : public Constant {
      46             : public:
      47             :   /// An enumeration for the kinds of linkage for global values.
      48             :   enum LinkageTypes {
      49             :     ExternalLinkage = 0,///< Externally visible function
      50             :     AvailableExternallyLinkage, ///< Available for inspection, not emission.
      51             :     LinkOnceAnyLinkage, ///< Keep one copy of function when linking (inline)
      52             :     LinkOnceODRLinkage, ///< Same, but only replaced by something equivalent.
      53             :     WeakAnyLinkage,     ///< Keep one copy of named function when linking (weak)
      54             :     WeakODRLinkage,     ///< Same, but only replaced by something equivalent.
      55             :     AppendingLinkage,   ///< Special purpose, only applies to global arrays
      56             :     InternalLinkage,    ///< Rename collisions when linking (static functions).
      57             :     PrivateLinkage,     ///< Like Internal, but omit from symbol table.
      58             :     ExternalWeakLinkage,///< ExternalWeak linkage description.
      59             :     CommonLinkage       ///< Tentative definitions.
      60             :   };
      61             : 
      62             :   /// An enumeration for the kinds of visibility of global values.
      63             :   enum VisibilityTypes {
      64             :     DefaultVisibility = 0,  ///< The GV is visible
      65             :     HiddenVisibility,       ///< The GV is hidden
      66             :     ProtectedVisibility     ///< The GV is protected
      67             :   };
      68             : 
      69             :   /// Storage classes of global values for PE targets.
      70             :   enum DLLStorageClassTypes {
      71             :     DefaultStorageClass   = 0,
      72             :     DLLImportStorageClass = 1, ///< Function to be imported from DLL
      73             :     DLLExportStorageClass = 2  ///< Function to be accessible from DLL.
      74             :   };
      75             : 
      76             : protected:
      77     1871308 :   GlobalValue(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
      78             :               LinkageTypes Linkage, const Twine &Name, unsigned AddressSpace)
      79     1871308 :       : Constant(PointerType::get(Ty, AddressSpace), VTy, Ops, NumOps),
      80             :         ValueType(Ty), Visibility(DefaultVisibility),
      81             :         UnnamedAddrVal(unsigned(UnnamedAddr::None)),
      82             :         DllStorageClass(DefaultStorageClass), ThreadLocal(NotThreadLocal),
      83             :         HasLLVMReservedName(false), IsDSOLocal(false), IntID((Intrinsic::ID)0U),
      84     1871308 :         Parent(nullptr) {
      85             :     setLinkage(Linkage);
      86     1871308 :     setName(Name);
      87     1871308 :   }
      88             : 
      89             :   Type *ValueType;
      90             : 
      91             :   static const unsigned GlobalValueSubClassDataBits = 17;
      92             : 
      93             :   // All bitfields use unsigned as the underlying type so that MSVC will pack
      94             :   // them.
      95             :   unsigned Linkage : 4;       // The linkage of this global
      96             :   unsigned Visibility : 2;    // The visibility style of this global
      97             :   unsigned UnnamedAddrVal : 2; // This value's address is not significant
      98             :   unsigned DllStorageClass : 2; // DLL storage class
      99             : 
     100             :   unsigned ThreadLocal : 3; // Is this symbol "Thread Local", if so, what is
     101             :                             // the desired model?
     102             : 
     103             :   /// True if the function's name starts with "llvm.".  This corresponds to the
     104             :   /// value of Function::isIntrinsic(), which may be true even if
     105             :   /// Function::intrinsicID() returns Intrinsic::not_intrinsic.
     106             :   unsigned HasLLVMReservedName : 1;
     107             : 
     108             :   /// If true then there is a definition within the same linkage unit and that
     109             :   /// definition cannot be runtime preempted.
     110             :   unsigned IsDSOLocal : 1;
     111             : 
     112             : private:
     113             :   // Give subclasses access to what otherwise would be wasted padding.
     114             :   // (17 + 4 + 2 + 2 + 2 + 3 + 1 + 1) == 32.
     115             :   unsigned SubClassData : GlobalValueSubClassDataBits;
     116             : 
     117             :   friend class Constant;
     118             : 
     119             :   void destroyConstantImpl();
     120             :   Value *handleOperandChangeImpl(Value *From, Value *To);
     121             : 
     122             :   /// Returns true if the definition of this global may be replaced by a
     123             :   /// differently optimized variant of the same source level function at link
     124             :   /// time.
     125      705442 :   bool mayBeDerefined() const {
     126             :     switch (getLinkage()) {
     127             :     case WeakODRLinkage:
     128             :     case LinkOnceODRLinkage:
     129             :     case AvailableExternallyLinkage:
     130             :       return true;
     131             : 
     132             :     case WeakAnyLinkage:
     133             :     case LinkOnceAnyLinkage:
     134             :     case CommonLinkage:
     135             :     case ExternalWeakLinkage:
     136             :     case ExternalLinkage:
     137             :     case AppendingLinkage:
     138             :     case InternalLinkage:
     139             :     case PrivateLinkage:
     140             :       return isInterposable();
     141             :     }
     142             : 
     143           0 :     llvm_unreachable("Fully covered switch above!");
     144             :   }
     145             : 
     146             :   void maybeSetDsoLocal() {
     147     5100236 :     if (hasLocalLinkage() ||
     148     1679570 :         (!hasDefaultVisibility() && !hasExternalWeakLinkage()))
     149             :       setDSOLocal(true);
     150             :   }
     151             : 
     152             : protected:
     153             :   /// The intrinsic ID for this subclass (which must be a Function).
     154             :   ///
     155             :   /// This member is defined by this class, but not used for anything.
     156             :   /// Subclasses can use it to store their intrinsic ID, if they have one.
     157             :   ///
     158             :   /// This is stored here to save space in Function on 64-bit hosts.
     159             :   Intrinsic::ID IntID;
     160             : 
     161             :   unsigned getGlobalValueSubClassData() const {
     162    88410347 :     return SubClassData;
     163             :   }
     164             :   void setGlobalValueSubClassData(unsigned V) {
     165             :     assert(V < (1 << GlobalValueSubClassDataBits) && "It will not fit");
     166     3699368 :     SubClassData = V;
     167             :   }
     168             : 
     169             :   Module *Parent;             // The containing module.
     170             : 
     171             :   // Used by SymbolTableListTraits.
     172           0 :   void setParent(Module *parent) {
     173     3379075 :     Parent = parent;
     174           0 :   }
     175             : 
     176             :   ~GlobalValue() {
     177     1301813 :     removeDeadConstantUsers();   // remove any dead constants using this.
     178             :   }
     179             : 
     180             : public:
     181             :   enum ThreadLocalMode {
     182             :     NotThreadLocal = 0,
     183             :     GeneralDynamicTLSModel,
     184             :     LocalDynamicTLSModel,
     185             :     InitialExecTLSModel,
     186             :     LocalExecTLSModel
     187             :   };
     188             : 
     189             :   GlobalValue(const GlobalValue &) = delete;
     190             : 
     191             :   unsigned getAlignment() const;
     192             :   unsigned getAddressSpace() const;
     193             : 
     194             :   enum class UnnamedAddr {
     195             :     None,
     196             :     Local,
     197             :     Global,
     198             :   };
     199             : 
     200             :   bool hasGlobalUnnamedAddr() const {
     201         122 :     return getUnnamedAddr() == UnnamedAddr::Global;
     202             :   }
     203             : 
     204             :   /// Returns true if this value's address is not significant in this module.
     205             :   /// This attribute is intended to be used only by the code generator and LTO
     206             :   /// to allow the linker to decide whether the global needs to be in the symbol
     207             :   /// table. It should probably not be used in optimizations, as the value may
     208             :   /// have uses outside the module; use hasGlobalUnnamedAddr() instead.
     209             :   bool hasAtLeastLocalUnnamedAddr() const {
     210         548 :     return getUnnamedAddr() != UnnamedAddr::None;
     211             :   }
     212             : 
     213             :   UnnamedAddr getUnnamedAddr() const {
     214     1383235 :     return UnnamedAddr(UnnamedAddrVal);
     215             :   }
     216      790592 :   void setUnnamedAddr(UnnamedAddr Val) { UnnamedAddrVal = unsigned(Val); }
     217             : 
     218             :   static UnnamedAddr getMinUnnamedAddr(UnnamedAddr A, UnnamedAddr B) {
     219         204 :     if (A == UnnamedAddr::None || B == UnnamedAddr::None)
     220             :       return UnnamedAddr::None;
     221           5 :     if (A == UnnamedAddr::Local || B == UnnamedAddr::Local)
     222             :       return UnnamedAddr::Local;
     223             :     return UnnamedAddr::Global;
     224             :   }
     225             : 
     226      325199 :   bool hasComdat() const { return getComdat() != nullptr; }
     227             :   const Comdat *getComdat() const;
     228             :   Comdat *getComdat() {
     229             :     return const_cast<Comdat *>(
     230      698303 :                            static_cast<const GlobalValue *>(this)->getComdat());
     231             :   }
     232             : 
     233     1211099 :   VisibilityTypes getVisibility() const { return VisibilityTypes(Visibility); }
     234    12468449 :   bool hasDefaultVisibility() const { return Visibility == DefaultVisibility; }
     235       17498 :   bool hasHiddenVisibility() const { return Visibility == HiddenVisibility; }
     236             :   bool hasProtectedVisibility() const {
     237             :     return Visibility == ProtectedVisibility;
     238             :   }
     239             :   void setVisibility(VisibilityTypes V) {
     240             :     assert((!hasLocalLinkage() || V == DefaultVisibility) &&
     241             :            "local linkage requires default visibility");
     242     2416768 :     Visibility = V;
     243             :     maybeSetDsoLocal();
     244             :   }
     245             : 
     246             :   /// If the value is "Thread Local", its value isn't shared by the threads.
     247          80 :   bool isThreadLocal() const { return getThreadLocalMode() != NotThreadLocal; }
     248             :   void setThreadLocal(bool Val) {
     249          19 :     setThreadLocalMode(Val ? GeneralDynamicTLSModel : NotThreadLocal);
     250             :   }
     251             :   void setThreadLocalMode(ThreadLocalMode Val) {
     252             :     assert(Val == NotThreadLocal || getValueID() != Value::FunctionVal);
     253      434345 :     ThreadLocal = Val;
     254             :   }
     255             :   ThreadLocalMode getThreadLocalMode() const {
     256     5348627 :     return static_cast<ThreadLocalMode>(ThreadLocal);
     257             :   }
     258             : 
     259             :   DLLStorageClassTypes getDLLStorageClass() const {
     260      328597 :     return DLLStorageClassTypes(DllStorageClass);
     261             :   }
     262             :   bool hasDLLImportStorageClass() const {
     263     8678028 :     return DllStorageClass == DLLImportStorageClass;
     264             :   }
     265             :   bool hasDLLExportStorageClass() const {
     266        6723 :     return DllStorageClass == DLLExportStorageClass;
     267             :   }
     268     3411730 :   void setDLLStorageClass(DLLStorageClassTypes C) { DllStorageClass = C; }
     269             : 
     270      686418 :   bool hasSection() const { return !getSection().empty(); }
     271             :   StringRef getSection() const;
     272             : 
     273             :   /// Global values are always pointers.
     274    99832859 :   PointerType *getType() const { return cast<PointerType>(User::getType()); }
     275             : 
     276           0 :   Type *getValueType() const { return ValueType; }
     277             : 
     278     2170838 :   void setDSOLocal(bool Local) { IsDSOLocal = Local; }
     279             : 
     280             :   bool isDSOLocal() const {
     281     6150126 :     return IsDSOLocal;
     282             :   }
     283             : 
     284             :   static LinkageTypes getLinkOnceLinkage(bool ODR) {
     285             :     return ODR ? LinkOnceODRLinkage : LinkOnceAnyLinkage;
     286             :   }
     287             :   static LinkageTypes getWeakLinkage(bool ODR) {
     288         148 :     return ODR ? WeakODRLinkage : WeakAnyLinkage;
     289             :   }
     290             : 
     291             :   static bool isExternalLinkage(LinkageTypes Linkage) {
     292             :     return Linkage == ExternalLinkage;
     293             :   }
     294             :   static bool isAvailableExternallyLinkage(LinkageTypes Linkage) {
     295             :     return Linkage == AvailableExternallyLinkage;
     296             :   }
     297             :   static bool isLinkOnceODRLinkage(LinkageTypes Linkage) {
     298             :     return Linkage == LinkOnceODRLinkage;
     299             :   }
     300             :   static bool isLinkOnceLinkage(LinkageTypes Linkage) {
     301     1430532 :     return Linkage == LinkOnceAnyLinkage || Linkage == LinkOnceODRLinkage;
     302             :   }
     303             :   static bool isWeakAnyLinkage(LinkageTypes Linkage) {
     304             :     return Linkage == WeakAnyLinkage;
     305             :   }
     306             :   static bool isWeakODRLinkage(LinkageTypes Linkage) {
     307             :     return Linkage == WeakODRLinkage;
     308             :   }
     309             :   static bool isWeakLinkage(LinkageTypes Linkage) {
     310       28938 :     return isWeakAnyLinkage(Linkage) || isWeakODRLinkage(Linkage);
     311             :   }
     312             :   static bool isAppendingLinkage(LinkageTypes Linkage) {
     313             :     return Linkage == AppendingLinkage;
     314             :   }
     315             :   static bool isInternalLinkage(LinkageTypes Linkage) {
     316        1619 :     return Linkage == InternalLinkage;
     317             :   }
     318             :   static bool isPrivateLinkage(LinkageTypes Linkage) {
     319             :     return Linkage == PrivateLinkage;
     320             :   }
     321             :   static bool isLocalLinkage(LinkageTypes Linkage) {
     322    25017928 :     return isInternalLinkage(Linkage) || isPrivateLinkage(Linkage);
     323             :   }
     324             :   static bool isExternalWeakLinkage(LinkageTypes Linkage) {
     325             :     return Linkage == ExternalWeakLinkage;
     326             :   }
     327             :   static bool isCommonLinkage(LinkageTypes Linkage) {
     328             :     return Linkage == CommonLinkage;
     329             :   }
     330             :   static bool isValidDeclarationLinkage(LinkageTypes Linkage) {
     331      338254 :     return isExternalWeakLinkage(Linkage) || isExternalLinkage(Linkage);
     332             :   }
     333             : 
     334             :   /// Whether the definition of this global may be replaced by something
     335             :   /// non-equivalent at link time. For example, if a function has weak linkage
     336             :   /// then the code defining it may be replaced by different code.
     337             :   static bool isInterposableLinkage(LinkageTypes Linkage) {
     338             :     switch (Linkage) {
     339             :     case WeakAnyLinkage:
     340             :     case LinkOnceAnyLinkage:
     341             :     case CommonLinkage:
     342             :     case ExternalWeakLinkage:
     343             :       return true;
     344             : 
     345             :     case AvailableExternallyLinkage:
     346             :     case LinkOnceODRLinkage:
     347             :     case WeakODRLinkage:
     348             :     // The above three cannot be overridden but can be de-refined.
     349             : 
     350             :     case ExternalLinkage:
     351             :     case AppendingLinkage:
     352             :     case InternalLinkage:
     353             :     case PrivateLinkage:
     354             :       return false;
     355             :     }
     356           0 :     llvm_unreachable("Fully covered switch above!");
     357             :   }
     358             : 
     359             :   /// Whether the definition of this global may be discarded if it is not used
     360             :   /// in its compilation unit.
     361             :   static bool isDiscardableIfUnused(LinkageTypes Linkage) {
     362      386897 :     return isLinkOnceLinkage(Linkage) || isLocalLinkage(Linkage) ||
     363             :            isAvailableExternallyLinkage(Linkage);
     364             :   }
     365             : 
     366             :   /// Whether the definition of this global may be replaced at link time.  NB:
     367             :   /// Using this method outside of the code generators is almost always a
     368             :   /// mistake: when working at the IR level use isInterposable instead as it
     369             :   /// knows about ODR semantics.
     370             :   static bool isWeakForLinker(LinkageTypes Linkage)  {
     371    23248640 :     return Linkage == WeakAnyLinkage || Linkage == WeakODRLinkage ||
     372    34869288 :            Linkage == LinkOnceAnyLinkage || Linkage == LinkOnceODRLinkage ||
     373    11623169 :            Linkage == CommonLinkage || Linkage == ExternalWeakLinkage;
     374             :   }
     375             : 
     376             :   /// Return true if the currently visible definition of this global (if any) is
     377             :   /// exactly the definition we will see at runtime.
     378             :   ///
     379             :   /// Non-exact linkage types inhibits most non-inlining IPO, since a
     380             :   /// differently optimized variant of the same function can have different
     381             :   /// observable or undefined behavior than in the variant currently visible.
     382             :   /// For instance, we could have started with
     383             :   ///
     384             :   ///   void foo(int *v) {
     385             :   ///     int t = 5 / v[0];
     386             :   ///     (void) t;
     387             :   ///   }
     388             :   ///
     389             :   /// and "refined" it to
     390             :   ///
     391             :   ///   void foo(int *v) { }
     392             :   ///
     393             :   /// However, we cannot infer readnone for `foo`, since that would justify
     394             :   /// DSE'ing a store to `v[0]` across a call to `foo`, which can cause
     395             :   /// undefined behavior if the linker replaces the actual call destination with
     396             :   /// the unoptimized `foo`.
     397             :   ///
     398             :   /// Inlining is okay across non-exact linkage types as long as they're not
     399             :   /// interposable (see \c isInterposable), since in such cases the currently
     400             :   /// visible variant is *a* correct implementation of the original source
     401             :   /// function; it just isn't the *only* correct implementation.
     402             :   bool isDefinitionExact() const {
     403      705442 :     return !mayBeDerefined();
     404             :   }
     405             : 
     406             :   /// Return true if this global has an exact defintion.
     407      933830 :   bool hasExactDefinition() const {
     408             :     // While this computes exactly the same thing as
     409             :     // isStrongDefinitionForLinker, the intended uses are different.  This
     410             :     // function is intended to help decide if specific inter-procedural
     411             :     // transforms are correct, while isStrongDefinitionForLinker's intended use
     412             :     // is in low level code generation.
     413      933830 :     return !isDeclaration() && isDefinitionExact();
     414             :   }
     415             : 
     416             :   /// Return true if this global's definition can be substituted with an
     417             :   /// *arbitrary* definition at link time.  We cannot do any IPO or inlinining
     418             :   /// across interposable call edges, since the callee can be replaced with
     419             :   /// something arbitrary at link time.
     420             :   bool isInterposable() const { return isInterposableLinkage(getLinkage()); }
     421             : 
     422             :   bool hasExternalLinkage() const { return isExternalLinkage(getLinkage()); }
     423             :   bool hasAvailableExternallyLinkage() const {
     424             :     return isAvailableExternallyLinkage(getLinkage());
     425             :   }
     426             :   bool hasLinkOnceLinkage() const { return isLinkOnceLinkage(getLinkage()); }
     427             :   bool hasLinkOnceODRLinkage() const {
     428             :     return isLinkOnceODRLinkage(getLinkage());
     429             :   }
     430             :   bool hasWeakLinkage() const { return isWeakLinkage(getLinkage()); }
     431             :   bool hasWeakAnyLinkage() const { return isWeakAnyLinkage(getLinkage()); }
     432             :   bool hasWeakODRLinkage() const { return isWeakODRLinkage(getLinkage()); }
     433             :   bool hasAppendingLinkage() const { return isAppendingLinkage(getLinkage()); }
     434             :   bool hasInternalLinkage() const { return isInternalLinkage(getLinkage()); }
     435             :   bool hasPrivateLinkage() const { return isPrivateLinkage(getLinkage()); }
     436             :   bool hasLocalLinkage() const { return isLocalLinkage(getLinkage()); }
     437             :   bool hasExternalWeakLinkage() const {
     438             :     return isExternalWeakLinkage(getLinkage());
     439             :   }
     440             :   bool hasCommonLinkage() const { return isCommonLinkage(getLinkage()); }
     441             :   bool hasValidDeclarationLinkage() const {
     442             :     return isValidDeclarationLinkage(getLinkage());
     443             :   }
     444             : 
     445             :   void setLinkage(LinkageTypes LT) {
     446             :     if (isLocalLinkage(LT))
     447       42719 :       Visibility = DefaultVisibility;
     448     3121934 :     Linkage = LT;
     449             :     maybeSetDsoLocal();
     450             :   }
     451   104349478 :   LinkageTypes getLinkage() const { return LinkageTypes(Linkage); }
     452             : 
     453             :   bool isDiscardableIfUnused() const {
     454             :     return isDiscardableIfUnused(getLinkage());
     455             :   }
     456             : 
     457             :   bool isWeakForLinker() const { return isWeakForLinker(getLinkage()); }
     458             : 
     459             : protected:
     460             :   /// Copy all additional attributes (those not needed to create a GlobalValue)
     461             :   /// from the GlobalValue Src to this one.
     462             :   void copyAttributesFrom(const GlobalValue *Src);
     463             : 
     464             : public:
     465             :   /// If the given string begins with the GlobalValue name mangling escape
     466             :   /// character '\1', drop it.
     467             :   ///
     468             :   /// This function applies a specific mangling that is used in PGO profiles,
     469             :   /// among other things. If you're trying to get a symbol name for an
     470             :   /// arbitrary GlobalValue, this is not the function you're looking for; see
     471             :   /// Mangler.h.
     472    22455456 :   static StringRef dropLLVMManglingEscape(StringRef Name) {
     473    22455456 :     if (!Name.empty() && Name[0] == '\1')
     474         564 :       return Name.substr(1);
     475    22454892 :     return Name;
     476             :   }
     477             : 
     478             :   /// Return the modified name for a global value suitable to be
     479             :   /// used as the key for a global lookup (e.g. profile or ThinLTO).
     480             :   /// The value's original name is \c Name and has linkage of type
     481             :   /// \c Linkage. The value is defined in module \c FileName.
     482             :   static std::string getGlobalIdentifier(StringRef Name,
     483             :                                          GlobalValue::LinkageTypes Linkage,
     484             :                                          StringRef FileName);
     485             : 
     486             :   /// Return the modified name for this global value suitable to be
     487             :   /// used as the key for a global lookup (e.g. profile or ThinLTO).
     488             :   std::string getGlobalIdentifier() const;
     489             : 
     490             :   /// Declare a type to represent a global unique identifier for a global value.
     491             :   /// This is a 64 bits hash that is used by PGO and ThinLTO to have a compact
     492             :   /// unique way to identify a symbol.
     493             :   using GUID = uint64_t;
     494             : 
     495             :   /// Return a 64-bit global unique ID constructed from global value name
     496             :   /// (i.e. returned by getGlobalIdentifier()).
     497       16904 :   static GUID getGUID(StringRef GlobalName) { return MD5Hash(GlobalName); }
     498             : 
     499             :   /// Return a 64-bit global unique ID constructed from global value name
     500             :   /// (i.e. returned by getGlobalIdentifier()).
     501       14798 :   GUID getGUID() const { return getGUID(getGlobalIdentifier()); }
     502             : 
     503             :   /// @name Materialization
     504             :   /// Materialization is used to construct functions only as they're needed.
     505             :   /// This
     506             :   /// is useful to reduce memory usage in LLVM or parsing work done by the
     507             :   /// BitcodeReader to load the Module.
     508             :   /// @{
     509             : 
     510             :   /// If this function's Module is being lazily streamed in functions from disk
     511             :   /// or some other source, this method can be used to check to see if the
     512             :   /// function has been read in yet or not.
     513             :   bool isMaterializable() const;
     514             : 
     515             :   /// Make sure this GlobalValue is fully read.
     516             :   Error materialize();
     517             : 
     518             : /// @}
     519             : 
     520             :   /// Return true if the primary definition of this global value is outside of
     521             :   /// the current translation unit.
     522             :   bool isDeclaration() const;
     523             : 
     524             :   bool isDeclarationForLinker() const {
     525    16766996 :     if (hasAvailableExternallyLinkage())
     526             :       return true;
     527             : 
     528    16777126 :     return isDeclaration();
     529             :   }
     530             : 
     531             :   /// Returns true if this global's definition will be the one chosen by the
     532             :   /// linker.
     533             :   ///
     534             :   /// NB! Ideally this should not be used at the IR level at all.  If you're
     535             :   /// interested in optimization constraints implied by the linker's ability to
     536             :   /// choose an implementation, prefer using \c hasExactDefinition.
     537    11394489 :   bool isStrongDefinitionForLinker() const {
     538    11394444 :     return !(isDeclarationForLinker() || isWeakForLinker());
     539             :   }
     540             : 
     541             :   // Returns true if the alignment of the value can be unilaterally
     542             :   // increased.
     543             :   bool canIncreaseAlignment() const;
     544             : 
     545             :   const GlobalObject *getBaseObject() const;
     546             :   GlobalObject *getBaseObject() {
     547             :     return const_cast<GlobalObject *>(
     548       41503 :                        static_cast<const GlobalValue *>(this)->getBaseObject());
     549             :   }
     550             : 
     551             :   /// Returns whether this is a reference to an absolute symbol.
     552             :   bool isAbsoluteSymbolRef() const;
     553             : 
     554             :   /// If this is an absolute symbol reference, returns the range of the symbol,
     555             :   /// otherwise returns None.
     556             :   Optional<ConstantRange> getAbsoluteSymbolRange() const;
     557             : 
     558             :   /// This method unlinks 'this' from the containing module, but does not delete
     559             :   /// it.
     560             :   void removeFromParent();
     561             : 
     562             :   /// This method unlinks 'this' from the containing module and deletes it.
     563             :   void eraseFromParent();
     564             : 
     565             :   /// Get the module that this global value is contained inside of...
     566           0 :   Module *getParent() { return Parent; }
     567           0 :   const Module *getParent() const { return Parent; }
     568             : 
     569             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
     570             :   static bool classof(const Value *V) {
     571    35433455 :     return V->getValueID() == Value::FunctionVal ||
     572    20469944 :            V->getValueID() == Value::GlobalVariableVal ||
     573    56811576 :            V->getValueID() == Value::GlobalAliasVal ||
     574             :            V->getValueID() == Value::GlobalIFuncVal;
     575             :   }
     576             : 
     577             :   /// True if GV can be left out of the object symbol table. This is the case
     578             :   /// for linkonce_odr values whose address is not significant. While legal, it
     579             :   /// is not normally profitable to omit them from the .o symbol table. Using
     580             :   /// this analysis makes sense when the information can be passed down to the
     581             :   /// linker or we are in LTO.
     582             :   bool canBeOmittedFromSymbolTable() const;
     583             : };
     584             : 
     585             : } // end namespace llvm
     586             : 
     587             : #endif // LLVM_IR_GLOBALVALUE_H

Generated by: LCOV version 1.13