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.
32   enum VCallVisibility {
33     // Type is potentially visible to external code.
34     VCallVisibilityPublic = 0,
35     // Type is only visible to code which will be in the current Module after
36     // LTO internalization.
37     VCallVisibilityLinkageUnit = 1,
38     // Type is only visible to code in the current Module.
39     VCallVisibilityTranslationUnit = 2,
40   };
41 
42 protected:
43   GlobalObject(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
44                LinkageTypes Linkage, const Twine &Name,
45                unsigned AddressSpace = 0)
46       : GlobalValue(Ty, VTy, Ops, NumOps, Linkage, Name, AddressSpace) {
47     setGlobalValueSubClassData(0);
48   }
49   ~GlobalObject();
50 
51   Comdat *ObjComdat = nullptr;
52   enum {
53     LastAlignmentBit = 5,
54     HasSectionHashEntryBit,
55 
56     GlobalObjectBits,
57   };
58   static const unsigned GlobalObjectSubClassDataBits =
59       GlobalValueSubClassDataBits - GlobalObjectBits;
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.
70   uint64_t getAlignment() const {
71     MaybeAlign Align = getAlign();
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 
85   /// Sets the alignment attribute of the GlobalObject.
86   void setAlignment(Align Align);
87 
88   /// Sets the alignment attribute of the GlobalObject.
89   /// This method will be deprecated as the alignment property should always be
90   /// defined.
91   void setAlignment(MaybeAlign Align);
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 {
110     return getGlobalValueSubClassData() & (1 << HasSectionHashEntryBit);
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.
117   StringRef getSection() const {
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; }
129   Comdat *getComdat() { return ObjComdat; }
130   void setComdat(Comdat *C);
131 
132   using Value::addMetadata;
133   using Value::clearMetadata;
134   using Value::eraseMetadata;
135   using Value::getAllMetadata;
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);
144   void setVCallVisibilityMetadata(VCallVisibility Visibility);
145   VCallVisibility getVCallVisibility() const;
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 
154 protected:
155   void copyAttributesFrom(const GlobalObject *Src);
156 
157 public:
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 
165 private:
166   void setGlobalObjectFlag(unsigned Bit, bool Val) {
167     unsigned Mask = 1 << Bit;
168     setGlobalValueSubClassData((~Mask & getGlobalValueSubClassData()) |
169                                (Val ? Mask : 0u));
170   }
171 
172   StringRef getSectionImpl() const;
173 };
174 
175 } // end namespace llvm
176 
177 #endif // LLVM_IR_GLOBALOBJECT_H
178