LCOV - code coverage report
Current view: top level - include/llvm/IR - GlobalObject.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 24 24 100.0 %
Date: 2017-09-14 15:23:50 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       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      998608 : 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      568533 :       : GlobalValue(Ty, VTy, Ops, NumOps, Linkage, Name, AddressSpace),
      36      568533 :         ObjComdat(nullptr) {
      37     1137066 :     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    46347220 :     unsigned Data = getGlobalValueSubClassData();
      61    23173610 :     unsigned AlignmentData = Data & AlignmentMask;
      62    23173610 :     return (1u << AlignmentData) >> 1;
      63             :   }
      64             :   void setAlignment(unsigned Align);
      65             : 
      66             :   unsigned getGlobalObjectSubClassData() const {
      67    14478665 :     unsigned ValueData = getGlobalValueSubClassData();
      68     7239333 :     return ValueData >> GlobalObjectBits;
      69             :   }
      70             : 
      71             :   void setGlobalObjectSubClassData(unsigned Val) {
      72     1222433 :     unsigned OldData = getGlobalValueSubClassData();
      73     2812477 :     setGlobalValueSubClassData((OldData & GlobalObjectMask) |
      74      795022 :                                (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     1907919 :     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      171302 :     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      233585 :   bool hasComdat() const { return getComdat() != nullptr; }
     101             :   const Comdat *getComdat() const { return ObjComdat; }
     102             :   Comdat *getComdat() { return ObjComdat; }
     103      271216 :   void setComdat(Comdat *C) { ObjComdat = C; }
     104             : 
     105             :   /// Check if this has any metadata.
     106     9908872 :   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     5854433 :     return V->getValueID() == Value::FunctionVal ||
     160     1940229 :            V->getValueID() == Value::GlobalVariableVal;
     161             :   }
     162             : 
     163             :   void clearMetadata();
     164             : 
     165             : private:
     166             :   void setGlobalObjectFlag(unsigned Bit, bool Val) {
     167       72541 :     unsigned Mask = 1 << Bit;
     168      232842 :     setGlobalValueSubClassData((~Mask & getGlobalValueSubClassData()) |
     169       15219 :                                (Val ? Mask : 0u));
     170             :   }
     171             : 
     172             :   bool hasMetadataHashEntry() const {
     173    19817744 :     return getGlobalValueSubClassData() & (1 << HasMetadataHashEntryBit);
     174             :   }
     175             :   void setHasMetadataHashEntry(bool HasEntry) {
     176      114644 :     setGlobalObjectFlag(HasMetadataHashEntryBit, HasEntry);
     177             :   }
     178             : 
     179             :   StringRef getSectionImpl() const;
     180             : };
     181             : 
     182             : } // end namespace llvm
     183             : 
     184             : #endif // LLVM_IR_GLOBALOBJECT_H

Generated by: LCOV version 1.13