ArchiveWriter.cpp Source File (original) (raw)

38#include

39#include

41#if !defined(_MSC_VER) && !defined(__MINGW32__)

42#include <unistd.h>

43#else

44#include <io.h>

45#endif

47using namespace llvm;

52 std::map<std::string, uint16_t> Map;

53 std::map<std::string, uint16_t> ECMap;

54};

61 auto MemBufferRef = this->Buf->getMemBufferRef();

65 if (OptionalObject) {

74 }

86 auto TargetTriple = Triple(IRObject.getTargetTriple());

88 } else {

91 }

92 }

95}

99 bool Deterministic) {

101 if (!BufOrErr)

103

106 M.MemberName = M.Buf->getBufferIdentifier();

107 if (!Deterministic) {

109 if (!ModTimeOrErr)

110 return ModTimeOrErr.takeError();

111 M.ModTime = ModTimeOrErr.get();

113 if (!UIDOrErr)

115 M.UID = UIDOrErr.get();

117 if (!GIDOrErr)

119 M.GID = GIDOrErr.get();

121 if (!AccessModeOrErr)

122 return AccessModeOrErr.takeError();

123 M.Perms = AccessModeOrErr.get();

124 }

125 return std::move(M);

126}

127

129 bool Deterministic) {

132 if (!FDOrErr)

133 return FDOrErr.takeError();

136

139

140

141

142

145

148 if (!MemberBufferOrErr)

150

153

155 M.Buf = std::move(*MemberBufferOrErr);

156 M.MemberName = M.Buf->getBufferIdentifier();

157 if (!Deterministic) {

158 M.ModTime = std::chrono::time_point_caststd::chrono::seconds(

159 Status.getLastModificationTime());

160 M.UID = Status.getUser();

161 M.GID = Status.getGroup();

162 M.Perms = Status.permissions();

163 }

164 return std::move(M);

165}

166

167template

171 unsigned SizeSoFar = OS.tell() - OldPos;

172 assert(SizeSoFar <= Size && "Data doesn't fit in Size");

174}

175

180

184

188

190 switch (Kind) {

195 return false;

199 return true;

200 }

202}

203

204template

210

214

217 unsigned UID, unsigned GID, unsigned Perms, uint64_t Size) {

219

220

221

224

227 Out << "`\n";

228}

229

230static void

233 unsigned UID, unsigned GID, unsigned Perms,

237}

238

239static void

242 unsigned UID, unsigned GID, unsigned Perms, uint64_t Size) {

243 uint64_t PosAfterHeader = Pos + 60 + Name.size();

244

246 unsigned NameWithPadding = Name.size() + Pad;

249 NameWithPadding + Size);

250 Out << Name;

251 while (Pad--)

253}

254

255static void

258 unsigned UID, unsigned GID, unsigned Perms,

261 unsigned NameLen = Name.size();

262

267

272 if (NameLen) {

274 if (NameLen % 2)

276 }

277 Out << "`\n";

278}

279

281 return Thin || Name.size() >= 16 || Name.contains('/');

282}

283

285 switch (Kind) {

290 return false;

294 return true;

295 }

297}

298

299static void

306 M.Perms, Size);

309 M.Perms, Size);

310 Out << '/';

312 if (Thin) {

315 } else {

316 auto Insertion = MemberNames.insert({M.MemberName, uint64_t(0)});

317 if (Insertion.second) {

318 Insertion.first->second = StringTable.tell();

322 else

324 }

325 NamePos = Insertion.first->second;

326 }

329}

330

331namespace {

332struct MemberData {

333 std::vector Symbols;

334 std::string Header;

335 StringRef Data;

337 uint64_t PreHeadPadSize = 0;

338 std::unique_ptr SymFile = nullptr;

339};

340}

341

343 unsigned Size = Names.size();

345 std::string Header;

349 Out << "`\n";

351 return {{}, std::move(Header), Names, Pad ? "\n" : ""};

352}

353

355 using namespace std::chrono;

356

357 if (!Deterministic)

358 return time_point_cast(system_clock::now());

360}

361

364 if (!SymFlagsOrErr)

365

368 return false;

370 return false;

372 return false;

373 return true;

374}

375

383

387 uint32_t *Padding = nullptr) {

388 assert((OffsetSize == 4 || OffsetSize == 8) && "Unsupported OffsetSize");

389 uint64_t Size = OffsetSize;

391 Size += NumSyms * OffsetSize * 2;

392 else

393 Size += NumSyms * OffsetSize;

395 Size += OffsetSize;

396 Size += StringTableSize;

397

398

399

400

401

402

404 ? 0

406

408 if (Padding)

409 *Padding = Pad;

411}

412

427

429 uint32_t *Padding = nullptr) {

431

433 Size += sizeof(uint16_t) + S.first.length() + 1;

434

437 if (Padding)

438 *Padding = Pad;

440}

441

444 uint64_t PrevMemberOffset = 0,

445 uint64_t NextMemberOffset = 0) {

447 const char *Name = is64BitKind(Kind) ? "__.SYMDEF_64" : "__.SYMDEF";

452 PrevMemberOffset, NextMemberOffset);

453 } else {

456 }

457}

458

466 auto computeSymbolTableHeaderSize = [=] {

470 return TmpBuf.size();

471 };

472 uint32_t HeaderSize = computeSymbolTableHeaderSize();

473 uint64_t Size = strlen("!\n") + HeaderSize + SymtabSize;

474

479 }

480

481 return Size + StringMemberSize;

482}

483

488

490 return nullptr;

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510 if (!ObjOrErr) {

511 switch (Kind) {

515 Warn(ObjOrErr.takeError());

516 return nullptr;

521 return ObjOrErr.takeError();

522 }

523 }

524 return std::move(*ObjOrErr);

525 } else {

527 if (!ObjOrErr)

528 return ObjOrErr.takeError();

529 return std::move(*ObjOrErr);

530 }

531}

532

534 return SymObj != nullptr ? SymObj->is64Bit() : false;

535}

536

537

539

540

541

542

543

545

546template

549

550

551 if (AuxHeader == nullptr)

553

554

555

556

557

558 if (AuxHeaderSize < offsetof(AuxiliaryHeader, ModuleType))

560

561

562

563 if (AuxHeader->SecNumOfLoader == 0)

565

566

567

568

569

570

572 std::max(AuxHeader->MaxAlignOfText, AuxHeader->MaxAlignOfData);

573 return 1 << (Log2OfAlign > Log2OfAIXPageSize ? Log2OfMaxAlign : Log2OfAlign);

574}

575

576

577

578

579

582 if (!XCOFFObj)

584

585

586

587 return XCOFFObj->is64Bit()

593}

594

598 unsigned NumSyms, uint64_t PrevMemberOffset = 0,

599 uint64_t NextMemberOffset = 0,

600 bool Is64Bit = false) {

601

602

604 return;

605

611 NextMemberOffset);

612

615 else

617

618 uint64_t Pos = MembersOffset;

619 for (const MemberData &M : Members) {

621 Pos += M.PreHeadPadSize;

623 Pos += M.Header.size() + M.Data.size() + M.Padding.size();

624 continue;

625 }

626 }

627

628 for (unsigned StringOffset : M.Symbols) {

632 }

633 Pos += M.Header.size() + M.Data.size() + M.Padding.size();

634 }

635

637

640

641 while (Pad--)

643}

644

651

652 uint32_t Pos = MembersOffset;

653

655 for (const MemberData &M : Members) {

656 printLE(Out, Pos);

657 Pos += M.Header.size() + M.Data.size() + M.Padding.size();

658 }

659

661

665 Out << S.first << '\0';

666

667 while (Pad--)

669}

670

678

680

684 Out << S.first << '\0';

685 while (Pad--)

687}

688

690 if (Obj.isCOFF())

693

694 if (Obj.isCOFFImportFile())

697

698 if (Obj.isIR()) {

701 if (!TripleStr)

702 return false;

703 Triple T(std::move(*TripleStr));

704 return T.isWindowsArm64EC() || T.getArch() == Triple::x86_64;

705 }

706

707 return false;

708}

709

711 if (Obj.isCOFF())

713

714 if (Obj.isCOFFImportFile())

716

717 if (Obj.isIR()) {

720 if (!TripleStr)

721 return false;

722 Triple T(std::move(*TripleStr));

724 }

725

726 return false;

727}

728

735

740 std::vector Ret;

741

742 if (Obj == nullptr)

743 return Ret;

744

745 std::map<std::string, uint16_t> *Map = nullptr;

748

751 continue;

752 if (Map) {

753 std::string Name;

755 if (Error E = S.printName(NameStream))

756 return std::move(E);

757 if (!Map->try_emplace(Name, Index).second)

758 continue;

760 Ret.push_back(SymNames.tell());

761 SymNames << Name << '\0';

762

763

766 }

767 } else {

768 Ret.push_back(SymNames.tell());

769 if (Error E = S.printName(SymNames))

770 return std::move(E);

771 SymNames << '\0';

772 }

773 }

774 return Ret;

775}

776

783 static char PaddingData[8] = {'\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n'};

787

788 std::vector Ret;

789 bool HasObject = false;

790

791

792

793

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837 bool UniqueTimestamps = Deterministic && isDarwin(Kind);

838 std::map<StringRef, unsigned> FilenameCount;

839 if (UniqueTimestamps) {

841 FilenameCount[M.MemberName]++;

842 for (auto &Entry : FilenameCount)

843 Entry.second = Entry.second > 1 ? 1 : 0;

844 }

845

846 std::vector<std::unique_ptr> SymFiles;

847

851 M.Buf->getMemBufferRef(), Context, Kind, [&](Error Err) {

852 Warn(createFileError(M.MemberName, std::move(Err)));

853 });

854 if (!SymFileOrErr)

856 SymFiles.push_back(std::move(*SymFileOrErr));

857 }

858 }

859

861 if (IsEC) {

863 } else {

864

865

866

867

868 bool HaveArm64 = false, HaveEC = false;

869 for (std::unique_ptr &SymFile : SymFiles) {

870 if (!SymFile)

871 continue;

872 if (!HaveArm64)

874 if (!HaveEC)

876 if (HaveArm64 && HaveEC) {

878 break;

879 }

880 }

881 }

882 }

883

884

885

887 uint64_t NextMemHeadPadSize = 0;

888

889 for (uint32_t Index = 0; Index < NewMembers.size(); ++Index) {

891 std::string Header;

893

896

897

898

899

900

901 unsigned MemberPadding =

903 unsigned TailPadding =

905 StringRef Padding = StringRef(PaddingData, MemberPadding + TailPadding);

906

908 if (UniqueTimestamps)

909

911 else

912 ModTime = M->ModTime;

913

916 std::string StringMsg =

917 "File " + M->MemberName.str() + " exceeds size limit";

920 }

921

922 std::unique_ptr CurSymFile;

923 if (!SymFiles.empty())

924 CurSymFile = std::move(SymFiles[Index]);

925

926

927

930 alignTo(M->MemberName.size(), 2);

931

932 if (M == NewMembers.begin())

933 NextMemHeadPadSize =

936 OffsetToMemData;

937

938 MemHeadPadSize = NextMemHeadPadSize;

939 Pos += MemHeadPadSize;

942

943

944

945 if (Index + 1 != SymFiles.size()) {

946 uint64_t OffsetToNextMemData =

948 alignTo(NewMembers[Index + 1].MemberName.size(), 2);

949 NextMemHeadPadSize =

952 OffsetToNextMemData;

953 NextOffset += NextMemHeadPadSize;

954 }

956 M->Perms, Size, PrevOffset, NextOffset);

957 PrevOffset = Pos;

958 } else {

960 ModTime, Size);

961 }

963

964 std::vector Symbols;

968 if (!SymbolsOrErr)

970 Symbols = std::move(*SymbolsOrErr);

971 if (CurSymFile)

972 HasObject = true;

973 }

974

975 Pos += Header.size() + Data.size() + Padding.size();

976 Ret.push_back({std::move(Symbols), std::move(Header), Data, Padding,

977 MemHeadPadSize, std::move(CurSymFile)});

978 }

979

980

981

983 SymNames << '\0' << '\0' << '\0';

984 return std::move(Ret);

985}

986

987namespace llvm {

988

992 if (Err)

993 return Err;

995 return Ret;

996}

997

998

1002 if (!PathToOrErr || !DirFromOrErr)

1004

1007

1008

1011

1012

1013 auto FromTo =

1016 auto FromI = FromTo.first;

1017 auto ToI = FromTo.second;

1018

1019

1021 for (auto FromE = sys::path::end(DirFrom); FromI != FromE; ++FromI)

1023

1024 for (auto ToE = sys::path::end(PathTo); ToI != ToE; ++ToI)

1026

1027 return std::string(Relative);

1028}

1029

1034 bool Thin, std::optional IsEC,

1036 assert((!Thin || isBSDLike (Kind)) && "Only the gnu format has a thin mode");

1037

1044

1045

1046

1047

1050

1051

1052

1054

1056 StringTable, SymNames, Kind, Thin, Deterministic, WriteSymtab,

1059 return E;

1060 std::vector &Data = *DataOrErr;

1061

1062 uint64_t StringTableSize = 0;

1063 MemberData StringTableMember;

1066 StringTableSize = StringTableMember.Header.size() +

1067 StringTableMember.Data.size() +

1068 StringTableMember.Padding.size();

1069 }

1070

1071

1072 uint64_t LastMemberEndOffset = 0;

1073 uint64_t LastMemberHeaderOffset = 0;

1075 uint64_t NumSyms32 = 0;

1076

1077 for (const auto &M : Data) {

1078

1079 LastMemberEndOffset += M.PreHeadPadSize;

1080 LastMemberHeaderOffset = LastMemberEndOffset;

1081

1082 LastMemberEndOffset += M.Header.size() + M.Data.size() + M.Padding.size();

1083 NumSyms += M.Symbols.size();

1084

1085

1086

1087

1088

1089

1092 NumSyms32 += M.Symbols.size();

1093 }

1094 }

1095

1096 std::optional<uint64_t> HeadersSize;

1097

1098

1099

1101

1103 NumSyms, SymNamesBuf.size(),

1105

1106

1107

1108

1109

1110

1111

1112

1113 uint64_t Sym64Threshold = 1ULL << 32;

1114 const char *Sym64Env = std::getenv("SYM64_THRESHOLD");

1115 if (Sym64Env)

1117

1118

1119

1120

1121 if (*HeadersSize + LastMemberHeaderOffset >= Sym64Threshold) {

1122 switch (Kind) {

1124

1126

1127

1129 "Archive is too large: ARM64X does not support archives larger "

1130 "than 4GB");

1131

1134 Thin, IsEC, Warn);

1137 break;

1138 default:

1140 break;

1141 }

1142 HeadersSize.reset();

1143 }

1144 }

1145

1146 if (Thin)

1147 Out << "!\n";

1149 Out << "\n";

1150 else

1151 Out << "!\n";

1152

1154 if (ShouldWriteSymtab) {

1155 if (!HeadersSize)

1157 Kind, Data.size(), StringTableSize, NumSyms, SymNamesBuf.size(),

1160 *HeadersSize, NumSyms);

1161

1164 }

1165

1166 if (StringTableSize)

1167 Out << StringTableMember.Header << StringTableMember.Data

1168 << StringTableMember.Padding;

1169

1170 if (ShouldWriteSymtab && SymMap.ECMap.size())

1172

1173 for (const MemberData &M : Data)

1174 Out << M.Header << M.Data << M.Padding;

1175 } else {

1177 LastMemberEndOffset += *HeadersSize;

1178 LastMemberHeaderOffset += *HeadersSize;

1179

1180

1181

1182 uint64_t MemberTableNameStrTblSize = 0;

1183 std::vector<size_t> MemberOffsets;

1184 std::vector MemberNames;

1185

1187 for (size_t I = 0, Size = NewMembers.size(); I != Size; ++I) {

1189 MemberTableNameStrTblSize += Member.MemberName.size() + 1;

1190 MemberEndOffset += Data[I].PreHeadPadSize;

1191 MemberOffsets.push_back(MemberEndOffset);

1192 MemberNames.push_back(Member.MemberName);

1193

1194

1197 alignTo(Member.MemberName.size(), 2);

1198 }

1199

1200

1201 uint64_t MemberTableSize = 20 +

1202 20 * MemberOffsets.size() +

1203 MemberTableNameStrTblSize;

1204

1209

1210 if (ShouldWriteSymtab && NumSyms)

1211

1212 for (const auto &M : Data) {

1214 M.SymFile.get(), 0,

1216 nullptr);

1217 if (!SymbolsOrErr)

1218 return SymbolsOrErr.takeError();

1219 }

1220

1221 uint64_t MemberTableEndOffset =

1222 LastMemberEndOffset +

1224

1225

1226

1227

1228 uint64_t GlobalSymbolOffset =

1229 (ShouldWriteSymtab &&

1231 ? MemberTableEndOffset

1232 : 0;

1233

1234 uint64_t GlobalSymbolOffset64 = 0;

1235 uint64_t NumSyms64 = NumSyms - NumSyms32;

1237 NumSyms64 > 0) {

1238 if (GlobalSymbolOffset == 0)

1239 GlobalSymbolOffset64 = MemberTableEndOffset;

1240 else

1241

1242

1243 GlobalSymbolOffset64 =

1245 (NumSyms32 + 1) * 8 + alignTo(SymNamesBuf32.size(), 2);

1246 }

1247

1248

1250 20);

1251

1252

1256 NewMembers.size()

1258 Data[0].PreHeadPadSize

1259 : 0,

1260 20);

1262 20);

1264 Out, 0,

1265 20);

1266

1267 for (const MemberData &M : Data) {

1268 Out << std::string(M.PreHeadPadSize, '\0');

1269 Out << M.Header << M.Data;

1270 if (M.Data.size() % 2)

1271 Out << '\0';

1272 }

1273

1274 if (NewMembers.size()) {

1275

1277 MemberTableSize, LastMemberHeaderOffset,

1278 GlobalSymbolOffset ? GlobalSymbolOffset

1279 : GlobalSymbolOffset64);

1281 for (uint64_t MemberOffset : MemberOffsets)

1283 20);

1284 for (StringRef MemberName : MemberNames)

1285 Out << MemberName << '\0';

1286

1287 if (MemberTableNameStrTblSize % 2)

1288 Out << '\0';

1289

1290

1291 if (ShouldWriteSymtab) {

1292

1293 if (GlobalSymbolOffset) {

1295 *HeadersSize, NumSyms32, LastMemberEndOffset,

1296 GlobalSymbolOffset64);

1297

1298 if (GlobalSymbolOffset64 && (SymNamesBuf32.size() % 2))

1299 Out << '\0';

1300 }

1301

1302

1303 if (GlobalSymbolOffset64)

1305 *HeadersSize, NumSyms64,

1306 GlobalSymbolOffset ? GlobalSymbolOffset

1307 : LastMemberEndOffset,

1308 0, true);

1309 }

1310 }

1311 }

1314}

1315

1319

1322 bool Deterministic, bool Thin,

1323 std::unique_ptr OldArchiveBuf,

1327 if (!Temp)

1330

1332 Deterministic, Thin, IsEC, Warn)) {

1333 if (Error DiscardError = Temp->discard())

1334 return joinErrors(std::move(E), std::move(DiscardError));

1335 return E;

1336 }

1337

1338

1339

1340

1341

1342

1343

1344

1345

1346

1347

1348 OldArchiveBuf.reset();

1349

1350 return Temp->keep(ArcName);

1351}

1352

1356 bool Deterministic, bool Thin,

1360

1363 Deterministic, Thin, std::nullopt, Warn))

1364 return std::move(E);

1365

1366 return std::make_unique(

1367 std::move(ArchiveBufferVector), false);

1368}

1369

1370}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

This file defines the StringMap class.

static void printNBits(raw_ostream &Out, object::Archive::Kind Kind, uint64_t Val)

Definition ArchiveWriter.cpp:376

bool isImportDescriptor(StringRef Name)

Definition ArchiveWriter.cpp:729

static sys::TimePoint< std::chrono::seconds > now(bool Deterministic)

Definition ArchiveWriter.cpp:354

static bool isDarwin(object::Archive::Kind Kind)

Definition ArchiveWriter.cpp:176

static uint64_t computeECSymbolsSize(SymMap &SymMap, uint32_t *Padding=nullptr)

Definition ArchiveWriter.cpp:428

static Expected< std::vector< unsigned > > getSymbols(SymbolicFile *Obj, uint16_t Index, raw_ostream &SymNames, SymMap *SymMap)

Definition ArchiveWriter.cpp:736

static bool is64BitSymbolicFile(const SymbolicFile *SymObj)

Definition ArchiveWriter.cpp:533

static uint64_t computeHeadersSize(object::Archive::Kind Kind, uint64_t NumMembers, uint64_t StringMemberSize, uint64_t NumSyms, uint64_t SymNamesSize, SymMap *SymMap)

Definition ArchiveWriter.cpp:459

static bool isBSDLike(object::Archive::Kind Kind)

Definition ArchiveWriter.cpp:189

static void printBSDMemberHeader(raw_ostream &Out, uint64_t Pos, StringRef Name, const sys::TimePoint< std::chrono::seconds > &ModTime, unsigned UID, unsigned GID, unsigned Perms, uint64_t Size)

Definition ArchiveWriter.cpp:240

static void writeSymbolTable(raw_ostream &Out, object::Archive::Kind Kind, bool Deterministic, ArrayRef< MemberData > Members, StringRef StringTable, uint64_t MembersOffset, unsigned NumSyms, uint64_t PrevMemberOffset=0, uint64_t NextMemberOffset=0, bool Is64Bit=false)

Definition ArchiveWriter.cpp:595

static const uint32_t MinBigArchiveMemDataAlign

Definition ArchiveWriter.cpp:544

static void writeSymbolMap(raw_ostream &Out, object::Archive::Kind Kind, bool Deterministic, ArrayRef< MemberData > Members, SymMap &SymMap, uint64_t MembersOffset)

Definition ArchiveWriter.cpp:645

static MemberData computeStringTable(StringRef Names)

Definition ArchiveWriter.cpp:342

uint16_t getAuxMaxAlignment(uint16_t AuxHeaderSize, AuxiliaryHeader *AuxHeader, uint16_t Log2OfMaxAlign)

Definition ArchiveWriter.cpp:547

static const uint32_t Log2OfAIXPageSize

Definition ArchiveWriter.cpp:538

static bool isECObject(object::SymbolicFile &Obj)

Definition ArchiveWriter.cpp:689

static Expected< std::unique_ptr< SymbolicFile > > getSymbolicFile(MemoryBufferRef Buf, LLVMContext &Context, object::Archive::Kind Kind, function_ref< void(Error)> Warn)

Definition ArchiveWriter.cpp:485

static bool isAIXBigArchive(object::Archive::Kind Kind)

Definition ArchiveWriter.cpp:181

static void writeSymbolTableHeader(raw_ostream &Out, object::Archive::Kind Kind, bool Deterministic, uint64_t Size, uint64_t PrevMemberOffset=0, uint64_t NextMemberOffset=0)

Definition ArchiveWriter.cpp:442

static void printRestOfMemberHeader(raw_ostream &Out, const sys::TimePoint< std::chrono::seconds > &ModTime, unsigned UID, unsigned GID, unsigned Perms, uint64_t Size)

Definition ArchiveWriter.cpp:215

static uint64_t computeSymbolTableSize(object::Archive::Kind Kind, uint64_t NumSyms, uint64_t OffsetSize, uint64_t StringTableSize, uint32_t *Padding=nullptr)

Definition ArchiveWriter.cpp:384

static bool isArchiveSymbol(const object::BasicSymbolRef &S)

Definition ArchiveWriter.cpp:362

static bool isCOFFArchive(object::Archive::Kind Kind)

Definition ArchiveWriter.cpp:185

static Expected< std::vector< MemberData > > computeMemberData(raw_ostream &StringTable, raw_ostream &SymNames, object::Archive::Kind Kind, bool Thin, bool Deterministic, SymtabWritingMode NeedSymbols, SymMap *SymMap, LLVMContext &Context, ArrayRef< NewArchiveMember > NewMembers, std::optional< bool > IsEC, function_ref< void(Error)> Warn)

Definition ArchiveWriter.cpp:778

static void printMemberHeader(raw_ostream &Out, uint64_t Pos, raw_ostream &StringTable, StringMap< uint64_t > &MemberNames, object::Archive::Kind Kind, bool Thin, const NewArchiveMember &M, sys::TimePoint< std::chrono::seconds > ModTime, uint64_t Size)

Definition ArchiveWriter.cpp:300

static void writeECSymbols(raw_ostream &Out, object::Archive::Kind Kind, bool Deterministic, ArrayRef< MemberData > Members, SymMap &SymMap)

Definition ArchiveWriter.cpp:671

static uint64_t computeSymbolMapSize(uint64_t NumObj, SymMap &SymMap, uint32_t *Padding=nullptr)

Definition ArchiveWriter.cpp:413

static void printLE(raw_ostream &Out, T Val)

Definition ArchiveWriter.cpp:211

static void printGNUSmallMemberHeader(raw_ostream &Out, StringRef Name, const sys::TimePoint< std::chrono::seconds > &ModTime, unsigned UID, unsigned GID, unsigned Perms, uint64_t Size)

Definition ArchiveWriter.cpp:231

static bool useStringTable(bool Thin, StringRef Name)

Definition ArchiveWriter.cpp:280

static bool is64BitKind(object::Archive::Kind Kind)

Definition ArchiveWriter.cpp:284

static uint32_t getMemberAlignment(SymbolicFile *SymObj)

Definition ArchiveWriter.cpp:580

static void printBigArchiveMemberHeader(raw_ostream &Out, StringRef Name, const sys::TimePoint< std::chrono::seconds > &ModTime, unsigned UID, unsigned GID, unsigned Perms, uint64_t Size, uint64_t PrevOffset, uint64_t NextOffset)

Definition ArchiveWriter.cpp:256

static void printWithSpacePadding(raw_ostream &OS, T Data, unsigned Size)

Definition ArchiveWriter.cpp:168

static bool isAnyArm64COFF(object::SymbolicFile &Obj)

Definition ArchiveWriter.cpp:710

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

#define offsetof(TYPE, MEMBER)

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

size_t size() const

size - Get the array size.

Represents either an error or a value T.

std::error_code getError() const

Lightweight error class with error context and mandatory checking.

static ErrorSuccess success()

Create a success value.

Tagged union holding either a T or a Error.

Error takeError()

Take ownership of the stored error.

reference get()

Returns a reference to the stored T value.

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

size_t getBufferSize() const

StringRef getBuffer() const

This interface provides simple read-only access to a block of memory, and provides simple methods for...

static ErrorOr< std::unique_ptr< MemoryBuffer > > getOpenFile(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize, bool RequiresNullTerminator=true, bool IsVolatile=false, std::optional< Align > Alignment=std::nullopt)

Given an already-open file descriptor, read the file and return a MemoryBuffer.

static std::unique_ptr< MemoryBuffer > getMemBuffer(StringRef InputData, StringRef BufferName="", bool RequiresNullTerminator=true)

Open the specified memory range as a MemoryBuffer.

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

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

StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...

bool insert(MapEntryTy *KeyValue)

insert - Insert the specified key/value pair into the map.

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

bool getAsInteger(unsigned Radix, T &Result) const

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

constexpr size_t size() const

size - Get the string size.

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

constexpr size_t size() const

Returns the byte size of the table.

Triple - Helper class for working with autoconf configuration names.

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

The instances of the Type class are immutable: once they are created, they are never changed.

An efficient, type-erasing, non-owning reference to a callable.

Expected< unsigned > getGID() const

LLVM_ABI Expected< MemoryBufferRef > getMemoryBufferRef() const

Expected< unsigned > getUID() const

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

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

static object::Archive::Kind getDefaultKind()

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

static const uint64_t MaxMemberSize

Size field is 10 decimal digits long.

This is a value type class that represents a single symbol in the list of symbols in the object file.

Expected< uint32_t > getFlags() const

Get symbol flags (bitwise OR of SymbolRef::Flags)

static Expected< OwningBinary< ObjectFile > > createObjectFile(StringRef ObjectPath)

static Expected< std::unique_ptr< SymbolicFile > > createSymbolicFile(MemoryBufferRef Object, llvm::file_magic Type, LLVMContext *Context, bool InitContent=true)

virtual bool is64Bit() const =0

static bool isSymbolicFile(file_magic Type, const LLVMContext *Context)

const XCOFFAuxiliaryHeader32 * auxiliaryHeader32() const

const XCOFFFileHeader64 * fileHeader64() const

const XCOFFFileHeader32 * fileHeader32() const

const XCOFFAuxiliaryHeader64 * auxiliaryHeader64() const

bool is64Bit() const override

A raw_ostream that writes to a file descriptor.

This class implements an extremely fast bulk output stream that can only output to a stream.

uint64_t tell() const

tell - Return the current offset with the file.

raw_ostream & write(unsigned char C)

raw_ostream & indent(unsigned NumSpaces)

indent - Insert 'NumSpaces' spaces.

A raw_ostream that writes to an std::string.

A raw_ostream that writes to an SmallVector or SmallString.

static LLVM_ABI Expected< TempFile > create(const Twine &Model, unsigned Mode=all_read|all_write, OpenFlags ExtraFlags=OF_None)

This creates a temporary file with createUniqueFile and schedules it for deletion with sys::RemoveFil...

Represents the result of a call to sys::fs::status().

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

@ IMAGE_FILE_MACHINE_ARM64

bool isAnyArm64(T Machine)

constexpr std::string_view NullImportDescriptorSymbolName

constexpr std::string_view NullThunkDataPrefix

constexpr std::string_view NullThunkDataSuffix

constexpr std::string_view ImportDescriptorPrefix

void write(void *memory, value_type value, endianness endian)

Write a value to memory with a particular endianness.

LLVM_ABI std::error_code closeFile(file_t &F)

Close the file object.

LLVM_ABI const file_t kInvalidFile

LLVM_ABI Expected< file_t > openNativeFileForRead(const Twine &Name, OpenFlags Flags=OF_None, SmallVectorImpl< char > *RealPath=nullptr)

Opens the file with the given name in a read-only mode, returning its open file descriptor.

LLVM_ABI std::error_code make_absolute(SmallVectorImpl< char > &path)

Make path an absolute path.

LLVM_ABI std::error_code status(const Twine &path, file_status &result, bool follow=true)

Get file status as if by POSIX stat().

LLVM_ABI const_iterator begin(StringRef path LLVM_LIFETIME_BOUND, Style style=Style::native)

Get begin iterator over path.

LLVM_ABI bool remove_dots(SmallVectorImpl< char > &path, bool remove_dot_dot=false, Style style=Style::native)

In-place remove any '.

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

Get parent path.

LLVM_ABI std::string convert_to_slash(StringRef path, Style style=Style::native)

Replaces backslashes with slashes if Windows.

LLVM_ABI StringRef root_name(StringRef path LLVM_LIFETIME_BOUND, Style style=Style::native)

Get root name.

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

Append to path.

LLVM_ABI const_iterator end(StringRef path LLVM_LIFETIME_BOUND)

Get end iterator over path.

std::chrono::time_point< std::chrono::system_clock, D > TimePoint

A time point on the system clock.

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

Convert a std::time_t to a TimePoint.

std::time_t toTimeT(TimePoint<> TP)

Convert a TimePoint to std::time_t.

This is an optimization pass for GlobalISel generic memory operations.

LLVM_ABI file_magic identify_magic(StringRef magic)

Identify the type of a binary file based on how magical it is.

LLVM_ABI void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner={})

Log all errors (if any) in E to OS.

LLVM_ABI Expected< std::unique_ptr< MemoryBuffer > > writeArchiveToBuffer(ArrayRef< NewArchiveMember > NewMembers, SymtabWritingMode WriteSymtab, object::Archive::Kind Kind, bool Deterministic, bool Thin, function_ref< void(Error)> Warn=warnToStderr)

Definition ArchiveWriter.cpp:1354

Error createFileError(const Twine &F, Error E)

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

Printable print(const GCNRegPressure &RP, const GCNSubtarget *ST=nullptr, unsigned DynamicVGPRBlockSize=0)

LLVM_ABI Error writeArchive(StringRef ArcName, ArrayRef< NewArchiveMember > NewMembers, SymtabWritingMode WriteSymtab, object::Archive::Kind Kind, bool Deterministic, bool Thin, std::unique_ptr< MemoryBuffer > OldArchiveBuf=nullptr, std::optional< bool > IsEC=std::nullopt, function_ref< void(Error)> Warn=warnToStderr)

Definition ArchiveWriter.cpp:1320

std::error_code make_error_code(BitcodeError E)

LLVM_ABI Expected< std::string > getBitcodeTargetTriple(MemoryBufferRef Buffer)

Read the header of the specified bitcode buffer and extract just the triple information.

auto dyn_cast_or_null(const Y &Val)

Error joinErrors(Error E1, Error E2)

Concatenate errors.

decltype(auto) get(const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)

constexpr T alignToPowerOf2(U Value, V Align)

Will overflow only if result is not representable in T.

LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)

bool isa(const From &Val)

isa - Return true if the parameter to the template is an instance of one of the template type argu...

format_object< Ts... > format(const char *Fmt, const Ts &... Vals)

These are helper functions used to produce formatted output.

Error make_error(ArgTs &&... Args)

Make a Error instance representing failure using the given error info type.

uint64_t offsetToAlignment(uint64_t Value, Align Alignment)

Returns the offset to the next integer (mod 2**64) that is greater than or equal to Value and is a mu...

LLVM_ABI raw_fd_ostream & errs()

This returns a reference to a raw_ostream for standard error.

FunctionAddr VTableAddr uintptr_t uintptr_t Data

LLVM_ABI void warnToStderr(Error Err)

Definition ArchiveWriter.cpp:1316

uint64_t alignTo(uint64_t Size, Align A)

Returns a multiple of A needed to store Size bytes.

decltype(auto) cast(const From &Val)

cast - Return the argument parameter cast to the specified type.

LLVM_ABI Expected< std::string > computeArchiveRelativePath(StringRef From, StringRef To)

Definition ArchiveWriter.cpp:999

LLVM_ABI Error errorCodeToError(std::error_code EC)

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

static ErrorOr< SmallString< 128 > > canonicalizePath(StringRef P)

Definition ArchiveWriter.cpp:989

std::error_code errnoAsErrorCode()

Helper to get errno as an std::error_code.

LLVM_ABI Error writeArchiveToStream(raw_ostream &Out, ArrayRef< NewArchiveMember > NewMembers, SymtabWritingMode WriteSymtab, object::Archive::Kind Kind, bool Deterministic, bool Thin, std::optional< bool > IsEC=std::nullopt, function_ref< void(Error)> Warn=warnToStderr)

Definition ArchiveWriter.cpp:1030

void consumeError(Error Err)

Consume a Error without doing anything.

Definition ArchiveWriter.cpp:50

std::map< std::string, uint16_t > ECMap

Definition ArchiveWriter.cpp:53

bool UseECMap

Definition ArchiveWriter.cpp:51

std::map< std::string, uint16_t > Map

Definition ArchiveWriter.cpp:52

This struct is a compact representation of a valid (non-zero power of two) alignment.

LLVM_ABI object::Archive::Kind detectKindFromObject() const

Definition ArchiveWriter.cpp:60

NewArchiveMember()=default

static LLVM_ABI Expected< NewArchiveMember > getFile(StringRef FileName, bool Deterministic)

Definition ArchiveWriter.cpp:128

static LLVM_ABI Expected< NewArchiveMember > getOldMember(const object::Archive::Child &OldMember, bool Deterministic)

Definition ArchiveWriter.cpp:98

std::unique_ptr< MemoryBuffer > Buf

file_magic - An "enum class" enumeration of file types based on magic (the first N bytes of the file)...