1 //===- Archive.h - ar archive file format -----------------------*- 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 ar archive file format class. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_OBJECT_ARCHIVE_H 15 #define LLVM_OBJECT_ARCHIVE_H 16 17 #include "llvm/ADT/Optional.h" 18 #include "llvm/ADT/StringRef.h" 19 #include "llvm/ADT/iterator_range.h" 20 #include "llvm/Object/Binary.h" 21 #include "llvm/Support/Chrono.h" 22 #include "llvm/Support/Error.h" 23 #include "llvm/Support/FileSystem.h" 24 #include "llvm/Support/MemoryBuffer.h" 25 #include <algorithm> 26 #include <cassert> 27 #include <cstdint> 28 #include <memory> 29 #include <string> 30 #include <vector> 31 32 namespace llvm { 33 namespace object { 34 35 class Archive; 36 37 class ArchiveMemberHeader { 38 public: 39 friend class Archive; 40 41 ArchiveMemberHeader(Archive const *Parent, const char *RawHeaderPtr, 42 uint64_t Size, Error *Err); 43 // ArchiveMemberHeader() = default; 44 45 /// Get the name without looking up long names. 46 Expected<StringRef> getRawName() const; 47 48 /// Get the name looking up long names. 49 Expected<StringRef> getName(uint64_t Size) const; 50 51 /// Members are not larger than 4GB. 52 Expected<uint32_t> getSize() const; 53 54 Expected<sys::fs::perms> getAccessMode() const; 55 Expected<sys::TimePoint<std::chrono::seconds>> getLastModified() const; 56 57 StringRef getRawLastModified() const { 58 return StringRef(ArMemHdr->LastModified, 59 sizeof(ArMemHdr->LastModified)).rtrim(' '); 60 } 61 62 Expected<unsigned> getUID() const; 63 Expected<unsigned> getGID() const; 64 65 // This returns the size of the private struct ArMemHdrType 66 uint64_t getSizeOf() const { 67 return sizeof(ArMemHdrType); 68 } 69 70 private: 71 struct ArMemHdrType { 72 char Name[16]; 73 char LastModified[12]; 74 char UID[6]; 75 char GID[6]; 76 char AccessMode[8]; 77 char Size[10]; ///< Size of data, not including header or padding. 78 char Terminator[2]; 79 }; 80 Archive const *Parent; 81 ArMemHdrType const *ArMemHdr; 82 }; 83 84 class Archive : public Binary { 85 virtual void anchor(); 86 87 public: 88 class Child { 89 friend Archive; 90 friend ArchiveMemberHeader; 91 92 const Archive *Parent; 93 ArchiveMemberHeader Header; 94 /// \brief Includes header but not padding byte. 95 StringRef Data; 96 /// \brief Offset from Data to the start of the file. 97 uint16_t StartOfFile; 98 99 Expected<bool> isThinMember() const; 100 101 public: 102 Child(const Archive *Parent, const char *Start, Error *Err); 103 Child(const Archive *Parent, StringRef Data, uint16_t StartOfFile); 104 105 bool operator ==(const Child &other) const { 106 assert(!Parent || !other.Parent || Parent == other.Parent); 107 return Data.begin() == other.Data.begin(); 108 } 109 110 const Archive *getParent() const { return Parent; } 111 Expected<Child> getNext() const; 112 113 Expected<StringRef> getName() const; 114 Expected<std::string> getFullName() const; 115 Expected<StringRef> getRawName() const { return Header.getRawName(); } 116 117 Expected<sys::TimePoint<std::chrono::seconds>> getLastModified() const { 118 return Header.getLastModified(); 119 } 120 121 StringRef getRawLastModified() const { 122 return Header.getRawLastModified(); 123 } 124 125 Expected<unsigned> getUID() const { return Header.getUID(); } 126 Expected<unsigned> getGID() const { return Header.getGID(); } 127 128 Expected<sys::fs::perms> getAccessMode() const { 129 return Header.getAccessMode(); 130 } 131 132 /// \return the size of the archive member without the header or padding. 133 Expected<uint64_t> getSize() const; 134 /// \return the size in the archive header for this member. 135 Expected<uint64_t> getRawSize() const; 136 137 Expected<StringRef> getBuffer() const; 138 uint64_t getChildOffset() const; 139 140 Expected<MemoryBufferRef> getMemoryBufferRef() const; 141 142 Expected<std::unique_ptr<Binary>> 143 getAsBinary(LLVMContext *Context = nullptr) const; 144 }; 145 146 class child_iterator { 147 Child C; 148 Error *E = nullptr; 149 150 public: 151 child_iterator() : C(Child(nullptr, nullptr, nullptr)) {} 152 child_iterator(const Child &C, Error *E) : C(C), E(E) {} 153 154 const Child *operator->() const { return &C; } 155 const Child &operator*() const { return C; } 156 157 bool operator==(const child_iterator &other) const { 158 // Ignore errors here: If an error occurred during increment then getNext 159 // will have been set to child_end(), and the following comparison should 160 // do the right thing. 161 return C == other.C; 162 } 163 164 bool operator!=(const child_iterator &other) const { 165 return !(*this == other); 166 } 167 168 // Code in loops with child_iterators must check for errors on each loop 169 // iteration. And if there is an error break out of the loop. 170 child_iterator &operator++() { // Preincrement 171 assert(E && "Can't increment iterator with no Error attached"); 172 ErrorAsOutParameter ErrAsOutParam(E); 173 if (auto ChildOrErr = C.getNext()) 174 C = *ChildOrErr; 175 else { 176 C = C.getParent()->child_end().C; 177 *E = ChildOrErr.takeError(); 178 E = nullptr; 179 } 180 return *this; 181 } 182 }; 183 184 class Symbol { 185 const Archive *Parent; 186 uint32_t SymbolIndex; 187 uint32_t StringIndex; // Extra index to the string. 188 189 public: 190 Symbol(const Archive *p, uint32_t symi, uint32_t stri) 191 : Parent(p) 192 , SymbolIndex(symi) 193 , StringIndex(stri) {} 194 195 bool operator ==(const Symbol &other) const { 196 return (Parent == other.Parent) && (SymbolIndex == other.SymbolIndex); 197 } 198 199 StringRef getName() const; 200 Expected<Child> getMember() const; 201 Symbol getNext() const; 202 }; 203 204 class symbol_iterator { 205 Symbol symbol; 206 207 public: 208 symbol_iterator(const Symbol &s) : symbol(s) {} 209 210 const Symbol *operator->() const { return &symbol; } 211 const Symbol &operator*() const { return symbol; } 212 213 bool operator==(const symbol_iterator &other) const { 214 return symbol == other.symbol; 215 } 216 217 bool operator!=(const symbol_iterator &other) const { 218 return !(*this == other); 219 } 220 221 symbol_iterator& operator++() { // Preincrement 222 symbol = symbol.getNext(); 223 return *this; 224 } 225 }; 226 227 Archive(MemoryBufferRef Source, Error &Err); 228 static Expected<std::unique_ptr<Archive>> create(MemoryBufferRef Source); 229 230 enum Kind { 231 K_GNU, 232 K_MIPS64, 233 K_BSD, 234 K_DARWIN, 235 K_DARWIN64, 236 K_COFF 237 }; 238 239 Kind kind() const { return (Kind)Format; } 240 bool isThin() const { return IsThin; } 241 242 child_iterator child_begin(Error &Err, bool SkipInternal = true) const; 243 child_iterator child_end() const; 244 iterator_range<child_iterator> children(Error &Err, 245 bool SkipInternal = true) const { 246 return make_range(child_begin(Err, SkipInternal), child_end()); 247 } 248 249 symbol_iterator symbol_begin() const; 250 symbol_iterator symbol_end() const; 251 iterator_range<symbol_iterator> symbols() const { 252 return make_range(symbol_begin(), symbol_end()); 253 } 254 255 // Cast methods. 256 static inline bool classof(Binary const *v) { 257 return v->isArchive(); 258 } 259 260 // check if a symbol is in the archive 261 Expected<Optional<Child>> findSym(StringRef name) const; 262 263 bool isEmpty() const; 264 bool hasSymbolTable() const; 265 StringRef getSymbolTable() const { return SymbolTable; } 266 StringRef getStringTable() const { return StringTable; } 267 uint32_t getNumberOfSymbols() const; 268 269 std::vector<std::unique_ptr<MemoryBuffer>> takeThinBuffers() { 270 return std::move(ThinBuffers); 271 } 272 273 private: 274 StringRef SymbolTable; 275 StringRef StringTable; 276 277 StringRef FirstRegularData; 278 uint16_t FirstRegularStartOfFile = -1; 279 void setFirstRegular(const Child &C); 280 281 unsigned Format : 3; 282 unsigned IsThin : 1; 283 mutable std::vector<std::unique_ptr<MemoryBuffer>> ThinBuffers; 284 }; 285 286 } // end namespace object 287 } // end namespace llvm 288 289 #endif // LLVM_OBJECT_ARCHIVE_H 290
