LCOV - code coverage report
Current view: top level - lib/Object - Archive.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 394 442 89.1 %
Date: 2018-10-20 13:21:21 Functions: 35 36 97.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- Archive.cpp - ar File Format implementation ------------------------===//
       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 defines the ArchiveObjectFile class.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "llvm/Object/Archive.h"
      15             : #include "llvm/ADT/Optional.h"
      16             : #include "llvm/ADT/SmallString.h"
      17             : #include "llvm/ADT/StringRef.h"
      18             : #include "llvm/ADT/Twine.h"
      19             : #include "llvm/Object/Binary.h"
      20             : #include "llvm/Object/Error.h"
      21             : #include "llvm/Support/Chrono.h"
      22             : #include "llvm/Support/Endian.h"
      23             : #include "llvm/Support/Error.h"
      24             : #include "llvm/Support/ErrorOr.h"
      25             : #include "llvm/Support/FileSystem.h"
      26             : #include "llvm/Support/MemoryBuffer.h"
      27             : #include "llvm/Support/Path.h"
      28             : #include "llvm/Support/raw_ostream.h"
      29             : #include <algorithm>
      30             : #include <cassert>
      31             : #include <cstddef>
      32             : #include <cstdint>
      33             : #include <cstring>
      34             : #include <memory>
      35             : #include <string>
      36             : #include <system_error>
      37             : 
      38             : using namespace llvm;
      39             : using namespace object;
      40             : using namespace llvm::support::endian;
      41             : 
      42             : static const char *const Magic = "!<arch>\n";
      43             : static const char *const ThinMagic = "!<thin>\n";
      44             : 
      45           0 : void Archive::anchor() {}
      46             : 
      47             : static Error
      48          18 : malformedError(Twine Msg) {
      49          36 :   std::string StringMsg = "truncated or malformed archive (" + Msg.str() + ")";
      50             :   return make_error<GenericBinaryError>(std::move(StringMsg),
      51          18 :                                         object_error::parse_failed);
      52             : }
      53             : 
      54        3962 : ArchiveMemberHeader::ArchiveMemberHeader(const Archive *Parent,
      55             :                                          const char *RawHeaderPtr,
      56        3962 :                                          uint64_t Size, Error *Err)
      57             :     : Parent(Parent),
      58        3962 :       ArMemHdr(reinterpret_cast<const ArMemHdrType *>(RawHeaderPtr)) {
      59        3962 :   if (RawHeaderPtr == nullptr)
      60             :     return;
      61             :   ErrorAsOutParameter ErrAsOutParam(Err);
      62             : 
      63        2672 :   if (Size < sizeof(ArMemHdrType)) {
      64           1 :     if (Err) {
      65             :       std::string Msg("remaining size of archive too small for next archive "
      66           1 :                       "member header ");
      67           1 :       Expected<StringRef> NameOrErr = getName(Size);
      68           1 :       if (!NameOrErr) {
      69           0 :         consumeError(NameOrErr.takeError());
      70           0 :         uint64_t Offset = RawHeaderPtr - Parent->getData().data();
      71           0 :         *Err = malformedError(Msg + "at offset " + Twine(Offset));
      72             :       } else
      73           3 :         *Err = malformedError(Msg + "for " + NameOrErr.get());
      74             :     }
      75           1 :     return;
      76             :   }
      77        2671 :   if (ArMemHdr->Terminator[0] != '`' || ArMemHdr->Terminator[1] != '\n') {
      78           1 :     if (Err) {
      79             :       std::string Buf;
      80           1 :       raw_string_ostream OS(Buf);
      81           1 :       OS.write_escaped(StringRef(ArMemHdr->Terminator,
      82           1 :                                  sizeof(ArMemHdr->Terminator)));
      83             :       OS.flush();
      84           1 :       std::string Msg("terminator characters in archive member \"" + Buf +
      85             :                       "\" not the correct \"`\\n\" values for the archive "
      86           1 :                       "member header ");
      87           1 :       Expected<StringRef> NameOrErr = getName(Size);
      88           1 :       if (!NameOrErr) {
      89           0 :         consumeError(NameOrErr.takeError());
      90           0 :         uint64_t Offset = RawHeaderPtr - Parent->getData().data();
      91           0 :         *Err = malformedError(Msg + "at offset " + Twine(Offset));
      92             :       } else
      93           3 :         *Err = malformedError(Msg + "for " + NameOrErr.get());
      94             :     }
      95           1 :     return;
      96             :   }
      97             : }
      98             : 
      99             : // This gets the raw name from the ArMemHdr->Name field and checks that it is
     100             : // valid for the kind of archive.  If it is not valid it returns an Error.
     101        8856 : Expected<StringRef> ArchiveMemberHeader::getRawName() const {
     102             :   char EndCond;
     103        8856 :   auto Kind = Parent->kind();
     104        8856 :   if (Kind == Archive::K_BSD || Kind == Archive::K_DARWIN64) {
     105        1207 :     if (ArMemHdr->Name[0] == ' ') {
     106           1 :       uint64_t Offset = reinterpret_cast<const char *>(ArMemHdr) -
     107           1 :                         Parent->getData().data();
     108           1 :       return malformedError("name contains a leading space for archive member "
     109           1 :                             "header at offset " + Twine(Offset));
     110             :     }
     111             :     EndCond = ' ';
     112             :   }
     113        7649 :   else if (ArMemHdr->Name[0] == '/' || ArMemHdr->Name[0] == '#')
     114             :     EndCond = ' ';
     115             :   else
     116             :     EndCond = '/';
     117             :   StringRef::size_type end =
     118       17710 :       StringRef(ArMemHdr->Name, sizeof(ArMemHdr->Name)).find(EndCond);
     119        8751 :   if (end == StringRef::npos)
     120             :     end = sizeof(ArMemHdr->Name);
     121             :   assert(end <= sizeof(ArMemHdr->Name) && end > 0);
     122             :   // Don't include the EndCond if there is one.
     123             :   return StringRef(ArMemHdr->Name, end);
     124             : }
     125             : 
     126             : // This gets the name looking up long names. Size is the size of the archive
     127             : // member including the header, so the size of any name following the header
     128             : // is checked to make sure it does not overflow.
     129        1626 : Expected<StringRef> ArchiveMemberHeader::getName(uint64_t Size) const {
     130             : 
     131             :   // This can be called from the ArchiveMemberHeader constructor when the
     132             :   // archive header is truncated to produce an error message with the name.
     133             :   // Make sure the name field is not truncated.
     134        1626 :   if (Size < offsetof(ArMemHdrType, Name) + sizeof(ArMemHdr->Name)) {
     135           0 :     uint64_t ArchiveOffset = reinterpret_cast<const char *>(ArMemHdr) -
     136           0 :                       Parent->getData().data();
     137           0 :     return malformedError("archive header truncated before the name field "
     138             :                           "for archive member header at offset " +
     139           0 :                           Twine(ArchiveOffset));
     140             :   }
     141             : 
     142             :   // The raw name itself can be invalid.
     143        1626 :   Expected<StringRef> NameOrErr = getRawName();
     144        1626 :   if (!NameOrErr)
     145             :     return NameOrErr.takeError();
     146        1626 :   StringRef Name = NameOrErr.get();
     147             : 
     148             :   // Check if it's a special name.
     149        3252 :   if (Name[0] == '/') {
     150         687 :     if (Name.size() == 1) // Linker member.
     151             :       return Name;
     152         687 :     if (Name.size() == 2 && Name[1] == '/') // String table.
     153             :       return Name;
     154             :     // It's a long name.
     155             :     // Get the string table offset.
     156             :     std::size_t StringOffset;
     157         689 :     if (Name.substr(1).rtrim(' ').getAsInteger(10, StringOffset)) {
     158             :       std::string Buf;
     159           2 :       raw_string_ostream OS(Buf);
     160           2 :       OS.write_escaped(Name.substr(1).rtrim(' '));
     161             :       OS.flush();
     162           4 :       uint64_t ArchiveOffset = reinterpret_cast<const char *>(ArMemHdr) -
     163           2 :                                Parent->getData().data();
     164           2 :       return malformedError("long name offset characters after the '/' are "
     165           4 :                             "not all decimal numbers: '" + Buf + "' for "
     166             :                             "archive member header at offset " +
     167           2 :                             Twine(ArchiveOffset));
     168             :     }
     169             : 
     170             :     // Verify it.
     171         685 :     if (StringOffset >= Parent->getStringTable().size()) {
     172           4 :       uint64_t ArchiveOffset = reinterpret_cast<const char *>(ArMemHdr) -
     173           2 :                                Parent->getData().data();
     174           2 :       return malformedError("long name offset " + Twine(StringOffset) + " past "
     175             :                             "the end of the string table for archive member "
     176           2 :                             "header at offset " + Twine(ArchiveOffset));
     177             :     }
     178             : 
     179             :     // GNU long file names end with a "/\n".
     180         683 :     if (Parent->kind() == Archive::K_GNU ||
     181             :         Parent->kind() == Archive::K_GNU64) {
     182         616 :       size_t End = Parent->getStringTable().find('\n', /*From=*/StringOffset);
     183         616 :       if (End == StringRef::npos || End < 1 ||
     184             :           Parent->getStringTable()[End - 1] != '/') {
     185           0 :         return malformedError("string table at long name offset " +
     186           0 :                               Twine(StringOffset) + "not terminated");
     187             :       }
     188        1848 :       return Parent->getStringTable().slice(StringOffset, End - 1);
     189             :     }
     190          67 :     return Parent->getStringTable().begin() + StringOffset;
     191             :   }
     192             : 
     193             :   if (Name.startswith("#1/")) {
     194             :     uint64_t NameLength;
     195         477 :     if (Name.substr(3).rtrim(' ').getAsInteger(10, NameLength)) {
     196             :       std::string Buf;
     197           0 :       raw_string_ostream OS(Buf);
     198           0 :       OS.write_escaped(Name.substr(3).rtrim(' '));
     199             :       OS.flush();
     200           0 :       uint64_t ArchiveOffset = reinterpret_cast<const char *>(ArMemHdr) -
     201           0 :                         Parent->getData().data();
     202           0 :       return malformedError("long name length characters after the #1/ are "
     203           0 :                             "not all decimal numbers: '" + Buf + "' for "
     204             :                             "archive member header at offset " +
     205           0 :                             Twine(ArchiveOffset));
     206             :     }
     207         477 :     if (getSizeOf() + NameLength > Size) {
     208           6 :       uint64_t ArchiveOffset = reinterpret_cast<const char *>(ArMemHdr) -
     209           3 :                         Parent->getData().data();
     210           3 :       return malformedError("long name length: " + Twine(NameLength) +
     211             :                             " extends past the end of the member or archive "
     212           3 :                             "for archive member header at offset " +
     213           3 :                             Twine(ArchiveOffset));
     214             :     }
     215         474 :     return StringRef(reinterpret_cast<const char *>(ArMemHdr) + getSizeOf(),
     216         474 :                      NameLength).rtrim('\0');
     217             :   }
     218             : 
     219             :   // It is not a long name so trim the blanks at the end of the name.
     220         924 :   if (Name[Name.size() - 1] != '/')
     221         462 :     return Name.rtrim(' ');
     222             : 
     223             :   // It's a simple name.
     224             :   return Name.drop_back(1);
     225             : }
     226             : 
     227        3975 : Expected<uint32_t> ArchiveMemberHeader::getSize() const {
     228             :   uint32_t Ret;
     229        3975 :   if (StringRef(ArMemHdr->Size,
     230        7950 :                 sizeof(ArMemHdr->Size)).rtrim(" ").getAsInteger(10, Ret)) {
     231             :     std::string Buf;
     232           2 :     raw_string_ostream OS(Buf);
     233           2 :     OS.write_escaped(StringRef(ArMemHdr->Size,
     234           2 :                                sizeof(ArMemHdr->Size)).rtrim(" "));
     235             :     OS.flush();
     236           4 :     uint64_t Offset = reinterpret_cast<const char *>(ArMemHdr) -
     237           2 :                       Parent->getData().data();
     238           2 :     return malformedError("characters in size field in archive header are not "
     239           4 :                           "all decimal numbers: '" + Buf + "' for archive "
     240           2 :                           "member header at offset " + Twine(Offset));
     241             :   }
     242             :   return Ret;
     243             : }
     244             : 
     245          77 : Expected<sys::fs::perms> ArchiveMemberHeader::getAccessMode() const {
     246             :   unsigned Ret;
     247          77 :   if (StringRef(ArMemHdr->AccessMode,
     248         154 :                 sizeof(ArMemHdr->AccessMode)).rtrim(' ').getAsInteger(8, Ret)) {
     249             :     std::string Buf;
     250           1 :     raw_string_ostream OS(Buf);
     251           1 :     OS.write_escaped(StringRef(ArMemHdr->AccessMode,
     252           1 :                                sizeof(ArMemHdr->AccessMode)).rtrim(" "));
     253             :     OS.flush();
     254           2 :     uint64_t Offset = reinterpret_cast<const char *>(ArMemHdr) -
     255           1 :                       Parent->getData().data();
     256           1 :     return malformedError("characters in AccessMode field in archive header "
     257           2 :                           "are not all decimal numbers: '" + Buf + "' for the "
     258           1 :                           "archive member header at offset " + Twine(Offset));
     259             :   }
     260             :   return static_cast<sys::fs::perms>(Ret);
     261             : }
     262             : 
     263             : Expected<sys::TimePoint<std::chrono::seconds>>
     264         100 : ArchiveMemberHeader::getLastModified() const {
     265             :   unsigned Seconds;
     266         100 :   if (StringRef(ArMemHdr->LastModified,
     267         100 :                 sizeof(ArMemHdr->LastModified)).rtrim(' ')
     268           1 :           .getAsInteger(10, Seconds)) {
     269             :     std::string Buf;
     270           1 :     raw_string_ostream OS(Buf);
     271           1 :     OS.write_escaped(StringRef(ArMemHdr->LastModified,
     272           1 :                                sizeof(ArMemHdr->LastModified)).rtrim(" "));
     273             :     OS.flush();
     274           2 :     uint64_t Offset = reinterpret_cast<const char *>(ArMemHdr) -
     275           1 :                       Parent->getData().data();
     276           1 :     return malformedError("characters in LastModified field in archive header "
     277           2 :                           "are not all decimal numbers: '" + Buf + "' for the "
     278           1 :                           "archive member header at offset " + Twine(Offset));
     279             :   }
     280             : 
     281          99 :   return sys::toTimePoint(Seconds);
     282             : }
     283             : 
     284          68 : Expected<unsigned> ArchiveMemberHeader::getUID() const {
     285             :   unsigned Ret;
     286         136 :   StringRef User = StringRef(ArMemHdr->UID, sizeof(ArMemHdr->UID)).rtrim(' ');
     287          68 :   if (User.empty())
     288             :     return 0;
     289          67 :   if (User.getAsInteger(10, Ret)) {
     290             :     std::string Buf;
     291           1 :     raw_string_ostream OS(Buf);
     292           1 :     OS.write_escaped(User);
     293             :     OS.flush();
     294           2 :     uint64_t Offset = reinterpret_cast<const char *>(ArMemHdr) -
     295           1 :                       Parent->getData().data();
     296           1 :     return malformedError("characters in UID field in archive header "
     297           2 :                           "are not all decimal numbers: '" + Buf + "' for the "
     298           1 :                           "archive member header at offset " + Twine(Offset));
     299             :   }
     300             :   return Ret;
     301             : }
     302             : 
     303          67 : Expected<unsigned> ArchiveMemberHeader::getGID() const {
     304             :   unsigned Ret;
     305         134 :   StringRef Group = StringRef(ArMemHdr->GID, sizeof(ArMemHdr->GID)).rtrim(' ');
     306          67 :   if (Group.empty())
     307             :     return 0;
     308          66 :   if (Group.getAsInteger(10, Ret)) {
     309             :     std::string Buf;
     310           1 :     raw_string_ostream OS(Buf);
     311           1 :     OS.write_escaped(Group);
     312             :     OS.flush();
     313           2 :     uint64_t Offset = reinterpret_cast<const char *>(ArMemHdr) -
     314           1 :                       Parent->getData().data();
     315           1 :     return malformedError("characters in GID field in archive header "
     316           2 :                           "are not all decimal numbers: '" + Buf + "' for the "
     317           1 :                           "archive member header at offset " + Twine(Offset));
     318             :   }
     319             :   return Ret;
     320             : }
     321             : 
     322         353 : Archive::Child::Child(const Archive *Parent, StringRef Data,
     323         353 :                       uint16_t StartOfFile)
     324             :     : Parent(Parent), Header(Parent, Data.data(), Data.size(), nullptr),
     325         706 :       Data(Data), StartOfFile(StartOfFile) {
     326         353 : }
     327             : 
     328        3609 : Archive::Child::Child(const Archive *Parent, const char *Start, Error *Err)
     329             :     : Parent(Parent),
     330             :       Header(Parent, Start,
     331             :              Parent
     332        5929 :                ? Parent->getData().size() - (Start - Parent->getData().data())
     333        5929 :                : 0, Err) {
     334        3609 :   if (!Start)
     335        1295 :     return;
     336             : 
     337             :   // If we are pointed to real data, Start is not a nullptr, then there must be
     338             :   // a non-null Err pointer available to report malformed data on.  Only in
     339             :   // the case sentinel value is being constructed is Err is permitted to be a
     340             :   // nullptr.
     341             :   assert(Err && "Err can't be nullptr if Start is not a nullptr");
     342             : 
     343             :   ErrorAsOutParameter ErrAsOutParam(Err);
     344             : 
     345             :   // If there was an error in the construction of the Header
     346             :   // then just return with the error now set.
     347        2320 :   if (*Err)
     348             :     return;
     349             : 
     350             :   uint64_t Size = Header.getSizeOf();
     351        2318 :   Data = StringRef(Start, Size);
     352        2318 :   Expected<bool> isThinOrErr = isThinMember();
     353        2318 :   if (!isThinOrErr) {
     354             :     *Err = isThinOrErr.takeError();
     355           1 :     return;
     356             :   }
     357        2317 :   bool isThin = isThinOrErr.get();
     358        2317 :   if (!isThin) {
     359        2274 :     Expected<uint64_t> MemberSize = getRawSize();
     360        2274 :     if (!MemberSize) {
     361             :       *Err = MemberSize.takeError();
     362             :       return;
     363             :     }
     364        2272 :     Size += MemberSize.get();
     365        2272 :     Data = StringRef(Start, Size);
     366             :   }
     367             : 
     368             :   // Setup StartOfFile and PaddingBytes.
     369        2315 :   StartOfFile = Header.getSizeOf();
     370             :   // Don't include attached name.
     371             :   Expected<StringRef> NameOrErr = getRawName();
     372        2315 :   if (!NameOrErr){
     373             :     *Err = NameOrErr.takeError();
     374           0 :     return;
     375             :   }
     376        2315 :   StringRef Name = NameOrErr.get();
     377             :   if (Name.startswith("#1/")) {
     378             :     uint64_t NameSize;
     379         368 :     if (Name.substr(3).rtrim(' ').getAsInteger(10, NameSize)) {
     380             :       std::string Buf;
     381           1 :       raw_string_ostream OS(Buf);
     382           1 :       OS.write_escaped(Name.substr(3).rtrim(' '));
     383             :       OS.flush();
     384           1 :       uint64_t Offset = Start - Parent->getData().data();
     385           1 :       *Err = malformedError("long name length characters after the #1/ are "
     386           2 :                             "not all decimal numbers: '" + Buf + "' for "
     387             :                             "archive member header at offset " +
     388           1 :                             Twine(Offset));
     389             :       return;
     390             :     }
     391         366 :     StartOfFile += NameSize;
     392             :   }
     393             : }
     394             : 
     395        1607 : Expected<uint64_t> Archive::Child::getSize() const {
     396        1607 :   if (Parent->IsThin) {
     397          40 :     Expected<uint32_t> Size = Header.getSize();
     398          40 :     if (!Size)
     399             :       return Size.takeError();
     400             :     return Size.get();
     401             :   }
     402        1567 :   return Data.size() - StartOfFile;
     403             : }
     404             : 
     405        3935 : Expected<uint64_t> Archive::Child::getRawSize() const {
     406        3935 :   return Header.getSize();
     407             : }
     408             : 
     409        3947 : Expected<bool> Archive::Child::isThinMember() const {
     410        3947 :   Expected<StringRef> NameOrErr = Header.getRawName();
     411        3947 :   if (!NameOrErr)
     412             :     return NameOrErr.takeError();
     413        3946 :   StringRef Name = NameOrErr.get();
     414        3946 :   return Parent->IsThin && Name != "/" && Name != "//";
     415             : }
     416             : 
     417          26 : Expected<std::string> Archive::Child::getFullName() const {
     418          26 :   Expected<bool> isThin = isThinMember();
     419          26 :   if (!isThin)
     420             :     return isThin.takeError();
     421             :   assert(isThin.get());
     422          26 :   Expected<StringRef> NameOrErr = getName();
     423          26 :   if (!NameOrErr)
     424             :     return NameOrErr.takeError();
     425          26 :   StringRef Name = *NameOrErr;
     426          26 :   if (sys::path::is_absolute(Name))
     427          12 :     return Name;
     428             : 
     429             :   SmallString<128> FullName = sys::path::parent_path(
     430          28 :       Parent->getMemoryBufferRef().getBufferIdentifier());
     431          14 :   sys::path::append(FullName, Name);
     432          14 :   return StringRef(FullName);
     433             : }
     434             : 
     435        1603 : Expected<StringRef> Archive::Child::getBuffer() const {
     436        1603 :   Expected<bool> isThinOrErr = isThinMember();
     437        1603 :   if (!isThinOrErr)
     438             :     return isThinOrErr.takeError();
     439        1603 :   bool isThin = isThinOrErr.get();
     440        1603 :   if (!isThin) {
     441        1579 :     Expected<uint32_t> Size = getSize();
     442        1579 :     if (!Size)
     443             :       return Size.takeError();
     444        3158 :     return StringRef(Data.data() + StartOfFile, Size.get());
     445             :   }
     446          48 :   Expected<std::string> FullNameOrErr = getFullName();
     447          24 :   if (!FullNameOrErr)
     448             :     return FullNameOrErr.takeError();
     449             :   const std::string &FullName = *FullNameOrErr;
     450          24 :   ErrorOr<std::unique_ptr<MemoryBuffer>> Buf = MemoryBuffer::getFile(FullName);
     451          24 :   if (std::error_code EC = Buf.getError())
     452           1 :     return errorCodeToError(EC);
     453          23 :   Parent->ThinBuffers.push_back(std::move(*Buf));
     454          23 :   return Parent->ThinBuffers.back()->getBuffer();
     455             : }
     456             : 
     457        1724 : Expected<Archive::Child> Archive::Child::getNext() const {
     458             :   size_t SpaceToSkip = Data.size();
     459             :   // If it's odd, add 1 to make it even.
     460        1724 :   if (SpaceToSkip & 1)
     461         225 :     ++SpaceToSkip;
     462             : 
     463        1724 :   const char *NextLoc = Data.data() + SpaceToSkip;
     464             : 
     465             :   // Check to see if this is at the end of the archive.
     466        3448 :   if (NextLoc == Parent->Data.getBufferEnd())
     467         346 :     return Child(nullptr, nullptr, nullptr);
     468             : 
     469             :   // Check to see if this is past the end of the archive.
     470        1378 :   if (NextLoc > Parent->Data.getBufferEnd()) {
     471             :     std::string Msg("offset to next archive member past the end of the archive "
     472           1 :                     "after member ");
     473           1 :     Expected<StringRef> NameOrErr = getName();
     474           1 :     if (!NameOrErr) {
     475           0 :       consumeError(NameOrErr.takeError());
     476           0 :       uint64_t Offset = Data.data() - Parent->getData().data();
     477           0 :       return malformedError(Msg + "at offset " + Twine(Offset));
     478             :     } else
     479           1 :       return malformedError(Msg + NameOrErr.get());
     480             :   }
     481             : 
     482             :   Error Err = Error::success();
     483        1377 :   Child Ret(Parent, NextLoc, &Err);
     484        1377 :   if (Err)
     485             :     return std::move(Err);
     486             :   return Ret;
     487             : }
     488             : 
     489         336 : uint64_t Archive::Child::getChildOffset() const {
     490         336 :   const char *a = Parent->Data.getBuffer().data();
     491             :   const char *c = Data.data();
     492         336 :   uint64_t offset = c - a;
     493         336 :   return offset;
     494             : }
     495             : 
     496        1624 : Expected<StringRef> Archive::Child::getName() const {
     497        1624 :   Expected<uint64_t> RawSizeOrErr = getRawSize();
     498        1624 :   if (!RawSizeOrErr)
     499             :     return RawSizeOrErr.takeError();
     500        1624 :   uint64_t RawSize = RawSizeOrErr.get();
     501        1624 :   Expected<StringRef> NameOrErr = Header.getName(Header.getSizeOf() + RawSize);
     502        1624 :   if (!NameOrErr)
     503             :     return NameOrErr.takeError();
     504        1617 :   StringRef Name = NameOrErr.get();
     505             :   return Name;
     506             : }
     507             : 
     508         749 : Expected<MemoryBufferRef> Archive::Child::getMemoryBufferRef() const {
     509         749 :   Expected<StringRef> NameOrErr = getName();
     510         749 :   if (!NameOrErr)
     511             :     return NameOrErr.takeError();
     512         746 :   StringRef Name = NameOrErr.get();
     513         746 :   Expected<StringRef> Buf = getBuffer();
     514         746 :   if (!Buf)
     515             :     return Buf.takeError();
     516             :   return MemoryBufferRef(*Buf, Name);
     517             : }
     518             : 
     519             : Expected<std::unique_ptr<Binary>>
     520         314 : Archive::Child::getAsBinary(LLVMContext *Context) const {
     521         314 :   Expected<MemoryBufferRef> BuffOrErr = getMemoryBufferRef();
     522         314 :   if (!BuffOrErr)
     523             :     return BuffOrErr.takeError();
     524             : 
     525         622 :   auto BinaryOrErr = createBinary(BuffOrErr.get(), Context);
     526         311 :   if (BinaryOrErr)
     527             :     return std::move(*BinaryOrErr);
     528             :   return BinaryOrErr.takeError();
     529             : }
     530             : 
     531         439 : Expected<std::unique_ptr<Archive>> Archive::create(MemoryBufferRef Source) {
     532             :   Error Err = Error::success();
     533         439 :   std::unique_ptr<Archive> Ret(new Archive(Source, Err));
     534         439 :   if (Err)
     535             :     return std::move(Err);
     536             :   return std::move(Ret);
     537             : }
     538             : 
     539         555 : void Archive::setFirstRegular(const Child &C) {
     540         555 :   FirstRegularData = C.Data;
     541         555 :   FirstRegularStartOfFile = C.StartOfFile;
     542         555 : }
     543             : 
     544         565 : Archive::Archive(MemoryBufferRef Source, Error &Err)
     545         565 :     : Binary(Binary::ID_Archive, Source) {
     546             :   ErrorAsOutParameter ErrAsOutParam(&Err);
     547             :   StringRef Buffer = Data.getBuffer();
     548             :   // Check for sufficient magic.
     549             :   if (Buffer.startswith(ThinMagic)) {
     550          20 :     IsThin = true;
     551             :   } else if (Buffer.startswith(Magic)) {
     552         544 :     IsThin = false;
     553             :   } else {
     554             :     Err = make_error<GenericBinaryError>("File too small to be an archive",
     555             :                                          object_error::invalid_file_type);
     556           1 :     return;
     557             :   }
     558             : 
     559             :   // Make sure Format is initialized before any call to
     560             :   // ArchiveMemberHeader::getName() is made.  This could be a valid empty
     561             :   // archive which is the same in all formats.  So claiming it to be gnu to is
     562             :   // fine if not totally correct before we look for a string table or table of
     563             :   // contents.
     564         564 :   Format = K_GNU;
     565             : 
     566             :   // Get the special members.
     567         564 :   child_iterator I = child_begin(Err, false);
     568         564 :   if (Err)
     569             :     return;
     570         561 :   child_iterator E = child_end();
     571             : 
     572             :   // See if this is a valid empty archive and if so return.
     573         561 :   if (I == E) {
     574             :     Err = Error::success();
     575           4 :     return;
     576             :   }
     577         557 :   const Child *C = &*I;
     578             : 
     579             :   auto Increment = [&]() {
     580             :     ++I;
     581             :     if (Err)
     582             :       return true;
     583             :     C = &*I;
     584             :     return false;
     585         557 :   };
     586             : 
     587             :   Expected<StringRef> NameOrErr = C->getRawName();
     588         557 :   if (!NameOrErr) {
     589             :     Err = NameOrErr.takeError();
     590           0 :     return;
     591             :   }
     592         557 :   StringRef Name = NameOrErr.get();
     593             : 
     594             :   // Below is the pattern that is used to figure out the archive format
     595             :   // GNU archive format
     596             :   //  First member : / (may exist, if it exists, points to the symbol table )
     597             :   //  Second member : // (may exist, if it exists, points to the string table)
     598             :   //  Note : The string table is used if the filename exceeds 15 characters
     599             :   // BSD archive format
     600             :   //  First member : __.SYMDEF or "__.SYMDEF SORTED" (the symbol table)
     601             :   //  There is no string table, if the filename exceeds 15 characters or has a
     602             :   //  embedded space, the filename has #1/<size>, The size represents the size
     603             :   //  of the filename that needs to be read after the archive header
     604             :   // COFF archive format
     605             :   //  First member : /
     606             :   //  Second member : / (provides a directory of symbols)
     607             :   //  Third member : // (may exist, if it exists, contains the string table)
     608             :   //  Note: Microsoft PE/COFF Spec 8.3 says that the third member is present
     609             :   //  even if the string table is empty. However, lib.exe does not in fact
     610             :   //  seem to create the third member if there's no member whose filename
     611             :   //  exceeds 15 characters. So the third member is optional.
     612             : 
     613             :   if (Name == "__.SYMDEF" || Name == "__.SYMDEF_64") {
     614             :     if (Name == "__.SYMDEF")
     615           0 :       Format = K_BSD;
     616             :     else // Name == "__.SYMDEF_64"
     617           0 :       Format = K_DARWIN64;
     618             :     // We know that the symbol table is not an external file, but we still must
     619             :     // check any Expected<> return value.
     620           0 :     Expected<StringRef> BufOrErr = C->getBuffer();
     621           0 :     if (!BufOrErr) {
     622             :       Err = BufOrErr.takeError();
     623           0 :       return;
     624             :     }
     625           0 :     SymbolTable = BufOrErr.get();
     626           0 :     if (Increment())
     627             :       return;
     628           0 :     setFirstRegular(*C);
     629             : 
     630             :     Err = Error::success();
     631           0 :     return;
     632             :   }
     633             : 
     634             :   if (Name.startswith("#1/")) {
     635         127 :     Format = K_BSD;
     636             :     // We know this is BSD, so getName will work since there is no string table.
     637         127 :     Expected<StringRef> NameOrErr = C->getName();
     638         127 :     if (!NameOrErr) {
     639             :       Err = NameOrErr.takeError();
     640           0 :       return;
     641             :     }
     642         127 :     Name = NameOrErr.get();
     643             :     if (Name == "__.SYMDEF SORTED" || Name == "__.SYMDEF") {
     644             :       // We know that the symbol table is not an external file, but we still
     645             :       // must check any Expected<> return value.
     646         122 :       Expected<StringRef> BufOrErr = C->getBuffer();
     647         122 :       if (!BufOrErr) {
     648             :         Err = BufOrErr.takeError();
     649           0 :         return;
     650             :       }
     651         122 :       SymbolTable = BufOrErr.get();
     652         122 :       if (Increment())
     653             :         return;
     654             :     }
     655             :     else if (Name == "__.SYMDEF_64 SORTED" || Name == "__.SYMDEF_64") {
     656           2 :       Format = K_DARWIN64;
     657             :       // We know that the symbol table is not an external file, but we still
     658             :       // must check any Expected<> return value.
     659           2 :       Expected<StringRef> BufOrErr = C->getBuffer();
     660           2 :       if (!BufOrErr) {
     661             :         Err = BufOrErr.takeError();
     662           0 :         return;
     663             :       }
     664           2 :       SymbolTable = BufOrErr.get();
     665           2 :       if (Increment())
     666             :         return;
     667             :     }
     668         126 :     setFirstRegular(*C);
     669         126 :     return;
     670             :   }
     671             : 
     672             :   // MIPS 64-bit ELF archives use a special format of a symbol table.
     673             :   // This format is marked by `ar_name` field equals to "/SYM64/".
     674             :   // For detailed description see page 96 in the following document:
     675             :   // http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf
     676             : 
     677             :   bool has64SymTable = false;
     678             :   if (Name == "/" || Name == "/SYM64/") {
     679             :     // We know that the symbol table is not an external file, but we still
     680             :     // must check any Expected<> return value.
     681         360 :     Expected<StringRef> BufOrErr = C->getBuffer();
     682         360 :     if (!BufOrErr) {
     683             :       Err = BufOrErr.takeError();
     684           0 :       return;
     685             :     }
     686         360 :     SymbolTable = BufOrErr.get();
     687             :     if (Name == "/SYM64/")
     688             :       has64SymTable = true;
     689             : 
     690         360 :     if (Increment())
     691             :       return;
     692         360 :     if (I == E) {
     693             :       Err = Error::success();
     694           1 :       return;
     695             :     }
     696         359 :     Expected<StringRef> NameOrErr = C->getRawName();
     697         359 :     if (!NameOrErr) {
     698             :       Err = NameOrErr.takeError();
     699             :       return;
     700             :     }
     701         359 :     Name = NameOrErr.get();
     702             :   }
     703             : 
     704             :   if (Name == "//") {
     705         284 :     Format = has64SymTable ? K_GNU64 : K_GNU;
     706             :     // The string table is never an external member, but we still
     707             :     // must check any Expected<> return value.
     708         284 :     Expected<StringRef> BufOrErr = C->getBuffer();
     709         284 :     if (!BufOrErr) {
     710             :       Err = BufOrErr.takeError();
     711           0 :       return;
     712             :     }
     713         284 :     StringTable = BufOrErr.get();
     714         284 :     if (Increment())
     715             :       return;
     716         284 :     setFirstRegular(*C);
     717             :     Err = Error::success();
     718         284 :     return;
     719             :   }
     720             : 
     721         145 :   if (Name[0] != '/') {
     722          98 :     Format = has64SymTable ? K_GNU64 : K_GNU;
     723          98 :     setFirstRegular(*C);
     724             :     Err = Error::success();
     725          98 :     return;
     726             :   }
     727             : 
     728             :   if (Name != "/") {
     729           0 :     Err = errorCodeToError(object_error::parse_failed);
     730           0 :     return;
     731             :   }
     732             : 
     733          47 :   Format = K_COFF;
     734             :   // We know that the symbol table is not an external file, but we still
     735             :   // must check any Expected<> return value.
     736          47 :   Expected<StringRef> BufOrErr = C->getBuffer();
     737          47 :   if (!BufOrErr) {
     738             :     Err = BufOrErr.takeError();
     739           0 :     return;
     740             :   }
     741          47 :   SymbolTable = BufOrErr.get();
     742             : 
     743          47 :   if (Increment())
     744             :     return;
     745             : 
     746          47 :   if (I == E) {
     747           0 :     setFirstRegular(*C);
     748             :     Err = Error::success();
     749           0 :     return;
     750             :   }
     751             : 
     752          94 :   NameOrErr = C->getRawName();
     753          47 :   if (!NameOrErr) {
     754             :     Err = NameOrErr.takeError();
     755           0 :     return;
     756             :   }
     757          47 :   Name = NameOrErr.get();
     758             : 
     759             :   if (Name == "//") {
     760             :     // The string table is never an external member, but we still
     761             :     // must check any Expected<> return value.
     762           7 :     Expected<StringRef> BufOrErr = C->getBuffer();
     763           7 :     if (!BufOrErr) {
     764             :       Err = BufOrErr.takeError();
     765           0 :       return;
     766             :     }
     767           7 :     StringTable = BufOrErr.get();
     768           7 :     if (Increment())
     769             :       return;
     770             :   }
     771             : 
     772          47 :   setFirstRegular(*C);
     773             :   Err = Error::success();
     774             : }
     775             : 
     776         933 : Archive::child_iterator Archive::child_begin(Error &Err,
     777             :                                              bool SkipInternal) const {
     778         933 :   if (isEmpty())
     779           6 :     return child_end();
     780             : 
     781         927 :   if (SkipInternal)
     782         353 :     return child_iterator(Child(this, FirstRegularData,
     783         353 :                                 FirstRegularStartOfFile),
     784             :                           &Err);
     785             : 
     786         574 :   const char *Loc = Data.getBufferStart() + strlen(Magic);
     787         574 :   Child C(this, Loc, &Err);
     788         574 :   if (Err)
     789           3 :     return child_end();
     790             :   return child_iterator(C, &Err);
     791             : }
     792             : 
     793         943 : Archive::child_iterator Archive::child_end() const {
     794         943 :   return child_iterator(Child(nullptr, nullptr, nullptr), nullptr);
     795             : }
     796             : 
     797        1371 : StringRef Archive::Symbol::getName() const {
     798        1371 :   return Parent->getSymbolTable().begin() + StringIndex;
     799             : }
     800             : 
     801         369 : Expected<Archive::Child> Archive::Symbol::getMember() const {
     802         369 :   const char *Buf = Parent->getSymbolTable().begin();
     803             :   const char *Offsets = Buf;
     804         369 :   if (Parent->kind() == K_GNU64 || Parent->kind() == K_DARWIN64)
     805           8 :     Offsets += sizeof(uint64_t);
     806             :   else
     807         361 :     Offsets += sizeof(uint32_t);
     808             :   uint64_t Offset = 0;
     809         369 :   if (Parent->kind() == K_GNU) {
     810         418 :     Offset = read32be(Offsets + SymbolIndex * 4);
     811         160 :   } else if (Parent->kind() == K_GNU64) {
     812           3 :     Offset = read64be(Offsets + SymbolIndex * 8);
     813         157 :   } else if (Parent->kind() == K_BSD) {
     814             :     // The SymbolIndex is an index into the ranlib structs that start at
     815             :     // Offsets (the first uint32_t is the number of bytes of the ranlib
     816             :     // structs).  The ranlib structs are a pair of uint32_t's the first
     817             :     // being a string table offset and the second being the offset into
     818             :     // the archive of the member that defines the symbol.  Which is what
     819             :     // is needed here.
     820          32 :     Offset = read32le(Offsets + SymbolIndex * 8 + 4);
     821         141 :   } else if (Parent->kind() == K_DARWIN64) {
     822             :     // The SymbolIndex is an index into the ranlib_64 structs that start at
     823             :     // Offsets (the first uint64_t is the number of bytes of the ranlib_64
     824             :     // structs).  The ranlib_64 structs are a pair of uint64_t's the first
     825             :     // being a string table offset and the second being the offset into
     826             :     // the archive of the member that defines the symbol.  Which is what
     827             :     // is needed here.
     828           5 :     Offset = read64le(Offsets + SymbolIndex * 16 + 8);
     829             :   } else {
     830             :     // Skip offsets.
     831             :     uint32_t MemberCount = read32le(Buf);
     832         136 :     Buf += MemberCount * 4 + 4;
     833             : 
     834             :     uint32_t SymbolCount = read32le(Buf);
     835         136 :     if (SymbolIndex >= SymbolCount)
     836           0 :       return errorCodeToError(object_error::parse_failed);
     837             : 
     838             :     // Skip SymbolCount to get to the indices table.
     839             :     const char *Indices = Buf + 4;
     840             : 
     841             :     // Get the index of the offset in the file member offset table for this
     842             :     // symbol.
     843         136 :     uint16_t OffsetIndex = read16le(Indices + SymbolIndex * 2);
     844             :     // Subtract 1 since OffsetIndex is 1 based.
     845         136 :     --OffsetIndex;
     846             : 
     847         136 :     if (OffsetIndex >= MemberCount)
     848           0 :       return errorCodeToError(object_error::parse_failed);
     849             : 
     850         272 :     Offset = read32le(Offsets + OffsetIndex * 4);
     851             :   }
     852             : 
     853         369 :   const char *Loc = Parent->getData().begin() + Offset;
     854             :   Error Err = Error::success();
     855         369 :   Child C(Parent, Loc, &Err);
     856         369 :   if (Err)
     857             :     return std::move(Err);
     858             :   return C;
     859             : }
     860             : 
     861         807 : Archive::Symbol Archive::Symbol::getNext() const {
     862         807 :   Symbol t(*this);
     863         807 :   if (Parent->kind() == K_BSD) {
     864             :     // t.StringIndex is an offset from the start of the __.SYMDEF or
     865             :     // "__.SYMDEF SORTED" member into the string table for the ranlib
     866             :     // struct indexed by t.SymbolIndex .  To change t.StringIndex to the
     867             :     // offset in the string table for t.SymbolIndex+1 we subtract the
     868             :     // its offset from the start of the string table for t.SymbolIndex
     869             :     // and add the offset of the string table for t.SymbolIndex+1.
     870             : 
     871             :     // The __.SYMDEF or "__.SYMDEF SORTED" member starts with a uint32_t
     872             :     // which is the number of bytes of ranlib structs that follow.  The ranlib
     873             :     // structs are a pair of uint32_t's the first being a string table offset
     874             :     // and the second being the offset into the archive of the member that
     875             :     // define the symbol. After that the next uint32_t is the byte count of
     876             :     // the string table followed by the string table.
     877             :     const char *Buf = Parent->getSymbolTable().begin();
     878             :     uint32_t RanlibCount = 0;
     879          16 :     RanlibCount = read32le(Buf) / 8;
     880             :     // If t.SymbolIndex + 1 will be past the count of symbols (the RanlibCount)
     881             :     // don't change the t.StringIndex as we don't want to reference a ranlib
     882             :     // past RanlibCount.
     883          16 :     if (t.SymbolIndex + 1 < RanlibCount) {
     884           4 :       const char *Ranlibs = Buf + 4;
     885             :       uint32_t CurRanStrx = 0;
     886             :       uint32_t NextRanStrx = 0;
     887           4 :       CurRanStrx = read32le(Ranlibs + t.SymbolIndex * 8);
     888           4 :       NextRanStrx = read32le(Ranlibs + (t.SymbolIndex + 1) * 8);
     889           4 :       t.StringIndex -= CurRanStrx;
     890           4 :       t.StringIndex += NextRanStrx;
     891             :     }
     892             :   } else {
     893             :     // Go to one past next null.
     894        1582 :     t.StringIndex = Parent->getSymbolTable().find('\0', t.StringIndex) + 1;
     895             :   }
     896         807 :   ++t.SymbolIndex;
     897         807 :   return t;
     898             : }
     899             : 
     900         240 : Archive::symbol_iterator Archive::symbol_begin() const {
     901         240 :   if (!hasSymbolTable())
     902           7 :     return symbol_iterator(Symbol(this, 0, 0));
     903             : 
     904             :   const char *buf = getSymbolTable().begin();
     905         233 :   if (kind() == K_GNU) {
     906             :     uint32_t symbol_count = 0;
     907             :     symbol_count = read32be(buf);
     908         180 :     buf += sizeof(uint32_t) + (symbol_count * (sizeof(uint32_t)));
     909          53 :   } else if (kind() == K_GNU64) {
     910             :     uint64_t symbol_count = read64be(buf);
     911           1 :     buf += sizeof(uint64_t) + (symbol_count * (sizeof(uint64_t)));
     912          52 :   } else if (kind() == K_BSD) {
     913             :     // The __.SYMDEF or "__.SYMDEF SORTED" member starts with a uint32_t
     914             :     // which is the number of bytes of ranlib structs that follow.  The ranlib
     915             :     // structs are a pair of uint32_t's the first being a string table offset
     916             :     // and the second being the offset into the archive of the member that
     917             :     // define the symbol. After that the next uint32_t is the byte count of
     918             :     // the string table followed by the string table.
     919             :     uint32_t ranlib_count = 0;
     920          12 :     ranlib_count = read32le(buf) / 8;
     921             :     const char *ranlibs = buf + 4;
     922             :     uint32_t ran_strx = 0;
     923             :     ran_strx = read32le(ranlibs);
     924          12 :     buf += sizeof(uint32_t) + (ranlib_count * (2 * (sizeof(uint32_t))));
     925             :     // Skip the byte count of the string table.
     926             :     buf += sizeof(uint32_t);
     927          12 :     buf += ran_strx;
     928          40 :   } else if (kind() == K_DARWIN64) {
     929             :     // The __.SYMDEF_64 or "__.SYMDEF_64 SORTED" member starts with a uint64_t
     930             :     // which is the number of bytes of ranlib_64 structs that follow.  The
     931             :     // ranlib_64 structs are a pair of uint64_t's the first being a string
     932             :     // table offset and the second being the offset into the archive of the
     933             :     // member that define the symbol. After that the next uint64_t is the byte
     934             :     // count of the string table followed by the string table.
     935             :     uint64_t ranlib_count = 0;
     936             :     ranlib_count = read64le(buf) / 16;
     937             :     const char *ranlibs = buf + 8;
     938             :     uint64_t ran_strx = 0;
     939             :     ran_strx = read64le(ranlibs);
     940           2 :     buf += sizeof(uint64_t) + (ranlib_count * (2 * (sizeof(uint64_t))));
     941             :     // Skip the byte count of the string table.
     942             :     buf += sizeof(uint64_t);
     943           2 :     buf += ran_strx;
     944             :   } else {
     945             :     uint32_t member_count = 0;
     946             :     uint32_t symbol_count = 0;
     947             :     member_count = read32le(buf);
     948          38 :     buf += 4 + (member_count * 4); // Skip offsets.
     949             :     symbol_count = read32le(buf);
     950          38 :     buf += 4 + (symbol_count * 2); // Skip indices.
     951             :   }
     952         233 :   uint32_t string_start_offset = buf - getSymbolTable().begin();
     953         233 :   return symbol_iterator(Symbol(this, 0, string_start_offset));
     954             : }
     955             : 
     956         240 : Archive::symbol_iterator Archive::symbol_end() const {
     957         240 :   return symbol_iterator(Symbol(this, getNumberOfSymbols(), 0));
     958             : }
     959             : 
     960         240 : uint32_t Archive::getNumberOfSymbols() const {
     961         240 :   if (!hasSymbolTable())
     962             :     return 0;
     963             :   const char *buf = getSymbolTable().begin();
     964         233 :   if (kind() == K_GNU)
     965         180 :     return read32be(buf);
     966          53 :   if (kind() == K_GNU64)
     967           1 :     return read64be(buf);
     968          52 :   if (kind() == K_BSD)
     969          12 :     return read32le(buf) / 8;
     970          40 :   if (kind() == K_DARWIN64)
     971           2 :     return read64le(buf) / 16;
     972             :   uint32_t member_count = 0;
     973             :   member_count = read32le(buf);
     974          38 :   buf += 4 + (member_count * 4); // Skip offsets.
     975          38 :   return read32le(buf);
     976             : }
     977             : 
     978           5 : Expected<Optional<Archive::Child>> Archive::findSym(StringRef name) const {
     979           5 :   Archive::symbol_iterator bs = symbol_begin();
     980           5 :   Archive::symbol_iterator es = symbol_end();
     981             : 
     982             :   for (; bs != es; ++bs) {
     983           8 :     StringRef SymName = bs->getName();
     984             :     if (SymName == name) {
     985           4 :       if (auto MemberOrErr = bs->getMember())
     986           4 :         return Child(*MemberOrErr);
     987             :       else
     988             :         return MemberOrErr.takeError();
     989             :     }
     990             :   }
     991             :   return Optional<Child>();
     992             : }
     993             : 
     994             : // Returns true if archive file contains no member file.
     995        2080 : bool Archive::isEmpty() const { return Data.getBufferSize() == 8; }
     996             : 
     997        1198 : bool Archive::hasSymbolTable() const { return !SymbolTable.empty(); }

Generated by: LCOV version 1.13