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