LLVM  6.0.0svn
GlobalVariable.h
Go to the documentation of this file.
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> {
44 
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.
56  Constant *Initializer = nullptr, const Twine &Name = "",
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,
65  bool isExternallyInitialized = false);
66  GlobalVariable(const GlobalVariable &) = delete;
67  GlobalVariable &operator=(const GlobalVariable &) = delete;
68 
71 
72  // FIXME: needed by operator delete
74  }
75 
76  // allocate space for exactly one operand
77  void *operator new(size_t s) {
78  return User::operator new(s, 1);
79  }
80 
81  /// Provide fast operand accessors
83 
84  /// Definitions have initializers, declarations don't.
85  ///
86  inline bool hasInitializer() const { return !isDeclaration(); }
87 
88  /// hasDefinitiveInitializer - Whether the global variable has an initializer,
89  /// and any other instances of the global (this can happen due to weak
90  /// linkage) are guaranteed to have the same initializer.
91  ///
92  /// Note that if you want to transform a global, you must use
93  /// hasUniqueInitializer() instead, because of the *_odr linkage type.
94  ///
95  /// Example:
96  ///
97  /// @a = global SomeType* null - Initializer is both definitive and unique.
98  ///
99  /// @b = global weak SomeType* null - Initializer is neither definitive nor
100  /// unique.
101  ///
102  /// @c = global weak_odr SomeType* null - Initializer is definitive, but not
103  /// unique.
104  inline bool hasDefinitiveInitializer() const {
105  return hasInitializer() &&
106  // The initializer of a global variable may change to something arbitrary
107  // at link time.
108  !isInterposable() &&
109  // The initializer of a global variable with the externally_initialized
110  // marker may change at runtime before C++ initializers are evaluated.
112  }
113 
114  /// hasUniqueInitializer - Whether the global variable has an initializer, and
115  /// any changes made to the initializer will turn up in the final executable.
116  inline bool hasUniqueInitializer() const {
117  return
118  // We need to be sure this is the definition that will actually be used
120  // It is not safe to modify initializers of global variables with the
121  // external_initializer marker since the value may be changed at runtime
122  // before C++ initializers are evaluated.
124  }
125 
126  /// getInitializer - Return the initializer for this global variable. It is
127  /// illegal to call this method if the global is external, because we cannot
128  /// tell what the value is initialized to!
129  ///
130  inline const Constant *getInitializer() const {
131  assert(hasInitializer() && "GV doesn't have initializer!");
132  return static_cast<Constant*>(Op<0>().get());
133  }
135  assert(hasInitializer() && "GV doesn't have initializer!");
136  return static_cast<Constant*>(Op<0>().get());
137  }
138  /// setInitializer - Sets the initializer for this global variable, removing
139  /// any existing initializer if InitVal==NULL. If this GV has type T*, the
140  /// initializer must have type T.
141  void setInitializer(Constant *InitVal);
142 
143  /// If the value is a global constant, its value is immutable throughout the
144  /// runtime execution of the program. Assigning a value into the constant
145  /// leads to undefined behavior.
146  ///
147  bool isConstant() const { return isConstantGlobal; }
148  void setConstant(bool Val) { isConstantGlobal = Val; }
149 
150  bool isExternallyInitialized() const {
151  return isExternallyInitializedConstant;
152  }
153  void setExternallyInitialized(bool Val) {
154  isExternallyInitializedConstant = Val;
155  }
156 
157  /// copyAttributesFrom - copy all additional attributes (those not needed to
158  /// create a GlobalVariable) from the GlobalVariable Src to this one.
159  void copyAttributesFrom(const GlobalVariable *Src);
160 
161  /// removeFromParent - This method unlinks 'this' from the containing module,
162  /// but does not delete it.
163  ///
164  void removeFromParent();
165 
166  /// eraseFromParent - This method unlinks 'this' from the containing module
167  /// and deletes it.
168  ///
169  void eraseFromParent();
170 
171  /// Drop all references in preparation to destroy the GlobalVariable. This
172  /// drops not only the reference to the initializer but also to any metadata.
173  void dropAllReferences();
174 
175  /// Attach a DIGlobalVariableExpression.
177 
178  /// Fill the vector with all debug info attachements.
180 
181  /// Add attribute to this global.
183  Attrs = Attrs.addAttribute(getContext(), Kind);
184  }
185 
186  /// Add attribute to this global.
188  Attrs = Attrs.addAttribute(getContext(), Kind, Val);
189  }
190 
191  /// Return true if the attribute exists.
193  return Attrs.hasAttribute(Kind);
194  }
195 
196  /// Return true if the attribute exists.
197  bool hasAttribute(StringRef Kind) const {
198  return Attrs.hasAttribute(Kind);
199  }
200 
201  /// Return true if any attributes exist.
202  bool hasAttributes() const {
203  return Attrs.hasAttributes();
204  }
205 
206  /// Return the attribute object.
208  return Attrs.getAttribute(Kind);
209  }
210 
211  /// Return the attribute object.
213  return Attrs.getAttribute(Kind);
214  }
215 
216  /// Return the attribute set for this global
218  return Attrs;
219  }
220 
221  /// Return attribute set as list with index.
222  /// FIXME: This may not be required once ValueEnumerators
223  /// in bitcode-writer can enumerate attribute-set.
224  AttributeList getAttributesAsList(unsigned index) const {
225  if (!hasAttributes())
226  return AttributeList();
227  std::pair<unsigned, AttributeSet> AS[1] = {{index, Attrs}};
228  return AttributeList::get(getContext(), AS);
229  }
230 
231  /// Set attribute list for this global
233  Attrs = A;
234  }
235 
236  /// Check if section name is present
237  bool hasImplicitSection() const {
238  return getAttributes().hasAttribute("bss-section") ||
239  getAttributes().hasAttribute("data-section") ||
240  getAttributes().hasAttribute("rodata-section");
241  }
242 
243  // Methods for support type inquiry through isa, cast, and dyn_cast:
244  static bool classof(const Value *V) {
245  return V->getValueID() == Value::GlobalVariableVal;
246  }
247 };
248 
249 template <>
251  public OptionalOperandTraits<GlobalVariable> {
252 };
253 
255 
256 } // end namespace llvm
257 
258 #endif // LLVM_IR_GLOBALVARIABLE_H
AttributeSet getAttributes() const
Return the attribute set for this global.
bool hasDefinitiveInitializer() const
hasDefinitiveInitializer - Whether the global variable has an initializer, and any other instances of...
unsigned getValueID() const
Return an ID for the concrete type of this object.
Definition: Value.h:459
static bool classof(const Value *V)
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
bool hasAttributes() const
Return true if any attributes exist.
void addAttribute(Attribute::AttrKind Kind)
Add attribute to this global.
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:697
bool isInterposable() const
Return true if this global&#39;s definition can be substituted with an arbitrary definition at link time...
Definition: GlobalValue.h:400
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
void setInitializer(Constant *InitVal)
setInitializer - Sets the initializer for this global variable, removing any existing initializer if ...
Definition: Globals.cpp:339
GlobalVariable & operator=(const GlobalVariable &)=delete
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
This file contains the simple types necessary to represent the attributes associated with functions a...
void addAttribute(StringRef Kind, StringRef Val=StringRef())
Add attribute to this global.
#define DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CLASS, VALUECLASS)
Macro for generating out-of-class operand accessor definitions.
bool hasImplicitSection() const
Check if section name is present.
Attribute getAttribute(Attribute::AttrKind Kind) const
Return the attribute object.
GlobalVariable(Type *Ty, bool isConstant, LinkageTypes Linkage, Constant *Initializer=nullptr, const Twine &Name="", ThreadLocalMode=NotThreadLocal, unsigned AddressSpace=0, bool isExternallyInitialized=false)
GlobalVariable ctor - If a parent module is specified, the global is automatically inserted into the ...
Definition: Globals.cpp:287
bool hasAttribute(Attribute::AttrKind Kind) const
Return true if the attribute exists in this set.
Definition: Attributes.cpp:573
AttributeList getAttributesAsList(unsigned index) const
Return attribute set as list with index.
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This is an important base class in LLVM.
Definition: Constant.h:42
void setExternallyInitialized(bool Val)
void getDebugInfo(SmallVectorImpl< DIGlobalVariableExpression *> &GVs) const
Fill the vector with all debug info attachements.
Definition: Metadata.cpp:1515
bool hasUniqueInitializer() const
hasUniqueInitializer - Whether the global variable has an initializer, and any changes made to the in...
void eraseFromParent()
eraseFromParent - This method unlinks &#39;this&#39; from the containing module and deletes it...
Definition: Globals.cpp:335
A pair of DIGlobalVariable and DIExpression.
OptionalOperandTraits - when the number of operands may change at runtime.
Definition: OperandTraits.h:54
bool hasAttribute(Attribute::AttrKind Kind) const
Return true if the attribute exists.
void setGlobalVariableNumOperands(unsigned NumOps)
Set the number of operands on a GlobalVariable.
Definition: User.h:192
void setConstant(bool Val)
const AMDGPUAS & AS
void removeFromParent()
removeFromParent - This method unlinks &#39;this&#39; from the containing module, but does not delete it...
Definition: Globals.cpp:331
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Provide fast operand accessors.
AddressSpace
Definition: NVPTXBaseInfo.h:22
unsigned Linkage
Definition: GlobalValue.h:93
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:48
void setAttributes(AttributeSet A)
Set attribute list for this global.
void dropAllReferences()
Drop all references in preparation to destroy the GlobalVariable.
Definition: Globals.cpp:369
bool isStrongDefinitionForLinker() const
Returns true if this global&#39;s definition will be the one chosen by the linker.
Definition: GlobalValue.h:516
void copyAttributesFrom(const GlobalVariable *Src)
copyAttributesFrom - copy all additional attributes (those not needed to create a GlobalVariable) fro...
Definition: Globals.cpp:362
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
Compile-time customization of User operands.
Definition: User.h:43
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:200
const unsigned Kind
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:73
bool hasInitializer() const
Definitions have initializers, declarations don&#39;t.
Attribute getAttribute(StringRef Kind) const
Return the attribute object.
void addDebugInfo(DIGlobalVariableExpression *GV)
Attach a DIGlobalVariableExpression.
Definition: Metadata.cpp:1511
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
Constant * getInitializer()
bool isExternallyInitialized() const
static AttributeList get(LLVMContext &C, ArrayRef< std::pair< unsigned, Attribute >> Attrs)
Create an AttributeList with the specified parameters in it.
Definition: Attributes.cpp:870
bool hasAttribute(StringRef Kind) const
Return true if the attribute exists.
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results...
Definition: Attributes.h:70