LLVM 17.0.0git
Archive.cpp
Go to the documentation of this file.
1//===- Archive.cpp - ar File Format implementation ------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the ArchiveObjectFile class.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/Object/Archive.h"
15#include "llvm/ADT/StringRef.h"
16#include "llvm/ADT/Twine.h"
17#include "llvm/Object/Binary.h"
18#include "llvm/Object/Error.h"
19#include "llvm/Support/Chrono.h"
20#include "llvm/Support/Endian.h"
21#include "llvm/Support/Error.h"
26#include "llvm/Support/Path.h"
29#include <algorithm>
30#include <cassert>
31#include <cstddef>
32#include <cstdint>
33#include <memory>
34#include <string>
35#include <system_error>
36
37using namespace llvm;
38using namespace object;
39using namespace llvm::support::endian;
40
41void Archive::anchor() {}
42
44 std::string StringMsg = "truncated or malformed archive (" + Msg.str() + ")";
45 return make_error<GenericBinaryError>(std::move(StringMsg),
47}
48
49static Error
51 const char *RawHeaderPtr, uint64_t Size) {
52 StringRef Msg("remaining size of archive too small for next archive "
53 "member header ");
54
55 Expected<StringRef> NameOrErr = ArMemHeader->getName(Size);
56 if (NameOrErr)
57 return malformedError(Msg + "for " + *NameOrErr);
58
59 consumeError(NameOrErr.takeError());
60 uint64_t Offset = RawHeaderPtr - ArMemHeader->Parent->getData().data();
61 return malformedError(Msg + "at offset " + Twine(Offset));
62}
63
64template <class T, std::size_t N>
66 return StringRef(Field, N).rtrim(" ");
67}
68
69template <class T>
71 return getFieldRawString(ArMemHdr->AccessMode);
72}
73
74template <class T>
76 return getFieldRawString(ArMemHdr->LastModified);
77}
78
80 return getFieldRawString(ArMemHdr->UID);
84 return getFieldRawString(ArMemHdr->GID);
85}
88 return reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
89}
90
93
95 const char *RawHeaderPtr,
96 uint64_t Size, Error *Err)
98 Parent, reinterpret_cast<const UnixArMemHdrType *>(RawHeaderPtr)) {
99 if (RawHeaderPtr == nullptr)
100 return;
101 ErrorAsOutParameter ErrAsOutParam(Err);
102
103 if (Size < getSizeOf()) {
104 *Err = createMemberHeaderParseError(this, RawHeaderPtr, Size);
105 return;
106 }
107 if (ArMemHdr->Terminator[0] != '`' || ArMemHdr->Terminator[1] != '\n') {
108 if (Err) {
109 std::string Buf;
113 OS.flush();
114 std::string Msg("terminator characters in archive member \"" + Buf +
115 "\" not the correct \"`\\n\" values for the archive "
116 "member header ");
117 Expected<StringRef> NameOrErr = getName(Size);
118 if (!NameOrErr) {
119 consumeError(NameOrErr.takeError());
120 uint64_t Offset = RawHeaderPtr - Parent->getData().data();
121 *Err = malformedError(Msg + "at offset " + Twine(Offset));
122 } else
123 *Err = malformedError(Msg + "for " + NameOrErr.get());
124 }
125 return;
126 }
127}
128
130 const char *RawHeaderPtr,
131 uint64_t Size, Error *Err)
133 Parent, reinterpret_cast<const BigArMemHdrType *>(RawHeaderPtr)) {
134 if (RawHeaderPtr == nullptr)
135 return;
136 ErrorAsOutParameter ErrAsOutParam(Err);
137
138 if (RawHeaderPtr + getSizeOf() >= Parent->getData().end()) {
139 if (Err)
140 *Err = malformedError("malformed AIX big archive: remaining buffer is "
141 "unable to contain next archive member");
142 return;
143 }
144
145 if (Size < getSizeOf()) {
146 Error SubErr = createMemberHeaderParseError(this, RawHeaderPtr, Size);
147 if (Err)
148 *Err = std::move(SubErr);
149 }
150}
151
152// This gets the raw name from the ArMemHdr->Name field and checks that it is
153// valid for the kind of archive. If it is not valid it returns an Error.
155 char EndCond;
156 auto Kind = Parent->kind();
158 if (ArMemHdr->Name[0] == ' ') {
160 reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
161 return malformedError("name contains a leading space for archive member "
162 "header at offset " +
163 Twine(Offset));
164 }
165 EndCond = ' ';
166 } else if (ArMemHdr->Name[0] == '/' || ArMemHdr->Name[0] == '#')
167 EndCond = ' ';
168 else
169 EndCond = '/';
171 StringRef(ArMemHdr->Name, sizeof(ArMemHdr->Name)).find(EndCond);
172 if (end == StringRef::npos)
173 end = sizeof(ArMemHdr->Name);
174 assert(end <= sizeof(ArMemHdr->Name) && end > 0);
175 // Don't include the EndCond if there is one.
176 return StringRef(ArMemHdr->Name, end);
177}
178
180getArchiveMemberDecField(Twine FieldName, const StringRef RawField,
181 const Archive *Parent,
182 const AbstractArchiveMemberHeader *MemHeader) {
184 if (RawField.getAsInteger(10, Value)) {
185 uint64_t Offset = MemHeader->getOffset();
186 return malformedError("characters in " + FieldName +
187 " field in archive member header are not "
188 "all decimal numbers: '" +
189 RawField +
190 "' for the archive "
191 "member header at offset " +
192 Twine(Offset));
193 }
194 return Value;
195}
196
198getArchiveMemberOctField(Twine FieldName, const StringRef RawField,
199 const Archive *Parent,
200 const AbstractArchiveMemberHeader *MemHeader) {
202 if (RawField.getAsInteger(8, Value)) {
203 uint64_t Offset = MemHeader->getOffset();
204 return malformedError("characters in " + FieldName +
205 " field in archive member header are not "
206 "all octal numbers: '" +
207 RawField +
208 "' for the archive "
209 "member header at offset " +
210 Twine(Offset));
211 }
212 return Value;
213}
214
217 "NameLen", getFieldRawString(ArMemHdr->NameLen), Parent, this);
218 if (!NameLenOrErr)
219 // TODO: Out-of-line.
220 return NameLenOrErr.takeError();
221 uint64_t NameLen = NameLenOrErr.get();
222
223 // If the name length is odd, pad with '\0' to get an even length. After
224 // padding, there is the name terminator "`\n".
225 uint64_t NameLenWithPadding = alignTo(NameLen, 2);
226 StringRef NameTerminator = "`\n";
227 StringRef NameStringWithNameTerminator =
228 StringRef(ArMemHdr->Name, NameLenWithPadding + NameTerminator.size());
229 if (!NameStringWithNameTerminator.endswith(NameTerminator)) {
231 reinterpret_cast<const char *>(ArMemHdr->Name + NameLenWithPadding) -
232 Parent->getData().data();
233 // TODO: Out-of-line.
234 return malformedError(
235 "name does not have name terminator \"`\\n\" for archive member"
236 "header at offset " +
237 Twine(Offset));
238 }
239 return StringRef(ArMemHdr->Name, NameLen);
240}
241
242// member including the header, so the size of any name following the header
243// is checked to make sure it does not overflow.
245
246 // This can be called from the ArchiveMemberHeader constructor when the
247 // archive header is truncated to produce an error message with the name.
248 // Make sure the name field is not truncated.
249 if (Size < offsetof(UnixArMemHdrType, Name) + sizeof(ArMemHdr->Name)) {
250 uint64_t ArchiveOffset =
251 reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
252 return malformedError("archive header truncated before the name field "
253 "for archive member header at offset " +
254 Twine(ArchiveOffset));
255 }
256
257 // The raw name itself can be invalid.
258 Expected<StringRef> NameOrErr = getRawName();
259 if (!NameOrErr)
260 return NameOrErr.takeError();
261 StringRef Name = NameOrErr.get();
262
263 // Check if it's a special name.
264 if (Name[0] == '/') {
265 if (Name.size() == 1) // Linker member.
266 return Name;
267 if (Name.size() == 2 && Name[1] == '/') // String table.
268 return Name;
269 // System libraries from the Windows SDK for Windows 11 contain this symbol.
270 // It looks like a CFG guard: we just skip it for now.
271 if (Name.equals("/<XFGHASHMAP>/"))
272 return Name;
273 // Some libraries (e.g., arm64rt.lib) from the Windows WDK
274 // (version 10.0.22000.0) contain this undocumented special member.
275 if (Name.equals("/<ECSYMBOLS>/"))
276 return Name;
277 // It's a long name.
278 // Get the string table offset.
279 std::size_t StringOffset;
280 if (Name.substr(1).rtrim(' ').getAsInteger(10, StringOffset)) {
281 std::string Buf;
283 OS.write_escaped(Name.substr(1).rtrim(' '));
284 OS.flush();
285 uint64_t ArchiveOffset =
286 reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
287 return malformedError("long name offset characters after the '/' are "
288 "not all decimal numbers: '" +
289 Buf + "' for archive member header at offset " +
290 Twine(ArchiveOffset));
291 }
292
293 // Verify it.
294 if (StringOffset >= Parent->getStringTable().size()) {
295 uint64_t ArchiveOffset =
296 reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
297 return malformedError("long name offset " + Twine(StringOffset) +
298 " past the end of the string table for archive "
299 "member header at offset " +
300 Twine(ArchiveOffset));
301 }
302
303 // GNU long file names end with a "/\n".
304 if (Parent->kind() == Archive::K_GNU ||
306 size_t End = Parent->getStringTable().find('\n', /*From=*/StringOffset);
307 if (End == StringRef::npos || End < 1 ||
308 Parent->getStringTable()[End - 1] != '/') {
309 return malformedError("string table at long name offset " +
310 Twine(StringOffset) + "not terminated");
311 }
312 return Parent->getStringTable().slice(StringOffset, End - 1);
313 }
314 return Parent->getStringTable().begin() + StringOffset;
315 }
316
317 if (Name.startswith("#1/")) {
318 uint64_t NameLength;
319 if (Name.substr(3).rtrim(' ').getAsInteger(10, NameLength)) {
320 std::string Buf;
322 OS.write_escaped(Name.substr(3).rtrim(' '));
323 OS.flush();
324 uint64_t ArchiveOffset =
325 reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
326 return malformedError("long name length characters after the #1/ are "
327 "not all decimal numbers: '" +
328 Buf + "' for archive member header at offset " +
329 Twine(ArchiveOffset));
330 }
331 if (getSizeOf() + NameLength > Size) {
332 uint64_t ArchiveOffset =
333 reinterpret_cast<const char *>(ArMemHdr) - Parent->getData().data();
334 return malformedError("long name length: " + Twine(NameLength) +
335 " extends past the end of the member or archive "
336 "for archive member header at offset " +
337 Twine(ArchiveOffset));
338 }
339 return StringRef(reinterpret_cast<const char *>(ArMemHdr) + getSizeOf(),
340 NameLength)
341 .rtrim('\0');
342 }
343
344 // It is not a long name so trim the blanks at the end of the name.
345 if (Name[Name.size() - 1] != '/')
346 return Name.rtrim(' ');
347
348 // It's a simple name.
349 return Name.drop_back(1);
350}
351
353 return getRawName();
354}
355
358 Parent, this);
359}
360
363 "size", getFieldRawString(ArMemHdr->Size), Parent, this);
364 if (!SizeOrErr)
365 return SizeOrErr.takeError();
366
367 Expected<uint64_t> NameLenOrErr = getRawNameSize();
368 if (!NameLenOrErr)
369 return NameLenOrErr.takeError();
370
371 return *SizeOrErr + alignTo(*NameLenOrErr, 2);
372}
373
376 "NameLen", getFieldRawString(ArMemHdr->NameLen), Parent, this);
377}
378
381 "NextOffset", getFieldRawString(ArMemHdr->NextOffset), Parent, this);
382}
383
385 Expected<uint64_t> AccessModeOrErr =
386 getArchiveMemberOctField("AccessMode", getRawAccessMode(), Parent, this);
387 if (!AccessModeOrErr)
388 return AccessModeOrErr.takeError();
389 return static_cast<sys::fs::perms>(*AccessModeOrErr);
390}
391
395 "LastModified", getRawLastModified(), Parent, this);
396
397 if (!SecondsOrErr)
398 return SecondsOrErr.takeError();
399
400 return sys::toTimePoint(*SecondsOrErr);
401}
402
405 if (User.empty())
406 return 0;
407 return getArchiveMemberDecField("UID", User, Parent, this);
408}
409
411 StringRef Group = getRawGID();
412 if (Group.empty())
413 return 0;
414 return getArchiveMemberDecField("GID", Group, Parent, this);
415}
416
418 Expected<StringRef> NameOrErr = getRawName();
419 if (!NameOrErr)
420 return NameOrErr.takeError();
421 StringRef Name = NameOrErr.get();
422 return Parent->isThin() && Name != "/" && Name != "//" && Name != "/SYM64/";
423}
424
427 Expected<bool> isThinOrErr = isThin();
428 if (!isThinOrErr)
429 return isThinOrErr.takeError();
430
431 bool isThin = isThinOrErr.get();
432 if (!isThin) {
433 Expected<uint64_t> MemberSize = getSize();
434 if (!MemberSize)
435 return MemberSize.takeError();
436
437 Size += MemberSize.get();
438 }
439
440 // If Size is odd, add 1 to make it even.
441 const char *NextLoc =
442 reinterpret_cast<const char *>(ArMemHdr) + alignTo(Size, 2);
443
444 if (NextLoc == Parent->getMemoryBufferRef().getBufferEnd())
445 return nullptr;
446
447 return NextLoc;
448}
449
451 if (getOffset() ==
452 static_cast<const BigArchive *>(Parent)->getLastChildOffset())
453 return nullptr;
454
455 Expected<uint64_t> NextOffsetOrErr = getNextOffset();
456 if (!NextOffsetOrErr)
457 return NextOffsetOrErr.takeError();
458 return Parent->getData().data() + NextOffsetOrErr.get();
459}
460
462 uint16_t StartOfFile)
463 : Parent(Parent), Data(Data), StartOfFile(StartOfFile) {
464 Header = Parent->createArchiveMemberHeader(Data.data(), Data.size(), nullptr);
465}
466
467Archive::Child::Child(const Archive *Parent, const char *Start, Error *Err)
468 : Parent(Parent) {
469 if (!Start) {
470 Header = nullptr;
471 return;
472 }
473
474 Header = Parent->createArchiveMemberHeader(
475 Start,
476 Parent ? Parent->getData().size() - (Start - Parent->getData().data())
477 : 0,
478 Err);
479
480 // If we are pointed to real data, Start is not a nullptr, then there must be
481 // a non-null Err pointer available to report malformed data on. Only in
482 // the case sentinel value is being constructed is Err is permitted to be a
483 // nullptr.
484 assert(Err && "Err can't be nullptr if Start is not a nullptr");
485
486 ErrorAsOutParameter ErrAsOutParam(Err);
487
488 // If there was an error in the construction of the Header
489 // then just return with the error now set.
490 if (*Err)
491 return;
492
493 uint64_t Size = Header->getSizeOf();
494 Data = StringRef(Start, Size);
495 Expected<bool> isThinOrErr = isThinMember();
496 if (!isThinOrErr) {
497 *Err = isThinOrErr.takeError();
498 return;
499 }
500 bool isThin = isThinOrErr.get();
501 if (!isThin) {
502 Expected<uint64_t> MemberSize = getRawSize();
503 if (!MemberSize) {
504 *Err = MemberSize.takeError();
505 return;
506 }
507 Size += MemberSize.get();
508 Data = StringRef(Start, Size);
509 }
510
511 // Setup StartOfFile and PaddingBytes.
512 StartOfFile = Header->getSizeOf();
513 // Don't include attached name.
514 Expected<StringRef> NameOrErr = getRawName();
515 if (!NameOrErr) {
516 *Err = NameOrErr.takeError();
517 return;
518 }
519 StringRef Name = NameOrErr.get();
520
521 if (Parent->kind() == Archive::K_AIXBIG) {
522 // The actual start of the file is after the name and any necessary
523 // even-alignment padding.
524 StartOfFile += ((Name.size() + 1) >> 1) << 1;
525 } else if (Name.startswith("#1/")) {
527 StringRef RawNameSize = Name.substr(3).rtrim(' ');
528 if (RawNameSize.getAsInteger(10, NameSize)) {
529 uint64_t Offset = Start - Parent->getData().data();
530 *Err = malformedError("long name length characters after the #1/ are "
531 "not all decimal numbers: '" +
532 RawNameSize +
533 "' for archive member header at offset " +
534 Twine(Offset));
535 return;
536 }
537 StartOfFile += NameSize;
538 }
539}
540
542 if (Parent->IsThin)
543 return Header->getSize();
544 return Data.size() - StartOfFile;
545}
546
548 return Header->getSize();
549}
550
551Expected<bool> Archive::Child::isThinMember() const { return Header->isThin(); }
552
554 Expected<bool> isThin = isThinMember();
555 if (!isThin)
556 return isThin.takeError();
557 assert(isThin.get());
558 Expected<StringRef> NameOrErr = getName();
559 if (!NameOrErr)
560 return NameOrErr.takeError();
561 StringRef Name = *NameOrErr;
563 return std::string(Name);
564
566 Parent->getMemoryBufferRef().getBufferIdentifier());
567 sys::path::append(FullName, Name);
568 return std::string(FullName.str());
569}
570
572 Expected<bool> isThinOrErr = isThinMember();
573 if (!isThinOrErr)
574 return isThinOrErr.takeError();
575 bool isThin = isThinOrErr.get();
576 if (!isThin) {
578 if (!Size)
579 return Size.takeError();
580 return StringRef(Data.data() + StartOfFile, Size.get());
581 }
582 Expected<std::string> FullNameOrErr = getFullName();
583 if (!FullNameOrErr)
584 return FullNameOrErr.takeError();
585 const std::string &FullName = *FullNameOrErr;
587 if (std::error_code EC = Buf.getError())
588 return errorCodeToError(EC);
589 Parent->ThinBuffers.push_back(std::move(*Buf));
590 return Parent->ThinBuffers.back()->getBuffer();
591}
592
594 Expected<const char *> NextLocOrErr = Header->getNextChildLoc();
595 if (!NextLocOrErr)
596 return NextLocOrErr.takeError();
597
598 const char *NextLoc = *NextLocOrErr;
599
600 // Check to see if this is at the end of the archive.
601 if (NextLoc == nullptr)
602 return Child(nullptr, nullptr, nullptr);
603
604 // Check to see if this is past the end of the archive.
605 if (NextLoc > Parent->Data.getBufferEnd()) {
606 std::string Msg("offset to next archive member past the end of the archive "
607 "after member ");
608 Expected<StringRef> NameOrErr = getName();
609 if (!NameOrErr) {
610 consumeError(NameOrErr.takeError());
611 uint64_t Offset = Data.data() - Parent->getData().data();
612 return malformedError(Msg + "at offset " + Twine(Offset));
613 } else
614 return malformedError(Msg + NameOrErr.get());
615 }
616
617 Error Err = Error::success();
618 Child Ret(Parent, NextLoc, &Err);
619 if (Err)
620 return std::move(Err);
621 return Ret;
622}
623
625 const char *a = Parent->Data.getBuffer().data();
626 const char *c = Data.data();
627 uint64_t offset = c - a;
628 return offset;
629}
630
632 Expected<uint64_t> RawSizeOrErr = getRawSize();
633 if (!RawSizeOrErr)
634 return RawSizeOrErr.takeError();
635 uint64_t RawSize = RawSizeOrErr.get();
636 Expected<StringRef> NameOrErr =
637 Header->getName(Header->getSizeOf() + RawSize);
638 if (!NameOrErr)
639 return NameOrErr.takeError();
640 StringRef Name = NameOrErr.get();
641 return Name;
642}
643
645 Expected<StringRef> NameOrErr = getName();
646 if (!NameOrErr)
647 return NameOrErr.takeError();
648 StringRef Name = NameOrErr.get();
649 Expected<StringRef> Buf = getBuffer();
650 if (!Buf)
651 return createFileError(Name, Buf.takeError());
652 return MemoryBufferRef(*Buf, Name);
653}
654
658 if (!BuffOrErr)
659 return BuffOrErr.takeError();
660
661 auto BinaryOrErr = createBinary(BuffOrErr.get(), Context);
662 if (BinaryOrErr)
663 return std::move(*BinaryOrErr);
664 return BinaryOrErr.takeError();
665}
666
668 Error Err = Error::success();
669 std::unique_ptr<Archive> Ret;
670 StringRef Buffer = Source.getBuffer();
671
672 if (Buffer.startswith(BigArchiveMagic))
673 Ret = std::make_unique<BigArchive>(Source, Err);
674 else
675 Ret = std::make_unique<Archive>(Source, Err);
676
677 if (Err)
678 return std::move(Err);
679 return std::move(Ret);
680}
681
682std::unique_ptr<AbstractArchiveMemberHeader>
684 Error *Err) const {
685 ErrorAsOutParameter ErrAsOutParam(Err);
686 if (kind() != K_AIXBIG)
687 return std::make_unique<ArchiveMemberHeader>(this, RawHeaderPtr, Size, Err);
688 return std::make_unique<BigArchiveMemberHeader>(this, RawHeaderPtr, Size,
689 Err);
690}
691
693 if (isThin())
694 return sizeof(ThinArchiveMagic) - 1;
695
696 if (Kind() == K_AIXBIG)
697 return sizeof(BigArchiveMagic) - 1;
698
699 return sizeof(ArchiveMagic) - 1;
700}
701
703 FirstRegularData = C.Data;
704 FirstRegularStartOfFile = C.StartOfFile;
705}
706
708 : Binary(Binary::ID_Archive, Source) {
709 ErrorAsOutParameter ErrAsOutParam(&Err);
710 StringRef Buffer = Data.getBuffer();
711 // Check for sufficient magic.
712 if (Buffer.startswith(ThinArchiveMagic)) {
713 IsThin = true;
714 } else if (Buffer.startswith(ArchiveMagic)) {
715 IsThin = false;
716 } else if (Buffer.startswith(BigArchiveMagic)) {
717 Format = K_AIXBIG;
718 IsThin = false;
719 return;
720 } else {
721 Err = make_error<GenericBinaryError>("file too small to be an archive",
723 return;
724 }
725
726 // Make sure Format is initialized before any call to
727 // ArchiveMemberHeader::getName() is made. This could be a valid empty
728 // archive which is the same in all formats. So claiming it to be gnu to is
729 // fine if not totally correct before we look for a string table or table of
730 // contents.
731 Format = K_GNU;
732
733 // Get the special members.
734 child_iterator I = child_begin(Err, false);
735 if (Err)
736 return;
738
739 // See if this is a valid empty archive and if so return.
740 if (I == E) {
741 Err = Error::success();
742 return;
743 }
744 const Child *C = &*I;
745
746 auto Increment = [&]() {
747 ++I;
748 if (Err)
749 return true;
750 C = &*I;
751 return false;
752 };
753
754 Expected<StringRef> NameOrErr = C->getRawName();
755 if (!NameOrErr) {
756 Err = NameOrErr.takeError();
757 return;
758 }
759 StringRef Name = NameOrErr.get();
760
761 // Below is the pattern that is used to figure out the archive format
762 // GNU archive format
763 // First member : / (may exist, if it exists, points to the symbol table )
764 // Second member : // (may exist, if it exists, points to the string table)
765 // Note : The string table is used if the filename exceeds 15 characters
766 // BSD archive format
767 // First member : __.SYMDEF or "__.SYMDEF SORTED" (the symbol table)
768 // There is no string table, if the filename exceeds 15 characters or has a
769 // embedded space, the filename has #1/<size>, The size represents the size
770 // of the filename that needs to be read after the archive header
771 // COFF archive format
772 // First member : /
773 // Second member : / (provides a directory of symbols)
774 // Third member : // (may exist, if it exists, contains the string table)
775 // Note: Microsoft PE/COFF Spec 8.3 says that the third member is present
776 // even if the string table is empty. However, lib.exe does not in fact
777 // seem to create the third member if there's no member whose filename
778 // exceeds 15 characters. So the third member is optional.
779
780 if (Name == "__.SYMDEF" || Name == "__.SYMDEF_64") {
781 if (Name == "__.SYMDEF")
782 Format = K_BSD;
783 else // Name == "__.SYMDEF_64"
784 Format = K_DARWIN64;
785 // We know that the symbol table is not an external file, but we still must
786 // check any Expected<> return value.
787 Expected<StringRef> BufOrErr = C->getBuffer();
788 if (!BufOrErr) {
789 Err = BufOrErr.takeError();
790 return;
791 }
792 SymbolTable = BufOrErr.get();
793 if (Increment())
794 return;
796
797 Err = Error::success();
798 return;
799 }
800
801 if (Name.startswith("#1/")) {
802 Format = K_BSD;
803 // We know this is BSD, so getName will work since there is no string table.
804 Expected<StringRef> NameOrErr = C->getName();
805 if (!NameOrErr) {
806 Err = NameOrErr.takeError();
807 return;
808 }
809 Name = NameOrErr.get();
810 if (Name == "__.SYMDEF SORTED" || Name == "__.SYMDEF") {
811 // We know that the symbol table is not an external file, but we still
812 // must check any Expected<> return value.
813 Expected<StringRef> BufOrErr = C->getBuffer();
814 if (!BufOrErr) {
815 Err = BufOrErr.takeError();
816 return;
817 }
818 SymbolTable = BufOrErr.get();
819 if (Increment())
820 return;
821 } else if (Name == "__.SYMDEF_64 SORTED" || Name == "__.SYMDEF_64") {
822 Format = K_DARWIN64;
823 // We know that the symbol table is not an external file, but we still
824 // must check any Expected<> return value.
825 Expected<StringRef> BufOrErr = C->getBuffer();
826 if (!BufOrErr) {
827 Err = BufOrErr.takeError();
828 return;
829 }
830 SymbolTable = BufOrErr.get();
831 if (Increment())
832 return;
833 }
835 return;
836 }
837
838 // MIPS 64-bit ELF archives use a special format of a symbol table.
839 // This format is marked by `ar_name` field equals to "/SYM64/".
840 // For detailed description see page 96 in the following document:
841 // http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf
842
843 bool has64SymTable = false;
844 if (Name == "/" || Name == "/SYM64/") {
845 // We know that the symbol table is not an external file, but we still
846 // must check any Expected<> return value.
847 Expected<StringRef> BufOrErr = C->getBuffer();
848 if (!BufOrErr) {
849 Err = BufOrErr.takeError();
850 return;
851 }
852 SymbolTable = BufOrErr.get();
853 if (Name == "/SYM64/")
854 has64SymTable = true;
855
856 if (Increment())
857 return;
858 if (I == E) {
859 Err = Error::success();
860 return;
861 }
862 Expected<StringRef> NameOrErr = C->getRawName();
863 if (!NameOrErr) {
864 Err = NameOrErr.takeError();
865 return;
866 }
867 Name = NameOrErr.get();
868 }
869
870 if (Name == "//") {
871 Format = has64SymTable ? K_GNU64 : K_GNU;
872 // The string table is never an external member, but we still
873 // must check any Expected<> return value.
874 Expected<StringRef> BufOrErr = C->getBuffer();
875 if (!BufOrErr) {
876 Err = BufOrErr.takeError();
877 return;
878 }
879 StringTable = BufOrErr.get();
880 if (Increment())
881 return;
883 Err = Error::success();
884 return;
885 }
886
887 if (Name[0] != '/') {
888 Format = has64SymTable ? K_GNU64 : K_GNU;
890 Err = Error::success();
891 return;
892 }
893
894 if (Name != "/") {
896 return;
897 }
898
899 Format = K_COFF;
900 // We know that the symbol table is not an external file, but we still
901 // must check any Expected<> return value.
902 Expected<StringRef> BufOrErr = C->getBuffer();
903 if (!BufOrErr) {
904 Err = BufOrErr.takeError();
905 return;
906 }
907 SymbolTable = BufOrErr.get();
908
909 if (Increment())
910 return;
911
912 if (I == E) {
914 Err = Error::success();
915 return;
916 }
917
918 NameOrErr = C->getRawName();
919 if (!NameOrErr) {
920 Err = NameOrErr.takeError();
921 return;
922 }
923 Name = NameOrErr.get();
924
925 if (Name == "//") {
926 // The string table is never an external member, but we still
927 // must check any Expected<> return value.
928 Expected<StringRef> BufOrErr = C->getBuffer();
929 if (!BufOrErr) {
930 Err = BufOrErr.takeError();
931 return;
932 }
933 StringTable = BufOrErr.get();
934 if (Increment())
935 return;
936 }
937
939 Err = Error::success();
940}
941
943 Triple HostTriple(sys::getProcessTriple());
944 return HostTriple.isOSDarwin()
946 : (HostTriple.isOSAIX() ? object::Archive::K_AIXBIG
948}
949
951 bool SkipInternal) const {
952 if (isEmpty())
953 return child_end();
954
955 if (SkipInternal)
956 return child_iterator::itr(
957 Child(this, FirstRegularData, FirstRegularStartOfFile), Err);
958
959 const char *Loc = Data.getBufferStart() + getFirstChildOffset();
960 Child C(this, Loc, &Err);
961 if (Err)
962 return child_end();
963 return child_iterator::itr(C, Err);
964}
965
967 return child_iterator::end(Child(nullptr, nullptr, nullptr));
968}
969
971 return Parent->getSymbolTable().begin() + StringIndex;
972}
973
975 const char *Buf = Parent->getSymbolTable().begin();
976 const char *Offsets = Buf;
977 if (Parent->kind() == K_GNU64 || Parent->kind() == K_DARWIN64 ||
978 Parent->kind() == K_AIXBIG)
979 Offsets += sizeof(uint64_t);
980 else
981 Offsets += sizeof(uint32_t);
982 uint64_t Offset = 0;
983 if (Parent->kind() == K_GNU) {
984 Offset = read32be(Offsets + SymbolIndex * 4);
985 } else if (Parent->kind() == K_GNU64 || Parent->kind() == K_AIXBIG) {
986 Offset = read64be(Offsets + SymbolIndex * 8);
987 } else if (Parent->kind() == K_BSD) {
988 // The SymbolIndex is an index into the ranlib structs that start at
989 // Offsets (the first uint32_t is the number of bytes of the ranlib
990 // structs). The ranlib structs are a pair of uint32_t's the first
991 // being a string table offset and the second being the offset into
992 // the archive of the member that defines the symbol. Which is what
993 // is needed here.
994 Offset = read32le(Offsets + SymbolIndex * 8 + 4);
995 } else if (Parent->kind() == K_DARWIN64) {
996 // The SymbolIndex is an index into the ranlib_64 structs that start at
997 // Offsets (the first uint64_t is the number of bytes of the ranlib_64
998 // structs). The ranlib_64 structs are a pair of uint64_t's the first
999 // being a string table offset and the second being the offset into
1000 // the archive of the member that defines the symbol. Which is what
1001 // is needed here.
1002 Offset = read64le(Offsets + SymbolIndex * 16 + 8);
1003 } else {
1004 // Skip offsets.
1005 uint32_t MemberCount = read32le(Buf);
1006 Buf += MemberCount * 4 + 4;
1007
1008 uint32_t SymbolCount = read32le(Buf);
1009 if (SymbolIndex >= SymbolCount)
1011
1012 // Skip SymbolCount to get to the indices table.
1013 const char *Indices = Buf + 4;
1014
1015 // Get the index of the offset in the file member offset table for this
1016 // symbol.
1017 uint16_t OffsetIndex = read16le(Indices + SymbolIndex * 2);
1018 // Subtract 1 since OffsetIndex is 1 based.
1019 --OffsetIndex;
1020
1021 if (OffsetIndex >= MemberCount)
1023
1024 Offset = read32le(Offsets + OffsetIndex * 4);
1025 }
1026
1027 const char *Loc = Parent->getData().begin() + Offset;
1028 Error Err = Error::success();
1029 Child C(Parent, Loc, &Err);
1030 if (Err)
1031 return std::move(Err);
1032 return C;
1033}
1034
1036 Symbol t(*this);
1037 if (Parent->kind() == K_BSD) {
1038 // t.StringIndex is an offset from the start of the __.SYMDEF or
1039 // "__.SYMDEF SORTED" member into the string table for the ranlib
1040 // struct indexed by t.SymbolIndex . To change t.StringIndex to the
1041 // offset in the string table for t.SymbolIndex+1 we subtract the
1042 // its offset from the start of the string table for t.SymbolIndex
1043 // and add the offset of the string table for t.SymbolIndex+1.
1044
1045 // The __.SYMDEF or "__.SYMDEF SORTED" member starts with a uint32_t
1046 // which is the number of bytes of ranlib structs that follow. The ranlib
1047 // structs are a pair of uint32_t's the first being a string table offset
1048 // and the second being the offset into the archive of the member that
1049 // define the symbol. After that the next uint32_t is the byte count of
1050 // the string table followed by the string table.
1051 const char *Buf = Parent->getSymbolTable().begin();
1052 uint32_t RanlibCount = 0;
1053 RanlibCount = read32le(Buf) / 8;
1054 // If t.SymbolIndex + 1 will be past the count of symbols (the RanlibCount)
1055 // don't change the t.StringIndex as we don't want to reference a ranlib
1056 // past RanlibCount.
1057 if (t.SymbolIndex + 1 < RanlibCount) {
1058 const char *Ranlibs = Buf + 4;
1059 uint32_t CurRanStrx = 0;
1060 uint32_t NextRanStrx = 0;
1061 CurRanStrx = read32le(Ranlibs + t.SymbolIndex * 8);
1062 NextRanStrx = read32le(Ranlibs + (t.SymbolIndex + 1) * 8);
1063 t.StringIndex -= CurRanStrx;
1064 t.StringIndex += NextRanStrx;
1065 }
1066 } else {
1067 // Go to one past next null.
1068 t.StringIndex = Parent->getSymbolTable().find('\0', t.StringIndex) + 1;
1069 }
1070 ++t.SymbolIndex;
1071 return t;
1072}
1073
1075 if (!hasSymbolTable())
1076 return symbol_iterator(Symbol(this, 0, 0));
1077
1078 const char *buf = getSymbolTable().begin();
1079 if (kind() == K_GNU) {
1080 uint32_t symbol_count = 0;
1081 symbol_count = read32be(buf);
1082 buf += sizeof(uint32_t) + (symbol_count * (sizeof(uint32_t)));
1083 } else if (kind() == K_GNU64) {
1084 uint64_t symbol_count = read64be(buf);
1085 buf += sizeof(uint64_t) + (symbol_count * (sizeof(uint64_t)));
1086 } else if (kind() == K_BSD) {
1087 // The __.SYMDEF or "__.SYMDEF SORTED" member starts with a uint32_t
1088 // which is the number of bytes of ranlib structs that follow. The ranlib
1089 // structs are a pair of uint32_t's the first being a string table offset
1090 // and the second being the offset into the archive of the member that
1091 // define the symbol. After that the next uint32_t is the byte count of
1092 // the string table followed by the string table.
1093 uint32_t ranlib_count = 0;
1094 ranlib_count = read32le(buf) / 8;
1095 const char *ranlibs = buf + 4;
1096 uint32_t ran_strx = 0;
1097 ran_strx = read32le(ranlibs);
1098 buf += sizeof(uint32_t) + (ranlib_count * (2 * (sizeof(uint32_t))));
1099 // Skip the byte count of the string table.
1100 buf += sizeof(uint32_t);
1101 buf += ran_strx;
1102 } else if (kind() == K_DARWIN64) {
1103 // The __.SYMDEF_64 or "__.SYMDEF_64 SORTED" member starts with a uint64_t
1104 // which is the number of bytes of ranlib_64 structs that follow. The
1105 // ranlib_64 structs are a pair of uint64_t's the first being a string
1106 // table offset and the second being the offset into the archive of the
1107 // member that define the symbol. After that the next uint64_t is the byte
1108 // count of the string table followed by the string table.
1109 uint64_t ranlib_count = 0;
1110 ranlib_count = read64le(buf) / 16;
1111 const char *ranlibs = buf + 8;
1112 uint64_t ran_strx = 0;
1113 ran_strx = read64le(ranlibs);
1114 buf += sizeof(uint64_t) + (ranlib_count * (2 * (sizeof(uint64_t))));
1115 // Skip the byte count of the string table.
1116 buf += sizeof(uint64_t);
1117 buf += ran_strx;
1118 } else if (kind() == K_AIXBIG) {
1119 buf = getStringTable().begin();
1120 } else {
1121 uint32_t member_count = 0;
1122 uint32_t symbol_count = 0;
1123 member_count = read32le(buf);
1124 buf += 4 + (member_count * 4); // Skip offsets.
1125 symbol_count = read32le(buf);
1126 buf += 4 + (symbol_count * 2); // Skip indices.
1127 }
1128 uint32_t string_start_offset = buf - getSymbolTable().begin();
1129 return symbol_iterator(Symbol(this, 0, string_start_offset));
1130}
1131
1133 return symbol_iterator(Symbol(this, getNumberOfSymbols(), 0));
1134}
1135
1137 if (!hasSymbolTable())
1138 return 0;
1139 const char *buf = getSymbolTable().begin();
1140 if (kind() == K_GNU)
1141 return read32be(buf);
1142 if (kind() == K_GNU64 || kind() == K_AIXBIG)
1143 return read64be(buf);
1144 if (kind() == K_BSD)
1145 return read32le(buf) / 8;
1146 if (kind() == K_DARWIN64)
1147 return read64le(buf) / 16;
1148 uint32_t member_count = 0;
1149 member_count = read32le(buf);
1150 buf += 4 + (member_count * 4); // Skip offsets.
1151 return read32le(buf);
1152}
1153
1157
1158 for (; bs != es; ++bs) {
1159 StringRef SymName = bs->getName();
1160 if (SymName == name) {
1161 if (auto MemberOrErr = bs->getMember())
1162 return Child(*MemberOrErr);
1163 else
1164 return MemberOrErr.takeError();
1165 }
1166 }
1167 return std::nullopt;
1168}
1169
1170// Returns true if archive file contains no member file.
1171bool Archive::isEmpty() const {
1173}
1174
1175bool Archive::hasSymbolTable() const { return !SymbolTable.empty(); }
1176
1178 : Archive(Source, Err) {
1179 ErrorAsOutParameter ErrAsOutParam(&Err);
1180 StringRef Buffer = Data.getBuffer();
1181 ArFixLenHdr = reinterpret_cast<const FixLenHdr *>(Buffer.data());
1182 uint64_t BufferSize = Data.getBufferSize();
1183
1184 if (BufferSize < sizeof(FixLenHdr)) {
1185 Err = malformedError("malformed AIX big archive: incomplete fixed length "
1186 "header, the archive is only" +
1187 Twine(BufferSize) + " byte(s)");
1188 return;
1189 }
1190
1192 if (RawOffset.getAsInteger(10, FirstChildOffset))
1193 // TODO: Out-of-line.
1194 Err = malformedError("malformed AIX big archive: first member offset \"" +
1195 RawOffset + "\" is not a number");
1196
1198 if (RawOffset.getAsInteger(10, LastChildOffset))
1199 // TODO: Out-of-line.
1200 Err = malformedError("malformed AIX big archive: last member offset \"" +
1201 RawOffset + "\" is not a number");
1202
1203 // Calculate the global symbol table.
1204 uint64_t GlobSymOffset = 0;
1206 if (RawOffset.getAsInteger(10, GlobSymOffset))
1207 // TODO: add test case.
1208 Err = malformedError(
1209 "malformed AIX big archive: global symbol table offset \"" + RawOffset +
1210 "\" is not a number");
1211
1212 if (Err)
1213 return;
1214
1215 if (GlobSymOffset > 0) {
1216 uint64_t GlobalSymTblContentOffset =
1217 GlobSymOffset + sizeof(BigArMemHdrType);
1218 if (GlobalSymTblContentOffset > BufferSize) {
1219 Err = malformedError("global symbol table header at offset 0x" +
1220 Twine::utohexstr(GlobSymOffset) + " and size 0x" +
1222 " goes past the end of file");
1223 return;
1224 }
1225
1226 const char *GlobSymTblLoc = Data.getBufferStart() + GlobSymOffset;
1227 const BigArMemHdrType *GlobalSymHdr =
1228 reinterpret_cast<const BigArMemHdrType *>(GlobSymTblLoc);
1229 RawOffset = getFieldRawString(GlobalSymHdr->Size);
1230 uint64_t Size;
1231 if (RawOffset.getAsInteger(10, Size)) {
1232 // TODO: add test case.
1233 Err = malformedError(
1234 "malformed AIX big archive: global symbol table size \"" + RawOffset +
1235 "\" is not a number");
1236 return;
1237 }
1238 if (GlobalSymTblContentOffset + Size > BufferSize) {
1239 Err = malformedError("global symbol table content at offset 0x" +
1240 Twine::utohexstr(GlobalSymTblContentOffset) +
1241 " and size 0x" + Twine::utohexstr(Size) +
1242 " goes past the end of file");
1243 return;
1244 }
1245 SymbolTable = StringRef(GlobSymTblLoc + sizeof(BigArMemHdrType), Size);
1246 unsigned SymNum = getNumberOfSymbols();
1247 unsigned SymOffsetsSize = 8 * (SymNum + 1);
1248 uint64_t SymbolTableStringSize = Size - SymOffsetsSize;
1249 StringTable =
1250 StringRef(GlobSymTblLoc + sizeof(BigArMemHdrType) + SymOffsetsSize,
1251 SymbolTableStringSize);
1252 }
1253
1254 child_iterator I = child_begin(Err, false);
1255 if (Err)
1256 return;
1258 if (I == E) {
1259 Err = Error::success();
1260 return;
1261 }
1263 Err = Error::success();
1264}
aarch64 promote const
#define offsetof(TYPE, MEMBER)
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
std::string Name
uint64_t Size
Provides ErrorOr<T> smart pointer.
#define I(x, y, z)
Definition: MD5.cpp:58
LLVMContext & Context
static Error malformedError(Twine Msg)
Definition: Archive.cpp:43
StringRef getFieldRawString(const T(&Field)[N])
Definition: Archive.cpp:65
Expected< uint64_t > getArchiveMemberOctField(Twine FieldName, const StringRef RawField, const Archive *Parent, const AbstractArchiveMemberHeader *MemHeader)
Definition: Archive.cpp:198
Expected< uint64_t > getArchiveMemberDecField(Twine FieldName, const StringRef RawField, const Archive *Parent, const AbstractArchiveMemberHeader *MemHeader)
Definition: Archive.cpp:180
static Error createMemberHeaderParseError(const AbstractArchiveMemberHeader *ArMemHeader, const char *RawHeaderPtr, uint64_t Size)
Definition: Archive.cpp:50
static StringRef getName(Value *V)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static const char * name
Definition: SMEABIPass.cpp:49
raw_pwrite_stream & OS
This file defines the SmallString class.
static unsigned getSize(unsigned Kind)
Helper for Errors used as out-parameters.
Definition: Error.h:1104
Represents either an error or a value T.
Definition: ErrorOr.h:56
std::error_code getError() const
Definition: ErrorOr.h:153
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
static ErrorSuccess success()
Create a success value.
Definition: Error.h:330
Tagged union holding either a T or a Error.
Definition: Error.h:470
Error takeError()
Take ownership of the stored error.
Definition: Error.h:597
reference get()
Returns a reference to the stored T value.
Definition: Error.h:567
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
size_t getBufferSize() const
const char * getBufferStart() const
StringRef getBuffer() const
const char * getBufferEnd() const
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, bool IsVolatile=false, std::optional< Align > Alignment=std::nullopt)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:261
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
Definition: StringRef.h:468
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
iterator begin() const
Definition: StringRef.h:111
size_t size_type
Definition: StringRef.h:56
StringRef slice(size_t Start, size_t End) const
Return a reference to the substring from [Start, End).
Definition: StringRef.h:671
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
bool startswith(StringRef Prefix) const
Definition: StringRef.h:261
iterator end() const
Definition: StringRef.h:113
StringRef rtrim(char Char) const
Return string with consecutive Char characters starting from the right removed.
Definition: StringRef.h:790
size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:295
bool endswith(StringRef Suffix) const
Definition: StringRef.h:277
static constexpr size_t npos
Definition: StringRef.h:52
const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:131
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
bool isOSAIX() const
Tests whether the OS is AIX.
Definition: Triple.h:670
bool isOSDarwin() const
Is this a "Darwin" OS (macOS, iOS, tvOS, watchOS, or DriverKit).
Definition: Triple.h:519
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
static Twine utohexstr(const uint64_t &Val)
Definition: Twine.h:404
LLVM Value Representation.
Definition: Value.h:74
A wrapper class for fallible iterators.
static fallible_iterator end(Underlying I)
Construct a fallible iterator that can be used as an end-of-range value.
static fallible_iterator itr(Underlying I, Error &Err)
Construct a fallible iterator that cannot be used as an end-of-range value.
virtual StringRef getRawGID() const =0
virtual StringRef getRawUID() const =0
Expected< unsigned > getUID() const
Definition: Archive.cpp:403
Expected< sys::fs::perms > getAccessMode() const
Definition: Archive.cpp:384
Expected< unsigned > getGID() const
Definition: Archive.cpp:410
virtual uint64_t getOffset() const =0
Expected< sys::TimePoint< std::chrono::seconds > > getLastModified() const
Definition: Archive.cpp:393
virtual StringRef getRawAccessMode() const =0
virtual StringRef getRawLastModified() const =0
virtual Expected< StringRef > getName(uint64_t Size) const =0
Get the name looking up long names.
ArchiveMemberHeader(const Archive *Parent, const char *RawHeaderPtr, uint64_t Size, Error *Err)
Definition: Archive.cpp:94
Expected< StringRef > getName(uint64_t Size) const override
Get the name looking up long names.
Definition: Archive.cpp:244
Expected< StringRef > getRawName() const override
Get the name without looking up long names.
Definition: Archive.cpp:154
Expected< bool > isThin() const override
Definition: Archive.cpp:417
Expected< uint64_t > getSize() const override
Definition: Archive.cpp:356
Expected< const char * > getNextChildLoc() const override
Get next file member location.
Definition: Archive.cpp:425
Expected< StringRef > getBuffer() const
Definition: Archive.cpp:571
Expected< Child > getNext() const
Definition: Archive.cpp:593
Expected< std::string > getFullName() const
Definition: Archive.cpp:553
uint64_t getChildOffset() const
Definition: Archive.cpp:624
Expected< uint64_t > getRawSize() const
Definition: Archive.cpp:547
Expected< StringRef > getName() const
Definition: Archive.cpp:631
Expected< uint64_t > getSize() const
Definition: Archive.cpp:541
Expected< StringRef > getRawName() const
Definition: Archive.h:225
Expected< std::unique_ptr< Binary > > getAsBinary(LLVMContext *Context=nullptr) const
Definition: Archive.cpp:656
Expected< MemoryBufferRef > getMemoryBufferRef() const
Definition: Archive.cpp:644
Child(const Archive *Parent, const char *Start, Error *Err)
Definition: Archive.cpp:467
Expected< Child > getMember() const
Definition: Archive.cpp:974
StringRef getName() const
Definition: Archive.cpp:970
std::unique_ptr< AbstractArchiveMemberHeader > createArchiveMemberHeader(const char *RawHeaderPtr, uint64_t Size, Error *Err) const
Definition: Archive.cpp:683
symbol_iterator symbol_begin() const
Definition: Archive.cpp:1074
virtual uint64_t getFirstChildOffset() const
Definition: Archive.h:365
bool isThin() const
Definition: Archive.h:339
StringRef getStringTable() const
Definition: Archive.h:363
uint32_t getNumberOfSymbols() const
Definition: Archive.cpp:1136
void setFirstRegular(const Child &C)
Definition: Archive.cpp:702
uint64_t getArchiveMagicLen() const
Definition: Archive.cpp:692
StringRef getSymbolTable() const
Definition: Archive.h:362
symbol_iterator symbol_end() const
Definition: Archive.cpp:1132
virtual bool isEmpty() const
Definition: Archive.cpp:1171
child_iterator child_end() const
Definition: Archive.cpp:966
bool hasSymbolTable() const
Definition: Archive.cpp:1175
StringRef StringTable
Definition: Archive.h:380
Archive(MemoryBufferRef Source, Error &Err)
Definition: Archive.cpp:707
Kind kind() const
Definition: Archive.h:338
StringRef SymbolTable
Definition: Archive.h:379
Expected< std::optional< Child > > findSym(StringRef name) const
Definition: Archive.cpp:1154
child_iterator child_begin(Error &Err, bool SkipInternal=true) const
Definition: Archive.cpp:950
static object::Archive::Kind getDefaultKindForHost()
Definition: Archive.cpp:942
static Expected< std::unique_ptr< Archive > > create(MemoryBufferRef Source)
Definition: Archive.cpp:667
Expected< uint64_t > getSize() const override
Definition: Archive.cpp:361
Expected< StringRef > getRawName() const override
Get the name without looking up long names.
Definition: Archive.cpp:215
Expected< const char * > getNextChildLoc() const override
Get next file member location.
Definition: Archive.cpp:450
Expected< StringRef > getName(uint64_t Size) const override
Get the name looking up long names.
Definition: Archive.cpp:352
Expected< uint64_t > getRawNameSize() const
Definition: Archive.cpp:374
Expected< uint64_t > getNextOffset() const
Definition: Archive.cpp:379
BigArchiveMemberHeader(Archive const *Parent, const char *RawHeaderPtr, uint64_t Size, Error *Err)
Definition: Archive.cpp:129
const FixLenHdr * ArFixLenHdr
Definition: Archive.h:405
uint64_t FirstChildOffset
Definition: Archive.h:406
uint64_t LastChildOffset
Definition: Archive.h:407
BigArchive(MemoryBufferRef Source, Error &Err)
Definition: Archive.cpp:1177
MemoryBufferRef Data
Definition: Binary.h:37
StringRef getData() const
Definition: Binary.cpp:39
MemoryBufferRef getMemoryBufferRef() const
Definition: Binary.cpp:43
StringRef getRawLastModified() const override
Definition: Archive.cpp:75
StringRef getRawUID() const override
Definition: Archive.cpp:79
uint64_t getOffset() const override
Definition: Archive.cpp:87
StringRef getRawAccessMode() const override
Definition: Archive.cpp:70
StringRef getRawGID() const override
Definition: Archive.cpp:83
raw_ostream & write_escaped(StringRef Str, bool UseHexEscapes=false)
Output Str, turning '\', '\t', ' ', '"', and anything that doesn't satisfy llvm::isPrint into an esca...
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:642
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
constexpr size_t NameSize
Definition: XCOFF.h:29
const char ArchiveMagic[]
Definition: Archive.h:33
const char ThinArchiveMagic[]
Definition: Archive.h:34
const char BigArchiveMagic[]
Definition: Archive.h:35
Expected< std::unique_ptr< Binary > > createBinary(MemoryBufferRef Source, LLVMContext *Context=nullptr, bool InitContent=true)
Create a Binary from Source, autodetecting the file type.
Definition: Binary.cpp:45
uint64_t read64le(const void *P)
Definition: Endian.h:382
uint16_t read16le(const void *P)
Definition: Endian.h:380
uint64_t read64be(const void *P)
Definition: Endian.h:385
uint32_t read32be(const void *P)
Definition: Endian.h:384
uint32_t read32le(const void *P)
Definition: Endian.h:381
StringRef parent_path(StringRef path, Style style=Style::native)
Get parent path.
Definition: Path.cpp:467
bool is_absolute(const Twine &path, Style style=Style::native)
Is path absolute?
Definition: Path.cpp:671
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition: Path.cpp:456
TimePoint< std::chrono::seconds > toTimePoint(std::time_t T)
Convert a std::time_t to a TimePoint.
Definition: Chrono.h:45
std::string getProcessTriple()
getProcessTriple() - Return an appropriate target triple for generating code to be loaded into the cu...
Definition: Host.cpp:1880
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:406
Error createFileError(const Twine &F, Error E)
Concatenate a source file path and/or name with an Error.
Definition: Error.h:1327
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:155
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:92
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1043
#define N
Fixed-Length Header.
Definition: Archive.h:394
char FirstChildOffset[20]
Offset to first archive member.
Definition: Archive.h:400
char LastChildOffset[20]
Offset to last archive member.
Definition: Archive.h:401
char GlobSymOffset[20]
Offset to global symbol table.
Definition: Archive.h:397
char Size[10]
Size of data, not including header or padding.
Definition: Archive.h:98