1//===-- llvm/GlobalObject.h - Class to represent global objects -*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This represents an independent object. That is, a function or a global
10// variable, but not an alias.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_IR_GLOBALOBJECT_H
15#define LLVM_IR_GLOBALOBJECT_H
16
17#include "llvm/ADT/StringRef.h"
18#include "llvm/IR/GlobalValue.h"
19#include "llvm/IR/Value.h"
20#include "llvm/Support/Alignment.h"
21
22namespace llvm {
23
24class Comdat;
25class MDNode;
26class Metadata;
27
28class GlobalObject : public GlobalValue {
29public:
30 // VCallVisibility - values for visibility metadata attached to vtables. This
31 // describes the scope in which a virtual call could end up being dispatched
32 // through this vtable.
33 enum VCallVisibility {
34 // Type is potentially visible to external code.
35 VCallVisibilityPublic = 0,
36 // Type is only visible to code which will be in the current Module after
37 // LTO internalization.
38 VCallVisibilityLinkageUnit = 1,
39 // Type is only visible to code in the current Module.
40 VCallVisibilityTranslationUnit = 2,
41 };
42
43protected:
44 GlobalObject(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
45 LinkageTypes Linkage, const Twine &Name,
46 unsigned AddressSpace = 0)
47 : GlobalValue(Ty, VTy, Ops, NumOps, Linkage, Name, AddressSpace),
48 ObjComdat(nullptr) {
49 setGlobalValueSubClassData(0);
50 }
51
52 Comdat *ObjComdat;
53 enum {
54 LastAlignmentBit = 4,
55 HasSectionHashEntryBit,
56
57 GlobalObjectBits,
58 };
59 static const unsigned GlobalObjectSubClassDataBits =
60 GlobalValueSubClassDataBits - GlobalObjectBits;
61
62private:
63 static const unsigned AlignmentBits = LastAlignmentBit + 1;
64 static const unsigned AlignmentMask = (1 << AlignmentBits) - 1;
65 static const unsigned GlobalObjectMask = (1 << GlobalObjectBits) - 1;
66
67public:
68 GlobalObject(const GlobalObject &) = delete;
69
70 /// FIXME: Remove this function once transition to Align is over.
71 unsigned getAlignment() const {
72 MaybeAlign Align = getAlign();
73 return Align ? Align->value() : 0;
74 }
75
76 /// Returns the alignment of the given variable or function.
77 ///
78 /// Note that for functions this is the alignment of the code, not the
79 /// alignment of a function pointer.
80 MaybeAlign getAlign() const {
81 unsigned Data = getGlobalValueSubClassData();
82 unsigned AlignmentData = Data & AlignmentMask;
83 return decodeMaybeAlign(AlignmentData);
84 }
85
86 void setAlignment(MaybeAlign Align);
87
88 unsigned getGlobalObjectSubClassData() const {
89 unsigned ValueData = getGlobalValueSubClassData();
90 return ValueData >> GlobalObjectBits;
91 }
92
93 void setGlobalObjectSubClassData(unsigned Val) {
94 unsigned OldData = getGlobalValueSubClassData();
95 setGlobalValueSubClassData((OldData & GlobalObjectMask) |
96 (Val << GlobalObjectBits));
97 assert(getGlobalObjectSubClassData() == Val && "representation error");
98 }
99
100 /// Check if this global has a custom object file section.
101 ///
102 /// This is more efficient than calling getSection() and checking for an empty
103 /// string.
104 bool hasSection() const {
105 return getGlobalValueSubClassData() & (1 << HasSectionHashEntryBit);
106 }
107
108 /// Get the custom section of this global if it has one.
109 ///
110 /// If this global does not have a custom section, this will be empty and the
111 /// default object file section (.text, .data, etc) will be used.
112 StringRef getSection() const {
113 return hasSection() ? getSectionImpl() : StringRef();
114 }
115
116 /// Change the section for this global.
117 ///
118 /// Setting the section to the empty string tells LLVM to choose an
119 /// appropriate default object file section.
120 void setSection(StringRef S);
121
122 bool hasComdat() const { return getComdat() != nullptr; }
123 const Comdat *getComdat() const { return ObjComdat; }
124 Comdat *getComdat() { return ObjComdat; }
125 void setComdat(Comdat *C) { ObjComdat = C; }
126
127 using Value::addMetadata;
128 using Value::clearMetadata;
129 using Value::eraseMetadata;
130 using Value::getAllMetadata;
131 using Value::getMetadata;
132 using Value::hasMetadata;
133 using Value::setMetadata;
134
135 /// Copy metadata from Src, adjusting offsets by Offset.
136 void copyMetadata(const GlobalObject *Src, unsigned Offset);
137
138 void addTypeMetadata(unsigned Offset, Metadata *TypeID);
139 void setVCallVisibilityMetadata(VCallVisibility Visibility);
140 VCallVisibility getVCallVisibility() const;
141
142 /// Returns true if the alignment of the value can be unilaterally
143 /// increased.
144 ///
145 /// Note that for functions this is the alignment of the code, not the
146 /// alignment of a function pointer.
147 bool canIncreaseAlignment() const;
148
149protected:
150 void copyAttributesFrom(const GlobalObject *Src);
151
152public:
153 // Methods for support type inquiry through isa, cast, and dyn_cast:
154 static bool classof(const Value *V) {
155 return V->getValueID() == Value::FunctionVal ||
156 V->getValueID() == Value::GlobalVariableVal;
157 }
158
159private:
160 void setGlobalObjectFlag(unsigned Bit, bool Val) {
161 unsigned Mask = 1 << Bit;
162 setGlobalValueSubClassData((~Mask & getGlobalValueSubClassData()) |
163 (Val ? Mask : 0u));
164 }
165
166 StringRef getSectionImpl() const;
167};
168
169} // end namespace llvm
170
171#endif // LLVM_IR_GLOBALOBJECT_H
172