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/Twine.h" 24 #include "llvm/ADT/ilist_node.h" 25 #include "llvm/IR/GlobalObject.h" 26 #include "llvm/IR/OperandTraits.h" 27 28 namespace llvm { 29 30 class Module; 31 class Constant; 32 template<typename ValueSubClass, typename ItemParentClass> 33 class SymbolTableListTraits; 34 35 class GlobalVariable : public GlobalObject, public ilist_node<GlobalVariable> { 36 friend class SymbolTableListTraits<GlobalVariable, Module>; 37 void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION; 38 void operator=(const GlobalVariable &) LLVM_DELETED_FUNCTION; 39 GlobalVariable(const GlobalVariable &) LLVM_DELETED_FUNCTION; 40 41 void setParent(Module *parent); 42 43 bool isConstantGlobal : 1; // Is this a global constant? 44 bool isExternallyInitializedConstant : 1; // Is this a global whose value 45 // can change from its initial 46 // value before global 47 // initializers are run? 48 49 public: 50 // allocate space for exactly one operand new(size_t s)51 void *operator new(size_t s) { 52 return User::operator new(s, 1); 53 } 54 55 /// GlobalVariable ctor - If a parent module is specified, the global is 56 /// automatically inserted into the end of the specified modules global list. 57 GlobalVariable(Type *Ty, bool isConstant, LinkageTypes Linkage, 58 Constant *Initializer = nullptr, const Twine &Name = "", 59 ThreadLocalMode = NotThreadLocal, unsigned AddressSpace = 0, 60 bool isExternallyInitialized = false); 61 /// GlobalVariable ctor - This creates a global and inserts it before the 62 /// specified other global. 63 GlobalVariable(Module &M, Type *Ty, bool isConstant, 64 LinkageTypes Linkage, Constant *Initializer, 65 const Twine &Name = "", GlobalVariable *InsertBefore = nullptr, 66 ThreadLocalMode = NotThreadLocal, unsigned AddressSpace = 0, 67 bool isExternallyInitialized = false); 68 ~GlobalVariable()69 ~GlobalVariable() { 70 NumOperands = 1; // FIXME: needed by operator delete 71 } 72 73 /// Provide fast operand accessors 74 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 75 76 /// Definitions have initializers, declarations don't. 77 /// hasInitializer()78 inline bool hasInitializer() const { return !isDeclaration(); } 79 80 /// hasDefinitiveInitializer - Whether the global variable has an initializer, 81 /// and any other instances of the global (this can happen due to weak 82 /// linkage) are guaranteed to have the same initializer. 83 /// 84 /// Note that if you want to transform a global, you must use 85 /// hasUniqueInitializer() instead, because of the *_odr linkage type. 86 /// 87 /// Example: 88 /// 89 /// @a = global SomeType* null - Initializer is both definitive and unique. 90 /// 91 /// @b = global weak SomeType* null - Initializer is neither definitive nor 92 /// unique. 93 /// 94 /// @c = global weak_odr SomeType* null - Initializer is definitive, but not 95 /// unique. hasDefinitiveInitializer()96 inline bool hasDefinitiveInitializer() const { 97 return hasInitializer() && 98 // The initializer of a global variable with weak linkage may change at 99 // link time. 100 !mayBeOverridden() && 101 // The initializer of a global variable with the externally_initialized 102 // marker may change at runtime before C++ initializers are evaluated. 103 !isExternallyInitialized(); 104 } 105 106 /// hasUniqueInitializer - Whether the global variable has an initializer, and 107 /// any changes made to the initializer will turn up in the final executable. hasUniqueInitializer()108 inline bool hasUniqueInitializer() const { 109 return hasInitializer() && 110 // It's not safe to modify initializers of global variables with weak 111 // linkage, because the linker might choose to discard the initializer and 112 // use the initializer from another instance of the global variable 113 // instead. It is wrong to modify the initializer of a global variable 114 // with *_odr linkage because then different instances of the global may 115 // have different initializers, breaking the One Definition Rule. 116 !isWeakForLinker() && 117 // It is not safe to modify initializers of global variables with the 118 // external_initializer marker since the value may be changed at runtime 119 // before C++ initializers are evaluated. 120 !isExternallyInitialized(); 121 } 122 123 /// getInitializer - Return the initializer for this global variable. It is 124 /// illegal to call this method if the global is external, because we cannot 125 /// tell what the value is initialized to! 126 /// getInitializer()127 inline const Constant *getInitializer() const { 128 assert(hasInitializer() && "GV doesn't have initializer!"); 129 return static_cast<Constant*>(Op<0>().get()); 130 } getInitializer()131 inline Constant *getInitializer() { 132 assert(hasInitializer() && "GV doesn't have initializer!"); 133 return static_cast<Constant*>(Op<0>().get()); 134 } 135 /// setInitializer - Sets the initializer for this global variable, removing 136 /// any existing initializer if InitVal==NULL. If this GV has type T*, the 137 /// initializer must have type T. 138 void setInitializer(Constant *InitVal); 139 140 /// If the value is a global constant, its value is immutable throughout the 141 /// runtime execution of the program. Assigning a value into the constant 142 /// leads to undefined behavior. 143 /// isConstant()144 bool isConstant() const { return isConstantGlobal; } setConstant(bool Val)145 void setConstant(bool Val) { isConstantGlobal = Val; } 146 isExternallyInitialized()147 bool isExternallyInitialized() const { 148 return isExternallyInitializedConstant; 149 } setExternallyInitialized(bool Val)150 void setExternallyInitialized(bool Val) { 151 isExternallyInitializedConstant = Val; 152 } 153 154 /// copyAttributesFrom - copy all additional attributes (those not needed to 155 /// create a GlobalVariable) from the GlobalVariable Src to this one. 156 void copyAttributesFrom(const GlobalValue *Src) override; 157 158 /// removeFromParent - This method unlinks 'this' from the containing module, 159 /// but does not delete it. 160 /// 161 void removeFromParent() override; 162 163 /// eraseFromParent - This method unlinks 'this' from the containing module 164 /// and deletes it. 165 /// 166 void eraseFromParent() override; 167 168 /// Override Constant's implementation of this method so we can 169 /// replace constant initializers. 170 void replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U) override; 171 172 // Methods for support type inquiry through isa, cast, and dyn_cast: classof(const Value * V)173 static inline bool classof(const Value *V) { 174 return V->getValueID() == Value::GlobalVariableVal; 175 } 176 }; 177 178 template <> 179 struct OperandTraits<GlobalVariable> : 180 public OptionalOperandTraits<GlobalVariable> { 181 }; 182 183 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalVariable, Value) 184 185 } // End llvm namespace 186 187 #endif 188