include/llvm/IR/GlobalObject.h

   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     HasMetadataHashEntryBit,
  58     HasSectionHashEntryBit,
  59
  60     GlobalObjectBits,
  61   };
  62   static const unsigned GlobalObjectSubClassDataBits =
  63       GlobalValueSubClassDataBits - GlobalObjectBits;
  64
  65 private:
  66   static const unsigned AlignmentBits = LastAlignmentBit + 1;
  67   static const unsigned AlignmentMask = (1 << AlignmentBits) - 1;
  68   static const unsigned GlobalObjectMask = (1 << GlobalObjectBits) - 1;
  69
  70 public:
  71   GlobalObject(const GlobalObject &) = delete;
  72
  73   unsigned getAlignment() const {
  74     unsigned Data = getGlobalValueSubClassData();
  75     unsigned AlignmentData = Data & AlignmentMask;
  76     MaybeAlign Align = decodeMaybeAlign(AlignmentData);
  77     return Align ? Align->value() : 0;
  78   }
  79
  80   /// FIXME: Remove this setter once the migration to MaybeAlign is over.
  81   void setAlignment(unsigned Align);
  82   void setAlignment(MaybeAlign Align);
  83
  84   unsigned getGlobalObjectSubClassData() const {
  85     unsigned ValueData = getGlobalValueSubClassData();
  86     return ValueData >> GlobalObjectBits;
  87   }
  88
  89   void setGlobalObjectSubClassData(unsigned Val) {
  90     unsigned OldData = getGlobalValueSubClassData();
  91     setGlobalValueSubClassData((OldData & GlobalObjectMask) |
  92                                (Val << GlobalObjectBits));
  93     assert(getGlobalObjectSubClassData() == Val && "representation error");
  94   }
  95
  96   /// Check if this global has a custom object file section.
  97   ///
  98   /// This is more efficient than calling getSection() and checking for an empty
  99   /// string.
 100   bool hasSection() const {
 101     return getGlobalValueSubClassData() & (1 << HasSectionHashEntryBit);
 102   }
 103
 104   /// Get the custom section of this global if it has one.
 105   ///
 106   /// If this global does not have a custom section, this will be empty and the
 107   /// default object file section (.text, .data, etc) will be used.
 108   StringRef getSection() const {
 109     return hasSection() ? getSectionImpl() : StringRef();
 110   }
 111
 112   /// Change the section for this global.
 113   ///
 114   /// Setting the section to the empty string tells LLVM to choose an
 115   /// appropriate default object file section.
 116   void setSection(StringRef S);
 117
 118   bool hasComdat() const { return getComdat() != nullptr; }
 119   const Comdat *getComdat() const { return ObjComdat; }
 120   Comdat *getComdat() { return ObjComdat; }
 121   void setComdat(Comdat *C) { ObjComdat = C; }
 122
 123   /// Check if this has any metadata.
 124   bool hasMetadata() const { return hasMetadataHashEntry(); }
 125
 126   /// Check if this has any metadata of the given kind.
 127   bool hasMetadata(unsigned KindID) const {
 128     return getMetadata(KindID) != nullptr;
 129   }
 130   bool hasMetadata(StringRef Kind) const {
 131     return getMetadata(Kind) != nullptr;
 132   }
 133
 134   /// Get the current metadata attachments for the given kind, if any.
 135   ///
 136   /// These functions require that the function have at most a single attachment
 137   /// of the given kind, and return \c nullptr if such an attachment is missing.
 138   /// @{
 139   MDNode *getMetadata(unsigned KindID) const;
 140   MDNode *getMetadata(StringRef Kind) const;
 141   /// @}
 142
 143   /// Appends all attachments with the given ID to \c MDs in insertion order.
 144   /// If the global has no attachments with the given ID, or if ID is invalid,
 145   /// leaves MDs unchanged.
 146   /// @{
 147   void getMetadata(unsigned KindID, SmallVectorImpl<MDNode *> &MDs) const;
 148   void getMetadata(StringRef Kind, SmallVectorImpl<MDNode *> &MDs) const;
 149   /// @}
 150
 151   /// Set a particular kind of metadata attachment.
 152   ///
 153   /// Sets the given attachment to \c MD, erasing it if \c MD is \c nullptr or
 154   /// replacing it if it already exists.
 155   /// @{
 156   void setMetadata(unsigned KindID, MDNode *MD);
 157   void setMetadata(StringRef Kind, MDNode *MD);
 158   /// @}
 159
 160   /// Add a metadata attachment.
 161   /// @{
 162   void addMetadata(unsigned KindID, MDNode &MD);
 163   void addMetadata(StringRef Kind, MDNode &MD);
 164   /// @}
 165
 166   /// Appends all attachments for the global to \c MDs, sorting by attachment
 167   /// ID. Attachments with the same ID appear in insertion order.
 168   void
 169   getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const;
 170
 171   /// Erase all metadata attachments with the given kind.
 172   ///
 173   /// \returns true if any metadata was removed.
 174   bool eraseMetadata(unsigned KindID);
 175
 176   /// Copy metadata from Src, adjusting offsets by Offset.
 177   void copyMetadata(const GlobalObject *Src, unsigned Offset);
 178
 179   void addTypeMetadata(unsigned Offset, Metadata *TypeID);
 180   void addVCallVisibilityMetadata(VCallVisibility Visibility);
 181   VCallVisibility getVCallVisibility() const;
 182
 183 protected:
 184   void copyAttributesFrom(const GlobalObject *Src);
 185
 186 public:
 187   // Methods for support type inquiry through isa, cast, and dyn_cast:
 188   static bool classof(const Value *V) {
 189     return V->getValueID() == Value::FunctionVal ||
 190            V->getValueID() == Value::GlobalVariableVal;
 191   }
 192
 193   void clearMetadata();
 194
 195 private:
 196   void setGlobalObjectFlag(unsigned Bit, bool Val) {
 197     unsigned Mask = 1 << Bit;
 198     setGlobalValueSubClassData((~Mask & getGlobalValueSubClassData()) |
 199                                (Val ? Mask : 0u));
 200   }
 201
 202   bool hasMetadataHashEntry() const {
 203     return getGlobalValueSubClassData() & (1 << HasMetadataHashEntryBit);
 204   }
 205   void setHasMetadataHashEntry(bool HasEntry) {
 206     setGlobalObjectFlag(HasMetadataHashEntryBit, HasEntry);
 207   }
 208
 209   StringRef getSectionImpl() const;
 210 };
 211
 212 } // end namespace llvm
 213
 214 #endif // LLVM_IR_GLOBALOBJECT_H