Home | History | Annotate | Download | only in IR 
      1 //===-- llvm/GlobalObject.h - Class to represent global objects -*- C++ -*-===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This represents an independent object. That is, a function or a global
     11 // variable, but not an alias.
     12 //
     13 //===----------------------------------------------------------------------===//
     14 
     15 #ifndef LLVM_IR_GLOBALOBJECT_H
     16 #define LLVM_IR_GLOBALOBJECT_H
     17 
     18 #include "llvm/ADT/StringRef.h"
     19 #include "llvm/IR/GlobalValue.h"
     20 #include "llvm/IR/Value.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 protected:
     32   GlobalObject(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
     33                LinkageTypes Linkage, const Twine &Name,
     34                unsigned AddressSpace = 0)
     35       : GlobalValue(Ty, VTy, Ops, NumOps, Linkage, Name, AddressSpace),
     36         ObjComdat(nullptr) {
     37     setGlobalValueSubClassData(0);
     38   }
     39 
     40   Comdat *ObjComdat;
     41   enum {
     42     LastAlignmentBit = 4,
     43     HasMetadataHashEntryBit,
     44     HasSectionHashEntryBit,
     45 
     46     GlobalObjectBits,
     47   };
     48   static const unsigned GlobalObjectSubClassDataBits =
     49       GlobalValueSubClassDataBits - GlobalObjectBits;
     50 
     51 private:
     52   static const unsigned AlignmentBits = LastAlignmentBit + 1;
     53   static const unsigned AlignmentMask = (1 << AlignmentBits) - 1;
     54   static const unsigned GlobalObjectMask = (1 << GlobalObjectBits) - 1;
     55 
     56 public:
     57   GlobalObject(const GlobalObject &) = delete;
     58 
     59   unsigned getAlignment() const {
     60     unsigned Data = getGlobalValueSubClassData();
     61     unsigned AlignmentData = Data & AlignmentMask;
     62     return (1u << AlignmentData) >> 1;
     63   }
     64   void setAlignment(unsigned Align);
     65 
     66   unsigned getGlobalObjectSubClassData() const {
     67     unsigned ValueData = getGlobalValueSubClassData();
     68     return ValueData >> GlobalObjectBits;
     69   }
     70 
     71   void setGlobalObjectSubClassData(unsigned Val) {
     72     unsigned OldData = getGlobalValueSubClassData();
     73     setGlobalValueSubClassData((OldData & GlobalObjectMask) |
     74                                (Val << GlobalObjectBits));
     75     assert(getGlobalObjectSubClassData() == Val && "representation error");
     76   }
     77 
     78   /// Check if this global has a custom object file section.
     79   ///
     80   /// This is more efficient than calling getSection() and checking for an empty
     81   /// string.
     82   bool hasSection() const {
     83     return getGlobalValueSubClassData() & (1 << HasSectionHashEntryBit);
     84   }
     85 
     86   /// Get the custom section of this global if it has one.
     87   ///
     88   /// If this global does not have a custom section, this will be empty and the
     89   /// default object file section (.text, .data, etc) will be used.
     90   StringRef getSection() const {
     91     return hasSection() ? getSectionImpl() : StringRef();
     92   }
     93 
     94   /// Change the section for this global.
     95   ///
     96   /// Setting the section to the empty string tells LLVM to choose an
     97   /// appropriate default object file section.
     98   void setSection(StringRef S);
     99 
    100   bool hasComdat() const { return getComdat() != nullptr; }
    101   const Comdat *getComdat() const { return ObjComdat; }
    102   Comdat *getComdat() { return ObjComdat; }
    103   void setComdat(Comdat *C) { ObjComdat = C; }
    104 
    105   /// Check if this has any metadata.
    106   bool hasMetadata() const { return hasMetadataHashEntry(); }
    107 
    108   /// Get the current metadata attachments for the given kind, if any.
    109   ///
    110   /// These functions require that the function have at most a single attachment
    111   /// of the given kind, and return \c nullptr if such an attachment is missing.
    112   /// @{
    113   MDNode *getMetadata(unsigned KindID) const;
    114   MDNode *getMetadata(StringRef Kind) const;
    115   /// @}
    116 
    117   /// Appends all attachments with the given ID to \c MDs in insertion order.
    118   /// If the global has no attachments with the given ID, or if ID is invalid,
    119   /// leaves MDs unchanged.
    120   /// @{
    121   void getMetadata(unsigned KindID, SmallVectorImpl<MDNode *> &MDs) const;
    122   void getMetadata(StringRef Kind, SmallVectorImpl<MDNode *> &MDs) const;
    123   /// @}
    124 
    125   /// Set a particular kind of metadata attachment.
    126   ///
    127   /// Sets the given attachment to \c MD, erasing it if \c MD is \c nullptr or
    128   /// replacing it if it already exists.
    129   /// @{
    130   void setMetadata(unsigned KindID, MDNode *MD);
    131   void setMetadata(StringRef Kind, MDNode *MD);
    132   /// @}
    133 
    134   /// Add a metadata attachment.
    135   /// @{
    136   void addMetadata(unsigned KindID, MDNode &MD);
    137   void addMetadata(StringRef Kind, MDNode &MD);
    138   /// @}
    139 
    140   /// Appends all attachments for the global to \c MDs, sorting by attachment
    141   /// ID. Attachments with the same ID appear in insertion order.
    142   void
    143   getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const;
    144 
    145   /// Erase all metadata attachments with the given kind.
    146   void eraseMetadata(unsigned KindID);
    147 
    148   /// Copy metadata from Src, adjusting offsets by Offset.
    149   void copyMetadata(const GlobalObject *Src, unsigned Offset);
    150 
    151   void addTypeMetadata(unsigned Offset, Metadata *TypeID);
    152 
    153 protected:
    154   void copyAttributesFrom(const GlobalObject *Src);
    155 
    156 public:
    157   // Methods for support type inquiry through isa, cast, and dyn_cast:
    158   static bool classof(const Value *V) {
    159     return V->getValueID() == Value::FunctionVal ||
    160            V->getValueID() == Value::GlobalVariableVal;
    161   }
    162 
    163   void clearMetadata();
    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   bool hasMetadataHashEntry() const {
    173     return getGlobalValueSubClassData() & (1 << HasMetadataHashEntryBit);
    174   }
    175   void setHasMetadataHashEntry(bool HasEntry) {
    176     setGlobalObjectFlag(HasMetadataHashEntryBit, HasEntry);
    177   }
    178 
    179   StringRef getSectionImpl() const;
    180 };
    181 
    182 } // end namespace llvm
    183 
    184 #endif // LLVM_IR_GLOBALOBJECT_H
    185