LLVM  6.0.0svn
GlobalObject.h
Go to the documentation of this file.
1 //===-- llvm/GlobalObject.h - Class to represent global objects -*- 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 represents an independent object. That is, a function or a global
11 // variable, but not an alias.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_IR_GLOBALOBJECT_H
16 #define LLVM_IR_GLOBALOBJECT_H
17 
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/IR/GlobalValue.h"
20 #include "llvm/IR/Value.h"
21 #include <string>
22 #include <utility>
23 
24 namespace llvm {
25 
26 class Comdat;
27 class MDNode;
28 class Metadata;
29 
30 class GlobalObject : public GlobalValue {
31 protected:
32  GlobalObject(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
34  unsigned AddressSpace = 0)
35  : GlobalValue(Ty, VTy, Ops, NumOps, Linkage, Name, AddressSpace),
36  ObjComdat(nullptr) {
38  }
39 
41  enum {
45 
47  };
48  static const unsigned GlobalObjectSubClassDataBits =
50 
51 private:
52  static const unsigned AlignmentBits = LastAlignmentBit + 1;
53  static const unsigned AlignmentMask = (1 << AlignmentBits) - 1;
54  static const unsigned GlobalObjectMask = (1 << GlobalObjectBits) - 1;
55 
56 public:
57  GlobalObject(const GlobalObject &) = delete;
58 
59  unsigned getAlignment() const {
60  unsigned Data = getGlobalValueSubClassData();
61  unsigned AlignmentData = Data & AlignmentMask;
62  return (1u << AlignmentData) >> 1;
63  }
64  void setAlignment(unsigned Align);
65 
66  unsigned getGlobalObjectSubClassData() const {
67  unsigned ValueData = getGlobalValueSubClassData();
68  return ValueData >> GlobalObjectBits;
69  }
70 
71  void setGlobalObjectSubClassData(unsigned Val) {
72  unsigned OldData = getGlobalValueSubClassData();
73  setGlobalValueSubClassData((OldData & GlobalObjectMask) |
74  (Val << GlobalObjectBits));
75  assert(getGlobalObjectSubClassData() == Val && "representation error");
76  }
77 
78  /// Check if this global has a custom object file section.
79  ///
80  /// This is more efficient than calling getSection() and checking for an empty
81  /// string.
82  bool hasSection() const {
84  }
85 
86  /// Get the custom section of this global if it has one.
87  ///
88  /// If this global does not have a custom section, this will be empty and the
89  /// default object file section (.text, .data, etc) will be used.
91  return hasSection() ? getSectionImpl() : StringRef();
92  }
93 
94  /// Change the section for this global.
95  ///
96  /// Setting the section to the empty string tells LLVM to choose an
97  /// appropriate default object file section.
98  void setSection(StringRef S);
99 
100  bool hasComdat() const { return getComdat() != nullptr; }
101  const Comdat *getComdat() const { return ObjComdat; }
102  Comdat *getComdat() { return ObjComdat; }
103  void setComdat(Comdat *C) { ObjComdat = C; }
104 
105  /// Check if this has any metadata.
106  bool hasMetadata() const { return hasMetadataHashEntry(); }
107 
108  /// Get the current metadata attachments for the given kind, if any.
109  ///
110  /// These functions require that the function have at most a single attachment
111  /// of the given kind, and return \c nullptr if such an attachment is missing.
112  /// @{
113  MDNode *getMetadata(unsigned KindID) const;
115  /// @}
116 
117  /// Appends all attachments with the given ID to \c MDs in insertion order.
118  /// If the global has no attachments with the given ID, or if ID is invalid,
119  /// leaves MDs unchanged.
120  /// @{
121  void getMetadata(unsigned KindID, SmallVectorImpl<MDNode *> &MDs) const;
122  void getMetadata(StringRef Kind, SmallVectorImpl<MDNode *> &MDs) const;
123  /// @}
124 
125  /// Set a particular kind of metadata attachment.
126  ///
127  /// Sets the given attachment to \c MD, erasing it if \c MD is \c nullptr or
128  /// replacing it if it already exists.
129  /// @{
130  void setMetadata(unsigned KindID, MDNode *MD);
131  void setMetadata(StringRef Kind, MDNode *MD);
132  /// @}
133 
134  /// Add a metadata attachment.
135  /// @{
136  void addMetadata(unsigned KindID, MDNode &MD);
137  void addMetadata(StringRef Kind, MDNode &MD);
138  /// @}
139 
140  /// Appends all attachments for the global to \c MDs, sorting by attachment
141  /// ID. Attachments with the same ID appear in insertion order.
142  void
143  getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const;
144 
145  /// Erase all metadata attachments with the given kind.
146  void eraseMetadata(unsigned KindID);
147 
148  /// Copy metadata from Src, adjusting offsets by Offset.
149  void copyMetadata(const GlobalObject *Src, unsigned Offset);
150 
151  void addTypeMetadata(unsigned Offset, Metadata *TypeID);
152 
153 protected:
154  void copyAttributesFrom(const GlobalObject *Src);
155 
156 public:
157  // Methods for support type inquiry through isa, cast, and dyn_cast:
158  static bool classof(const Value *V) {
159  return V->getValueID() == Value::FunctionVal ||
160  V->getValueID() == Value::GlobalVariableVal;
161  }
162 
163  void clearMetadata();
164 
165 private:
166  void setGlobalObjectFlag(unsigned Bit, bool Val) {
167  unsigned Mask = 1 << Bit;
169  (Val ? Mask : 0u));
170  }
171 
172  bool hasMetadataHashEntry() const {
174  }
175  void setHasMetadataHashEntry(bool HasEntry) {
176  setGlobalObjectFlag(HasMetadataHashEntryBit, HasEntry);
177  }
178 
179  StringRef getSectionImpl() const;
180 };
181 
182 } // end namespace llvm
183 
184 #endif // LLVM_IR_GLOBALOBJECT_H
uint64_t CallInst * C
StringRef getSection() const
Get the custom section of this global if it has one.
Definition: GlobalObject.h:90
unsigned getAlignment() const
Definition: GlobalObject.h:59
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
unsigned getValueID() const
Return an ID for the concrete type of this object.
Definition: Value.h:465
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
Metadata node.
Definition: Metadata.h:862
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode *>> &MDs) const
Appends all attachments for the global to MDs, sorting by attachment ID.
Definition: Metadata.cpp:1404
void setAlignment(unsigned Align)
Definition: Globals.cpp:111
void copyMetadata(const GlobalObject *Src, unsigned Offset)
Copy metadata from Src, adjusting offsets by Offset.
Definition: Metadata.cpp:1443
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
Definition: Metadata.cpp:1431
static const unsigned GlobalObjectSubClassDataBits
Definition: GlobalObject.h:48
void setComdat(Comdat *C)
Definition: GlobalObject.h:103
Comdat * getComdat()
Definition: GlobalObject.h:102
GlobalObject(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps, LinkageTypes Linkage, const Twine &Name, unsigned AddressSpace=0)
Definition: GlobalObject.h:32
void addTypeMetadata(unsigned Offset, Metadata *TypeID)
Definition: Metadata.cpp:1484
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
unsigned getGlobalObjectSubClassData() const
Definition: GlobalObject.h:66
Type::TypeID TypeID
unsigned getGlobalValueSubClassData() const
Definition: GlobalValue.h:154
bool hasSection() const
Check if this global has a custom object file section.
Definition: GlobalObject.h:82
AddressSpace
Definition: NVPTXBaseInfo.h:22
void addMetadata(unsigned KindID, MDNode &MD)
Add a metadata attachment.
Definition: Metadata.cpp:1382
void setGlobalObjectSubClassData(unsigned Val)
Definition: GlobalObject.h:71
unsigned Linkage
Definition: GlobalValue.h:94
ValueTy
Concrete subclass of this.
Definition: Value.h:446
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:48
void setGlobalValueSubClassData(unsigned V)
Definition: GlobalValue.h:157
static bool classof(const Value *V)
Definition: GlobalObject.h:158
bool hasComdat() const
Definition: GlobalObject.h:100
void setMetadata(unsigned KindID, MDNode *MD)
Set a particular kind of metadata attachment.
Definition: Metadata.cpp:1421
const Comdat * getComdat() const
Definition: GlobalObject.h:101
static const unsigned GlobalValueSubClassDataBits
Definition: GlobalValue.h:90
const unsigned Kind
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void eraseMetadata(unsigned KindID)
Erase all metadata attachments with the given kind.
Definition: Metadata.cpp:1393
LLVM Value Representation.
Definition: Value.h:73
bool hasMetadata() const
Check if this has any metadata.
Definition: GlobalObject.h:106
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E&#39;s largest value.
Definition: BitmaskEnum.h:81
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
void copyAttributesFrom(const GlobalObject *Src)
Definition: Globals.cpp:121
Root of the metadata hierarchy.
Definition: Metadata.h:58
void setSection(StringRef S)
Change the section for this global.
Definition: Globals.cpp:184
std::vector< uint32_t > Metadata
PAL metadata represented as a vector.