LLVM 18.0.0git
GlobalObject.h
Go to the documentation of this file.
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"
21
22namespace llvm {
23
24class Comdat;
25class Metadata;
26
27class GlobalObject : public GlobalValue {
28public:
29 // VCallVisibility - values for visibility metadata attached to vtables. This
30 // describes the scope in which a virtual call could end up being dispatched
31 // through this vtable.
33 // Type is potentially visible to external code.
35 // Type is only visible to code which will be in the current Module after
36 // LTO internalization.
38 // Type is only visible to code in the current Module.
40 };
41
42protected:
43 GlobalObject(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
45 unsigned AddressSpace = 0)
46 : GlobalValue(Ty, VTy, Ops, NumOps, Linkage, Name, AddressSpace) {
48 }
50
51 Comdat *ObjComdat = nullptr;
52 enum {
55
57 };
58 static const unsigned GlobalObjectSubClassDataBits =
60
61private:
62 static const unsigned AlignmentBits = LastAlignmentBit + 1;
63 static const unsigned AlignmentMask = (1 << AlignmentBits) - 1;
64 static const unsigned GlobalObjectMask = (1 << GlobalObjectBits) - 1;
65
66public:
67 GlobalObject(const GlobalObject &) = delete;
68
69 /// FIXME: Remove this function once transition to Align is over.
72 return Align ? Align->value() : 0;
73 }
74
75 /// Returns the alignment of the given variable or function.
76 ///
77 /// Note that for functions this is the alignment of the code, not the
78 /// alignment of a function pointer.
81 unsigned AlignmentData = Data & AlignmentMask;
82 return decodeMaybeAlign(AlignmentData);
83 }
84
85 /// Sets the alignment attribute of the GlobalObject.
87
88 /// Sets the alignment attribute of the GlobalObject.
89 /// This method will be deprecated as the alignment property should always be
90 /// defined.
92
93 unsigned getGlobalObjectSubClassData() const {
94 unsigned ValueData = getGlobalValueSubClassData();
95 return ValueData >> GlobalObjectBits;
96 }
97
98 void setGlobalObjectSubClassData(unsigned Val) {
99 unsigned OldData = getGlobalValueSubClassData();
100 setGlobalValueSubClassData((OldData & GlobalObjectMask) |
101 (Val << GlobalObjectBits));
102 assert(getGlobalObjectSubClassData() == Val && "representation error");
103 }
104
105 /// Check if this global has a custom object file section.
106 ///
107 /// This is more efficient than calling getSection() and checking for an empty
108 /// string.
109 bool hasSection() const {
111 }
112
113 /// Get the custom section of this global if it has one.
114 ///
115 /// If this global does not have a custom section, this will be empty and the
116 /// default object file section (.text, .data, etc) will be used.
118 return hasSection() ? getSectionImpl() : StringRef();
119 }
120
121 /// Change the section for this global.
122 ///
123 /// Setting the section to the empty string tells LLVM to choose an
124 /// appropriate default object file section.
125 void setSection(StringRef S);
126
127 bool hasComdat() const { return getComdat() != nullptr; }
128 const Comdat *getComdat() const { return ObjComdat; }
130 void setComdat(Comdat *C);
131
132 using Value::addMetadata;
136 using Value::getMetadata;
137 using Value::hasMetadata;
138 using Value::setMetadata;
139
140 /// Copy metadata from Src, adjusting offsets by Offset.
141 void copyMetadata(const GlobalObject *Src, unsigned Offset);
142
143 void addTypeMetadata(unsigned Offset, Metadata *TypeID);
146
147 /// Returns true if the alignment of the value can be unilaterally
148 /// increased.
149 ///
150 /// Note that for functions this is the alignment of the code, not the
151 /// alignment of a function pointer.
152 bool canIncreaseAlignment() const;
153
154protected:
155 void copyAttributesFrom(const GlobalObject *Src);
156
157public:
158 // Methods for support type inquiry through isa, cast, and dyn_cast:
159 static bool classof(const Value *V) {
160 return V->getValueID() == Value::FunctionVal ||
161 V->getValueID() == Value::GlobalVariableVal ||
162 V->getValueID() == Value::GlobalIFuncVal;
163 }
164
165private:
166 void setGlobalObjectFlag(unsigned Bit, bool Val) {
167 unsigned Mask = 1 << Bit;
169 (Val ? Mask : 0u));
170 }
171
172 StringRef getSectionImpl() const;
173};
174
175} // end namespace llvm
176
177#endif // LLVM_IR_GLOBALOBJECT_H
std::string Name
Type::TypeID TypeID
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Comdat * getComdat()
Definition: GlobalObject.h:129
StringRef getSection() const
Get the custom section of this global if it has one.
Definition: GlobalObject.h:117
void addTypeMetadata(unsigned Offset, Metadata *TypeID)
Definition: Metadata.cpp:1742
MaybeAlign getAlign() const
Returns the alignment of the given variable or function.
Definition: GlobalObject.h:79
static bool classof(const Value *V)
Definition: GlobalObject.h:159
static const unsigned GlobalObjectSubClassDataBits
Definition: GlobalObject.h:58
GlobalObject(const GlobalObject &)=delete
void setAlignment(Align Align)
Sets the alignment attribute of the GlobalObject.
Definition: Globals.cpp:128
void copyMetadata(const GlobalObject *Src, unsigned Offset)
Copy metadata from Src, adjusting offsets by Offset.
Definition: Metadata.cpp:1701
void setComdat(Comdat *C)
Definition: Globals.cpp:196
GlobalObject(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps, LinkageTypes Linkage, const Twine &Name, unsigned AddressSpace=0)
Definition: GlobalObject.h:43
bool hasComdat() const
Definition: GlobalObject.h:127
VCallVisibility getVCallVisibility() const
Definition: Metadata.cpp:1761
void copyAttributesFrom(const GlobalObject *Src)
Definition: Globals.cpp:138
uint64_t getAlignment() const
FIXME: Remove this function once transition to Align is over.
Definition: GlobalObject.h:70
void setSection(StringRef S)
Change the section for this global.
Definition: Globals.cpp:250
const Comdat * getComdat() const
Definition: GlobalObject.h:128
void setGlobalObjectSubClassData(unsigned Val)
Definition: GlobalObject.h:98
unsigned getGlobalObjectSubClassData() const
Definition: GlobalObject.h:93
bool hasSection() const
Check if this global has a custom object file section.
Definition: GlobalObject.h:109
bool canIncreaseAlignment() const
Returns true if the alignment of the value can be unilaterally increased.
Definition: Globals.cpp:287
void setVCallVisibilityMetadata(VCallVisibility Visibility)
Definition: Metadata.cpp:1751
unsigned Visibility
Definition: GlobalValue.h:95
static const unsigned GlobalValueSubClassDataBits
Definition: GlobalValue.h:90
unsigned getGlobalValueSubClassData() const
Definition: GlobalValue.h:171
void setGlobalValueSubClassData(unsigned V)
Definition: GlobalValue.h:174
unsigned Linkage
Definition: GlobalValue.h:94
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:47
Root of the metadata hierarchy.
Definition: Metadata.h:62
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43
LLVM Value Representation.
Definition: Value.h:74
bool hasMetadata() const
Return true if this value has any metadata attached to it.
Definition: Value.h:589
void setMetadata(unsigned KindID, MDNode *Node)
Set a particular kind of metadata attachment.
Definition: Metadata.cpp:1447
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * > > &MDs) const
Appends all metadata attached to this value to MDs, sorting by KindID.
Definition: Metadata.cpp:1437
bool eraseMetadata(unsigned KindID)
Erase all metadata attachments with the given kind.
Definition: Metadata.cpp:1492
void addMetadata(unsigned KindID, MDNode &MD)
Add a metadata attachment.
Definition: Metadata.cpp:1481
void clearMetadata()
Erase all metadata attached to this Value.
Definition: Metadata.cpp:1504
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
Definition: Value.h:565
ValueTy
Concrete subclass of this.
Definition: Value.h:513
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
AddressSpace
Definition: NVPTXBaseInfo.h:21
MaybeAlign decodeMaybeAlign(unsigned Value)
Dual operation of the encode function above.
Definition: Alignment.h:220
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
uint64_t value() const
This is a hole in the type system and should not be abused.
Definition: Alignment.h:85
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:117