Home | History | Annotate | Download | only in Object 
      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_OBJECTFILE_H
     15 #define LLVM_OBJECT_OBJECTFILE_H
     16 
     17 #include "llvm/ADT/StringRef.h"
     18 #include "llvm/Object/Binary.h"
     19 #include "llvm/Support/DataTypes.h"
     20 #include "llvm/Support/ErrorHandling.h"
     21 #include "llvm/Support/MemoryBuffer.h"
     22 #include <cstring>
     23 #include <vector>
     24 
     25 namespace llvm {
     26 namespace object {
     27 
     28 class ObjectFile;
     29 
     30 union DataRefImpl {
     31   struct {
     32     // ELF needs this for relocations. This entire union should probably be a
     33     // char[max(8, sizeof(uintptr_t))] and require the impl to cast.
     34     uint16_t a, b;
     35     uint32_t c;
     36   } w;
     37   struct {
     38     uint32_t a, b;
     39   } d;
     40   uintptr_t p;
     41   DataRefImpl() {
     42     std::memset(this, 0, sizeof(DataRefImpl));
     43   }
     44 };
     45 
     46 template<class content_type>
     47 class content_iterator {
     48   content_type Current;
     49 public:
     50   content_iterator(content_type symb)
     51     : Current(symb) {}
     52 
     53   const content_type* operator->() const {
     54     return &Current;
     55   }
     56 
     57   const content_type &operator*() const {
     58     return Current;
     59   }
     60 
     61   bool operator==(const content_iterator &other) const {
     62     return Current == other.Current;
     63   }
     64 
     65   bool operator!=(const content_iterator &other) const {
     66     return !(*this == other);
     67   }
     68 
     69   content_iterator& increment(error_code &err) {
     70     content_type next;
     71     if (error_code ec = Current.getNext(next))
     72       err = ec;
     73     else
     74       Current = next;
     75     return *this;
     76   }
     77 };
     78 
     79 inline bool operator==(const DataRefImpl &a, const DataRefImpl &b) {
     80   // Check bitwise identical. This is the only legal way to compare a union w/o
     81   // knowing which member is in use.
     82   return std::memcmp(&a, &b, sizeof(DataRefImpl)) == 0;
     83 }
     84 
     85 inline bool operator<(const DataRefImpl &a, const DataRefImpl &b) {
     86   // Check bitwise identical. This is the only legal way to compare a union w/o
     87   // knowing which member is in use.
     88   return std::memcmp(&a, &b, sizeof(DataRefImpl)) < 0;
     89 }
     90 
     91 class SymbolRef;
     92 
     93 /// RelocationRef - This is a value type class that represents a single
     94 /// relocation in the list of relocations in the object file.
     95 class RelocationRef {
     96   DataRefImpl RelocationPimpl;
     97   const ObjectFile *OwningObject;
     98 
     99 public:
    100   RelocationRef() : OwningObject(NULL) { }
    101 
    102   RelocationRef(DataRefImpl RelocationP, const ObjectFile *Owner);
    103 
    104   bool operator==(const RelocationRef &Other) const;
    105 
    106   error_code getNext(RelocationRef &Result) const;
    107 
    108   error_code getAddress(uint64_t &Result) const;
    109   error_code getOffset(uint64_t &Result) const;
    110   error_code getSymbol(SymbolRef &Result) const;
    111   error_code getType(uint64_t &Result) const;
    112 
    113   /// @brief Indicates whether this relocation should hidden when listing
    114   /// relocations, usually because it is the trailing part of a multipart
    115   /// relocation that will be printed as part of the leading relocation.
    116   error_code getHidden(bool &Result) const;
    117 
    118   /// @brief Get a string that represents the type of this relocation.
    119   ///
    120   /// This is for display purposes only.
    121   error_code getTypeName(SmallVectorImpl<char> &Result) const;
    122   error_code getAdditionalInfo(int64_t &Result) const;
    123 
    124   /// @brief Get a string that represents the calculation of the value of this
    125   ///        relocation.
    126   ///
    127   /// This is for display purposes only.
    128   error_code getValueString(SmallVectorImpl<char> &Result) const;
    129 
    130   DataRefImpl getRawDataRefImpl() const;
    131 };
    132 typedef content_iterator<RelocationRef> relocation_iterator;
    133 
    134 /// SectionRef - This is a value type class that represents a single section in
    135 /// the list of sections in the object file.
    136 class SectionRef {
    137   friend class SymbolRef;
    138   DataRefImpl SectionPimpl;
    139   const ObjectFile *OwningObject;
    140 
    141 public:
    142   SectionRef() : OwningObject(NULL) { }
    143 
    144   SectionRef(DataRefImpl SectionP, const ObjectFile *Owner);
    145 
    146   bool operator==(const SectionRef &Other) const;
    147   bool operator<(const SectionRef &Other) const;
    148 
    149   error_code getNext(SectionRef &Result) const;
    150 
    151   error_code getName(StringRef &Result) const;
    152   error_code getAddress(uint64_t &Result) const;
    153   error_code getSize(uint64_t &Result) const;
    154   error_code getContents(StringRef &Result) const;
    155 
    156   /// @brief Get the alignment of this section as the actual value (not log 2).
    157   error_code getAlignment(uint64_t &Result) const;
    158 
    159   // FIXME: Move to the normalization layer when it's created.
    160   error_code isText(bool &Result) const;
    161   error_code isData(bool &Result) const;
    162   error_code isBSS(bool &Result) const;
    163   error_code isRequiredForExecution(bool &Result) const;
    164   error_code isVirtual(bool &Result) const;
    165   error_code isZeroInit(bool &Result) const;
    166   error_code isReadOnlyData(bool &Result) const;
    167 
    168   error_code containsSymbol(SymbolRef S, bool &Result) const;
    169 
    170   relocation_iterator begin_relocations() const;
    171   relocation_iterator end_relocations() const;
    172 
    173   DataRefImpl getRawDataRefImpl() const;
    174 };
    175 typedef content_iterator<SectionRef> section_iterator;
    176 
    177 /// SymbolRef - This is a value type class that represents a single symbol in
    178 /// the list of symbols in the object file.
    179 class SymbolRef {
    180   friend class SectionRef;
    181   DataRefImpl SymbolPimpl;
    182   const ObjectFile *OwningObject;
    183 
    184 public:
    185   SymbolRef() : OwningObject(NULL) { }
    186 
    187   enum Type {
    188     ST_Unknown, // Type not specified
    189     ST_Data,
    190     ST_Debug,
    191     ST_File,
    192     ST_Function,
    193     ST_Other
    194   };
    195 
    196   enum Flags {
    197     SF_None            = 0,
    198     SF_Undefined       = 1U << 0,  // Symbol is defined in another object file
    199     SF_Global          = 1U << 1,  // Global symbol
    200     SF_Weak            = 1U << 2,  // Weak symbol
    201     SF_Absolute        = 1U << 3,  // Absolute symbol
    202     SF_ThreadLocal     = 1U << 4,  // Thread local symbol
    203     SF_Common          = 1U << 5,  // Symbol has common linkage
    204     SF_FormatSpecific  = 1U << 31  // Specific to the object file format
    205                                    // (e.g. section symbols)
    206   };
    207 
    208   SymbolRef(DataRefImpl SymbolP, const ObjectFile *Owner);
    209 
    210   bool operator==(const SymbolRef &Other) const;
    211   bool operator<(const SymbolRef &Other) const;
    212 
    213   error_code getNext(SymbolRef &Result) const;
    214 
    215   error_code getName(StringRef &Result) const;
    216   /// Returns the symbol virtual address (i.e. address at which it will be
    217   /// mapped).
    218   error_code getAddress(uint64_t &Result) const;
    219   error_code getFileOffset(uint64_t &Result) const;
    220   error_code getSize(uint64_t &Result) const;
    221   error_code getType(SymbolRef::Type &Result) const;
    222 
    223   /// Returns the ascii char that should be displayed in a symbol table dump via
    224   /// nm for this symbol.
    225   error_code getNMTypeChar(char &Result) const;
    226 
    227   /// Get symbol flags (bitwise OR of SymbolRef::Flags)
    228   error_code getFlags(uint32_t &Result) const;
    229 
    230   /// @brief Return true for common symbols such as uninitialized globals
    231   error_code isCommon(bool &Result) const;
    232 
    233   /// @brief Get section this symbol is defined in reference to. Result is
    234   /// end_sections() if it is undefined or is an absolute symbol.
    235   error_code getSection(section_iterator &Result) const;
    236 
    237   /// @brief Get value of the symbol in the symbol table.
    238   error_code getValue(uint64_t &Val) const;
    239 
    240   DataRefImpl getRawDataRefImpl() const;
    241 };
    242 typedef content_iterator<SymbolRef> symbol_iterator;
    243 
    244 /// LibraryRef - This is a value type class that represents a single library in
    245 /// the list of libraries needed by a shared or dynamic object.
    246 class LibraryRef {
    247   friend class SectionRef;
    248   DataRefImpl LibraryPimpl;
    249   const ObjectFile *OwningObject;
    250 
    251 public:
    252   LibraryRef() : OwningObject(NULL) { }
    253 
    254   LibraryRef(DataRefImpl LibraryP, const ObjectFile *Owner);
    255 
    256   bool operator==(const LibraryRef &Other) const;
    257   bool operator<(const LibraryRef &Other) const;
    258 
    259   error_code getNext(LibraryRef &Result) const;
    260 
    261   // Get the path to this library, as stored in the object file.
    262   error_code getPath(StringRef &Result) const;
    263 
    264   DataRefImpl getRawDataRefImpl() const;
    265 };
    266 typedef content_iterator<LibraryRef> library_iterator;
    267 
    268 const uint64_t UnknownAddressOrSize = ~0ULL;
    269 
    270 /// ObjectFile - This class is the base class for all object file types.
    271 /// Concrete instances of this object are created by createObjectFile, which
    272 /// figures out which type to create.
    273 class ObjectFile : public Binary {
    274   virtual void anchor();
    275   ObjectFile() LLVM_DELETED_FUNCTION;
    276   ObjectFile(const ObjectFile &other) LLVM_DELETED_FUNCTION;
    277 
    278 protected:
    279   ObjectFile(unsigned int Type, MemoryBuffer *source, error_code &ec);
    280 
    281   const uint8_t *base() const {
    282     return reinterpret_cast<const uint8_t *>(Data->getBufferStart());
    283   }
    284 
    285   // These functions are for SymbolRef to call internally. The main goal of
    286   // this is to allow SymbolRef::SymbolPimpl to point directly to the symbol
    287   // entry in the memory mapped object file. SymbolPimpl cannot contain any
    288   // virtual functions because then it could not point into the memory mapped
    289   // file.
    290   //
    291   // Implementations assume that the DataRefImpl is valid and has not been
    292   // modified externally. It's UB otherwise.
    293   friend class SymbolRef;
    294   virtual error_code getSymbolNext(DataRefImpl Symb, SymbolRef &Res) const = 0;
    295   virtual error_code getSymbolName(DataRefImpl Symb, StringRef &Res) const = 0;
    296   virtual error_code getSymbolAddress(DataRefImpl Symb, uint64_t &Res) const = 0;
    297   virtual error_code getSymbolFileOffset(DataRefImpl Symb, uint64_t &Res)const=0;
    298   virtual error_code getSymbolSize(DataRefImpl Symb, uint64_t &Res) const = 0;
    299   virtual error_code getSymbolType(DataRefImpl Symb,
    300                                    SymbolRef::Type &Res) const = 0;
    301   virtual error_code getSymbolNMTypeChar(DataRefImpl Symb, char &Res) const = 0;
    302   virtual error_code getSymbolFlags(DataRefImpl Symb,
    303                                     uint32_t &Res) const = 0;
    304   virtual error_code getSymbolSection(DataRefImpl Symb,
    305                                       section_iterator &Res) const = 0;
    306   virtual error_code getSymbolValue(DataRefImpl Symb, uint64_t &Val) const = 0;
    307 
    308   // Same as above for SectionRef.
    309   friend class SectionRef;
    310   virtual error_code getSectionNext(DataRefImpl Sec, SectionRef &Res) const = 0;
    311   virtual error_code getSectionName(DataRefImpl Sec, StringRef &Res) const = 0;
    312   virtual error_code getSectionAddress(DataRefImpl Sec, uint64_t &Res) const =0;
    313   virtual error_code getSectionSize(DataRefImpl Sec, uint64_t &Res) const = 0;
    314   virtual error_code getSectionContents(DataRefImpl Sec, StringRef &Res)const=0;
    315   virtual error_code getSectionAlignment(DataRefImpl Sec, uint64_t &Res)const=0;
    316   virtual error_code isSectionText(DataRefImpl Sec, bool &Res) const = 0;
    317   virtual error_code isSectionData(DataRefImpl Sec, bool &Res) const = 0;
    318   virtual error_code isSectionBSS(DataRefImpl Sec, bool &Res) const = 0;
    319   virtual error_code isSectionRequiredForExecution(DataRefImpl Sec,
    320                                                    bool &Res) const = 0;
    321   // A section is 'virtual' if its contents aren't present in the object image.
    322   virtual error_code isSectionVirtual(DataRefImpl Sec, bool &Res) const = 0;
    323   virtual error_code isSectionZeroInit(DataRefImpl Sec, bool &Res) const = 0;
    324   virtual error_code isSectionReadOnlyData(DataRefImpl Sec, bool &Res) const =0;
    325   virtual error_code sectionContainsSymbol(DataRefImpl Sec, DataRefImpl Symb,
    326                                            bool &Result) const = 0;
    327   virtual relocation_iterator getSectionRelBegin(DataRefImpl Sec) const = 0;
    328   virtual relocation_iterator getSectionRelEnd(DataRefImpl Sec) const = 0;
    329 
    330 
    331   // Same as above for RelocationRef.
    332   friend class RelocationRef;
    333   virtual error_code getRelocationNext(DataRefImpl Rel,
    334                                        RelocationRef &Res) const = 0;
    335   virtual error_code getRelocationAddress(DataRefImpl Rel,
    336                                           uint64_t &Res) const =0;
    337   virtual error_code getRelocationOffset(DataRefImpl Rel,
    338                                          uint64_t &Res) const =0;
    339   virtual error_code getRelocationSymbol(DataRefImpl Rel,
    340                                          SymbolRef &Res) const = 0;
    341   virtual error_code getRelocationType(DataRefImpl Rel,
    342                                        uint64_t &Res) const = 0;
    343   virtual error_code getRelocationTypeName(DataRefImpl Rel,
    344                                        SmallVectorImpl<char> &Result) const = 0;
    345   virtual error_code getRelocationAdditionalInfo(DataRefImpl Rel,
    346                                                  int64_t &Res) const = 0;
    347   virtual error_code getRelocationValueString(DataRefImpl Rel,
    348                                        SmallVectorImpl<char> &Result) const = 0;
    349   virtual error_code getRelocationHidden(DataRefImpl Rel, bool &Result) const {
    350     Result = false;
    351     return object_error::success;
    352   }
    353 
    354   // Same for LibraryRef
    355   friend class LibraryRef;
    356   virtual error_code getLibraryNext(DataRefImpl Lib, LibraryRef &Res) const = 0;
    357   virtual error_code getLibraryPath(DataRefImpl Lib, StringRef &Res) const = 0;
    358 
    359 public:
    360 
    361   virtual symbol_iterator begin_symbols() const = 0;
    362   virtual symbol_iterator end_symbols() const = 0;
    363 
    364   virtual symbol_iterator begin_dynamic_symbols() const = 0;
    365   virtual symbol_iterator end_dynamic_symbols() const = 0;
    366 
    367   virtual section_iterator begin_sections() const = 0;
    368   virtual section_iterator end_sections() const = 0;
    369 
    370   virtual library_iterator begin_libraries_needed() const = 0;
    371   virtual library_iterator end_libraries_needed() const = 0;
    372 
    373   /// @brief The number of bytes used to represent an address in this object
    374   ///        file format.
    375   virtual uint8_t getBytesInAddress() const = 0;
    376 
    377   virtual StringRef getFileFormatName() const = 0;
    378   virtual /* Triple::ArchType */ unsigned getArch() const = 0;
    379 
    380   /// For shared objects, returns the name which this object should be
    381   /// loaded from at runtime. This corresponds to DT_SONAME on ELF and
    382   /// LC_ID_DYLIB (install name) on MachO.
    383   virtual StringRef getLoadName() const = 0;
    384 
    385   /// @returns Pointer to ObjectFile subclass to handle this type of object.
    386   /// @param ObjectPath The path to the object file. ObjectPath.isObject must
    387   ///        return true.
    388   /// @brief Create ObjectFile from path.
    389   static ObjectFile *createObjectFile(StringRef ObjectPath);
    390   static ObjectFile *createObjectFile(MemoryBuffer *Object);
    391 
    392   static inline bool classof(const Binary *v) {
    393     return v->isObject();
    394   }
    395 
    396 public:
    397   static ObjectFile *createCOFFObjectFile(MemoryBuffer *Object);
    398   static ObjectFile *createELFObjectFile(MemoryBuffer *Object);
    399   static ObjectFile *createMachOObjectFile(MemoryBuffer *Object);
    400 };
    401 
    402 // Inline function definitions.
    403 inline SymbolRef::SymbolRef(DataRefImpl SymbolP, const ObjectFile *Owner)
    404   : SymbolPimpl(SymbolP)
    405   , OwningObject(Owner) {}
    406 
    407 inline bool SymbolRef::operator==(const SymbolRef &Other) const {
    408   return SymbolPimpl == Other.SymbolPimpl;
    409 }
    410 
    411 inline bool SymbolRef::operator<(const SymbolRef &Other) const {
    412   return SymbolPimpl < Other.SymbolPimpl;
    413 }
    414 
    415 inline error_code SymbolRef::getNext(SymbolRef &Result) const {
    416   return OwningObject->getSymbolNext(SymbolPimpl, Result);
    417 }
    418 
    419 inline error_code SymbolRef::getName(StringRef &Result) const {
    420   return OwningObject->getSymbolName(SymbolPimpl, Result);
    421 }
    422 
    423 inline error_code SymbolRef::getAddress(uint64_t &Result) const {
    424   return OwningObject->getSymbolAddress(SymbolPimpl, Result);
    425 }
    426 
    427 inline error_code SymbolRef::getFileOffset(uint64_t &Result) const {
    428   return OwningObject->getSymbolFileOffset(SymbolPimpl, Result);
    429 }
    430 
    431 inline error_code SymbolRef::getSize(uint64_t &Result) const {
    432   return OwningObject->getSymbolSize(SymbolPimpl, Result);
    433 }
    434 
    435 inline error_code SymbolRef::getNMTypeChar(char &Result) const {
    436   return OwningObject->getSymbolNMTypeChar(SymbolPimpl, Result);
    437 }
    438 
    439 inline error_code SymbolRef::getFlags(uint32_t &Result) const {
    440   return OwningObject->getSymbolFlags(SymbolPimpl, Result);
    441 }
    442 
    443 inline error_code SymbolRef::getSection(section_iterator &Result) const {
    444   return OwningObject->getSymbolSection(SymbolPimpl, Result);
    445 }
    446 
    447 inline error_code SymbolRef::getType(SymbolRef::Type &Result) const {
    448   return OwningObject->getSymbolType(SymbolPimpl, Result);
    449 }
    450 
    451 inline error_code SymbolRef::getValue(uint64_t &Val) const {
    452   return OwningObject->getSymbolValue(SymbolPimpl, Val);
    453 }
    454 
    455 inline DataRefImpl SymbolRef::getRawDataRefImpl() const {
    456   return SymbolPimpl;
    457 }
    458 
    459 
    460 /// SectionRef
    461 inline SectionRef::SectionRef(DataRefImpl SectionP,
    462                               const ObjectFile *Owner)
    463   : SectionPimpl(SectionP)
    464   , OwningObject(Owner) {}
    465 
    466 inline bool SectionRef::operator==(const SectionRef &Other) const {
    467   return SectionPimpl == Other.SectionPimpl;
    468 }
    469 
    470 inline bool SectionRef::operator<(const SectionRef &Other) const {
    471   return SectionPimpl < Other.SectionPimpl;
    472 }
    473 
    474 inline error_code SectionRef::getNext(SectionRef &Result) const {
    475   return OwningObject->getSectionNext(SectionPimpl, Result);
    476 }
    477 
    478 inline error_code SectionRef::getName(StringRef &Result) const {
    479   return OwningObject->getSectionName(SectionPimpl, Result);
    480 }
    481 
    482 inline error_code SectionRef::getAddress(uint64_t &Result) const {
    483   return OwningObject->getSectionAddress(SectionPimpl, Result);
    484 }
    485 
    486 inline error_code SectionRef::getSize(uint64_t &Result) const {
    487   return OwningObject->getSectionSize(SectionPimpl, Result);
    488 }
    489 
    490 inline error_code SectionRef::getContents(StringRef &Result) const {
    491   return OwningObject->getSectionContents(SectionPimpl, Result);
    492 }
    493 
    494 inline error_code SectionRef::getAlignment(uint64_t &Result) const {
    495   return OwningObject->getSectionAlignment(SectionPimpl, Result);
    496 }
    497 
    498 inline error_code SectionRef::isText(bool &Result) const {
    499   return OwningObject->isSectionText(SectionPimpl, Result);
    500 }
    501 
    502 inline error_code SectionRef::isData(bool &Result) const {
    503   return OwningObject->isSectionData(SectionPimpl, Result);
    504 }
    505 
    506 inline error_code SectionRef::isBSS(bool &Result) const {
    507   return OwningObject->isSectionBSS(SectionPimpl, Result);
    508 }
    509 
    510 inline error_code SectionRef::isRequiredForExecution(bool &Result) const {
    511   return OwningObject->isSectionRequiredForExecution(SectionPimpl, Result);
    512 }
    513 
    514 inline error_code SectionRef::isVirtual(bool &Result) const {
    515   return OwningObject->isSectionVirtual(SectionPimpl, Result);
    516 }
    517 
    518 inline error_code SectionRef::isZeroInit(bool &Result) const {
    519   return OwningObject->isSectionZeroInit(SectionPimpl, Result);
    520 }
    521 
    522 inline error_code SectionRef::isReadOnlyData(bool &Result) const {
    523   return OwningObject->isSectionReadOnlyData(SectionPimpl, Result);
    524 }
    525 
    526 inline error_code SectionRef::containsSymbol(SymbolRef S, bool &Result) const {
    527   return OwningObject->sectionContainsSymbol(SectionPimpl, S.SymbolPimpl,
    528                                              Result);
    529 }
    530 
    531 inline relocation_iterator SectionRef::begin_relocations() const {
    532   return OwningObject->getSectionRelBegin(SectionPimpl);
    533 }
    534 
    535 inline relocation_iterator SectionRef::end_relocations() const {
    536   return OwningObject->getSectionRelEnd(SectionPimpl);
    537 }
    538 
    539 inline DataRefImpl SectionRef::getRawDataRefImpl() const {
    540   return SectionPimpl;
    541 }
    542 
    543 /// RelocationRef
    544 inline RelocationRef::RelocationRef(DataRefImpl RelocationP,
    545                               const ObjectFile *Owner)
    546   : RelocationPimpl(RelocationP)
    547   , OwningObject(Owner) {}
    548 
    549 inline bool RelocationRef::operator==(const RelocationRef &Other) const {
    550   return RelocationPimpl == Other.RelocationPimpl;
    551 }
    552 
    553 inline error_code RelocationRef::getNext(RelocationRef &Result) const {
    554   return OwningObject->getRelocationNext(RelocationPimpl, Result);
    555 }
    556 
    557 inline error_code RelocationRef::getAddress(uint64_t &Result) const {
    558   return OwningObject->getRelocationAddress(RelocationPimpl, Result);
    559 }
    560 
    561 inline error_code RelocationRef::getOffset(uint64_t &Result) const {
    562   return OwningObject->getRelocationOffset(RelocationPimpl, Result);
    563 }
    564 
    565 inline error_code RelocationRef::getSymbol(SymbolRef &Result) const {
    566   return OwningObject->getRelocationSymbol(RelocationPimpl, Result);
    567 }
    568 
    569 inline error_code RelocationRef::getType(uint64_t &Result) const {
    570   return OwningObject->getRelocationType(RelocationPimpl, Result);
    571 }
    572 
    573 inline error_code RelocationRef::getTypeName(SmallVectorImpl<char> &Result)
    574   const {
    575   return OwningObject->getRelocationTypeName(RelocationPimpl, Result);
    576 }
    577 
    578 inline error_code RelocationRef::getAdditionalInfo(int64_t &Result) const {
    579   return OwningObject->getRelocationAdditionalInfo(RelocationPimpl, Result);
    580 }
    581 
    582 inline error_code RelocationRef::getValueString(SmallVectorImpl<char> &Result)
    583   const {
    584   return OwningObject->getRelocationValueString(RelocationPimpl, Result);
    585 }
    586 
    587 inline error_code RelocationRef::getHidden(bool &Result) const {
    588   return OwningObject->getRelocationHidden(RelocationPimpl, Result);
    589 }
    590 
    591 inline DataRefImpl RelocationRef::getRawDataRefImpl() const {
    592   return RelocationPimpl;
    593 }
    594 
    595 // Inline function definitions.
    596 inline LibraryRef::LibraryRef(DataRefImpl LibraryP, const ObjectFile *Owner)
    597   : LibraryPimpl(LibraryP)
    598   , OwningObject(Owner) {}
    599 
    600 inline bool LibraryRef::operator==(const LibraryRef &Other) const {
    601   return LibraryPimpl == Other.LibraryPimpl;
    602 }
    603 
    604 inline bool LibraryRef::operator<(const LibraryRef &Other) const {
    605   return LibraryPimpl < Other.LibraryPimpl;
    606 }
    607 
    608 inline error_code LibraryRef::getNext(LibraryRef &Result) const {
    609   return OwningObject->getLibraryNext(LibraryPimpl, Result);
    610 }
    611 
    612 inline error_code LibraryRef::getPath(StringRef &Result) const {
    613   return OwningObject->getLibraryPath(LibraryPimpl, Result);
    614 }
    615 
    616 } // end namespace object
    617 } // end namespace llvm
    618 
    619 #endif
    620