contrib/llvm/include/llvm/Object/MachOObject.h

   1 //===- MachOObject.h - Mach-O Object File Wrapper ---------------*- 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 #ifndef LLVM_OBJECT_MACHOOBJECT_H
  11 #define LLVM_OBJECT_MACHOOBJECT_H
  12
  13 #include <string>
  14 #include "llvm/ADT/InMemoryStruct.h"
  15 #include "llvm/ADT/OwningPtr.h"
  16 #include "llvm/ADT/StringRef.h"
  17 #include "llvm/Object/MachOFormat.h"
  18
  19 namespace llvm {
  20
  21 class MemoryBuffer;
  22 class raw_ostream;
  23
  24 namespace object {
  25
  26 /// \brief Wrapper object for manipulating Mach-O object files.
  27 ///
  28 /// This class is designed to implement a full-featured, efficient, portable,
  29 /// and robust Mach-O interface to Mach-O object files. It does not attempt to
  30 /// smooth over rough edges in the Mach-O format or generalize access to object
  31 /// independent features.
  32 ///
  33 /// The class is designed around accessing the Mach-O object which is expected
  34 /// to be fully loaded into memory.
  35 ///
  36 /// This class is *not* suitable for concurrent use. For efficient operation,
  37 /// the class uses APIs which rely on the ability to cache the results of
  38 /// certain calls in internal objects which are not safe for concurrent
  39 /// access. This allows the API to be zero-copy on the common paths.
  40 //
  41 // FIXME: It would be cool if we supported a "paged" MemoryBuffer
  42 // implementation. This would allow us to implement a more sensible version of
  43 // MemoryObject which can work like a MemoryBuffer, but be more efficient for
  44 // objects which are in the current address space.
  45 class MachOObject {
  46 public:
  47   struct LoadCommandInfo {
  48     /// The load command information.
  49     macho::LoadCommand Command;
  50
  51     /// The offset to the start of the load command in memory.
  52     uint64_t Offset;
  53   };
  54
  55 private:
  56   OwningPtr<MemoryBuffer> Buffer;
  57
  58   /// Whether the object is little endian.
  59   bool IsLittleEndian;
  60   /// Whether the object is 64-bit.
  61   bool Is64Bit;
  62   /// Whether the object is swapped endianness from the host.
  63   bool IsSwappedEndian;
  64   /// Whether the string table has been registered.
  65   bool HasStringTable;
  66
  67   /// The cached information on the load commands.
  68   LoadCommandInfo *LoadCommands;
  69   mutable unsigned NumLoadedCommands;
  70
  71   /// The cached copy of the header.
  72   macho::Header Header;
  73   macho::Header64Ext Header64Ext;
  74
  75   /// Cache string table information.
  76   StringRef StringTable;
  77
  78 private:
  79   MachOObject(MemoryBuffer *Buffer, bool IsLittleEndian, bool Is64Bit);
  80
  81 public:
  82   ~MachOObject();
  83
  84   /// \brief Load a Mach-O object from a MemoryBuffer object.
  85   ///
  86   /// \param Buffer - The buffer to load the object from. This routine takes
  87   /// exclusive ownership of the buffer (which is passed to the returned object
  88   /// on success).
  89   /// \param ErrorStr [out] - If given, will be set to a user readable error
  90   /// message on failure.
  91   /// \returns The loaded object, or null on error.
  92   static MachOObject *LoadFromBuffer(MemoryBuffer *Buffer,
  93                                      std::string *ErrorStr = 0);
  94
  95   /// @name File Information
  96   /// @{
  97
  98   bool isLittleEndian() const { return IsLittleEndian; }
  99   bool isSwappedEndian() const { return IsSwappedEndian; }
 100   bool is64Bit() const { return Is64Bit; }
 101
 102   unsigned getHeaderSize() const {
 103     return Is64Bit ? macho::Header64Size : macho::Header32Size;
 104   }
 105
 106   StringRef getData(size_t Offset, size_t Size) const;
 107
 108   /// @}
 109   /// @name String Table Data
 110   /// @{
 111
 112   StringRef getStringTableData() const {
 113     assert(HasStringTable && "String table has not been registered!");
 114     return StringTable;
 115   }
 116
 117   StringRef getStringAtIndex(unsigned Index) const {
 118     size_t End = getStringTableData().find('\0', Index);
 119     return getStringTableData().slice(Index, End);
 120   }
 121
 122   void RegisterStringTable(macho::SymtabLoadCommand &SLC);
 123
 124   /// @}
 125   /// @name Object Header Access
 126   /// @{
 127
 128   const macho::Header &getHeader() const { return Header; }
 129   const macho::Header64Ext &getHeader64Ext() const {
 130     assert(is64Bit() && "Invalid access!");
 131     return Header64Ext;
 132   }
 133
 134   /// @}
 135   /// @name Object Structure Access
 136   /// @{
 137
 138   /// \brief Retrieve the information for the given load command.
 139   const LoadCommandInfo &getLoadCommandInfo(unsigned Index) const;
 140
 141   void ReadSegmentLoadCommand(
 142     const LoadCommandInfo &LCI,
 143     InMemoryStruct<macho::SegmentLoadCommand> &Res) const;
 144   void ReadSegment64LoadCommand(
 145     const LoadCommandInfo &LCI,
 146     InMemoryStruct<macho::Segment64LoadCommand> &Res) const;
 147   void ReadSymtabLoadCommand(
 148     const LoadCommandInfo &LCI,
 149     InMemoryStruct<macho::SymtabLoadCommand> &Res) const;
 150   void ReadDysymtabLoadCommand(
 151     const LoadCommandInfo &LCI,
 152     InMemoryStruct<macho::DysymtabLoadCommand> &Res) const;
 153   void ReadLinkeditDataLoadCommand(
 154     const LoadCommandInfo &LCI,
 155     InMemoryStruct<macho::LinkeditDataLoadCommand> &Res) const;
 156   void ReadIndirectSymbolTableEntry(
 157     const macho::DysymtabLoadCommand &DLC,
 158     unsigned Index,
 159     InMemoryStruct<macho::IndirectSymbolTableEntry> &Res) const;
 160   void ReadSection(
 161     const LoadCommandInfo &LCI,
 162     unsigned Index,
 163     InMemoryStruct<macho::Section> &Res) const;
 164   void ReadSection64(
 165     const LoadCommandInfo &LCI,
 166     unsigned Index,
 167     InMemoryStruct<macho::Section64> &Res) const;
 168   void ReadRelocationEntry(
 169     uint64_t RelocationTableOffset, unsigned Index,
 170     InMemoryStruct<macho::RelocationEntry> &Res) const;
 171   void ReadSymbolTableEntry(
 172     uint64_t SymbolTableOffset, unsigned Index,
 173     InMemoryStruct<macho::SymbolTableEntry> &Res) const;
 174   void ReadSymbol64TableEntry(
 175     uint64_t SymbolTableOffset, unsigned Index,
 176     InMemoryStruct<macho::Symbol64TableEntry> &Res) const;
 177   void ReadULEB128s(uint64_t Index, SmallVectorImpl<uint64_t> &Out) const;
 178
 179   /// @}
 180
 181   /// @name Object Dump Facilities
 182   /// @{
 183   /// dump - Support for debugging, callable in GDB: V->dump()
 184   //
 185   void dump() const;
 186   void dumpHeader() const;
 187
 188   /// print - Implement operator<< on Value.
 189   ///
 190   void print(raw_ostream &O) const;
 191   void printHeader(raw_ostream &O) const;
 192
 193   /// @}
 194 };
 195
 196 inline raw_ostream &operator<<(raw_ostream &OS, const MachOObject &V) {
 197   V.print(OS);
 198   return OS;
 199 }
 200
 201 } // end namespace object
 202 } // end namespace llvm
 203
 204 #endif