LLVM  15.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"
20 #include "llvm/Support/Alignment.h"
21 
22 namespace llvm {
23 
24 class Comdat;
25 class Metadata;
26 
27 class GlobalObject : public GlobalValue {
28 public:
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 
42 protected:
43  GlobalObject(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
45  unsigned AddressSpace = 0)
46  : GlobalValue(Ty, VTy, Ops, NumOps, Linkage, Name, AddressSpace) {
48  }
49  ~GlobalObject();
50 
51  Comdat *ObjComdat = nullptr;
52  enum {
55 
57  };
58  static const unsigned GlobalObjectSubClassDataBits =
60 
61 private:
62  static const unsigned AlignmentBits = LastAlignmentBit + 1;
63  static const unsigned AlignmentMask = (1 << AlignmentBits) - 1;
64  static const unsigned GlobalObjectMask = (1 << GlobalObjectBits) - 1;
65 
66 public:
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.
79  MaybeAlign getAlign() const {
80  unsigned Data = getGlobalValueSubClassData();
81  unsigned AlignmentData = Data & AlignmentMask;
82  return decodeMaybeAlign(AlignmentData);
83  }
84 
86 
87  unsigned getGlobalObjectSubClassData() const {
88  unsigned ValueData = getGlobalValueSubClassData();
89  return ValueData >> GlobalObjectBits;
90  }
91 
92  void setGlobalObjectSubClassData(unsigned Val) {
93  unsigned OldData = getGlobalValueSubClassData();
94  setGlobalValueSubClassData((OldData & GlobalObjectMask) |
95  (Val << GlobalObjectBits));
96  assert(getGlobalObjectSubClassData() == Val && "representation error");
97  }
98 
99  /// Check if this global has a custom object file section.
100  ///
101  /// This is more efficient than calling getSection() and checking for an empty
102  /// string.
103  bool hasSection() const {
105  }
106 
107  /// Get the custom section of this global if it has one.
108  ///
109  /// If this global does not have a custom section, this will be empty and the
110  /// default object file section (.text, .data, etc) will be used.
112  return hasSection() ? getSectionImpl() : StringRef();
113  }
114 
115  /// Change the section for this global.
116  ///
117  /// Setting the section to the empty string tells LLVM to choose an
118  /// appropriate default object file section.
119  void setSection(StringRef S);
120 
121  bool hasComdat() const { return getComdat() != nullptr; }
122  const Comdat *getComdat() const { return ObjComdat; }
123  Comdat *getComdat() { return ObjComdat; }
124  void setComdat(Comdat *C);
125 
126  using Value::addMetadata;
127  using Value::clearMetadata;
128  using Value::eraseMetadata;
129  using Value::getAllMetadata;
130  using Value::getMetadata;
131  using Value::hasMetadata;
132  using Value::setMetadata;
133 
134  /// Copy metadata from Src, adjusting offsets by Offset.
135  void copyMetadata(const GlobalObject *Src, unsigned Offset);
136 
137  void addTypeMetadata(unsigned Offset, Metadata *TypeID);
140 
141  /// Returns true if the alignment of the value can be unilaterally
142  /// increased.
143  ///
144  /// Note that for functions this is the alignment of the code, not the
145  /// alignment of a function pointer.
146  bool canIncreaseAlignment() const;
147 
148 protected:
149  void copyAttributesFrom(const GlobalObject *Src);
150 
151 public:
152  // Methods for support type inquiry through isa, cast, and dyn_cast:
153  static bool classof(const Value *V) {
154  return V->getValueID() == Value::FunctionVal ||
155  V->getValueID() == Value::GlobalVariableVal ||
156  V->getValueID() == Value::GlobalIFuncVal;
157  }
158 
159 private:
160  void setGlobalObjectFlag(unsigned Bit, bool Val) {
161  unsigned Mask = 1 << Bit;
163  (Val ? Mask : 0u));
164  }
165 
166  StringRef getSectionImpl() const;
167 };
168 
169 } // end namespace llvm
170 
171 #endif // LLVM_IR_GLOBALOBJECT_H
llvm::GlobalObject::setComdat
void setComdat(Comdat *C)
Definition: Globals.cpp:194
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::GlobalObject::getComdat
Comdat * getComdat()
Definition: GlobalObject.h:123
llvm::GlobalObject::~GlobalObject
~GlobalObject()
Definition: Globals.cpp:100
llvm::GlobalObject::setGlobalObjectSubClassData
void setGlobalObjectSubClassData(unsigned Val)
Definition: GlobalObject.h:92
llvm::GlobalValue::Visibility
unsigned Visibility
Definition: GlobalValue.h:95
llvm::GlobalObject::VCallVisibilityTranslationUnit
@ VCallVisibilityTranslationUnit
Definition: GlobalObject.h:39
StringRef.h
llvm::GlobalObject::classof
static bool classof(const Value *V)
Definition: GlobalObject.h:153
llvm::GlobalObject::getSection
StringRef getSection() const
Get the custom section of this global if it has one.
Definition: GlobalObject.h:111
llvm::GlobalObject::getAlign
MaybeAlign getAlign() const
Returns the alignment of the given variable or function.
Definition: GlobalObject.h:79
llvm::GlobalObject::HasSectionHashEntryBit
@ HasSectionHashEntryBit
Definition: GlobalObject.h:54
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::GlobalObject::GlobalObject
GlobalObject(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps, LinkageTypes Linkage, const Twine &Name, unsigned AddressSpace=0)
Definition: GlobalObject.h:43
llvm::GlobalValue::LinkageTypes
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:47
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
llvm::GlobalValue::GlobalValueSubClassDataBits
static const unsigned GlobalValueSubClassDataBits
Definition: GlobalValue.h:90
llvm::BitmaskEnumDetail::Mask
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:80
llvm::GlobalObject::GlobalObjectSubClassDataBits
static const unsigned GlobalObjectSubClassDataBits
Definition: GlobalObject.h:58
GlobalValue.h
llvm::GlobalObject::setSection
void setSection(StringRef S)
Change the section for this global.
Definition: Globals.cpp:248
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::GlobalObject
Definition: GlobalObject.h:27
llvm::GlobalObject::setVCallVisibilityMetadata
void setVCallVisibilityMetadata(VCallVisibility Visibility)
Definition: Metadata.cpp:1614
llvm::GlobalObject::getComdat
const Comdat * getComdat() const
Definition: GlobalObject.h:122
llvm::MaybeAlign
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:117
llvm::Value::getValueID
unsigned getValueID() const
Return an ID for the concrete type of this object.
Definition: Value.h:532
llvm::GlobalObject::getGlobalObjectSubClassData
unsigned getGlobalObjectSubClassData() const
Definition: GlobalObject.h:87
llvm::GlobalObject::VCallVisibilityPublic
@ VCallVisibilityPublic
Definition: GlobalObject.h:34
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::Comdat
Definition: Comdat.h:33
llvm::Metadata
Root of the metadata hierarchy.
Definition: Metadata.h:62
llvm::AddressSpace
AddressSpace
Definition: NVPTXBaseInfo.h:21
llvm::GlobalObject::LastAlignmentBit
@ LastAlignmentBit
Definition: GlobalObject.h:53
TypeID
Type::TypeID TypeID
Definition: Mips16HardFloat.cpp:102
llvm::GlobalObject::hasSection
bool hasSection() const
Check if this global has a custom object file section.
Definition: GlobalObject.h:103
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::Value::addMetadata
void addMetadata(unsigned KindID, MDNode &MD)
Add a metadata attachment.
Definition: Metadata.cpp:1366
llvm::GlobalObject::canIncreaseAlignment
bool canIncreaseAlignment() const
Returns true if the alignment of the value can be unilaterally increased.
Definition: Globals.cpp:278
uint64_t
llvm::GlobalObject::copyMetadata
void copyMetadata(const GlobalObject *Src, unsigned Offset)
Copy metadata from Src, adjusting offsets by Offset.
Definition: Metadata.cpp:1564
llvm::GlobalValue::Linkage
unsigned Linkage
Definition: GlobalValue.h:94
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::Value::clearMetadata
void clearMetadata()
Erase all metadata attached to this Value.
Definition: Metadata.cpp:1389
llvm::GlobalObject::hasComdat
bool hasComdat() const
Definition: GlobalObject.h:121
llvm::Value::ValueTy
ValueTy
Concrete subclass of this.
Definition: Value.h:513
llvm::GlobalValue::getGlobalValueSubClassData
unsigned getGlobalValueSubClassData() const
Definition: GlobalValue.h:163
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::Value::getMetadata
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
Definition: Metadata.cpp:1295
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::Value::setMetadata
void setMetadata(unsigned KindID, MDNode *Node)
Set a particular kind of metadata attachment.
Definition: Metadata.cpp:1332
llvm::GlobalObject::getAlignment
uint64_t getAlignment() const
FIXME: Remove this function once transition to Align is over.
Definition: GlobalObject.h:70
llvm::Value::eraseMetadata
bool eraseMetadata(unsigned KindID)
Erase all metadata attachments with the given kind.
Definition: Metadata.cpp:1377
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
Alignment.h
llvm::GlobalObject::VCallVisibility
VCallVisibility
Definition: GlobalObject.h:32
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
llvm::GlobalObject::addTypeMetadata
void addTypeMetadata(unsigned Offset, Metadata *TypeID)
Definition: Metadata.cpp:1605
llvm::Align::value
uint64_t value() const
This is a hole in the type system and should not be abused.
Definition: Alignment.h:85
llvm::GlobalValue::setGlobalValueSubClassData
void setGlobalValueSubClassData(unsigned V)
Definition: GlobalValue.h:166
llvm::decodeMaybeAlign
MaybeAlign decodeMaybeAlign(unsigned Value)
Dual operation of the encode function above.
Definition: Alignment.h:221
llvm::GlobalObject::GlobalObjectBits
@ GlobalObjectBits
Definition: GlobalObject.h:56
LineType::Metadata
@ Metadata
llvm::GlobalObject::getVCallVisibility
VCallVisibility getVCallVisibility() const
Definition: Metadata.cpp:1624
llvm::tgtok::Bit
@ Bit
Definition: TGLexer.h:50
llvm::GlobalObject::copyAttributesFrom
void copyAttributesFrom(const GlobalObject *Src)
Definition: Globals.cpp:136
llvm::Value::getAllMetadata
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * >> &MDs) const
Appends all metadata attached to this value to MDs, sorting by KindID.
Definition: Metadata.cpp:1321
llvm::GlobalObject::ObjComdat
Comdat * ObjComdat
Definition: GlobalObject.h:51
llvm::GlobalObject::setAlignment
void setAlignment(MaybeAlign Align)
Definition: Globals.cpp:126
Value.h
llvm::Value::hasMetadata
bool hasMetadata() const
Return true if this value has any metadata attached to it.
Definition: Value.h:588
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::GlobalObject::VCallVisibilityLinkageUnit
@ VCallVisibilityLinkageUnit
Definition: GlobalObject.h:37
llvm::Use
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43