COFFEmitter.cpp Source File (original) (raw)

24#include

25#include

27using namespace llvm;

29namespace {

33struct COFFParser {

35 : Obj(Obj), SectionTableStart(0), SectionTableSize(0), ErrHandler(EH) {

39 }

41 bool useBigObj() const {

42 return static_cast<int32_t>(Obj.Sections.size()) >

44 }

46 bool isPE() const { return Obj.OptionalHeader.has_value(); }

49 uint32_t getFileAlignment() const {

51 }

53 unsigned getHeaderSize() const {

55 }

57 unsigned getSymbolSize() const {

59 }

61 bool parseSections() {

69 } else {

72 std::string str = utostr(Index);

73 if (str.size() > 7) {

74 ErrHandler("string table got too large");

75 return false;

76 }

78 std::copy(str.begin(), str.end(), Sec.Header.Name + 1);

79 }

83 ErrHandler("section alignment is too large");

84 return false;

85 }

87 ErrHandler("section alignment is not a power of 2");

88 return false;

89 }

91 }

92 }

93 return true;

94 }

96 bool parseSymbols() {

102 std::copy(Name.begin(), Name.end(), Sym.Header.Name);

103 } else {

104

107 Index;

108 }

109

110 Sym.Header.Type = Sym.SimpleType;

112 }

113 return true;

114 }

115

117 if (!parseSections())

118 return false;

119 if (!parseSymbols())

120 return false;

121 return true;

122 }

123

126 if (Inserted) {

127 StringTable.append(Str.begin(), Str.end());

129 }

130 return It->second;

131 }

132

134

141

143};

144

145enum { DOSStubSize = 128 };

146

147}

148

149

150

152 if (!CP.isPE())

153 return true;

156 CP.Obj.Header.SizeOfOptionalHeader =

158 CP.Obj.OptionalHeader->Header.NumberOfRvaAndSize;

159 return true;

160}

161

165 using namespace codeview;

166 ExitOnError Err("Error occurred writing .debug$S section");

167 auto CVSS =

169

170 std::vector Builders;

172 for (auto &SS : CVSS) {

173 DebugSubsectionRecordBuilder B(SS);

174 Size += B.calculateSerializedLength();

175 Builders.push_back(std::move(B));

176 }

180

182 for (const auto &B : Builders) {

183 Err(B.commit(Writer, CodeViewContainer::ObjectFile));

184 }

185 return {Output};

186}

187

188

189

191

192

193 CP.SectionTableStart =

194 CP.getHeaderSize() + CP.Obj.Header.SizeOfOptionalHeader;

195 if (CP.isPE())

196 CP.SectionTableStart += DOSStubSize + sizeof(COFF::PEMagic);

197 CP.SectionTableSize = COFF::SectionSize * CP.Obj.Sections.size();

198

199 uint32_t CurrentSectionDataOffset =

200 CP.SectionTableStart + CP.SectionTableSize;

201

203

204

207 CP.StringsAndChecksums);

208 if (CP.StringsAndChecksums.hasChecksums() &&

209 CP.StringsAndChecksums.hasStrings())

210 break;

211 }

212 }

213

214

216 if (S.Name == ".debug$S") {

218 assert(CP.StringsAndChecksums.hasStrings() &&

219 "Object file does not have debug string table!");

220

222 toDebugS(S.DebugS, CP.StringsAndChecksums, CP.Allocator);

223 }

224 } else if (S.Name == ".debug$T") {

227 } else if (S.Name == ".debug$P") {

230 } else if (S.Name == ".debug$H") {

233 }

234

237 DataSize += E.size();

238 if (DataSize > 0) {

239 CurrentSectionDataOffset = alignTo(CurrentSectionDataOffset,

240 CP.isPE() ? CP.getFileAlignment() : 4);

242 if (CP.isPE())

252 } else

255 }

256 } else {

257

258

260 }

261 }

262

263 uint32_t SymbolTableStart = CurrentSectionDataOffset;

264

265

266 uint32_t NumberOfSymbols = 0;

267 for (std::vectorCOFFYAML::Symbol::iterator i = CP.Obj.Symbols.begin(),

268 e = CP.Obj.Symbols.end();

269 i != e; ++i) {

270 uint32_t NumberOfAuxSymbols = 0;

271 if (i->FunctionDefinition)

272 NumberOfAuxSymbols += 1;

273 if (i->bfAndefSymbol)

274 NumberOfAuxSymbols += 1;

275 if (i->WeakExternal)

276 NumberOfAuxSymbols += 1;

277 if (!i->File.empty())

278 NumberOfAuxSymbols +=

279 (i->File.size() + CP.getSymbolSize() - 1) / CP.getSymbolSize();

280 if (i->SectionDefinition)

281 NumberOfAuxSymbols += 1;

282 if (i->CLRToken)

283 NumberOfAuxSymbols += 1;

284 i->Header.NumberOfAuxSymbols = NumberOfAuxSymbols;

285 NumberOfSymbols += 1 + NumberOfAuxSymbols;

286 }

287

288

289 CP.Obj.Header.NumberOfSections = CP.Obj.Sections.size();

290 CP.Obj.Header.NumberOfSymbols = NumberOfSymbols;

291 if (NumberOfSymbols > 0 || CP.StringTable.size() > 4)

292 CP.Obj.Header.PointerToSymbolTable = SymbolTableStart;

293 else

294 CP.Obj.Header.PointerToSymbolTable = 0;

295

297 CP.StringTable.size();

298

299 return true;

300}

301

305};

306

307template <typename value_type>

310 char Buffer[sizeof(BLE.Value)];

311 support::endian::write<value_type, llvm::endianness::little>(Buffer,

314 return OS;

315}

316

317template <typename value_type>

320}

321

323

324template <size_t NumBytes>

326 char Buffer[NumBytes];

327 memset(Buffer, 0, sizeof(Buffer));

328 OS.write(Buffer, sizeof(Buffer));

329 return OS;

330}

331

334}

335

336template

338 T Header) {

339 memset(Header, 0, sizeof(*Header));

340 Header->Magic = Magic;

341 Header->SectionAlignment = CP.Obj.OptionalHeader->Header.SectionAlignment;

342 Header->FileAlignment = CP.Obj.OptionalHeader->Header.FileAlignment;

343 uint32_t SizeOfCode = 0, SizeOfInitializedData = 0,

344 SizeOfUninitializedData = 0;

345 uint32_t SizeOfHeaders = alignTo(CP.SectionTableStart + CP.SectionTableSize,

346 Header->FileAlignment);

347 uint32_t SizeOfImage = alignTo(SizeOfHeaders, Header->SectionAlignment);

356 if (S.Name == ".text")

358 else if (S.Name == ".data")

362 }

363 Header->SizeOfCode = SizeOfCode;

364 Header->SizeOfInitializedData = SizeOfInitializedData;

365 Header->SizeOfUninitializedData = SizeOfUninitializedData;

366 Header->AddressOfEntryPoint =

367 CP.Obj.OptionalHeader->Header.AddressOfEntryPoint;

368 Header->ImageBase = CP.Obj.OptionalHeader->Header.ImageBase;

369 Header->MajorOperatingSystemVersion =

370 CP.Obj.OptionalHeader->Header.MajorOperatingSystemVersion;

371 Header->MinorOperatingSystemVersion =

372 CP.Obj.OptionalHeader->Header.MinorOperatingSystemVersion;

373 Header->MajorImageVersion = CP.Obj.OptionalHeader->Header.MajorImageVersion;

374 Header->MinorImageVersion = CP.Obj.OptionalHeader->Header.MinorImageVersion;

375 Header->MajorSubsystemVersion =

376 CP.Obj.OptionalHeader->Header.MajorSubsystemVersion;

377 Header->MinorSubsystemVersion =

378 CP.Obj.OptionalHeader->Header.MinorSubsystemVersion;

379 Header->SizeOfImage = SizeOfImage;

380 Header->SizeOfHeaders = SizeOfHeaders;

381 Header->Subsystem = CP.Obj.OptionalHeader->Header.Subsystem;

382 Header->DLLCharacteristics = CP.Obj.OptionalHeader->Header.DLLCharacteristics;

383 Header->SizeOfStackReserve = CP.Obj.OptionalHeader->Header.SizeOfStackReserve;

384 Header->SizeOfStackCommit = CP.Obj.OptionalHeader->Header.SizeOfStackCommit;

385 Header->SizeOfHeapReserve = CP.Obj.OptionalHeader->Header.SizeOfHeapReserve;

386 Header->SizeOfHeapCommit = CP.Obj.OptionalHeader->Header.SizeOfHeapCommit;

387 Header->NumberOfRvaAndSize = CP.Obj.OptionalHeader->Header.NumberOfRvaAndSize;

388 return BaseOfData;

389}

390

392 if (CP.isPE()) {

393

395 memset(&DH, 0, sizeof(DH));

396

397

398 DH.Magic[0] = 'M';

399 DH.Magic[1] = 'Z';

400

401

402

404

406

407

408 OS.write(reinterpret_cast<char *>(&DH), sizeof(DH));

409

410

412

414 }

415 if (CP.useBigObj()) {

420 << binary_le(CP.Obj.Header.Machine)

421 << binary_le(CP.Obj.Header.TimeDateStamp);

425 << binary_le(CP.Obj.Header.PointerToSymbolTable)

426 << binary_le(CP.Obj.Header.NumberOfSymbols);

427 } else {

429 << binary_le(static_cast<int16_t>(CP.Obj.Header.NumberOfSections))

430 << binary_le(CP.Obj.Header.TimeDateStamp)

431 << binary_le(CP.Obj.Header.PointerToSymbolTable)

432 << binary_le(CP.Obj.Header.NumberOfSymbols)

433 << binary_le(CP.Obj.Header.SizeOfOptionalHeader)

434 << binary_le(CP.Obj.Header.Characteristics);

435 }

436 if (CP.isPE()) {

437 if (CP.is64Bit()) {

440 OS.write(reinterpret_cast<char *>(&PEH), sizeof(PEH));

441 } else {

446 OS.write(reinterpret_cast<char *>(&PEH), sizeof(PEH));

447 }

448 for (uint32_t I = 0; I < CP.Obj.OptionalHeader->Header.NumberOfRvaAndSize;

449 ++I) {

450 const std::optionalCOFF::DataDirectory *DataDirectories =

451 CP.Obj.OptionalHeader->DataDirectories;

452 uint32_t NumDataDir = std::size(CP.Obj.OptionalHeader->DataDirectories);

453 if (I >= NumDataDir || !DataDirectories[I]) {

456 } else {

457 OS << binary_le(DataDirectories[I]->RelativeVirtualAddress);

459 }

460 }

461 }

462

464

476 }

477 assert(OS.tell() == CP.SectionTableStart + CP.SectionTableSize);

478

479 unsigned CurSymbol = 0;

482 SymbolTableIndexMap[Sym.Name] = CurSymbol;

483 CurSymbol += 1 + Sym.Header.NumberOfAuxSymbols;

484 }

485

486

489 continue;

493 E.writeAsBinary(OS);

499 OS << binary_le<uint32_t>( S.Relocations.size() + 1)

500 << binary_le<uint32_t>( 0)

501 << binary_le<uint16_t>( 0);

504 if (R.SymbolTableIndex) {

505 if (!R.SymbolName.empty())

507 << "Both SymbolName and SymbolTableIndex specified\n";

508 SymbolTableIndex = *R.SymbolTableIndex;

509 } else {

510 SymbolTableIndex = SymbolTableIndexMap[R.SymbolName];

511 }

514 }

515 }

516

517

518

519 for (std::vectorCOFFYAML::Symbol::const_iterator i = CP.Obj.Symbols.begin(),

520 e = CP.Obj.Symbols.end();

521 i != e; ++i) {

524 if (CP.useBigObj())

525 OS << binary_le(i->Header.SectionNumber);

526 else

527 OS << binary_le(static_cast<int16_t>(i->Header.SectionNumber));

529 << binary_le(i->Header.NumberOfAuxSymbols);

530

531 if (i->FunctionDefinition) {

532 OS << binary_le(i->FunctionDefinition->TagIndex)

533 << binary_le(i->FunctionDefinition->TotalSize)

534 << binary_le(i->FunctionDefinition->PointerToLinenumber)

535 << binary_le(i->FunctionDefinition->PointerToNextFunction)

536 << zeros(i->FunctionDefinition->unused);

538 }

539 if (i->bfAndefSymbol) {

540 OS << zeros(i->bfAndefSymbol->unused1)

541 << binary_le(i->bfAndefSymbol->Linenumber)

542 << zeros(i->bfAndefSymbol->unused2)

543 << binary_le(i->bfAndefSymbol->PointerToNextFunction)

544 << zeros(i->bfAndefSymbol->unused3);

546 }

547 if (i->WeakExternal) {

548 OS << binary_le(i->WeakExternal->TagIndex)

549 << binary_le(i->WeakExternal->Characteristics)

550 << zeros(i->WeakExternal->unused);

552 }

553 if (!i->File.empty()) {

554 unsigned SymbolSize = CP.getSymbolSize();

555 uint32_t NumberOfAuxRecords =

556 (i->File.size() + SymbolSize - 1) / SymbolSize;

557 uint32_t NumberOfAuxBytes = NumberOfAuxRecords * SymbolSize;

558 uint32_t NumZeros = NumberOfAuxBytes - i->File.size();

559 OS.write(i->File.data(), i->File.size());

561 }

562 if (i->SectionDefinition) {

563 OS << binary_le(i->SectionDefinition->Length)

564 << binary_le(i->SectionDefinition->NumberOfRelocations)

565 << binary_le(i->SectionDefinition->NumberOfLinenumbers)

566 << binary_le(i->SectionDefinition->CheckSum)

567 << binary_le(static_cast<int16_t>(i->SectionDefinition->Number))

568 << binary_le(i->SectionDefinition->Selection)

569 << zeros(i->SectionDefinition->unused)

570 << binary_le(static_cast<int16_t>(i->SectionDefinition->Number >> 16));

572 }

573 if (i->CLRToken) {

574 OS << binary_le(i->CLRToken->AuxType) << zeros(i->CLRToken->unused1)

575 << binary_le(i->CLRToken->SymbolTableIndex)

576 << zeros(i->CLRToken->unused2);

578 }

579 }

580

581

582 if (CP.Obj.Header.PointerToSymbolTable)

583 OS.write(&CP.StringTable[0], CP.StringTable.size());

584 return true;

585}

586

590 Size += sizeof(*UInt32);

596}

597

599 OS.write(reinterpret_cast<const char *>(&S),

600 std::min(sizeof(S), static_cast<size_t>(S.Size)));

601 if (sizeof(S) < S.Size)

603}

604

606 if (UInt32)

608 Binary.writeAsBinary(OS);

609 if (LoadConfig32)

611 if (LoadConfig64)

613}

614

615namespace llvm {

616namespace yaml {

617

620 COFFParser CP(Doc, ErrHandler);

621 if (!CP.parse()) {

622 ErrHandler("failed to parse YAML file");

623 return false;

624 }

625

627 ErrHandler("failed to layout optional header for COFF file");

628 return false;

629 }

630

632 ErrHandler("failed to layout COFF file");

633 return false;

634 }

636 ErrHandler("failed to write COFF file");

637 return false;

638 }

639 return true;

640}

641

642}

643}

This file defines the StringMap class.

static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")

static bool layoutCOFF(COFFParser &CP)

binary_le_impl< value_type > binary_le(value_type V)

static void writeLoadConfig(T &S, raw_ostream &OS)

static yaml::BinaryRef toDebugS(ArrayRef< CodeViewYAML::YAMLDebugSubsection > Subsections, const codeview::StringsAndChecksums &SC, BumpPtrAllocator &Allocator)

zeros_impl< sizeof(T)> zeros(const T &)

static uint32_t initializeOptionalHeader(COFFParser &CP, uint16_t Magic, T Header)

raw_ostream & operator<<(raw_ostream &OS, const binary_le_impl< value_type > &BLE)

static bool writeCOFF(COFFParser &CP, raw_ostream &OS)

static bool layoutOptionalHeader(COFFParser &CP)

static size_t getStringIndex(StringRef Name)

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

static bool is64Bit(const char *name)

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

size_t size() const

size - Get the array size.

Provides write only access to a subclass of WritableBinaryStream.

Error writeInteger(T Value)

Write the integer Value to the underlying stream in the specified endianness.

Allocate memory in an ever growing pool, as if by bump-pointer.

Helper for check-and-exit error handling.

MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...

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

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

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

constexpr size_t size() const

Returns the byte size of the table.

LLVM Value Representation.

static raw_ostream & error()

Convenience method for printing "error: " to stderr.

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

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

raw_ostream & write_zeros(unsigned NumZeros)

write_zeros - Insert 'NumZeros' nulls.

uint64_t tell() const

tell - Return the current offset with the file.

raw_ostream & write(unsigned char C)

Specialized YAMLIO scalar type for representing a binary blob.

ArrayRef< uint8_t >::size_type binary_size() const

The number of bytes that are represented by this BinaryRef.

void writeAsBinary(raw_ostream &OS, uint64_t N=UINT64_MAX) const

Write the contents (regardless of whether it is binary or a hex string) as binary to the given raw_os...

@ IMAGE_FILE_MACHINE_UNKNOWN

@ IMAGE_SCN_CNT_UNINITIALIZED_DATA

@ IMAGE_SCN_CNT_INITIALIZED_DATA

@ IMAGE_SCN_LNK_NRELOC_OVFL

const int32_t MaxNumberOfSections16

static const char BigObjMagic[]

static const char PEMagic[]

@ SCT_COMPLEX_TYPE_SHIFT

Type is formed as (base + (derived << SCT_COMPLEX_TYPE_SHIFT))

void initializeStringsAndChecksums(ArrayRef< YAMLDebugSubsection > Sections, codeview::StringsAndChecksums &SC)

Expected< std::vector< std::shared_ptr< codeview::DebugSubsection > > > toCodeViewSubsectionList(BumpPtrAllocator &Allocator, ArrayRef< YAMLDebugSubsection > Subsections, const codeview::StringsAndChecksums &SC)

ArrayRef< uint8_t > toDebugH(const DebugHSection &DebugH, BumpPtrAllocator &Alloc)

ArrayRef< uint8_t > toDebugT(ArrayRef< LeafRecord >, BumpPtrAllocator &Alloc, StringRef SectionName)

bool yaml2coff(COFFYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH)

This is an optimization pass for GlobalISel generic memory operations.

unsigned Log2_32(uint32_t Value)

Return the floor log base 2 of the specified value, -1 if the value is zero.

constexpr bool isPowerOf2_32(uint32_t Value)

Return true if the argument is a power of two > 0.

uint64_t alignTo(uint64_t Size, Align A)

Returns a multiple of A needed to store Size bytes.

binary_le_impl(value_type V)

std::optional< PEHeader > OptionalHeader

std::vector< Section > Sections

std::vector< Symbol > Symbols

std::optional< object::coff_load_configuration64 > LoadConfig64

std::optional< object::coff_load_configuration32 > LoadConfig32

void writeAsBinary(raw_ostream &OS) const

std::optional< uint32_t > UInt32

std::vector< CodeViewYAML::YAMLDebugSubsection > DebugS

std::vector< SectionDataEntry > StructuredData

std::vector< CodeViewYAML::LeafRecord > DebugT

yaml::BinaryRef SectionData

std::optional< CodeViewYAML::DebugHSection > DebugH

std::vector< CodeViewYAML::LeafRecord > DebugP

std::vector< Relocation > Relocations

uint32_t PointerToRelocations

uint16_t NumberOfLineNumbers

uint32_t PointerToRawData

uint16_t NumberOfRelocations

uint32_t PointerToLineNumbers

Common declarations for yaml2obj.