contrib/llvm/include/llvm/Object/SymbolicFile.h

   1 //===- SymbolicFile.h - Interface that only provides symbols ----*- 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 the SymbolicFile interface.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_OBJECT_SYMBOLICFILE_H
  15 #define LLVM_OBJECT_SYMBOLICFILE_H
  16
  17 #include "llvm/ADT/iterator_range.h"
  18 #include "llvm/ADT/StringRef.h"
  19 #include "llvm/Object/Binary.h"
  20 #include "llvm/Support/Error.h"
  21 #include "llvm/Support/FileSystem.h"
  22 #include "llvm/Support/Format.h"
  23 #include "llvm/Support/MemoryBuffer.h"
  24 #include <cinttypes>
  25 #include <cstdint>
  26 #include <cstring>
  27 #include <iterator>
  28 #include <memory>
  29 #include <system_error>
  30
  31 namespace llvm {
  32 namespace object {
  33
  34 union DataRefImpl {
  35   // This entire union should probably be a
  36   // char[max(8, sizeof(uintptr_t))] and require the impl to cast.
  37   struct {
  38     uint32_t a, b;
  39   } d;
  40   uintptr_t p;
  41
  42   DataRefImpl() { std::memset(this, 0, sizeof(DataRefImpl)); }
  43 };
  44
  45 template <typename OStream>
  46 OStream& operator<<(OStream &OS, const DataRefImpl &D) {
  47   OS << "(" << format("0x%08" PRIxPTR, D.p) << " (" << format("0x%08x", D.d.a)
  48      << ", " << format("0x%08x", D.d.b) << "))";
  49   return OS;
  50 }
  51
  52 inline bool operator==(const DataRefImpl &a, const DataRefImpl &b) {
  53   // Check bitwise identical. This is the only legal way to compare a union w/o
  54   // knowing which member is in use.
  55   return std::memcmp(&a, &b, sizeof(DataRefImpl)) == 0;
  56 }
  57
  58 inline bool operator!=(const DataRefImpl &a, const DataRefImpl &b) {
  59   return !operator==(a, b);
  60 }
  61
  62 inline bool operator<(const DataRefImpl &a, const DataRefImpl &b) {
  63   // Check bitwise identical. This is the only legal way to compare a union w/o
  64   // knowing which member is in use.
  65   return std::memcmp(&a, &b, sizeof(DataRefImpl)) < 0;
  66 }
  67
  68 template <class content_type>
  69 class content_iterator
  70     : public std::iterator<std::forward_iterator_tag, content_type> {
  71   content_type Current;
  72
  73 public:
  74   content_iterator(content_type symb) : Current(std::move(symb)) {}
  75
  76   const content_type *operator->() const { return &Current; }
  77
  78   const content_type &operator*() const { return Current; }
  79
  80   bool operator==(const content_iterator &other) const {
  81     return Current == other.Current;
  82   }
  83
  84   bool operator!=(const content_iterator &other) const {
  85     return !(*this == other);
  86   }
  87
  88   content_iterator &operator++() { // preincrement
  89     Current.moveNext();
  90     return *this;
  91   }
  92 };
  93
  94 class SymbolicFile;
  95
  96 /// This is a value type class that represents a single symbol in the list of
  97 /// symbols in the object file.
  98 class BasicSymbolRef {
  99   DataRefImpl SymbolPimpl;
 100   const SymbolicFile *OwningObject = nullptr;
 101
 102 public:
 103   enum Flags : unsigned {
 104     SF_None = 0,
 105     SF_Undefined = 1U << 0,      // Symbol is defined in another object file
 106     SF_Global = 1U << 1,         // Global symbol
 107     SF_Weak = 1U << 2,           // Weak symbol
 108     SF_Absolute = 1U << 3,       // Absolute symbol
 109     SF_Common = 1U << 4,         // Symbol has common linkage
 110     SF_Indirect = 1U << 5,       // Symbol is an alias to another symbol
 111     SF_Exported = 1U << 6,       // Symbol is visible to other DSOs
 112     SF_FormatSpecific = 1U << 7, // Specific to the object file format
 113                                  // (e.g. section symbols)
 114     SF_Thumb = 1U << 8,          // Thumb symbol in a 32-bit ARM binary
 115     SF_Hidden = 1U << 9,         // Symbol has hidden visibility
 116     SF_Const = 1U << 10,         // Symbol value is constant
 117     SF_Executable = 1U << 11,    // Symbol points to an executable section
 118                                  // (IR only)
 119   };
 120
 121   BasicSymbolRef() = default;
 122   BasicSymbolRef(DataRefImpl SymbolP, const SymbolicFile *Owner);
 123
 124   bool operator==(const BasicSymbolRef &Other) const;
 125   bool operator<(const BasicSymbolRef &Other) const;
 126
 127   void moveNext();
 128
 129   std::error_code printName(raw_ostream &OS) const;
 130
 131   /// Get symbol flags (bitwise OR of SymbolRef::Flags)
 132   uint32_t getFlags() const;
 133
 134   DataRefImpl getRawDataRefImpl() const;
 135   const SymbolicFile *getObject() const;
 136 };
 137
 138 using basic_symbol_iterator = content_iterator<BasicSymbolRef>;
 139
 140 class SymbolicFile : public Binary {
 141 public:
 142   SymbolicFile(unsigned int Type, MemoryBufferRef Source);
 143   ~SymbolicFile() override;
 144
 145   // virtual interface.
 146   virtual void moveSymbolNext(DataRefImpl &Symb) const = 0;
 147
 148   virtual std::error_code printSymbolName(raw_ostream &OS,
 149                                           DataRefImpl Symb) const = 0;
 150
 151   virtual uint32_t getSymbolFlags(DataRefImpl Symb) const = 0;
 152
 153   virtual basic_symbol_iterator symbol_begin() const = 0;
 154
 155   virtual basic_symbol_iterator symbol_end() const = 0;
 156
 157   // convenience wrappers.
 158   using basic_symbol_iterator_range = iterator_range<basic_symbol_iterator>;
 159   basic_symbol_iterator_range symbols() const {
 160     return basic_symbol_iterator_range(symbol_begin(), symbol_end());
 161   }
 162
 163   // construction aux.
 164   static Expected<std::unique_ptr<SymbolicFile>>
 165   createSymbolicFile(MemoryBufferRef Object, sys::fs::file_magic Type,
 166                      LLVMContext *Context);
 167
 168   static Expected<std::unique_ptr<SymbolicFile>>
 169   createSymbolicFile(MemoryBufferRef Object) {
 170     return createSymbolicFile(Object, sys::fs::file_magic::unknown, nullptr);
 171   }
 172   static Expected<OwningBinary<SymbolicFile>>
 173   createSymbolicFile(StringRef ObjectPath);
 174
 175   static inline bool classof(const Binary *v) {
 176     return v->isSymbolic();
 177   }
 178 };
 179
 180 inline BasicSymbolRef::BasicSymbolRef(DataRefImpl SymbolP,
 181                                       const SymbolicFile *Owner)
 182     : SymbolPimpl(SymbolP), OwningObject(Owner) {}
 183
 184 inline bool BasicSymbolRef::operator==(const BasicSymbolRef &Other) const {
 185   return SymbolPimpl == Other.SymbolPimpl;
 186 }
 187
 188 inline bool BasicSymbolRef::operator<(const BasicSymbolRef &Other) const {
 189   return SymbolPimpl < Other.SymbolPimpl;
 190 }
 191
 192 inline void BasicSymbolRef::moveNext() {
 193   return OwningObject->moveSymbolNext(SymbolPimpl);
 194 }
 195
 196 inline std::error_code BasicSymbolRef::printName(raw_ostream &OS) const {
 197   return OwningObject->printSymbolName(OS, SymbolPimpl);
 198 }
 199
 200 inline uint32_t BasicSymbolRef::getFlags() const {
 201   return OwningObject->getSymbolFlags(SymbolPimpl);
 202 }
 203
 204 inline DataRefImpl BasicSymbolRef::getRawDataRefImpl() const {
 205   return SymbolPimpl;
 206 }
 207
 208 inline const SymbolicFile *BasicSymbolRef::getObject() const {
 209   return OwningObject;
 210 }
 211
 212 } // end namespace object
 213 } // end namespace llvm
 214
 215 #endif // LLVM_OBJECT_SYMBOLICFILE_H