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
24namespace llvm {
25
26class Comdat;
27class MDNode;
28class Metadata;
29
30class GlobalObject : public GlobalValue {
31protected:
32 GlobalObject(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
33 LinkageTypes Linkage, const Twine &Name,
34 unsigned AddressSpace = 0)
35 : GlobalValue(Ty, VTy, Ops, NumOps, Linkage, Name, AddressSpace),
36 ObjComdat(nullptr) {
37 setGlobalValueSubClassData(0);
38 }
39
40 Comdat *ObjComdat;
41 enum {
42 LastAlignmentBit = 4,
43 HasMetadataHashEntryBit,
44 HasSectionHashEntryBit,
45
46 GlobalObjectBits,
47 };
48 static const unsigned GlobalObjectSubClassDataBits =
49 GlobalValueSubClassDataBits - GlobalObjectBits;
50
51private:
52 static const unsigned AlignmentBits = LastAlignmentBit + 1;
53 static const unsigned AlignmentMask = (1 << AlignmentBits) - 1;
54 static const unsigned GlobalObjectMask = (1 << GlobalObjectBits) - 1;
55
56public:
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 {
83 return getGlobalValueSubClassData() & (1 << HasSectionHashEntryBit);
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.
90 StringRef getSection() const {
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 /// Check if this has any metadata of the given kind.
109 bool hasMetadata(unsigned KindID) const {
110 return getMetadata(KindID) != nullptr;
111 }
112 bool hasMetadata(StringRef Kind) const {
113 return getMetadata(Kind) != nullptr;
114 }
115
116 /// Get the current metadata attachments for the given kind, if any.
117 ///
118 /// These functions require that the function have at most a single attachment
119 /// of the given kind, and return \c nullptr if such an attachment is missing.
120 /// @{
121 MDNode *getMetadata(unsigned KindID) const;
122 MDNode *getMetadata(StringRef Kind) const;
123 /// @}
124
125 /// Appends all attachments with the given ID to \c MDs in insertion order.
126 /// If the global has no attachments with the given ID, or if ID is invalid,
127 /// leaves MDs unchanged.
128 /// @{
129 void getMetadata(unsigned KindID, SmallVectorImpl<MDNode *> &MDs) const;
130 void getMetadata(StringRef Kind, SmallVectorImpl<MDNode *> &MDs) const;
131 /// @}
132
133 /// Set a particular kind of metadata attachment.
134 ///
135 /// Sets the given attachment to \c MD, erasing it if \c MD is \c nullptr or
136 /// replacing it if it already exists.
137 /// @{
138 void setMetadata(unsigned KindID, MDNode *MD);
139 void setMetadata(StringRef Kind, MDNode *MD);
140 /// @}
141
142 /// Add a metadata attachment.
143 /// @{
144 void addMetadata(unsigned KindID, MDNode &MD);
145 void addMetadata(StringRef Kind, MDNode &MD);
146 /// @}
147
148 /// Appends all attachments for the global to \c MDs, sorting by attachment
149 /// ID. Attachments with the same ID appear in insertion order.
150 void
151 getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const;
152
153 /// Erase all metadata attachments with the given kind.
154 ///
155 /// \returns true if any metadata was removed.
156 bool eraseMetadata(unsigned KindID);
157
158 /// Copy metadata from Src, adjusting offsets by Offset.
159 void copyMetadata(const GlobalObject *Src, unsigned Offset);
160
161 void addTypeMetadata(unsigned Offset, Metadata *TypeID);
162
163protected:
164 void copyAttributesFrom(const GlobalObject *Src);
165
166public:
167 // Methods for support type inquiry through isa, cast, and dyn_cast:
168 static bool classof(const Value *V) {
169 return V->getValueID() == Value::FunctionVal ||
170 V->getValueID() == Value::GlobalVariableVal;
171 }
172
173 void clearMetadata();
174
175private:
176 void setGlobalObjectFlag(unsigned Bit, bool Val) {
177 unsigned Mask = 1 << Bit;
178 setGlobalValueSubClassData((~Mask & getGlobalValueSubClassData()) |
179 (Val ? Mask : 0u));
180 }
181
182 bool hasMetadataHashEntry() const {
183 return getGlobalValueSubClassData() & (1 << HasMetadataHashEntryBit);
184 }
185 void setHasMetadataHashEntry(bool HasEntry) {
186 setGlobalObjectFlag(HasMetadataHashEntryBit, HasEntry);
187 }
188
189 StringRef getSectionImpl() const;
190};
191
192} // end namespace llvm
193
194#endif // LLVM_IR_GLOBALOBJECT_H
195