LCOV - code coverage report
Current view: top level - include/llvm/IR - GlobalVariable.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 31 35 88.6 %
Date: 2018-10-19 05:06:59 Functions: 5 7 71.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- llvm/GlobalVariable.h - GlobalVariable class ------------*- 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 contains the declaration of the GlobalVariable class, which
      11             : // represents a single global variable (or constant) in the VM.
      12             : //
      13             : // Global variables are constant pointers that refer to hunks of space that are
      14             : // allocated by either the VM, or by the linker in a static compiler.  A global
      15             : // variable may have an initial value, which is copied into the executables .data
      16             : // area.  Global Constants are required to have initializers.
      17             : //
      18             : //===----------------------------------------------------------------------===//
      19             : 
      20             : #ifndef LLVM_IR_GLOBALVARIABLE_H
      21             : #define LLVM_IR_GLOBALVARIABLE_H
      22             : 
      23             : #include "llvm/ADT/PointerUnion.h"
      24             : #include "llvm/ADT/Twine.h"
      25             : #include "llvm/ADT/ilist_node.h"
      26             : #include "llvm/IR/Attributes.h"
      27             : #include "llvm/IR/GlobalObject.h"
      28             : #include "llvm/IR/OperandTraits.h"
      29             : #include "llvm/IR/Value.h"
      30             : #include <cassert>
      31             : #include <cstddef>
      32             : 
      33             : namespace llvm {
      34             : 
      35             : class Constant;
      36             : class Module;
      37             : 
      38             : template <typename ValueSubClass> class SymbolTableListTraits;
      39             : class DIGlobalVariable;
      40             : class DIGlobalVariableExpression;
      41             : 
      42             : class GlobalVariable : public GlobalObject, public ilist_node<GlobalVariable> {
      43             :   friend class SymbolTableListTraits<GlobalVariable>;
      44             : 
      45             :   AttributeSet Attrs;
      46             :   bool isConstantGlobal : 1;                   // Is this a global constant?
      47             :   bool isExternallyInitializedConstant : 1;    // Is this a global whose value
      48             :                                                // can change from its initial
      49             :                                                // value before global
      50             :                                                // initializers are run?
      51             : 
      52             : public:
      53             :   /// GlobalVariable ctor - If a parent module is specified, the global is
      54             :   /// automatically inserted into the end of the specified modules global list.
      55             :   GlobalVariable(Type *Ty, bool isConstant, LinkageTypes Linkage,
      56             :                  Constant *Initializer = nullptr, const Twine &Name = "",
      57             :                  ThreadLocalMode = NotThreadLocal, unsigned AddressSpace = 0,
      58             :                  bool isExternallyInitialized = false);
      59             :   /// GlobalVariable ctor - This creates a global and inserts it before the
      60             :   /// specified other global.
      61             :   GlobalVariable(Module &M, Type *Ty, bool isConstant,
      62             :                  LinkageTypes Linkage, Constant *Initializer,
      63             :                  const Twine &Name = "", GlobalVariable *InsertBefore = nullptr,
      64             :                  ThreadLocalMode = NotThreadLocal, unsigned AddressSpace = 0,
      65             :                  bool isExternallyInitialized = false);
      66             :   GlobalVariable(const GlobalVariable &) = delete;
      67             :   GlobalVariable &operator=(const GlobalVariable &) = delete;
      68             : 
      69      263496 :   ~GlobalVariable() {
      70      131748 :     dropAllReferences();
      71      131748 :   }
      72             : 
      73             :   // allocate space for exactly one operand
      74             :   void *operator new(size_t s) {
      75      382297 :     return User::operator new(s, 1);
      76             :   }
      77             : 
      78             :   // delete space for exactly one operand as created in the corresponding new operator
      79             :   void operator delete(void *ptr){
      80             :     assert(ptr != nullptr && "must not be nullptr");
      81             :     User *Obj = static_cast<User *>(ptr);
      82             :     // Number of operands can be set to 0 after construction and initialization. Make sure
      83             :     // that number of operands is reset to 1, as this is needed in User::operator delete
      84             :     Obj->setGlobalVariableNumOperands(1);
      85      131703 :     User::operator delete(Obj);
      86             :   }
      87             : 
      88             :   /// Provide fast operand accessors
      89             :   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
      90             : 
      91             :   /// Definitions have initializers, declarations don't.
      92             :   ///
      93    34689149 :   inline bool hasInitializer() const { return !isDeclaration(); }
      94             : 
      95             :   /// hasDefinitiveInitializer - Whether the global variable has an initializer,
      96             :   /// and any other instances of the global (this can happen due to weak
      97             :   /// linkage) are guaranteed to have the same initializer.
      98             :   ///
      99             :   /// Note that if you want to transform a global, you must use
     100             :   /// hasUniqueInitializer() instead, because of the *_odr linkage type.
     101             :   ///
     102             :   /// Example:
     103             :   ///
     104             :   /// @a = global SomeType* null - Initializer is both definitive and unique.
     105             :   ///
     106             :   /// @b = global weak SomeType* null - Initializer is neither definitive nor
     107             :   /// unique.
     108             :   ///
     109             :   /// @c = global weak_odr SomeType* null - Initializer is definitive, but not
     110             :   /// unique.
     111    20903427 :   inline bool hasDefinitiveInitializer() const {
     112             :     return hasInitializer() &&
     113             :       // The initializer of a global variable may change to something arbitrary
     114             :       // at link time.
     115    20903427 :       !isInterposable() &&
     116             :       // The initializer of a global variable with the externally_initialized
     117             :       // marker may change at runtime before C++ initializers are evaluated.
     118    20903427 :       !isExternallyInitialized();
     119             :   }
     120             : 
     121             :   /// hasUniqueInitializer - Whether the global variable has an initializer, and
     122             :   /// any changes made to the initializer will turn up in the final executable.
     123             :   inline bool hasUniqueInitializer() const {
     124             :     return
     125             :         // We need to be sure this is the definition that will actually be used
     126        1113 :         isStrongDefinitionForLinker() &&
     127             :         // It is not safe to modify initializers of global variables with the
     128             :         // external_initializer marker since the value may be changed at runtime
     129             :         // before C++ initializers are evaluated.
     130             :         !isExternallyInitialized();
     131             :   }
     132             : 
     133             :   /// getInitializer - Return the initializer for this global variable.  It is
     134             :   /// illegal to call this method if the global is external, because we cannot
     135             :   /// tell what the value is initialized to!
     136             :   ///
     137             :   inline const Constant *getInitializer() const {
     138             :     assert(hasInitializer() && "GV doesn't have initializer!");
     139     1275455 :     return static_cast<Constant*>(Op<0>().get());
     140             :   }
     141             :   inline Constant *getInitializer() {
     142             :     assert(hasInitializer() && "GV doesn't have initializer!");
     143      477488 :     return static_cast<Constant*>(Op<0>().get());
     144             :   }
     145             :   /// setInitializer - Sets the initializer for this global variable, removing
     146             :   /// any existing initializer if InitVal==NULL.  If this GV has type T*, the
     147             :   /// initializer must have type T.
     148             :   void setInitializer(Constant *InitVal);
     149             : 
     150             :   /// If the value is a global constant, its value is immutable throughout the
     151             :   /// runtime execution of the program.  Assigning a value into the constant
     152             :   /// leads to undefined behavior.
     153             :   ///
     154    44181176 :   bool isConstant() const { return isConstantGlobal; }
     155       92641 :   void setConstant(bool Val) { isConstantGlobal = Val; }
     156             : 
     157             :   bool isExternallyInitialized() const {
     158    20876018 :     return isExternallyInitializedConstant;
     159             :   }
     160             :   void setExternallyInitialized(bool Val) {
     161       29977 :     isExternallyInitializedConstant = Val;
     162             :   }
     163             : 
     164             :   /// copyAttributesFrom - copy all additional attributes (those not needed to
     165             :   /// create a GlobalVariable) from the GlobalVariable Src to this one.
     166             :   void copyAttributesFrom(const GlobalVariable *Src);
     167             : 
     168             :   /// removeFromParent - This method unlinks 'this' from the containing module,
     169             :   /// but does not delete it.
     170             :   ///
     171             :   void removeFromParent();
     172             : 
     173             :   /// eraseFromParent - This method unlinks 'this' from the containing module
     174             :   /// and deletes it.
     175             :   ///
     176             :   void eraseFromParent();
     177             : 
     178             :   /// Drop all references in preparation to destroy the GlobalVariable. This
     179             :   /// drops not only the reference to the initializer but also to any metadata.
     180             :   void dropAllReferences();
     181             : 
     182             :   /// Attach a DIGlobalVariableExpression.
     183             :   void addDebugInfo(DIGlobalVariableExpression *GV);
     184             : 
     185             :   /// Fill the vector with all debug info attachements.
     186             :   void getDebugInfo(SmallVectorImpl<DIGlobalVariableExpression *> &GVs) const;
     187             : 
     188             :   /// Add attribute to this global.
     189             :   void addAttribute(Attribute::AttrKind Kind) {
     190             :     Attrs = Attrs.addAttribute(getContext(), Kind);
     191             :   }
     192             : 
     193             :   /// Add attribute to this global.
     194          44 :   void addAttribute(StringRef Kind, StringRef Val = StringRef()) {
     195          44 :     Attrs = Attrs.addAttribute(getContext(), Kind, Val);
     196          44 :   }
     197             : 
     198             :   /// Return true if the attribute exists.
     199             :   bool hasAttribute(Attribute::AttrKind Kind) const {
     200             :     return Attrs.hasAttribute(Kind);
     201             :   }
     202             : 
     203             :   /// Return true if the attribute exists.
     204             :   bool hasAttribute(StringRef Kind) const {
     205             :     return Attrs.hasAttribute(Kind);
     206             :   }
     207             : 
     208             :   /// Return true if any attributes exist.
     209             :   bool hasAttributes() const {
     210       16211 :     return Attrs.hasAttributes();
     211             :   }
     212             : 
     213             :   /// Return the attribute object.
     214             :   Attribute getAttribute(Attribute::AttrKind Kind) const {
     215             :     return Attrs.getAttribute(Kind);
     216             :   }
     217             : 
     218             :   /// Return the attribute object.
     219             :   Attribute getAttribute(StringRef Kind) const {
     220             :     return Attrs.getAttribute(Kind);
     221             :   }
     222             : 
     223             :   /// Return the attribute set for this global
     224           0 :   AttributeSet getAttributes() const {
     225           0 :     return Attrs;
     226             :   }
     227             : 
     228             :   /// Return attribute set as list with index.
     229             :   /// FIXME: This may not be required once ValueEnumerators
     230             :   /// in bitcode-writer can enumerate attribute-set.
     231        4426 :   AttributeList getAttributesAsList(unsigned index) const {
     232        4426 :     if (!hasAttributes())
     233        4402 :       return AttributeList();
     234             :     std::pair<unsigned, AttributeSet> AS[1] = {{index, Attrs}};
     235          24 :     return AttributeList::get(getContext(), AS);
     236             :   }
     237             : 
     238             :   /// Set attribute list for this global
     239           0 :   void setAttributes(AttributeSet A) {
     240        7758 :     Attrs = A;
     241           0 :   }
     242             : 
     243             :   /// Check if section name is present
     244        1702 :   bool hasImplicitSection() const {
     245        5080 :     return getAttributes().hasAttribute("bss-section") ||
     246        3377 :            getAttributes().hasAttribute("data-section") ||
     247        3350 :            getAttributes().hasAttribute("rodata-section");
     248             :   }
     249             : 
     250             :   // Methods for support type inquiry through isa, cast, and dyn_cast:
     251             :   static bool classof(const Value *V) {
     252   127311539 :     return V->getValueID() == Value::GlobalVariableVal;
     253             :   }
     254             : };
     255             : 
     256             : template <>
     257             : struct OperandTraits<GlobalVariable> :
     258             :   public OptionalOperandTraits<GlobalVariable> {
     259             : };
     260             : 
     261         293 : DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalVariable, Value)
     262             : 
     263             : } // end namespace llvm
     264             : 
     265             : #endif // LLVM_IR_GLOBALVARIABLE_H

Generated by: LCOV version 1.13