include/llvm/Object/ObjectFile.h

   1 //===- ObjectFile.h - File format independent object file -------*- 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 file declares a file format independent ObjectFile class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_OBJECT_OBJECT_FILE_H
  15 #define LLVM_OBJECT_OBJECT_FILE_H
  16
  17 #include "llvm/ADT/StringRef.h"
  18 #include "llvm/Support/DataTypes.h"
  19 #include <cstring>
  20
  21 namespace llvm {
  22
  23 class MemoryBuffer;
  24 class StringRef;
  25
  26 namespace object {
  27
  28 class ObjectFile;
  29
  30 union DataRefImpl {
  31   struct {
  32     uint32_t a, b;
  33   } d;
  34   intptr_t p;
  35 };
  36
  37 static bool operator ==(const DataRefImpl &a, const DataRefImpl &b) {
  38   // Check bitwise identical. This is the only legal way to compare a union w/o
  39   // knowing which member is in use.
  40   return std::memcmp(&a, &b, sizeof(DataRefImpl)) == 0;
  41 }
  42
  43 /// SymbolRef - This is a value type class that represents a single symbol in
  44 /// the list of symbols in the object file.
  45 class SymbolRef {
  46   DataRefImpl SymbolPimpl;
  47   const ObjectFile *OwningObject;
  48
  49 public:
  50   SymbolRef(DataRefImpl SymbolP, const ObjectFile *Owner);
  51
  52   bool operator==(const SymbolRef &Other) const;
  53
  54   SymbolRef getNext() const;
  55
  56   StringRef getName() const;
  57   uint64_t  getAddress() const;
  58   uint64_t  getSize() const;
  59
  60   /// Returns the ascii char that should be displayed in a symbol table dump via
  61   /// nm for this symbol.
  62   char      getNMTypeChar() const;
  63
  64   /// Returns true for symbols that are internal to the object file format such
  65   /// as section symbols.
  66   bool      isInternal() const;
  67 };
  68
  69 /// SectionRef - This is a value type class that represents a single section in
  70 /// the list of sections in the object file.
  71 class SectionRef {
  72   DataRefImpl SectionPimpl;
  73   const ObjectFile *OwningObject;
  74
  75 public:
  76   SectionRef(DataRefImpl SectionP, const ObjectFile *Owner);
  77
  78   bool operator==(const SectionRef &Other) const;
  79
  80   SectionRef getNext() const;
  81
  82   StringRef getName() const;
  83   uint64_t  getAddress() const;
  84   uint64_t  getSize() const;
  85   StringRef getContents() const;
  86
  87   // FIXME: Move to the normalization layer when it's created.
  88   bool      isText() const;
  89 };
  90
  91 const uint64_t UnknownAddressOrSize = ~0ULL;
  92
  93 /// ObjectFile - This class is the base class for all object file types.
  94 /// Concrete instances of this object are created by createObjectFile, which
  95 /// figure out which type to create.
  96 class ObjectFile {
  97 private:
  98   ObjectFile(); // = delete
  99   ObjectFile(const ObjectFile &other); // = delete
 100
 101 protected:
 102   MemoryBuffer *MapFile;
 103   const uint8_t *base;
 104
 105   ObjectFile(MemoryBuffer *Object);
 106
 107   // These functions are for SymbolRef to call internally. The main goal of
 108   // this is to allow SymbolRef::SymbolPimpl to point directly to the symbol
 109   // entry in the memory mapped object file. SymbolPimpl cannot contain any
 110   // virtual functions because then it could not point into the memory mapped
 111   // file.
 112   friend class SymbolRef;
 113   virtual SymbolRef getSymbolNext(DataRefImpl Symb) const = 0;
 114   virtual StringRef getSymbolName(DataRefImpl Symb) const = 0;
 115   virtual uint64_t  getSymbolAddress(DataRefImpl Symb) const = 0;
 116   virtual uint64_t  getSymbolSize(DataRefImpl Symb) const = 0;
 117   virtual char      getSymbolNMTypeChar(DataRefImpl Symb) const = 0;
 118   virtual bool      isSymbolInternal(DataRefImpl Symb) const = 0;
 119
 120   // Same as above for SectionRef.
 121   friend class SectionRef;
 122   virtual SectionRef getSectionNext(DataRefImpl Sec) const = 0;
 123   virtual StringRef  getSectionName(DataRefImpl Sec) const = 0;
 124   virtual uint64_t   getSectionAddress(DataRefImpl Sec) const = 0;
 125   virtual uint64_t   getSectionSize(DataRefImpl Sec) const = 0;
 126   virtual StringRef  getSectionContents(DataRefImpl Sec) const = 0;
 127   virtual bool       isSectionText(DataRefImpl Sec) const = 0;
 128
 129
 130 public:
 131   template<class content_type>
 132   class content_iterator {
 133     content_type Current;
 134   public:
 135     content_iterator(content_type symb)
 136       : Current(symb) {}
 137
 138     const content_type* operator->() const {
 139       return &Current;
 140     }
 141
 142     bool operator==(const content_iterator &other) const {
 143       return Current == other.Current;
 144     }
 145
 146     bool operator!=(const content_iterator &other) const {
 147       return !(*this == other);
 148     }
 149
 150     content_iterator& operator++() {  // Preincrement
 151       Current = Current.getNext();
 152       return *this;
 153     }
 154   };
 155
 156   typedef content_iterator<SymbolRef> symbol_iterator;
 157   typedef content_iterator<SectionRef> section_iterator;
 158
 159   virtual ~ObjectFile();
 160
 161   virtual symbol_iterator begin_symbols() const = 0;
 162   virtual symbol_iterator end_symbols() const = 0;
 163
 164   virtual section_iterator begin_sections() const = 0;
 165   virtual section_iterator end_sections() const = 0;
 166
 167   /// @brief The number of bytes used to represent an address in this object
 168   ///        file format.
 169   virtual uint8_t getBytesInAddress() const = 0;
 170
 171   virtual StringRef getFileFormatName() const = 0;
 172   virtual /* Triple::ArchType */ unsigned getArch() const = 0;
 173
 174   StringRef getFilename() const;
 175
 176   /// @returns Pointer to ObjectFile subclass to handle this type of object.
 177   /// @param ObjectPath The path to the object file. ObjectPath.isObject must
 178   ///        return true.
 179   /// @brief Create ObjectFile from path.
 180   static ObjectFile *createObjectFile(StringRef ObjectPath);
 181   static ObjectFile *createObjectFile(MemoryBuffer *Object);
 182
 183 private:
 184   static ObjectFile *createCOFFObjectFile(MemoryBuffer *Object);
 185   static ObjectFile *createELFObjectFile(MemoryBuffer *Object);
 186   static ObjectFile *createMachOObjectFile(MemoryBuffer *Object);
 187   static ObjectFile *createArchiveObjectFile(MemoryBuffer *Object);
 188   static ObjectFile *createLibObjectFile(MemoryBuffer *Object);
 189 };
 190
 191 // Inline function definitions.
 192 inline SymbolRef::SymbolRef(DataRefImpl SymbolP, const ObjectFile *Owner)
 193   : SymbolPimpl(SymbolP)
 194   , OwningObject(Owner) {}
 195
 196 inline bool SymbolRef::operator==(const SymbolRef &Other) const {
 197   return SymbolPimpl == Other.SymbolPimpl;
 198 }
 199
 200 inline SymbolRef SymbolRef::getNext() const {
 201   return OwningObject->getSymbolNext(SymbolPimpl);
 202 }
 203
 204 inline StringRef SymbolRef::getName() const {
 205   return OwningObject->getSymbolName(SymbolPimpl);
 206 }
 207
 208 inline uint64_t SymbolRef::getAddress() const {
 209   return OwningObject->getSymbolAddress(SymbolPimpl);
 210 }
 211
 212 inline uint64_t SymbolRef::getSize() const {
 213   return OwningObject->getSymbolSize(SymbolPimpl);
 214 }
 215
 216 inline char SymbolRef::getNMTypeChar() const {
 217   return OwningObject->getSymbolNMTypeChar(SymbolPimpl);
 218 }
 219
 220 inline bool SymbolRef::isInternal() const {
 221   return OwningObject->isSymbolInternal(SymbolPimpl);
 222 }
 223
 224
 225 /// SectionRef
 226 inline SectionRef::SectionRef(DataRefImpl SectionP,
 227                               const ObjectFile *Owner)
 228   : SectionPimpl(SectionP)
 229   , OwningObject(Owner) {}
 230
 231 inline bool SectionRef::operator==(const SectionRef &Other) const {
 232   return SectionPimpl == Other.SectionPimpl;
 233 }
 234
 235 inline SectionRef SectionRef::getNext() const {
 236   return OwningObject->getSectionNext(SectionPimpl);
 237 }
 238
 239 inline StringRef SectionRef::getName() const {
 240   return OwningObject->getSectionName(SectionPimpl);
 241 }
 242
 243 inline uint64_t SectionRef::getAddress() const {
 244   return OwningObject->getSectionAddress(SectionPimpl);
 245 }
 246
 247 inline uint64_t SectionRef::getSize() const {
 248   return OwningObject->getSectionSize(SectionPimpl);
 249 }
 250
 251 inline StringRef SectionRef::getContents() const {
 252   return OwningObject->getSectionContents(SectionPimpl);
 253 }
 254
 255 inline bool SectionRef::isText() const {
 256   return OwningObject->isSectionText(SectionPimpl);
 257 }
 258
 259 } // end namespace object
 260 } // end namespace llvm
 261
 262 #endif