Movatterモバイル変換

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//===----------------------------------------------------------------------===//

13#include "llvm/Object/Archive.h"

14#include "llvm/ADT/SmallString.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/EndianStream.h"

22#include "llvm/Support/Error.h"

23#include "llvm/Support/ErrorOr.h"

24#include "llvm/Support/FileSystem.h"

25#include "llvm/Support/MathExtras.h"

26#include "llvm/Support/MemoryBuffer.h"

27#include "llvm/Support/Path.h"

28#include "llvm/Support/raw_ostream.h"

29#include "llvm/TargetParser/Host.h"

30#include <cassert>

31#include <cstddef>

32#include <cstdint>

33#include <memory>

34#include <string>

35#include <system_error>

37using namespacellvm;

38using namespaceobject;

39using namespacellvm::support::endian;

41void Archive::anchor() {}

43staticError malformedError(Twine Msg) {

44 std::string StringMsg ="truncated or malformed archive (" + Msg.str() +")";

45return make_error<GenericBinaryError>(std::move(StringMsg),

46object_error::parse_failed);

47}

49staticError

50createMemberHeaderParseError(constAbstractArchiveMemberHeader *ArMemHeader,

51constchar *RawHeaderPtr,uint64_t Size) {

52StringRef Msg("remaining size of archive too small for next archive "

53"member header ");

55Expected<StringRef> NameOrErr = ArMemHeader->getName(Size);

56if (NameOrErr)

57returnmalformedError(Msg +"for " + *NameOrErr);

59consumeError(NameOrErr.takeError());

60uint64_t Offset = RawHeaderPtr - ArMemHeader->Parent->getData().data();

61returnmalformedError(Msg +"at offset " +Twine(Offset));

62}

64template <class T, std::size_t N>

65StringRef getFieldRawString(constT (&Field)[N]) {

66returnStringRef(Field,N).rtrim(" ");

67}

69template <class T>

70StringRef CommonArchiveMemberHeader<T>::getRawAccessMode() const{

71returngetFieldRawString(ArMemHdr->AccessMode);

72}

74template <class T>

75StringRef CommonArchiveMemberHeader<T>::getRawLastModified() const{

76returngetFieldRawString(ArMemHdr->LastModified);

77}

79template <class T>StringRef CommonArchiveMemberHeader<T>::getRawUID() const{

80returngetFieldRawString(ArMemHdr->UID);

81}

83template <class T>StringRef CommonArchiveMemberHeader<T>::getRawGID() const{

84returngetFieldRawString(ArMemHdr->GID);

85}

87template <class T>uint64_t CommonArchiveMemberHeader<T>::getOffset() const{

88returnreinterpret_cast<constchar *>(ArMemHdr) - Parent->getData().data();

89}

91templateclassobject::CommonArchiveMemberHeader<UnixArMemHdrType>;

92templateclassobject::CommonArchiveMemberHeader<BigArMemHdrType>;

94ArchiveMemberHeader::ArchiveMemberHeader(constArchive *Parent,

95constchar *RawHeaderPtr,

96uint64_t Size,Error *Err)

97 :CommonArchiveMemberHeader<UnixArMemHdrType>(

98 Parent, reinterpret_cast<const UnixArMemHdrType *>(RawHeaderPtr)) {

99if (RawHeaderPtr ==nullptr)

100return;

101ErrorAsOutParameter ErrAsOutParam(Err);

102

103if (Size <getSizeOf()) {

104 *Err =createMemberHeaderParseError(this, RawHeaderPtr,Size);

105return;

106 }

107if (ArMemHdr->Terminator[0] !='`' ||ArMemHdr->Terminator[1] !='\n') {

108if (Err) {

109 std::string Buf;

110raw_string_ostream OS(Buf);

111OS.write_escaped(

112StringRef(ArMemHdr->Terminator,sizeof(ArMemHdr->Terminator)));

113OS.flush();

114 std::string Msg("terminator characters in archive member \"" + Buf +

115"\" not the correct \"`\\n\" values for the archive "

116"member header ");

117Expected<StringRef> NameOrErr =getName(Size);

118if (!NameOrErr) {

119consumeError(NameOrErr.takeError());

120uint64_t Offset = RawHeaderPtr -Parent->getData().data();

121 *Err =malformedError(Msg +"at offset " +Twine(Offset));

122 }else

123 *Err =malformedError(Msg +"for " + NameOrErr.get());

124 }

125return;

126 }

127}

128

129BigArchiveMemberHeader::BigArchiveMemberHeader(constArchive *Parent,

130constchar *RawHeaderPtr,

131uint64_t Size,Error *Err)

132 :CommonArchiveMemberHeader<BigArMemHdrType>(

133 Parent, reinterpret_cast<const BigArMemHdrType *>(RawHeaderPtr)) {

134if (RawHeaderPtr ==nullptr)

135return;

136ErrorAsOutParameter ErrAsOutParam(Err);

137

138if (RawHeaderPtr +getSizeOf() >=Parent->getData().end()) {

139if (Err)

140 *Err =malformedError("malformed AIX big archive: remaining buffer is "

141"unable to contain next archive member");

142return;

143 }

144

145if (Size <getSizeOf()) {

146Error SubErr =createMemberHeaderParseError(this, RawHeaderPtr,Size);

147if (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.

154Expected<StringRef>ArchiveMemberHeader::getRawName() const{

155char EndCond;

156autoKind =Parent->kind();

157if (Kind ==Archive::K_BSD ||Kind ==Archive::K_DARWIN64) {

158if (ArMemHdr->Name[0] ==' ') {

159uint64_t Offset =

160reinterpret_cast<constchar *>(ArMemHdr) -Parent->getData().data();

161returnmalformedError("name contains a leading space for archive member "

162"header at offset " +

163Twine(Offset));

164 }

165 EndCond =' ';

166 }elseif (ArMemHdr->Name[0] =='/' ||ArMemHdr->Name[0] =='#')

167 EndCond =' ';

168else

169 EndCond ='/';

170StringRef::size_type end =

171StringRef(ArMemHdr->Name,sizeof(ArMemHdr->Name)).find(EndCond);

172if (end ==StringRef::npos)

173 end =sizeof(ArMemHdr->Name);

174assert(end <=sizeof(ArMemHdr->Name) && end > 0);

175// Don't include the EndCond if there is one.

176returnStringRef(ArMemHdr->Name, end);

177}

178

179Expected<uint64_t>

180getArchiveMemberDecField(Twine FieldName,constStringRef RawField,

181constArchive *Parent,

182constAbstractArchiveMemberHeader *MemHeader) {

183uint64_t Value;

184if (RawField.getAsInteger(10,Value)) {

185uint64_t Offset = MemHeader->getOffset();

186returnmalformedError("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 " +

192Twine(Offset));

193 }

194returnValue;

195}

196

197Expected<uint64_t>

198getArchiveMemberOctField(Twine FieldName,constStringRef RawField,

199constArchive *Parent,

200constAbstractArchiveMemberHeader *MemHeader) {

201uint64_t Value;

202if (RawField.getAsInteger(8,Value)) {

203uint64_t Offset = MemHeader->getOffset();

204returnmalformedError("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 " +

210Twine(Offset));

211 }

212returnValue;

213}

214

215Expected<StringRef>BigArchiveMemberHeader::getRawName() const{

216Expected<uint64_t> NameLenOrErr =getArchiveMemberDecField(

217"NameLen",getFieldRawString(ArMemHdr->NameLen),Parent,this);

218if (!NameLenOrErr)

219// TODO: Out-of-line.

220return NameLenOrErr.takeError();

221uint64_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".

225uint64_t NameLenWithPadding =alignTo(NameLen, 2);

226StringRef NameTerminator ="`\n";

227StringRef NameStringWithNameTerminator =

228StringRef(ArMemHdr->Name, NameLenWithPadding + NameTerminator.size());

229if (!NameStringWithNameTerminator.ends_with(NameTerminator)) {

230uint64_t Offset =

231reinterpret_cast<constchar *>(ArMemHdr->Name + NameLenWithPadding) -

232Parent->getData().data();

233// TODO: Out-of-line.

234returnmalformedError(

235"name does not have name terminator \"`\\n\" for archive member"

236"header at offset " +

237Twine(Offset));

238 }

239returnStringRef(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.

244Expected<StringRef>ArchiveMemberHeader::getName(uint64_t Size) const{

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.

249if (Size <offsetof(UnixArMemHdrType,Name) +sizeof(ArMemHdr->Name)) {

250uint64_t ArchiveOffset =

251reinterpret_cast<constchar *>(ArMemHdr) -Parent->getData().data();

252returnmalformedError("archive header truncated before the name field "

253"for archive member header at offset " +

254Twine(ArchiveOffset));

255 }

256

257// The raw name itself can be invalid.

258Expected<StringRef> NameOrErr =getRawName();

259if (!NameOrErr)

260return NameOrErr.takeError();

261StringRef Name = NameOrErr.get();

262

263// Check if it's a special name.

264if (Name[0] =='/') {

265if (Name.size() == 1)// Linker member.

266returnName;

267if (Name.size() == 2 &&Name[1] =='/')// String table.

268returnName;

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.

271if (Name =="/<XFGHASHMAP>/")

272returnName;

273// Some libraries (e.g., arm64rt.lib) from the Windows WDK

274// (version 10.0.22000.0) contain this undocumented special member.

275if (Name =="/<ECSYMBOLS>/")

276returnName;

277// It's a long name.

278// Get the string table offset.

279 std::size_t StringOffset;

280if (Name.substr(1).rtrim(' ').getAsInteger(10, StringOffset)) {

281 std::string Buf;

282raw_string_ostream OS(Buf);

283OS.write_escaped(Name.substr(1).rtrim(' '));

284OS.flush();

285uint64_t ArchiveOffset =

286reinterpret_cast<constchar *>(ArMemHdr) -Parent->getData().data();

287returnmalformedError("long name offset characters after the '/' are "

288"not all decimal numbers: '" +

289 Buf +"' for archive member header at offset " +

290Twine(ArchiveOffset));

291 }

292

293// Verify it.

294if (StringOffset >=Parent->getStringTable().size()) {

295uint64_t ArchiveOffset =

296reinterpret_cast<constchar *>(ArMemHdr) -Parent->getData().data();

297returnmalformedError("long name offset " +Twine(StringOffset) +

298" past the end of the string table for archive "

299"member header at offset " +

300Twine(ArchiveOffset));

301 }

302

303// GNU long file names end with a "/\n".

304if (Parent->kind() ==Archive::K_GNU ||

305Parent->kind() ==Archive::K_GNU64) {

306size_tEnd =Parent->getStringTable().find('\n',/*From=*/StringOffset);

307if (End ==StringRef::npos ||End < 1 ||

308Parent->getStringTable()[End - 1] !='/') {

309returnmalformedError("string table at long name offset " +

310Twine(StringOffset) +"not terminated");

311 }

312returnParent->getStringTable().slice(StringOffset,End - 1);

313 }

314returnParent->getStringTable().begin() + StringOffset;

315 }

316

317if (Name.starts_with("#1/")) {

318uint64_t NameLength;

319if (Name.substr(3).rtrim(' ').getAsInteger(10, NameLength)) {

320 std::string Buf;

321raw_string_ostream OS(Buf);

322OS.write_escaped(Name.substr(3).rtrim(' '));

323OS.flush();

324uint64_t ArchiveOffset =

325reinterpret_cast<constchar *>(ArMemHdr) -Parent->getData().data();

326returnmalformedError("long name length characters after the #1/ are "

327"not all decimal numbers: '" +

328 Buf +"' for archive member header at offset " +

329Twine(ArchiveOffset));

330 }

331if (getSizeOf() + NameLength >Size) {

332uint64_t ArchiveOffset =

333reinterpret_cast<constchar *>(ArMemHdr) -Parent->getData().data();

334returnmalformedError("long name length: " +Twine(NameLength) +

335" extends past the end of the member or archive "

336"for archive member header at offset " +

337Twine(ArchiveOffset));

338 }

339returnStringRef(reinterpret_cast<constchar *>(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.

345if (Name[Name.size() - 1] !='/')

346returnName.rtrim(' ');

347

348// It's a simple name.

349returnName.drop_back(1);

350}

351

352Expected<StringRef>BigArchiveMemberHeader::getName(uint64_t Size) const{

353returngetRawName();

354}

355

356Expected<uint64_t>ArchiveMemberHeader::getSize() const{

357returngetArchiveMemberDecField("size",getFieldRawString(ArMemHdr->Size),

358Parent,this);

359}

360

361Expected<uint64_t>BigArchiveMemberHeader::getSize() const{

362Expected<uint64_t> SizeOrErr =getArchiveMemberDecField(

363"size",getFieldRawString(ArMemHdr->Size),Parent,this);

364if (!SizeOrErr)

365return SizeOrErr.takeError();

366

367Expected<uint64_t> NameLenOrErr =getRawNameSize();

368if (!NameLenOrErr)

369return NameLenOrErr.takeError();

370

371return *SizeOrErr +alignTo(*NameLenOrErr, 2);

372}

373

374Expected<uint64_t>BigArchiveMemberHeader::getRawNameSize() const{

375returngetArchiveMemberDecField(

376"NameLen",getFieldRawString(ArMemHdr->NameLen),Parent,this);

377}

378

379Expected<uint64_t>BigArchiveMemberHeader::getNextOffset() const{

380returngetArchiveMemberDecField(

381"NextOffset",getFieldRawString(ArMemHdr->NextOffset),Parent,this);

382}

383

384Expected<sys::fs::perms>AbstractArchiveMemberHeader::getAccessMode() const{

385Expected<uint64_t> AccessModeOrErr =

386getArchiveMemberOctField("AccessMode",getRawAccessMode(),Parent,this);

387if (!AccessModeOrErr)

388return AccessModeOrErr.takeError();

389returnstatic_cast<sys::fs::perms>(*AccessModeOrErr);

390}

391

392Expected<sys::TimePoint<std::chrono::seconds>>

393AbstractArchiveMemberHeader::getLastModified() const{

394Expected<uint64_t> SecondsOrErr =getArchiveMemberDecField(

395"LastModified",getRawLastModified(),Parent,this);

396

397if (!SecondsOrErr)

398return SecondsOrErr.takeError();

399

400returnsys::toTimePoint(*SecondsOrErr);

401}

402

403Expected<unsigned>AbstractArchiveMemberHeader::getUID() const{

404StringRef User =getRawUID();

405if (User.empty())

406return 0;

407returngetArchiveMemberDecField("UID",User,Parent,this);

408}

409

410Expected<unsigned>AbstractArchiveMemberHeader::getGID() const{

411StringRef Group =getRawGID();

412if (Group.empty())

413return 0;

414returngetArchiveMemberDecField("GID", Group,Parent,this);

415}

416

417Expected<bool>ArchiveMemberHeader::isThin() const{

418Expected<StringRef> NameOrErr =getRawName();

419if (!NameOrErr)

420return NameOrErr.takeError();

421StringRef Name = NameOrErr.get();

422returnParent->isThin() &&Name !="/" &&Name !="//" &&Name !="/SYM64/";

423}

424

425Expected<const char *>ArchiveMemberHeader::getNextChildLoc() const{

426uint64_t Size =getSizeOf();

427Expected<bool> isThinOrErr =isThin();

428if (!isThinOrErr)

429return isThinOrErr.takeError();

430

431boolisThin = isThinOrErr.get();

432if (!isThin) {

433Expected<uint64_t> MemberSize =getSize();

434if (!MemberSize)

435return MemberSize.takeError();

436

437Size += MemberSize.get();

438 }

439

440// If Size is odd, add 1 to make it even.

441constchar *NextLoc =

442reinterpret_cast<constchar *>(ArMemHdr) +alignTo(Size, 2);

443

444if (NextLoc ==Parent->getMemoryBufferRef().getBufferEnd())

445returnnullptr;

446

447return NextLoc;

448}

449

450Expected<const char *>BigArchiveMemberHeader::getNextChildLoc() const{

451if (getOffset() ==

452static_cast<constBigArchive *>(Parent)->getLastChildOffset())

453returnnullptr;

454

455Expected<uint64_t> NextOffsetOrErr =getNextOffset();

456if (!NextOffsetOrErr)

457return NextOffsetOrErr.takeError();

458returnParent->getData().data() + NextOffsetOrErr.get();

459}

460

461Archive::Child::Child(constArchive *Parent,StringRef Data,

462uint16_t StartOfFile)

463 : Parent(Parent),Data(Data), StartOfFile(StartOfFile) {

464 Header = Parent->createArchiveMemberHeader(Data.data(), Data.size(),nullptr);

465}

466

467Archive::Child::Child(constArchive *Parent,constchar *Start,Error *Err)

468 : Parent(Parent) {

469if (!Start) {

470 Header =nullptr;

471 StartOfFile = -1;

472return;

473 }

474

475 Header = Parent->createArchiveMemberHeader(

476 Start,

477 Parent ? Parent->getData().size() - (Start - Parent->getData().data())

478 : 0,

479 Err);

480

481// If we are pointed to real data, Start is not a nullptr, then there must be

482// a non-null Err pointer available to report malformed data on. Only in

483// the case sentinel value is being constructed is Err is permitted to be a

484// nullptr.

485assert(Err &&"Err can't be nullptr if Start is not a nullptr");

486

487ErrorAsOutParameter ErrAsOutParam(Err);

488

489// If there was an error in the construction of the Header

490// then just return with the error now set.

491if (*Err)

492return;

493

494uint64_t Size = Header->getSizeOf();

495 Data =StringRef(Start,Size);

496Expected<bool> isThinOrErr = isThinMember();

497if (!isThinOrErr) {

498 *Err = isThinOrErr.takeError();

499return;

500 }

501boolisThin = isThinOrErr.get();

502if (!isThin) {

503Expected<uint64_t> MemberSize =getRawSize();

504if (!MemberSize) {

505 *Err = MemberSize.takeError();

506return;

507 }

508Size += MemberSize.get();

509 Data =StringRef(Start,Size);

510 }

511

512// Setup StartOfFile and PaddingBytes.

513 StartOfFile = Header->getSizeOf();

514// Don't include attached name.

515Expected<StringRef> NameOrErr =getRawName();

516if (!NameOrErr) {

517 *Err = NameOrErr.takeError();

518return;

519 }

520StringRef Name = NameOrErr.get();

521

522if (Parent->kind() ==Archive::K_AIXBIG) {

523// The actual start of the file is after the name and any necessary

524// even-alignment padding.

525 StartOfFile += ((Name.size() + 1) >> 1) << 1;

526 }elseif (Name.starts_with("#1/")) {

527uint64_t NameSize;

528StringRef RawNameSize =Name.substr(3).rtrim(' ');

529if (RawNameSize.getAsInteger(10,NameSize)) {

530uint64_t Offset = Start - Parent->getData().data();

531 *Err =malformedError("long name length characters after the #1/ are "

532"not all decimal numbers: '" +

533 RawNameSize +

534"' for archive member header at offset " +

535Twine(Offset));

536return;

537 }

538 StartOfFile +=NameSize;

539 }

540}

541

542Expected<uint64_t>Archive::Child::getSize() const{

543if (Parent->IsThin)

544return Header->getSize();

545returnData.size() - StartOfFile;

546}

547

548Expected<uint64_t>Archive::Child::getRawSize() const{

549return Header->getSize();

550}

551

552Expected<bool> Archive::Child::isThinMember() const{return Header->isThin(); }

553

554Expected<std::string>Archive::Child::getFullName() const{

555Expected<bool>isThin = isThinMember();

556if (!isThin)

557returnisThin.takeError();

558assert(isThin.get());

559Expected<StringRef> NameOrErr =getName();

560if (!NameOrErr)

561return NameOrErr.takeError();

562StringRef Name = *NameOrErr;

563if (sys::path::is_absolute(Name))

564return std::string(Name);

565

566SmallString<128> FullName =sys::path::parent_path(

567 Parent->getMemoryBufferRef().getBufferIdentifier());

568sys::path::append(FullName,Name);

569return std::string(FullName);

570}

571

572Expected<StringRef>Archive::Child::getBuffer() const{

573Expected<bool> isThinOrErr = isThinMember();

574if (!isThinOrErr)

575return isThinOrErr.takeError();

576boolisThin = isThinOrErr.get();

577if (!isThin) {

578Expected<uint64_t>Size =getSize();

579if (!Size)

580returnSize.takeError();

581returnStringRef(Data.data() + StartOfFile,Size.get());

582 }

583Expected<std::string> FullNameOrErr = getFullName();

584if (!FullNameOrErr)

585return FullNameOrErr.takeError();

586const std::string &FullName = *FullNameOrErr;

587ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =MemoryBuffer::getFile(FullName);

588if (std::error_code EC = Buf.getError())

589returnerrorCodeToError(EC);

590 Parent->ThinBuffers.push_back(std::move(*Buf));

591return Parent->ThinBuffers.back()->getBuffer();

592}

593

594Expected<Archive::Child>Archive::Child::getNext() const{

595Expected<const char *> NextLocOrErr = Header->getNextChildLoc();

596if (!NextLocOrErr)

597return NextLocOrErr.takeError();

598

599constchar *NextLoc = *NextLocOrErr;

600

601// Check to see if this is at the end of the archive.

602if (NextLoc ==nullptr)

603returnChild(nullptr,nullptr,nullptr);

604

605// Check to see if this is past the end of the archive.

606if (NextLoc > Parent->Data.getBufferEnd()) {

607 std::string Msg("offset to next archive member past the end of the archive "

608"after member ");

609Expected<StringRef> NameOrErr =getName();

610if (!NameOrErr) {

611consumeError(NameOrErr.takeError());

612uint64_t Offset =Data.data() - Parent->getData().data();

613returnmalformedError(Msg +"at offset " +Twine(Offset));

614 }else

615returnmalformedError(Msg + NameOrErr.get());

616 }

617

618Error Err =Error::success();

619Child Ret(Parent, NextLoc, &Err);

620if (Err)

621return std::move(Err);

622return Ret;

623}

624

625uint64_t Archive::Child::getChildOffset() const{

626constchar *a = Parent->Data.getBuffer().data();

627constchar *c =Data.data();

628uint64_t offset = c - a;

629return offset;

630}

631

632Expected<StringRef>Archive::Child::getName() const{

633Expected<uint64_t> RawSizeOrErr = getRawSize();

634if (!RawSizeOrErr)

635return RawSizeOrErr.takeError();

636uint64_t RawSize = RawSizeOrErr.get();

637Expected<StringRef> NameOrErr =

638 Header->getName(Header->getSizeOf() + RawSize);

639if (!NameOrErr)

640return NameOrErr.takeError();

641StringRef Name = NameOrErr.get();

642returnName;

643}

644

645Expected<MemoryBufferRef>Archive::Child::getMemoryBufferRef() const{

646Expected<StringRef> NameOrErr =getName();

647if (!NameOrErr)

648return NameOrErr.takeError();

649StringRef Name = NameOrErr.get();

650Expected<StringRef> Buf = getBuffer();

651if (!Buf)

652returncreateFileError(Name, Buf.takeError());

653returnMemoryBufferRef(*Buf,Name);

654}

655

656Expected<std::unique_ptr<Binary>>

657Archive::Child::getAsBinary(LLVMContext *Context) const{

658Expected<MemoryBufferRef> BuffOrErr =getMemoryBufferRef();

659if (!BuffOrErr)

660return BuffOrErr.takeError();

661

662auto BinaryOrErr =createBinary(BuffOrErr.get(), Context);

663if (BinaryOrErr)

664return std::move(*BinaryOrErr);

665return BinaryOrErr.takeError();

666}

667

668Expected<std::unique_ptr<Archive>>Archive::create(MemoryBufferRef Source) {

669Error Err =Error::success();

670 std::unique_ptr<Archive> Ret;

671StringRef Buffer = Source.getBuffer();

672

673if (Buffer.starts_with(BigArchiveMagic))

674 Ret = std::make_unique<BigArchive>(Source, Err);

675else

676 Ret = std::make_unique<Archive>(Source, Err);

677

678if (Err)

679return std::move(Err);

680return std::move(Ret);

681}

682

683std::unique_ptr<AbstractArchiveMemberHeader>

684Archive::createArchiveMemberHeader(constchar *RawHeaderPtr,uint64_t Size,

685Error *Err) const{

686ErrorAsOutParameter ErrAsOutParam(Err);

687if (kind() !=K_AIXBIG)

688return std::make_unique<ArchiveMemberHeader>(this, RawHeaderPtr,Size, Err);

689return std::make_unique<BigArchiveMemberHeader>(this, RawHeaderPtr,Size,

690 Err);

691}

692

693uint64_t Archive::getArchiveMagicLen() const{

694if (isThin())

695returnsizeof(ThinArchiveMagic) - 1;

696

697if (Kind() ==K_AIXBIG)

698returnsizeof(BigArchiveMagic) - 1;

699

700returnsizeof(ArchiveMagic) - 1;

701}

702

703voidArchive::setFirstRegular(constChild &C) {

704 FirstRegularData =C.Data;

705 FirstRegularStartOfFile =C.StartOfFile;

706}

707

708Archive::Archive(MemoryBufferRef Source,Error &Err)

709 :Binary(Binary::ID_Archive, Source) {

710ErrorAsOutParameter ErrAsOutParam(Err);

711StringRef Buffer =Data.getBuffer();

712// Check for sufficient magic.

713if (Buffer.starts_with(ThinArchiveMagic)) {

714 IsThin =true;

715 }elseif (Buffer.starts_with(ArchiveMagic)) {

716 IsThin =false;

717 }elseif (Buffer.starts_with(BigArchiveMagic)) {

718 Format =K_AIXBIG;

719 IsThin =false;

720return;

721 }else {

722 Err = make_error<GenericBinaryError>("file too small to be an archive",

723object_error::invalid_file_type);

724return;

725 }

726

727// Make sure Format is initialized before any call to

728// ArchiveMemberHeader::getName() is made. This could be a valid empty

729// archive which is the same in all formats. So claiming it to be gnu to is

730// fine if not totally correct before we look for a string table or table of

731// contents.

732 Format =K_GNU;

733

734// Get the special members.

735child_iterator I =child_begin(Err,false);

736if (Err)

737return;

738child_iterator E =child_end();

739

740// See if this is a valid empty archive and if so return.

741if (I == E) {

742 Err =Error::success();

743return;

744 }

745constChild *C = &*I;

746

747auto Increment = [&]() {

748 ++I;

749if (Err)

750returntrue;

751C = &*I;

752returnfalse;

753 };

754

755Expected<StringRef> NameOrErr =C->getRawName();

756if (!NameOrErr) {

757 Err = NameOrErr.takeError();

758return;

759 }

760StringRef Name = NameOrErr.get();

761

762// Below is the pattern that is used to figure out the archive format

763// GNU archive format

764// First member : / (may exist, if it exists, points to the symbol table )

765// Second member : // (may exist, if it exists, points to the string table)

766// Note : The string table is used if the filename exceeds 15 characters

767// BSD archive format

768// First member : __.SYMDEF or "__.SYMDEF SORTED" (the symbol table)

769// There is no string table, if the filename exceeds 15 characters or has a

770// embedded space, the filename has #1/<size>, The size represents the size

771// of the filename that needs to be read after the archive header

772// COFF archive format

773// First member : /

774// Second member : / (provides a directory of symbols)

775// Third member : // (may exist, if it exists, contains the string table)

776// Note: Microsoft PE/COFF Spec 8.3 says that the third member is present

777// even if the string table is empty. However, lib.exe does not in fact

778// seem to create the third member if there's no member whose filename

779// exceeds 15 characters. So the third member is optional.

780

781if (Name =="__.SYMDEF" ||Name =="__.SYMDEF_64") {

782if (Name =="__.SYMDEF")

783 Format =K_BSD;

784else// Name == "__.SYMDEF_64"

785 Format =K_DARWIN64;

786// We know that the symbol table is not an external file, but we still must

787// check any Expected<> return value.

788Expected<StringRef> BufOrErr =C->getBuffer();

789if (!BufOrErr) {

790 Err = BufOrErr.takeError();

791return;

792 }

793SymbolTable = BufOrErr.get();

794if (Increment())

795return;

796setFirstRegular(*C);

797

798 Err =Error::success();

799return;

800 }

801

802if (Name.starts_with("#1/")) {

803 Format =K_BSD;

804// We know this is BSD, so getName will work since there is no string table.

805Expected<StringRef> NameOrErr =C->getName();

806if (!NameOrErr) {

807 Err = NameOrErr.takeError();

808return;

809 }

810Name = NameOrErr.get();

811if (Name =="__.SYMDEF SORTED" ||Name =="__.SYMDEF") {

812// We know that the symbol table is not an external file, but we still

813// must check any Expected<> return value.

814Expected<StringRef> BufOrErr =C->getBuffer();

815if (!BufOrErr) {

816 Err = BufOrErr.takeError();

817return;

818 }

819SymbolTable = BufOrErr.get();

820if (Increment())

821return;

822 }elseif (Name =="__.SYMDEF_64 SORTED" ||Name =="__.SYMDEF_64") {

823 Format =K_DARWIN64;

824// We know that the symbol table is not an external file, but we still

825// must check any Expected<> return value.

826Expected<StringRef> BufOrErr =C->getBuffer();

827if (!BufOrErr) {

828 Err = BufOrErr.takeError();

829return;

830 }

831SymbolTable = BufOrErr.get();

832if (Increment())

833return;

834 }

835setFirstRegular(*C);

836return;

837 }

838

839// MIPS 64-bit ELF archives use a special format of a symbol table.

840// This format is marked by `ar_name` field equals to "/SYM64/".

841// For detailed description see page 96 in the following document:

842// http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf

843

844bool has64SymTable =false;

845if (Name =="/" ||Name =="/SYM64/") {

846// We know that the symbol table is not an external file, but we still

847// must check any Expected<> return value.

848Expected<StringRef> BufOrErr =C->getBuffer();

849if (!BufOrErr) {

850 Err = BufOrErr.takeError();

851return;

852 }

853SymbolTable = BufOrErr.get();

854if (Name =="/SYM64/")

855 has64SymTable =true;

856

857if (Increment())

858return;

859if (I == E) {

860 Err =Error::success();

861return;

862 }

863Expected<StringRef> NameOrErr =C->getRawName();

864if (!NameOrErr) {

865 Err = NameOrErr.takeError();

866return;

867 }

868Name = NameOrErr.get();

869 }

870

871if (Name =="//") {

872 Format = has64SymTable ?K_GNU64 :K_GNU;

873// The string table is never an external member, but we still

874// must check any Expected<> return value.

875Expected<StringRef> BufOrErr =C->getBuffer();

876if (!BufOrErr) {

877 Err = BufOrErr.takeError();

878return;

879 }

880StringTable = BufOrErr.get();

881if (Increment())

882return;

883setFirstRegular(*C);

884 Err =Error::success();

885return;

886 }

887

888if (Name[0] !='/') {

889 Format = has64SymTable ?K_GNU64 :K_GNU;

890setFirstRegular(*C);

891 Err =Error::success();

892return;

893 }

894

895if (Name !="/") {

896 Err =errorCodeToError(object_error::parse_failed);

897return;

898 }

899

900 Format =K_COFF;

901// We know that the symbol table is not an external file, but we still

902// must check any Expected<> return value.

903Expected<StringRef> BufOrErr =C->getBuffer();

904if (!BufOrErr) {

905 Err = BufOrErr.takeError();

906return;

907 }

908SymbolTable = BufOrErr.get();

909

910if (Increment())

911return;

912

913if (I == E) {

914setFirstRegular(*C);

915 Err =Error::success();

916return;

917 }

918

919 NameOrErr =C->getRawName();

920if (!NameOrErr) {

921 Err = NameOrErr.takeError();

922return;

923 }

924Name = NameOrErr.get();

925

926if (Name =="//") {

927// The string table is never an external member, but we still

928// must check any Expected<> return value.

929Expected<StringRef> BufOrErr =C->getBuffer();

930if (!BufOrErr) {

931 Err = BufOrErr.takeError();

932return;

933 }

934StringTable = BufOrErr.get();

935if (Increment())

936return;

937

938if (I == E) {

939setFirstRegular(*C);

940 Err =Error::success();

941return;

942 }

943

944 NameOrErr =C->getRawName();

945if (!NameOrErr) {

946 Err = NameOrErr.takeError();

947return;

948 }

949Name = NameOrErr.get();

950 }

951

952if (Name =="/<ECSYMBOLS>/") {

953// ARM64EC-aware libraries contain an additional special member with

954// an EC symbol map after the string table. Its format is similar to a

955// regular symbol map, except it doesn't contain member offsets. Its indexes

956// refer to member offsets from the regular symbol table instead.

957Expected<StringRef> BufOrErr =C->getBuffer();

958if (!BufOrErr) {

959 Err = BufOrErr.takeError();

960return;

961 }

962ECSymbolTable = BufOrErr.get();

963if (Increment())

964return;

965 }

966

967setFirstRegular(*C);

968 Err =Error::success();

969}

970

971object::Archive::Kind Archive::getDefaultKindForTriple(constTriple &T) {

972if (T.isOSDarwin())

973returnobject::Archive::K_DARWIN;

974if (T.isOSAIX())

975returnobject::Archive::K_AIXBIG;

976if (T.isOSWindows())

977returnobject::Archive::K_COFF;

978returnobject::Archive::K_GNU;

979}

980

981object::Archive::Kind Archive::getDefaultKind() {

982Triple HostTriple(sys::getDefaultTargetTriple());

983returngetDefaultKindForTriple(HostTriple);

984}

985

986Archive::child_iterator Archive::child_begin(Error &Err,

987bool SkipInternal) const{

988if (isEmpty())

989returnchild_end();

990

991if (SkipInternal)

992returnchild_iterator::itr(

993Child(this, FirstRegularData, FirstRegularStartOfFile), Err);

994

995constchar *Loc =Data.getBufferStart() +getFirstChildOffset();

996Child C(this, Loc, &Err);

997if (Err)

998returnchild_end();

999returnchild_iterator::itr(C, Err);

1000}

1001

1002Archive::child_iterator Archive::child_end() const{

1003returnchild_iterator::end(Child(nullptr,nullptr,nullptr));

1004}

1005

1006boolArchive::Symbol::isECSymbol() const{

1007// Symbols use SymbolCount..SymbolCount+getNumberOfECSymbols() for EC symbol

1008// indexes.

1009uint32_t SymbolCount = Parent->getNumberOfSymbols();

1010return SymbolCount <= SymbolIndex &&

1011 SymbolIndex < SymbolCount + Parent->getNumberOfECSymbols();

1012}

1013

1014StringRef Archive::Symbol::getName() const{

1015if (isECSymbol())

1016return Parent->ECSymbolTable.begin() + StringIndex;

1017return Parent->getSymbolTable().begin() + StringIndex;

1018}

1019

1020Expected<Archive::Child>Archive::Symbol::getMember() const{

1021constchar *Buf = Parent->getSymbolTable().begin();

1022constchar *Offsets = Buf;

1023if (Parent->kind() ==K_GNU64 || Parent->kind() ==K_DARWIN64 ||

1024 Parent->kind() ==K_AIXBIG)

1025 Offsets +=sizeof(uint64_t);

1026else

1027 Offsets +=sizeof(uint32_t);

1028uint64_t Offset = 0;

1029if (Parent->kind() ==K_GNU) {

1030Offset =read32be(Offsets + SymbolIndex * 4);

1031 }elseif (Parent->kind() ==K_GNU64 || Parent->kind() ==K_AIXBIG) {

1032Offset =read64be(Offsets + SymbolIndex * 8);

1033 }elseif (Parent->kind() ==K_BSD) {

1034// The SymbolIndex is an index into the ranlib structs that start at

1035// Offsets (the first uint32_t is the number of bytes of the ranlib

1036// structs). The ranlib structs are a pair of uint32_t's the first

1037// being a string table offset and the second being the offset into

1038// the archive of the member that defines the symbol. Which is what

1039// is needed here.

1040Offset =read32le(Offsets + SymbolIndex * 8 + 4);

1041 }elseif (Parent->kind() ==K_DARWIN64) {

1042// The SymbolIndex is an index into the ranlib_64 structs that start at

1043// Offsets (the first uint64_t is the number of bytes of the ranlib_64

1044// structs). The ranlib_64 structs are a pair of uint64_t's the first

1045// being a string table offset and the second being the offset into

1046// the archive of the member that defines the symbol. Which is what

1047// is needed here.

1048Offset =read64le(Offsets + SymbolIndex * 16 + 8);

1049 }else {

1050// Skip offsets.

1051uint32_t MemberCount =read32le(Buf);

1052 Buf += MemberCount * 4 + 4;

1053

1054uint32_t SymbolCount =read32le(Buf);

1055uint16_t OffsetIndex;

1056if (SymbolIndex < SymbolCount) {

1057// Skip SymbolCount to get to the indices table.

1058constchar *Indices = Buf + 4;

1059

1060// Get the index of the offset in the file member offset table for this

1061// symbol.

1062 OffsetIndex =read16le(Indices + SymbolIndex * 2);

1063 }elseif (isECSymbol()) {

1064// Skip SymbolCount to get to the indices table.

1065constchar *Indices = Parent->ECSymbolTable.begin() + 4;

1066

1067// Get the index of the offset in the file member offset table for this

1068// symbol.

1069 OffsetIndex =read16le(Indices + (SymbolIndex - SymbolCount) * 2);

1070 }else {

1071returnerrorCodeToError(object_error::parse_failed);

1072 }

1073// Subtract 1 since OffsetIndex is 1 based.

1074 --OffsetIndex;

1075

1076if (OffsetIndex >= MemberCount)

1077returnerrorCodeToError(object_error::parse_failed);

1078

1079Offset =read32le(Offsets + OffsetIndex * 4);

1080 }

1081

1082constchar *Loc = Parent->getData().begin() +Offset;

1083Error Err =Error::success();

1084Child C(Parent, Loc, &Err);

1085if (Err)

1086return std::move(Err);

1087returnC;

1088}

1089

1090Archive::Symbol Archive::Symbol::getNext() const{

1091Symbol t(*this);

1092if (Parent->kind() ==K_BSD) {

1093// t.StringIndex is an offset from the start of the __.SYMDEF or

1094// "__.SYMDEF SORTED" member into the string table for the ranlib

1095// struct indexed by t.SymbolIndex . To change t.StringIndex to the

1096// offset in the string table for t.SymbolIndex+1 we subtract the

1097// its offset from the start of the string table for t.SymbolIndex

1098// and add the offset of the string table for t.SymbolIndex+1.

1099

1100// The __.SYMDEF or "__.SYMDEF SORTED" member starts with a uint32_t

1101// which is the number of bytes of ranlib structs that follow. The ranlib

1102// structs are a pair of uint32_t's the first being a string table offset

1103// and the second being the offset into the archive of the member that

1104// define the symbol. After that the next uint32_t is the byte count of

1105// the string table followed by the string table.

1106constchar *Buf = Parent->getSymbolTable().begin();

1107uint32_t RanlibCount = 0;

1108 RanlibCount =read32le(Buf) / 8;

1109// If t.SymbolIndex + 1 will be past the count of symbols (the RanlibCount)

1110// don't change the t.StringIndex as we don't want to reference a ranlib

1111// past RanlibCount.

1112if (t.SymbolIndex + 1 < RanlibCount) {

1113constchar *Ranlibs = Buf + 4;

1114uint32_t CurRanStrx = 0;

1115uint32_t NextRanStrx = 0;

1116 CurRanStrx =read32le(Ranlibs + t.SymbolIndex * 8);

1117 NextRanStrx =read32le(Ranlibs + (t.SymbolIndex + 1) * 8);

1118 t.StringIndex -= CurRanStrx;

1119 t.StringIndex += NextRanStrx;

1120 }

1121 }elseif (t.isECSymbol()) {

1122// Go to one past next null.

1123 t.StringIndex = Parent->ECSymbolTable.find('\0', t.StringIndex) + 1;

1124 }else {

1125// Go to one past next null.

1126 t.StringIndex = Parent->getSymbolTable().find('\0', t.StringIndex) + 1;

1127 }

1128 ++t.SymbolIndex;

1129return t;

1130}

1131

1132Archive::symbol_iterator Archive::symbol_begin() const{

1133if (!hasSymbolTable())

1134returnsymbol_iterator(Symbol(this, 0, 0));

1135

1136constchar *buf =getSymbolTable().begin();

1137if (kind() ==K_GNU) {

1138uint32_t symbol_count = 0;

1139 symbol_count =read32be(buf);

1140 buf +=sizeof(uint32_t) + (symbol_count * (sizeof(uint32_t)));

1141 }elseif (kind() ==K_GNU64) {

1142uint64_t symbol_count =read64be(buf);

1143 buf +=sizeof(uint64_t) + (symbol_count * (sizeof(uint64_t)));

1144 }elseif (kind() ==K_BSD) {

1145// The __.SYMDEF or "__.SYMDEF SORTED" member starts with a uint32_t

1146// which is the number of bytes of ranlib structs that follow. The ranlib

1147// structs are a pair of uint32_t's the first being a string table offset

1148// and the second being the offset into the archive of the member that

1149// define the symbol. After that the next uint32_t is the byte count of

1150// the string table followed by the string table.

1151uint32_t ranlib_count = 0;

1152 ranlib_count =read32le(buf) / 8;

1153constchar *ranlibs = buf + 4;

1154uint32_t ran_strx = 0;

1155 ran_strx =read32le(ranlibs);

1156 buf +=sizeof(uint32_t) + (ranlib_count * (2 * (sizeof(uint32_t))));

1157// Skip the byte count of the string table.

1158 buf +=sizeof(uint32_t);

1159 buf += ran_strx;

1160 }elseif (kind() ==K_DARWIN64) {

1161// The __.SYMDEF_64 or "__.SYMDEF_64 SORTED" member starts with a uint64_t

1162// which is the number of bytes of ranlib_64 structs that follow. The

1163// ranlib_64 structs are a pair of uint64_t's the first being a string

1164// table offset and the second being the offset into the archive of the

1165// member that define the symbol. After that the next uint64_t is the byte

1166// count of the string table followed by the string table.

1167uint64_t ranlib_count = 0;

1168 ranlib_count =read64le(buf) / 16;

1169constchar *ranlibs = buf + 8;

1170uint64_t ran_strx = 0;

1171 ran_strx =read64le(ranlibs);

1172 buf +=sizeof(uint64_t) + (ranlib_count * (2 * (sizeof(uint64_t))));

1173// Skip the byte count of the string table.

1174 buf +=sizeof(uint64_t);

1175 buf += ran_strx;

1176 }elseif (kind() ==K_AIXBIG) {

1177 buf =getStringTable().begin();

1178 }else {

1179uint32_t member_count = 0;

1180uint32_t symbol_count = 0;

1181 member_count =read32le(buf);

1182 buf += 4 + (member_count * 4);// Skip offsets.

1183 symbol_count =read32le(buf);

1184 buf += 4 + (symbol_count * 2);// Skip indices.

1185 }

1186uint32_t string_start_offset = buf -getSymbolTable().begin();

1187returnsymbol_iterator(Symbol(this, 0, string_start_offset));

1188}

1189

1190Archive::symbol_iterator Archive::symbol_end() const{

1191returnsymbol_iterator(Symbol(this,getNumberOfSymbols(), 0));

1192}

1193

1194Expected<iterator_range<Archive::symbol_iterator>>Archive::ec_symbols() const{

1195uint32_t Count = 0;

1196

1197// Validate EC symbol table.

1198if (!ECSymbolTable.empty()) {

1199if (ECSymbolTable.size() <sizeof(uint32_t))

1200returnmalformedError("invalid EC symbols size (" +

1201Twine(ECSymbolTable.size()) +")");

1202if (SymbolTable.size() <sizeof(uint32_t))

1203returnmalformedError("invalid symbols size (" +

1204Twine(ECSymbolTable.size()) +")");

1205

1206 Count =read32le(ECSymbolTable.begin());

1207size_t StringIndex =sizeof(uint32_t) + Count *sizeof(uint16_t);

1208if (ECSymbolTable.size() < StringIndex)

1209returnmalformedError("invalid EC symbols size. Size was " +

1210Twine(ECSymbolTable.size()) +", but expected " +

1211Twine(StringIndex));

1212

1213uint32_t MemberCount =read32le(SymbolTable.begin());

1214constchar *Indexes =ECSymbolTable.begin() +sizeof(uint32_t);

1215

1216for (uint32_t i = 0; i < Count; ++i) {

1217uint16_t Index =read16le(Indexes + i *sizeof(uint16_t));

1218if (!Index)

1219returnmalformedError("invalid EC symbol index 0");

1220if (Index > MemberCount)

1221returnmalformedError("invalid EC symbol index " +Twine(Index) +

1222" is larger than member count " +

1223Twine(MemberCount));

1224

1225 StringIndex =ECSymbolTable.find('\0', StringIndex);

1226if (StringIndex ==StringRef::npos)

1227returnmalformedError("malformed EC symbol names: not null-terminated");

1228 ++StringIndex;

1229 }

1230 }

1231

1232uint32_t SymbolCount =getNumberOfSymbols();

1233returnmake_range(

1234symbol_iterator(Symbol(this, SymbolCount,

1235sizeof(uint32_t) + Count *sizeof(uint16_t))),

1236symbol_iterator(Symbol(this, SymbolCount + Count, 0)));

1237}

1238

1239uint32_t Archive::getNumberOfSymbols() const{

1240if (!hasSymbolTable())

1241return 0;

1242constchar *buf =getSymbolTable().begin();

1243if (kind() ==K_GNU)

1244returnread32be(buf);

1245if (kind() ==K_GNU64 ||kind() ==K_AIXBIG)

1246returnread64be(buf);

1247if (kind() ==K_BSD)

1248returnread32le(buf) / 8;

1249if (kind() ==K_DARWIN64)

1250returnread64le(buf) / 16;

1251uint32_t member_count = 0;

1252 member_count =read32le(buf);

1253 buf += 4 + (member_count * 4);// Skip offsets.

1254returnread32le(buf);

1255}

1256

1257uint32_t Archive::getNumberOfECSymbols() const{

1258if (ECSymbolTable.size() <sizeof(uint32_t))

1259return 0;

1260returnread32le(ECSymbolTable.begin());

1261}

1262

1263Expected<std::optional<Archive::Child>>Archive::findSym(StringRef name) const{

1264Archive::symbol_iterator bs =symbol_begin();

1265Archive::symbol_iterator es =symbol_end();

1266

1267for (; bs != es; ++bs) {

1268StringRef SymName = bs->getName();

1269if (SymName ==name) {

1270if (auto MemberOrErr = bs->getMember())

1271returnChild(*MemberOrErr);

1272else

1273return MemberOrErr.takeError();

1274 }

1275 }

1276return std::nullopt;

1277}

1278

1279// Returns true if archive file contains no member file.

1280boolArchive::isEmpty() const{

1281returnData.getBufferSize() ==getArchiveMagicLen();

1282}

1283

1284boolArchive::hasSymbolTable() const{return !SymbolTable.empty(); }

1285

1286staticError getGlobalSymtabLocAndSize(constMemoryBufferRef &Data,

1287uint64_t GlobalSymtabOffset,

1288constchar *&GlobalSymtabLoc,

1289uint64_t &Size,constchar *BitMessage) {

1290uint64_t BufferSize =Data.getBufferSize();

1291uint64_t GlobalSymtabContentOffset =

1292 GlobalSymtabOffset +sizeof(BigArMemHdrType);

1293if (GlobalSymtabContentOffset > BufferSize)

1294returnmalformedError(

1295Twine(BitMessage) +" global symbol table header at offset 0x" +

1296Twine::utohexstr(GlobalSymtabOffset) +" and size 0x" +

1297Twine::utohexstr(sizeof(BigArMemHdrType)) +

1298" goes past the end of file");

1299

1300 GlobalSymtabLoc =Data.getBufferStart() + GlobalSymtabOffset;

1301constBigArMemHdrType *GlobalSymHdr =

1302reinterpret_cast<constBigArMemHdrType *>(GlobalSymtabLoc);

1303StringRef RawOffset =getFieldRawString(GlobalSymHdr->Size);

1304if (RawOffset.getAsInteger(10,Size))

1305returnmalformedError(Twine(BitMessage) +" global symbol table size \"" +

1306 RawOffset +"\" is not a number");

1307

1308if (GlobalSymtabContentOffset +Size > BufferSize)

1309returnmalformedError(

1310Twine(BitMessage) +" global symbol table content at offset 0x" +

1311Twine::utohexstr(GlobalSymtabContentOffset) +" and size 0x" +

1312Twine::utohexstr(Size) +" goes past the end of file");

1313

1314returnError::success();

1315}

1316

1317structGlobalSymtabInfo {

1318uint64_t SymNum;

1319StringRef SymbolTable;

1320StringRef SymbolOffsetTable;

1321StringRef StringTable;

1322};

1323

1324staticvoid

1325appendGlobalSymbolTableInfo(SmallVector<GlobalSymtabInfo> &SymtabInfos,

1326constchar *GlobalSymtabLoc,uint64_t Size) {

1327// In a big archive, a global symbol table contains the following information:

1328// - The number of symbols.

1329// - The array of offsets into the archive file. The length is eight

1330// times the number of symbols.

1331// - The name-string table. The size is:

1332// Size-(8*(the number of symbols + 1)).

1333

1334StringRef SymbolTable =

1335StringRef(GlobalSymtabLoc +sizeof(BigArMemHdrType),Size);

1336uint64_t SymNum =read64be(GlobalSymtabLoc +sizeof(BigArMemHdrType));

1337StringRef SymbolOffsetTable =StringRef(SymbolTable.data() + 8, 8 * SymNum);

1338unsigned SymOffsetsSize = 8 * (SymNum + 1);

1339uint64_t SymbolTableStringSize =Size - SymOffsetsSize;

1340StringRef StringTable =

1341StringRef(SymbolTable.data() + SymOffsetsSize, SymbolTableStringSize);

1342 SymtabInfos.push_back({SymNum,SymbolTable, SymbolOffsetTable,StringTable});

1343}

1344

1345BigArchive::BigArchive(MemoryBufferRef Source,Error &Err)

1346 :Archive(Source, Err) {

1347ErrorAsOutParameter ErrAsOutParam(&Err);

1348StringRef Buffer =Data.getBuffer();

1349ArFixLenHdr =reinterpret_cast<constFixLenHdr *>(Buffer.data());

1350uint64_t BufferSize =Data.getBufferSize();

1351

1352if (BufferSize <sizeof(FixLenHdr)) {

1353 Err =malformedError("malformed AIX big archive: incomplete fixed length "

1354"header, the archive is only" +

1355Twine(BufferSize) +" byte(s)");

1356return;

1357 }

1358

1359StringRef RawOffset =getFieldRawString(ArFixLenHdr->FirstChildOffset);

1360if (RawOffset.getAsInteger(10,FirstChildOffset))

1361// TODO: Out-of-line.

1362 Err =malformedError("malformed AIX big archive: first member offset \"" +

1363 RawOffset +"\" is not a number");

1364

1365 RawOffset =getFieldRawString(ArFixLenHdr->LastChildOffset);

1366if (RawOffset.getAsInteger(10,LastChildOffset))

1367// TODO: Out-of-line.

1368 Err =malformedError("malformed AIX big archive: last member offset \"" +

1369 RawOffset +"\" is not a number");

1370

1371uint64_t GlobSymtab32Offset = 0;

1372 RawOffset =getFieldRawString(ArFixLenHdr->GlobSymOffset);

1373if (RawOffset.getAsInteger(10, GlobSymtab32Offset)) {

1374 Err =malformedError("global symbol table "

1375"offset of 32-bit members \"" +

1376 RawOffset +"\" is not a number");

1377return;

1378 }

1379

1380uint64_t GlobSymtab64Offset = 0;

1381 RawOffset =getFieldRawString(ArFixLenHdr->GlobSym64Offset);

1382if (RawOffset.getAsInteger(10, GlobSymtab64Offset)) {

1383 Err =malformedError("global symbol table "

1384"offset of 64-bit members\"" +

1385 RawOffset +"\" is not a number");

1386return;

1387 }

1388

1389constchar *GlobSymtab32Loc =nullptr;

1390constchar *GlobSymtab64Loc =nullptr;

1391uint64_t GlobSymtab32Size = 0;

1392uint64_t GlobSymtab64Size = 0;

1393constMemoryBufferRef &MemBuffRef =getMemoryBufferRef();

1394

1395if (GlobSymtab32Offset) {

1396 Err =

1397getGlobalSymtabLocAndSize(MemBuffRef, GlobSymtab32Offset,

1398 GlobSymtab32Loc, GlobSymtab32Size,"32-bit");

1399if (Err)

1400return;

1401

1402Has32BitGlobalSymtab =true;

1403 }

1404

1405if (GlobSymtab64Offset) {

1406 Err =

1407getGlobalSymtabLocAndSize(MemBuffRef, GlobSymtab64Offset,

1408 GlobSymtab64Loc, GlobSymtab64Size,"64-bit");

1409if (Err)

1410return;

1411

1412Has64BitGlobalSymtab =true;

1413 }

1414

1415SmallVector<GlobalSymtabInfo> SymtabInfos;

1416

1417if (GlobSymtab32Offset)

1418appendGlobalSymbolTableInfo(SymtabInfos, GlobSymtab32Loc, GlobSymtab32Size);

1419if (GlobSymtab64Offset)

1420appendGlobalSymbolTableInfo(SymtabInfos, GlobSymtab64Loc, GlobSymtab64Size);

1421

1422if (SymtabInfos.size() == 1) {

1423SymbolTable = SymtabInfos[0].SymbolTable;

1424StringTable = SymtabInfos[0].StringTable;

1425 }elseif (SymtabInfos.size() == 2) {

1426// In order to let the Archive::Symbol::getNext() work for both 32-bit and

1427// 64-bit global symbol tables, we need to merge them into a single table.

1428raw_string_ostream Out(MergedGlobalSymtabBuf);

1429uint64_t SymNum = SymtabInfos[0].SymNum + SymtabInfos[1].SymNum;

1430write(Out, SymNum,llvm::endianness::big);

1431// Merge symbol offset.

1432 Out << SymtabInfos[0].SymbolOffsetTable;

1433 Out << SymtabInfos[1].SymbolOffsetTable;

1434// Merge string table.

1435 Out << SymtabInfos[0].StringTable;

1436 Out << SymtabInfos[1].StringTable;

1437SymbolTable =MergedGlobalSymtabBuf;

1438// The size of the symbol offset to the member file is 8 bytes.

1439StringTable =StringRef(SymbolTable.begin() + (SymNum + 1) * 8,

1440 SymtabInfos[0].StringTable.size() +

1441 SymtabInfos[1].StringTable.size());

1442 }

1443

1444child_iterator I =child_begin(Err,false);

1445if (Err)

1446return;

1447child_iterator E =child_end();

1448if (I == E) {

1449 Err =Error::success();

1450return;

1451 }

1452setFirstRegular(*I);

1453 Err =Error::success();

1454}

const

aarch64 promote const

Definition:AArch64PromoteConstant.cpp:230

offsetof

#define offsetof(TYPE, MEMBER)

Definition:AMDHSAKernelDescriptor.h:30

Binary.h

Chrono.h

Name

std::string Name

Definition:ELFObjHandler.cpp:77

Size

uint64_t Size

Definition:ELFObjHandler.cpp:81

End

bool End

Definition:ELF_riscv.cpp:480

EndianStream.h

Endian.h

ErrorOr.h

Provides ErrorOr<T> smart pointer.

FileSystem.h

Host.h

#define I(x, y, z)

Definition:MD5.cpp:58

MathExtras.h

MemoryBuffer.h

appendGlobalSymbolTableInfo

static void appendGlobalSymbolTableInfo(SmallVector< GlobalSymtabInfo > &SymtabInfos, const char *GlobalSymtabLoc, uint64_t Size)

Definition:Archive.cpp:1325

getGlobalSymtabLocAndSize

static Error getGlobalSymtabLocAndSize(const MemoryBufferRef &Data, uint64_t GlobalSymtabOffset, const char *&GlobalSymtabLoc, uint64_t &Size, const char *BitMessage)

Definition:Archive.cpp:1286

malformedError

static Error malformedError(Twine Msg)

Definition:Archive.cpp:43

getFieldRawString

StringRef getFieldRawString(const T(&Field)[N])

Definition:Archive.cpp:65

getArchiveMemberOctField

Expected< uint64_t > getArchiveMemberOctField(Twine FieldName, const StringRef RawField, const Archive *Parent, const AbstractArchiveMemberHeader *MemHeader)

Definition:Archive.cpp:198

getArchiveMemberDecField

Expected< uint64_t > getArchiveMemberDecField(Twine FieldName, const StringRef RawField, const Archive *Parent, const AbstractArchiveMemberHeader *MemHeader)

Definition:Archive.cpp:180

createMemberHeaderParseError

static Error createMemberHeaderParseError(const AbstractArchiveMemberHeader *ArMemHeader, const char *RawHeaderPtr, uint64_t Size)

Definition:Archive.cpp:50

Path.h

getName

static StringRef getName(Value *V)

Definition:ProvenanceAnalysisEvaluator.cpp:20

assert

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

name

static const char * name

Definition:SMEABIPass.cpp:46

raw_pwrite_stream & OS

Definition:SampleProfWriter.cpp:51

SmallString.h

This file defines the SmallString class.

StringRef.h

Twine.h

getSize

static unsigned getSize(unsigned Kind)

Definition:XtensaAsmBackend.cpp:134

llvm::ErrorAsOutParameter

Helper for Errors used as out-parameters.

Definition:Error.h:1130

llvm::ErrorOr

Represents either an error or a value T.

Definition:ErrorOr.h:56

llvm::ErrorOr::getError

std::error_code getError() const

Definition:ErrorOr.h:152

llvm::Error

Lightweight error class with error context and mandatory checking.

Definition:Error.h:160

llvm::Error::success

static ErrorSuccess success()

Create a success value.

Definition:Error.h:337

llvm::Expected

Tagged union holding either a T or a Error.

Definition:Error.h:481

llvm::Expected::takeError

Error takeError()

Take ownership of the stored error.

Definition:Error.h:608

llvm::Expected::get

reference get()

Returns a reference to the stored T value.

Definition:Error.h:578

llvm::LLVMContext

This is an important class for using LLVM in a threaded context.

Definition:LLVMContext.h:67

llvm::MemoryBufferRef

Definition:MemoryBufferRef.h:22

llvm::MemoryBufferRef::getBufferSize

size_t getBufferSize() const

Definition:MemoryBufferRef.h:37

llvm::MemoryBufferRef::getBufferStart

const char * getBufferStart() const

Definition:MemoryBufferRef.h:35

llvm::MemoryBufferRef::getBuffer

StringRef getBuffer() const

Definition:MemoryBufferRef.h:32

llvm::MemoryBufferRef::getBufferEnd

const char * getBufferEnd() const

Definition:MemoryBufferRef.h:36

llvm::MemoryBuffer::getFile

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,...

Definition:MemoryBuffer.cpp:260

llvm::SmallString

SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...

Definition:SmallString.h:26

llvm::SmallVectorBase::size

size_t size() const

Definition:SmallVector.h:78

llvm::SmallVectorTemplateBase::push_back

void push_back(const T &Elt)

Definition:SmallVector.h:413

llvm::SmallVector

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

Definition:SmallVector.h:1196

llvm::StringRef

StringRef - Represent a constant reference to a string, i.e.

Definition:StringRef.h:51

llvm::StringRef::getAsInteger

bool getAsInteger(unsigned Radix, T &Result) const

Parse the current string as an integer of the specified radix.

Definition:StringRef.h:470

llvm::StringRef::starts_with

bool starts_with(StringRef Prefix) const

Check if this string starts with the given Prefix.

Definition:StringRef.h:265

llvm::StringRef::empty

constexpr bool empty() const

empty - Check if the string is empty.

Definition:StringRef.h:147

llvm::StringRef::begin

iterator begin() const

Definition:StringRef.h:116

llvm::StringRef::size_type

size_t size_type

Definition:StringRef.h:57

llvm::StringRef::slice

StringRef slice(size_t Start, size_t End) const

Return a reference to the substring from [Start, End).

Definition:StringRef.h:684

llvm::StringRef::size

constexpr size_t size() const

size - Get the string size.

Definition:StringRef.h:150

llvm::StringRef::data

constexpr const char * data() const

data - Get a pointer to the start of the string (which may not be null terminated).

Definition:StringRef.h:144

llvm::StringRef::end

iterator end() const

Definition:StringRef.h:118

llvm::StringRef::rtrim

StringRef rtrim(char Char) const

Return string with consecutive Char characters starting from the right removed.

Definition:StringRef.h:803

llvm::StringRef::find

size_t find(char C, size_t From=0) const

Search for the first character C in the string.

Definition:StringRef.h:297

llvm::StringRef::ends_with

bool ends_with(StringRef Suffix) const

Check if this string ends with the given Suffix.

Definition:StringRef.h:277

llvm::StringRef::npos

static constexpr size_t npos

Definition:StringRef.h:53

llvm::StringTable

A table of densely packed, null-terminated strings indexed by offset.

Definition:StringTable.h:33

llvm::Triple

Triple - Helper class for working with autoconf configuration names.

Definition:Triple.h:44

llvm::Twine

Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...

Definition:Twine.h:81

llvm::Twine::str

std::string str() const

Return the twine contents as a std::string.

Definition:Twine.cpp:17

llvm::Twine::utohexstr

static Twine utohexstr(const uint64_t &Val)

Definition:Twine.h:416

llvm::User

Definition:User.h:44

llvm::Value

LLVM Value Representation.

Definition:Value.h:74

llvm::fallible_iterator

A wrapper class for fallible iterators.

Definition:fallible_iterator.h:68

llvm::fallible_iterator::end

static fallible_iterator end(Underlying I)

Construct a fallible iterator that can be used as an end-of-range value.

Definition:fallible_iterator.h:94

llvm::fallible_iterator::itr

static fallible_iterator itr(Underlying I, Error &Err)

Construct a fallible iterator that cannot be used as an end-of-range value.

Definition:fallible_iterator.h:84

llvm::object::AbstractArchiveMemberHeader

Definition:Archive.h:39

llvm::object::AbstractArchiveMemberHeader::Parent

const Archive * Parent

Definition:Archive.h:73

llvm::object::AbstractArchiveMemberHeader::getRawGID

virtual StringRef getRawGID() const =0

llvm::object::AbstractArchiveMemberHeader::getRawUID

virtual StringRef getRawUID() const =0

llvm::object::AbstractArchiveMemberHeader::getUID

Expected< unsigned > getUID() const

Definition:Archive.cpp:403

llvm::object::AbstractArchiveMemberHeader::getAccessMode

Expected< sys::fs::perms > getAccessMode() const

Definition:Archive.cpp:384

llvm::object::AbstractArchiveMemberHeader::getGID

Expected< unsigned > getGID() const

Definition:Archive.cpp:410

llvm::object::AbstractArchiveMemberHeader::getOffset

virtual uint64_t getOffset() const =0

llvm::object::AbstractArchiveMemberHeader::getLastModified

Expected< sys::TimePoint< std::chrono::seconds > > getLastModified() const

Definition:Archive.cpp:393

llvm::object::AbstractArchiveMemberHeader::getRawAccessMode

virtual StringRef getRawAccessMode() const =0

llvm::object::AbstractArchiveMemberHeader::getRawLastModified

virtual StringRef getRawLastModified() const =0

llvm::object::AbstractArchiveMemberHeader::getName

virtual Expected< StringRef > getName(uint64_t Size) const =0

Get the name looking up long names.

llvm::object::ArchiveMemberHeader::ArchiveMemberHeader

ArchiveMemberHeader(const Archive *Parent, const char *RawHeaderPtr, uint64_t Size, Error *Err)

Definition:Archive.cpp:94

llvm::object::ArchiveMemberHeader::getName

Expected< StringRef > getName(uint64_t Size) const override

Get the name looking up long names.

Definition:Archive.cpp:244

llvm::object::ArchiveMemberHeader::getRawName

Expected< StringRef > getRawName() const override

Get the name without looking up long names.

Definition:Archive.cpp:154

llvm::object::ArchiveMemberHeader::isThin

Expected< bool > isThin() const override

Definition:Archive.cpp:417

llvm::object::ArchiveMemberHeader::getSize

Expected< uint64_t > getSize() const override

Definition:Archive.cpp:356

llvm::object::ArchiveMemberHeader::getNextChildLoc

Expected< const char * > getNextChildLoc() const override

Get next file member location.

Definition:Archive.cpp:425

llvm::object::Archive::Child

Definition:Archive.h:160

llvm::object::Archive::Child::getBuffer

Expected< StringRef > getBuffer() const

Definition:Archive.cpp:572

llvm::object::Archive::Child::getNext

Expected< Child > getNext() const

Definition:Archive.cpp:594

llvm::object::Archive::Child::getFullName

Expected< std::string > getFullName() const

Definition:Archive.cpp:554

llvm::object::Archive::Child::getChildOffset

uint64_t getChildOffset() const

Definition:Archive.cpp:625

llvm::object::Archive::Child::getRawSize

Expected< uint64_t > getRawSize() const

Definition:Archive.cpp:548

llvm::object::Archive::Child::getName

Expected< StringRef > getName() const

Definition:Archive.cpp:632

llvm::object::Archive::Child::getSize

Expected< uint64_t > getSize() const

Definition:Archive.cpp:542

llvm::object::Archive::Child::getRawName

Expected< StringRef > getRawName() const

Definition:Archive.h:225

llvm::object::Archive::Child::getAsBinary

Expected< std::unique_ptr< Binary > > getAsBinary(LLVMContext *Context=nullptr) const

Definition:Archive.cpp:657

llvm::object::Archive::Child::getMemoryBufferRef

Expected< MemoryBufferRef > getMemoryBufferRef() const

Definition:Archive.cpp:645

llvm::object::Archive::Child::Child

Child(const Archive *Parent, const char *Start, Error *Err)

Definition:Archive.cpp:467

llvm::object::Archive::Symbol

Definition:Archive.h:289

llvm::object::Archive::Symbol::getNext

Symbol getNext() const

Definition:Archive.cpp:1090

llvm::object::Archive::Symbol::getMember

Expected< Child > getMember() const

Definition:Archive.cpp:1020

llvm::object::Archive::Symbol::getName

StringRef getName() const

Definition:Archive.cpp:1014

llvm::object::Archive::Symbol::isECSymbol

bool isECSymbol() const

Definition:Archive.cpp:1006

llvm::object::Archive::symbol_iterator

Definition:Archive.h:308

llvm::object::Archive

Definition:Archive.h:156

llvm::object::Archive::createArchiveMemberHeader

std::unique_ptr< AbstractArchiveMemberHeader > createArchiveMemberHeader(const char *RawHeaderPtr, uint64_t Size, Error *Err) const

Definition:Archive.cpp:684

llvm::object::Archive::symbol_begin

symbol_iterator symbol_begin() const

Definition:Archive.cpp:1132

llvm::object::Archive::getFirstChildOffset

virtual uint64_t getFirstChildOffset() const

Definition:Archive.h:370

llvm::object::Archive::isThin

bool isThin() const

Definition:Archive.h:340

llvm::object::Archive::getStringTable

StringRef getStringTable() const

Definition:Archive.h:367

llvm::object::Archive::getNumberOfSymbols

uint32_t getNumberOfSymbols() const

Definition:Archive.cpp:1239

llvm::object::Archive::getNumberOfECSymbols

uint32_t getNumberOfECSymbols() const

Definition:Archive.cpp:1257

llvm::object::Archive::setFirstRegular

void setFirstRegular(const Child &C)

Definition:Archive.cpp:703

llvm::object::Archive::getArchiveMagicLen

uint64_t getArchiveMagicLen() const

Definition:Archive.cpp:693

llvm::object::Archive::getSymbolTable

StringRef getSymbolTable() const

Definition:Archive.h:366

llvm::object::Archive::ECSymbolTable

StringRef ECSymbolTable

Definition:Archive.h:385

llvm::object::Archive::symbol_end

symbol_iterator symbol_end() const

Definition:Archive.cpp:1190

llvm::object::Archive::getDefaultKind

static object::Archive::Kind getDefaultKind()

Definition:Archive.cpp:981

llvm::object::Archive::isEmpty

virtual bool isEmpty() const

Definition:Archive.cpp:1280

llvm::object::Archive::child_end

child_iterator child_end() const

Definition:Archive.cpp:1002

llvm::object::Archive::hasSymbolTable

bool hasSymbolTable() const

Definition:Archive.cpp:1284

llvm::object::Archive::Archive

Archive(MemoryBufferRef Source, Error &Err)

Definition:Archive.cpp:708

llvm::object::Archive::kind

Kind kind() const

Definition:Archive.h:339

llvm::object::Archive::getDefaultKindForTriple

static object::Archive::Kind getDefaultKindForTriple(const Triple &T)

Definition:Archive.cpp:971

llvm::object::Archive::SymbolTable

StringRef SymbolTable

Definition:Archive.h:384

llvm::object::Archive::Kind

Kind

Definition:Archive.h:337

llvm::object::Archive::K_AIXBIG

@ K_AIXBIG

Definition:Archive.h:337

llvm::object::Archive::K_DARWIN

@ K_DARWIN

Definition:Archive.h:337

llvm::object::Archive::K_GNU

@ K_GNU

Definition:Archive.h:337

llvm::object::Archive::K_BSD

@ K_BSD

Definition:Archive.h:337

llvm::object::Archive::K_COFF

@ K_COFF

Definition:Archive.h:337

llvm::object::Archive::K_DARWIN64

@ K_DARWIN64

Definition:Archive.h:337

llvm::object::Archive::K_GNU64

@ K_GNU64

Definition:Archive.h:337

llvm::object::Archive::ec_symbols

Expected< iterator_range< symbol_iterator > > ec_symbols() const

Definition:Archive.cpp:1194

llvm::object::Archive::findSym

Expected< std::optional< Child > > findSym(StringRef name) const

Definition:Archive.cpp:1263

llvm::object::Archive::child_begin

child_iterator child_begin(Error &Err, bool SkipInternal=true) const

Definition:Archive.cpp:986

llvm::object::Archive::create

static Expected< std::unique_ptr< Archive > > create(MemoryBufferRef Source)

Definition:Archive.cpp:668

llvm::object::BigArchiveMemberHeader::getSize

Expected< uint64_t > getSize() const override

Definition:Archive.cpp:361

llvm::object::BigArchiveMemberHeader::getRawName

Expected< StringRef > getRawName() const override

Get the name without looking up long names.

Definition:Archive.cpp:215

llvm::object::BigArchiveMemberHeader::getNextChildLoc

Expected< const char * > getNextChildLoc() const override

Get next file member location.

Definition:Archive.cpp:450

llvm::object::BigArchiveMemberHeader::getName

Expected< StringRef > getName(uint64_t Size) const override

Get the name looking up long names.

Definition:Archive.cpp:352

llvm::object::BigArchiveMemberHeader::getRawNameSize

Expected< uint64_t > getRawNameSize() const

Definition:Archive.cpp:374

llvm::object::BigArchiveMemberHeader::getNextOffset

Expected< uint64_t > getNextOffset() const

Definition:Archive.cpp:379

llvm::object::BigArchiveMemberHeader::BigArchiveMemberHeader

BigArchiveMemberHeader(Archive const *Parent, const char *RawHeaderPtr, uint64_t Size, Error *Err)

Definition:Archive.cpp:129

llvm::object::BigArchive

Definition:Archive.h:397

llvm::object::BigArchive::Has32BitGlobalSymtab

bool Has32BitGlobalSymtab

Definition:Archive.h:415

llvm::object::BigArchive::MergedGlobalSymtabBuf

std::string MergedGlobalSymtabBuf

Definition:Archive.h:414

llvm::object::BigArchive::Has64BitGlobalSymtab

bool Has64BitGlobalSymtab

Definition:Archive.h:416

llvm::object::BigArchive::ArFixLenHdr

const FixLenHdr * ArFixLenHdr

Definition:Archive.h:411

llvm::object::BigArchive::FirstChildOffset

uint64_t FirstChildOffset

Definition:Archive.h:412

llvm::object::BigArchive::LastChildOffset

uint64_t LastChildOffset

Definition:Archive.h:413

llvm::object::BigArchive::BigArchive

BigArchive(MemoryBufferRef Source, Error &Err)

Definition:Archive.cpp:1345

llvm::object::Binary

Definition:Binary.h:32

llvm::object::Binary::Data

MemoryBufferRef Data

Definition:Binary.h:37

llvm::object::Binary::ID_Archive

@ ID_Archive

Definition:Binary.h:42

llvm::object::Binary::getData

StringRef getData() const

Definition:Binary.cpp:39

llvm::object::Binary::getMemoryBufferRef

MemoryBufferRef getMemoryBufferRef() const

Definition:Binary.cpp:43

llvm::object::CommonArchiveMemberHeader

Definition:Archive.h:77

llvm::object::CommonArchiveMemberHeader::getRawLastModified

StringRef getRawLastModified() const override

Definition:Archive.cpp:75

llvm::object::CommonArchiveMemberHeader::getRawUID

StringRef getRawUID() const override

Definition:Archive.cpp:79

llvm::object::CommonArchiveMemberHeader< UnixArMemHdrType >::getSizeOf

uint64_t getSizeOf() const override

Definition:Archive.h:87

llvm::object::CommonArchiveMemberHeader::getOffset

uint64_t getOffset() const override

Definition:Archive.cpp:87

llvm::object::CommonArchiveMemberHeader::getRawAccessMode

StringRef getRawAccessMode() const override

Definition:Archive.cpp:70

llvm::object::CommonArchiveMemberHeader::getRawGID

StringRef getRawGID() const override

Definition:Archive.cpp:83

llvm::object::CommonArchiveMemberHeader< UnixArMemHdrType >::ArMemHdr

UnixArMemHdrType const * ArMemHdr

Definition:Archive.h:89

llvm::raw_ostream::flush

void flush()

Definition:raw_ostream.h:198

llvm::raw_ostream::write_escaped

raw_ostream & write_escaped(StringRef Str, bool UseHexEscapes=false)

Output Str, turning '\', '\t', ' ', '"', and anything that doesn't satisfy llvm::isPrint into an esca...

Definition:raw_ostream.cpp:168

llvm::raw_string_ostream

A raw_ostream that writes to an std::string.

Definition:raw_ostream.h:661

@ C

The default llvm calling convention, compatible with C.

Definition:CallingConv.h:34

llvm::XCOFF::NameSize

constexpr size_t NameSize

Definition:XCOFF.h:29

llvm::object::ArchiveMagic

const char ArchiveMagic[]

Definition:Archive.h:33

llvm::object::Kind

Kind

Definition:COFFModuleDefinition.cpp:31

llvm::object::ThinArchiveMagic

const char ThinArchiveMagic[]

Definition:Archive.h:34

llvm::object::object_error::invalid_file_type

@ invalid_file_type

llvm::object::object_error::parse_failed

@ parse_failed

llvm::object::BigArchiveMagic

const char BigArchiveMagic[]

Definition:Archive.h:35

llvm::object::createBinary

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

llvm::support::endian

Definition:Endian.h:41

llvm::support::endian::read64le

uint64_t read64le(const void *P)

Definition:Endian.h:428

llvm::support::endian::read16le

uint16_t read16le(const void *P)

Definition:Endian.h:422

llvm::support::endian::read64be

uint64_t read64be(const void *P)

Definition:Endian.h:437

llvm::support::endian::read32be

uint32_t read32be(const void *P)

Definition:Endian.h:434

llvm::support::endian::read32le

uint32_t read32le(const void *P)

Definition:Endian.h:425

llvm::sys::fs::perms

perms

Definition:FileSystem.h:81

llvm::sys::path::parent_path

StringRef parent_path(StringRef path LLVM_LIFETIME_BOUND, Style style=Style::native)

Get parent path.

Definition:Path.cpp:467

llvm::sys::path::is_absolute

bool is_absolute(const Twine &path, Style style=Style::native)

Is path absolute?

Definition:Path.cpp:671

llvm::sys::path::append

void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")

Append to path.

Definition:Path.cpp:456

llvm::sys::toTimePoint

TimePoint< std::chrono::seconds > toTimePoint(std::time_t T)

Convert a std::time_t to a TimePoint.

Definition:Chrono.h:65

llvm::sys::getDefaultTargetTriple

std::string getDefaultTargetTriple()

getDefaultTargetTriple() - Return the default target triple the compiler has been configured to produ...

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition:AddressRanges.h:18

llvm::Offset

@ Offset

Definition:DWP.cpp:480

llvm::createFileError

Error createFileError(const Twine &F, Error E)

Concatenate a source file path and/or name with an Error.

Definition:Error.h:1385

llvm::make_range

iterator_range< T > make_range(T x, T y)

Convenience function for iterating over sub-ranges.

Definition:iterator_range.h:77

llvm::write

Error write(MCStreamer &Out, ArrayRef< std::string > Inputs, OnCuIndexOverflow OverflowOptValue)

Definition:DWP.cpp:625

llvm::alignTo

uint64_t alignTo(uint64_t Size, Align A)

Returns a multiple of A needed to store Size bytes.

Definition:Alignment.h:155

llvm::errorCodeToError

Error errorCodeToError(std::error_code EC)

Helper for converting an std::error_code to a Error.

Definition:Error.cpp:111

llvm::endianness::big

@ big

llvm::Data

@ Data

Definition:SIMachineScheduler.h:55

llvm::consumeError

void consumeError(Error Err)

Consume a Error without doing anything.

Definition:Error.h:1069

raw_ostream.h

#define N

GlobalSymtabInfo

Definition:Archive.cpp:1317

GlobalSymtabInfo::StringTable

StringRef StringTable

Definition:Archive.cpp:1321

GlobalSymtabInfo::SymbolTable

StringRef SymbolTable

Definition:Archive.cpp:1319

GlobalSymtabInfo::SymNum

uint64_t SymNum

Definition:Archive.cpp:1318

GlobalSymtabInfo::SymbolOffsetTable

StringRef SymbolOffsetTable

Definition:Archive.cpp:1320

llvm::OptimizedStructLayoutField

A field in a structure.

Definition:OptimizedStructLayout.h:45

llvm::object::BigArMemHdrType

Definition:Archive.h:120

llvm::object::BigArMemHdrType::NextOffset

char NextOffset[20]

Definition:Archive.h:122

llvm::object::BigArMemHdrType::Size

char Size[20]

Definition:Archive.h:121

llvm::object::BigArMemHdrType::NameLen

char NameLen[4]

Definition:Archive.h:128

llvm::object::BigArMemHdrType::Name

char Name[2]

Definition:Archive.h:130

llvm::object::BigArchive::FixLenHdr

Fixed-Length Header.

Definition:Archive.h:400

llvm::object::BigArchive::FixLenHdr::FirstChildOffset

char FirstChildOffset[20]

Offset to first archive member.

Definition:Archive.h:406

llvm::object::BigArchive::FixLenHdr::LastChildOffset

char LastChildOffset[20]

Offset to last archive member.

Definition:Archive.h:407

llvm::object::BigArchive::FixLenHdr::GlobSym64Offset

char GlobSym64Offset[20]

Offset global symbol table for 64-bit objects.

Definition:Archive.h:405

llvm::object::BigArchive::FixLenHdr::GlobSymOffset

char GlobSymOffset[20]

Offset to global symbol table.

Definition:Archive.h:403

llvm::object::UnixArMemHdrType

Definition:Archive.h:92

llvm::object::UnixArMemHdrType::Terminator

char Terminator[2]

Definition:Archive.h:99

llvm::object::UnixArMemHdrType::Size

char Size[10]

Size of data, not including header or padding.

Definition:Archive.h:98

llvm::object::UnixArMemHdrType::Name

char Name[16]

Definition:Archive.h:93