| //===- Archive.h - ar archive file format -----------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file declares the ar archive file format class. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLVM_OBJECT_ARCHIVE_H |
| #define LLVM_OBJECT_ARCHIVE_H |
| |
| #include "llvm/ADT/SmallString.h" |
| #include "llvm/ADT/StringRef.h" |
| #include "llvm/ADT/Twine.h" |
| #include "llvm/Object/Binary.h" |
| #include "llvm/Support/DataTypes.h" |
| #include "llvm/Support/ErrorHandling.h" |
| #include "llvm/Support/MemoryBuffer.h" |
| |
| namespace llvm { |
| namespace object { |
| struct ArchiveMemberHeader { |
| char Name[16]; |
| char LastModified[12]; |
| char UID[6]; |
| char GID[6]; |
| char AccessMode[8]; |
| char Size[10]; ///< Size of data, not including header or padding. |
| char Terminator[2]; |
| |
| ///! Get the name without looking up long names. |
| llvm::StringRef getName() const { |
| char EndCond; |
| if (Name[0] == '/' || Name[0] == '#') |
| EndCond = ' '; |
| else |
| EndCond = '/'; |
| llvm::StringRef::size_type end = |
| llvm::StringRef(Name, sizeof(Name)).find(EndCond); |
| if (end == llvm::StringRef::npos) |
| end = sizeof(Name); |
| assert(end <= sizeof(Name) && end > 0); |
| // Don't include the EndCond if there is one. |
| return llvm::StringRef(Name, end); |
| } |
| |
| uint64_t getSize() const { |
| uint64_t ret; |
| if (llvm::StringRef(Size, sizeof(Size)).rtrim(" ").getAsInteger(10, ret)) |
| llvm_unreachable("Size is not an integer."); |
| return ret; |
| } |
| }; |
| |
| static const ArchiveMemberHeader *ToHeader(const char *base) { |
| return reinterpret_cast<const ArchiveMemberHeader *>(base); |
| } |
| |
| class Archive : public Binary { |
| virtual void anchor(); |
| public: |
| class Child { |
| const Archive *Parent; |
| /// \brief Includes header but not padding byte. |
| StringRef Data; |
| /// \brief Offset from Data to the start of the file. |
| uint16_t StartOfFile; |
| |
| public: |
| Child(const Archive *p, StringRef d) : Parent(p), Data(d) { |
| if (!p || d.empty()) |
| return; |
| // Setup StartOfFile and PaddingBytes. |
| StartOfFile = sizeof(ArchiveMemberHeader); |
| // Don't include attached name. |
| StringRef Name = ToHeader(Data.data())->getName(); |
| if (Name.startswith("#1/")) { |
| uint64_t NameSize; |
| if (Name.substr(3).rtrim(" ").getAsInteger(10, NameSize)) |
| llvm_unreachable("Long name length is not an integer"); |
| StartOfFile += NameSize; |
| } |
| } |
| |
| bool operator ==(const Child &other) const { |
| return (Parent == other.Parent) && (Data.begin() == other.Data.begin()); |
| } |
| |
| bool operator <(const Child &other) const { |
| return Data.begin() < other.Data.begin(); |
| } |
| |
| Child getNext() const { |
| size_t SpaceToSkip = Data.size(); |
| // If it's odd, add 1 to make it even. |
| if (SpaceToSkip & 1) |
| ++SpaceToSkip; |
| |
| const char *NextLoc = Data.data() + SpaceToSkip; |
| |
| // Check to see if this is past the end of the archive. |
| if (NextLoc >= Parent->Data->getBufferEnd()) |
| return Child(Parent, StringRef(0, 0)); |
| |
| size_t NextSize = |
| sizeof(ArchiveMemberHeader) + ToHeader(NextLoc)->getSize(); |
| |
| return Child(Parent, StringRef(NextLoc, NextSize)); |
| } |
| |
| error_code getName(StringRef &Result) const; |
| int getLastModified() const; |
| int getUID() const; |
| int getGID() const; |
| int getAccessMode() const; |
| /// \return the size of the archive member without the header or padding. |
| uint64_t getSize() const { return Data.size() - StartOfFile; } |
| |
| StringRef getBuffer() const { |
| return StringRef(Data.data() + StartOfFile, getSize()); |
| } |
| |
| error_code getMemoryBuffer(OwningPtr<MemoryBuffer> &Result, |
| bool FullPath = false) const { |
| StringRef Name; |
| if (error_code ec = getName(Name)) |
| return ec; |
| SmallString<128> Path; |
| Result.reset(MemoryBuffer::getMemBuffer( |
| getBuffer(), FullPath ? (Twine(Parent->getFileName()) + "(" + Name + |
| ")").toStringRef(Path) : Name, false)); |
| return error_code::success(); |
| } |
| |
| error_code getAsBinary(OwningPtr<Binary> &Result) const; |
| }; |
| |
| class child_iterator { |
| Child child; |
| public: |
| child_iterator() : child(Child(0, StringRef())) {} |
| child_iterator(const Child &c) : child(c) {} |
| const Child* operator->() const { |
| return &child; |
| } |
| |
| bool operator==(const child_iterator &other) const { |
| return child == other.child; |
| } |
| |
| bool operator!=(const child_iterator &other) const { |
| return !(*this == other); |
| } |
| |
| bool operator <(const child_iterator &other) const { |
| return child < other.child; |
| } |
| |
| child_iterator& operator++() { // Preincrement |
| child = child.getNext(); |
| return *this; |
| } |
| }; |
| |
| class Symbol { |
| const Archive *Parent; |
| uint32_t SymbolIndex; |
| uint32_t StringIndex; // Extra index to the string. |
| |
| public: |
| bool operator ==(const Symbol &other) const { |
| return (Parent == other.Parent) && (SymbolIndex == other.SymbolIndex); |
| } |
| |
| Symbol(const Archive *p, uint32_t symi, uint32_t stri) |
| : Parent(p) |
| , SymbolIndex(symi) |
| , StringIndex(stri) {} |
| error_code getName(StringRef &Result) const; |
| error_code getMember(child_iterator &Result) const; |
| Symbol getNext() const; |
| }; |
| |
| class symbol_iterator { |
| Symbol symbol; |
| public: |
| symbol_iterator(const Symbol &s) : symbol(s) {} |
| const Symbol *operator->() const { |
| return &symbol; |
| } |
| |
| bool operator==(const symbol_iterator &other) const { |
| return symbol == other.symbol; |
| } |
| |
| bool operator!=(const symbol_iterator &other) const { |
| return !(*this == other); |
| } |
| |
| symbol_iterator& operator++() { // Preincrement |
| symbol = symbol.getNext(); |
| return *this; |
| } |
| }; |
| |
| Archive(MemoryBuffer *source, error_code &ec); |
| |
| enum Kind { |
| K_GNU, |
| K_BSD, |
| K_COFF |
| }; |
| |
| Kind kind() const { |
| return Format; |
| } |
| |
| child_iterator begin_children(bool skip_internal = true) const; |
| child_iterator end_children() const; |
| |
| symbol_iterator begin_symbols() const; |
| symbol_iterator end_symbols() const; |
| |
| // Cast methods. |
| static inline bool classof(Binary const *v) { |
| return v->isArchive(); |
| } |
| |
| // check if a symbol is in the archive |
| child_iterator findSym(StringRef name) const; |
| |
| private: |
| child_iterator SymbolTable; |
| child_iterator StringTable; |
| Kind Format; |
| }; |
| |
| } |
| } |
| |
| #endif |