MC: Change object writers to use endian::Writer. NFCI.
Part of PR37466.
Differential Revision: https://reviews.llvm.org/D47040
llvm-svn: 332861
diff --git a/llvm/lib/MC/WinCOFFObjectWriter.cpp b/llvm/lib/MC/WinCOFFObjectWriter.cpp
index 392bd02..c87bc02 100644
--- a/llvm/lib/MC/WinCOFFObjectWriter.cpp
+++ b/llvm/lib/MC/WinCOFFObjectWriter.cpp
@@ -125,6 +125,8 @@
class WinCOFFObjectWriter : public MCObjectWriter {
public:
+ support::endian::Writer W;
+
using symbols = std::vector<std::unique_ptr<COFFSymbol>>;
using sections = std::vector<std::unique_ptr<COFFSection>>;
@@ -225,7 +227,8 @@
WinCOFFObjectWriter::WinCOFFObjectWriter(
std::unique_ptr<MCWinCOFFObjectTargetWriter> MOTW, raw_pwrite_stream &OS)
- : MCObjectWriter(OS, true), TargetObjectWriter(std::move(MOTW)) {
+ : MCObjectWriter(OS, true), W(OS, support::little),
+ TargetObjectWriter(std::move(MOTW)) {
Header.Machine = TargetObjectWriter->getMachine();
}
@@ -472,40 +475,40 @@
void WinCOFFObjectWriter::WriteFileHeader(const COFF::header &Header) {
if (UseBigObj) {
- writeLE16(COFF::IMAGE_FILE_MACHINE_UNKNOWN);
- writeLE16(0xFFFF);
- writeLE16(COFF::BigObjHeader::MinBigObjectVersion);
- writeLE16(Header.Machine);
- writeLE32(Header.TimeDateStamp);
- writeBytes(StringRef(COFF::BigObjMagic, sizeof(COFF::BigObjMagic)));
- writeLE32(0);
- writeLE32(0);
- writeLE32(0);
- writeLE32(0);
- writeLE32(Header.NumberOfSections);
- writeLE32(Header.PointerToSymbolTable);
- writeLE32(Header.NumberOfSymbols);
+ W.write<uint16_t>(COFF::IMAGE_FILE_MACHINE_UNKNOWN);
+ W.write<uint16_t>(0xFFFF);
+ W.write<uint16_t>(COFF::BigObjHeader::MinBigObjectVersion);
+ W.write<uint16_t>(Header.Machine);
+ W.write<uint32_t>(Header.TimeDateStamp);
+ W.OS.write(COFF::BigObjMagic, sizeof(COFF::BigObjMagic));
+ W.write<uint32_t>(0);
+ W.write<uint32_t>(0);
+ W.write<uint32_t>(0);
+ W.write<uint32_t>(0);
+ W.write<uint32_t>(Header.NumberOfSections);
+ W.write<uint32_t>(Header.PointerToSymbolTable);
+ W.write<uint32_t>(Header.NumberOfSymbols);
} else {
- writeLE16(Header.Machine);
- writeLE16(static_cast<int16_t>(Header.NumberOfSections));
- writeLE32(Header.TimeDateStamp);
- writeLE32(Header.PointerToSymbolTable);
- writeLE32(Header.NumberOfSymbols);
- writeLE16(Header.SizeOfOptionalHeader);
- writeLE16(Header.Characteristics);
+ W.write<uint16_t>(Header.Machine);
+ W.write<uint16_t>(static_cast<int16_t>(Header.NumberOfSections));
+ W.write<uint32_t>(Header.TimeDateStamp);
+ W.write<uint32_t>(Header.PointerToSymbolTable);
+ W.write<uint32_t>(Header.NumberOfSymbols);
+ W.write<uint16_t>(Header.SizeOfOptionalHeader);
+ W.write<uint16_t>(Header.Characteristics);
}
}
void WinCOFFObjectWriter::WriteSymbol(const COFFSymbol &S) {
- writeBytes(StringRef(S.Data.Name, COFF::NameSize));
- writeLE32(S.Data.Value);
+ W.OS.write(S.Data.Name, COFF::NameSize);
+ W.write<uint32_t>(S.Data.Value);
if (UseBigObj)
- writeLE32(S.Data.SectionNumber);
+ W.write<uint32_t>(S.Data.SectionNumber);
else
- writeLE16(static_cast<int16_t>(S.Data.SectionNumber));
- writeLE16(S.Data.Type);
- write8(S.Data.StorageClass);
- write8(S.Data.NumberOfAuxSymbols);
+ W.write<uint16_t>(static_cast<int16_t>(S.Data.SectionNumber));
+ W.write<uint16_t>(S.Data.Type);
+ W.OS << char(S.Data.StorageClass);
+ W.OS << char(S.Data.NumberOfAuxSymbols);
WriteAuxiliarySymbols(S.Aux);
}
@@ -514,46 +517,45 @@
for (const AuxSymbol &i : S) {
switch (i.AuxType) {
case ATFunctionDefinition:
- writeLE32(i.Aux.FunctionDefinition.TagIndex);
- writeLE32(i.Aux.FunctionDefinition.TotalSize);
- writeLE32(i.Aux.FunctionDefinition.PointerToLinenumber);
- writeLE32(i.Aux.FunctionDefinition.PointerToNextFunction);
- WriteZeros(sizeof(i.Aux.FunctionDefinition.unused));
+ W.write<uint32_t>(i.Aux.FunctionDefinition.TagIndex);
+ W.write<uint32_t>(i.Aux.FunctionDefinition.TotalSize);
+ W.write<uint32_t>(i.Aux.FunctionDefinition.PointerToLinenumber);
+ W.write<uint32_t>(i.Aux.FunctionDefinition.PointerToNextFunction);
+ W.OS.write_zeros(sizeof(i.Aux.FunctionDefinition.unused));
if (UseBigObj)
- WriteZeros(COFF::Symbol32Size - COFF::Symbol16Size);
+ W.OS.write_zeros(COFF::Symbol32Size - COFF::Symbol16Size);
break;
case ATbfAndefSymbol:
- WriteZeros(sizeof(i.Aux.bfAndefSymbol.unused1));
- writeLE16(i.Aux.bfAndefSymbol.Linenumber);
- WriteZeros(sizeof(i.Aux.bfAndefSymbol.unused2));
- writeLE32(i.Aux.bfAndefSymbol.PointerToNextFunction);
- WriteZeros(sizeof(i.Aux.bfAndefSymbol.unused3));
+ W.OS.write_zeros(sizeof(i.Aux.bfAndefSymbol.unused1));
+ W.write<uint16_t>(i.Aux.bfAndefSymbol.Linenumber);
+ W.OS.write_zeros(sizeof(i.Aux.bfAndefSymbol.unused2));
+ W.write<uint32_t>(i.Aux.bfAndefSymbol.PointerToNextFunction);
+ W.OS.write_zeros(sizeof(i.Aux.bfAndefSymbol.unused3));
if (UseBigObj)
- WriteZeros(COFF::Symbol32Size - COFF::Symbol16Size);
+ W.OS.write_zeros(COFF::Symbol32Size - COFF::Symbol16Size);
break;
case ATWeakExternal:
- writeLE32(i.Aux.WeakExternal.TagIndex);
- writeLE32(i.Aux.WeakExternal.Characteristics);
- WriteZeros(sizeof(i.Aux.WeakExternal.unused));
+ W.write<uint32_t>(i.Aux.WeakExternal.TagIndex);
+ W.write<uint32_t>(i.Aux.WeakExternal.Characteristics);
+ W.OS.write_zeros(sizeof(i.Aux.WeakExternal.unused));
if (UseBigObj)
- WriteZeros(COFF::Symbol32Size - COFF::Symbol16Size);
+ W.OS.write_zeros(COFF::Symbol32Size - COFF::Symbol16Size);
break;
case ATFile:
- writeBytes(
- StringRef(reinterpret_cast<const char *>(&i.Aux),
- UseBigObj ? COFF::Symbol32Size : COFF::Symbol16Size));
+ W.OS.write(reinterpret_cast<const char *>(&i.Aux),
+ UseBigObj ? COFF::Symbol32Size : COFF::Symbol16Size);
break;
case ATSectionDefinition:
- writeLE32(i.Aux.SectionDefinition.Length);
- writeLE16(i.Aux.SectionDefinition.NumberOfRelocations);
- writeLE16(i.Aux.SectionDefinition.NumberOfLinenumbers);
- writeLE32(i.Aux.SectionDefinition.CheckSum);
- writeLE16(static_cast<int16_t>(i.Aux.SectionDefinition.Number));
- write8(i.Aux.SectionDefinition.Selection);
- WriteZeros(sizeof(i.Aux.SectionDefinition.unused));
- writeLE16(static_cast<int16_t>(i.Aux.SectionDefinition.Number >> 16));
+ W.write<uint32_t>(i.Aux.SectionDefinition.Length);
+ W.write<uint16_t>(i.Aux.SectionDefinition.NumberOfRelocations);
+ W.write<uint16_t>(i.Aux.SectionDefinition.NumberOfLinenumbers);
+ W.write<uint32_t>(i.Aux.SectionDefinition.CheckSum);
+ W.write<uint16_t>(static_cast<int16_t>(i.Aux.SectionDefinition.Number));
+ W.OS << char(i.Aux.SectionDefinition.Selection);
+ W.OS.write_zeros(sizeof(i.Aux.SectionDefinition.unused));
+ W.write<uint16_t>(static_cast<int16_t>(i.Aux.SectionDefinition.Number >> 16));
if (UseBigObj)
- WriteZeros(COFF::Symbol32Size - COFF::Symbol16Size);
+ W.OS.write_zeros(COFF::Symbol32Size - COFF::Symbol16Size);
break;
}
}
@@ -579,23 +581,23 @@
COFF::section &S = Section->Header;
if (Section->Relocations.size() >= 0xffff)
S.Characteristics |= COFF::IMAGE_SCN_LNK_NRELOC_OVFL;
- writeBytes(StringRef(S.Name, COFF::NameSize));
- writeLE32(S.VirtualSize);
- writeLE32(S.VirtualAddress);
- writeLE32(S.SizeOfRawData);
- writeLE32(S.PointerToRawData);
- writeLE32(S.PointerToRelocations);
- writeLE32(S.PointerToLineNumbers);
- writeLE16(S.NumberOfRelocations);
- writeLE16(S.NumberOfLineNumbers);
- writeLE32(S.Characteristics);
+ W.OS.write(S.Name, COFF::NameSize);
+ W.write<uint32_t>(S.VirtualSize);
+ W.write<uint32_t>(S.VirtualAddress);
+ W.write<uint32_t>(S.SizeOfRawData);
+ W.write<uint32_t>(S.PointerToRawData);
+ W.write<uint32_t>(S.PointerToRelocations);
+ W.write<uint32_t>(S.PointerToLineNumbers);
+ W.write<uint16_t>(S.NumberOfRelocations);
+ W.write<uint16_t>(S.NumberOfLineNumbers);
+ W.write<uint32_t>(S.Characteristics);
}
}
void WinCOFFObjectWriter::WriteRelocation(const COFF::relocation &R) {
- writeLE32(R.VirtualAddress);
- writeLE32(R.SymbolTableIndex);
- writeLE16(R.Type);
+ W.write<uint32_t>(R.VirtualAddress);
+ W.write<uint32_t>(R.SymbolTableIndex);
+ W.write<uint16_t>(R.Type);
}
// Write MCSec's contents. What this function does is essentially
@@ -611,7 +613,7 @@
Asm.writeSectionData(VecOS, &MCSec, Layout);
// Write the section contents to the object file.
- getStream() << Buf;
+ W.OS << Buf;
// Calculate our CRC with an initial value of '0', this is not how
// JamCRC is specified but it aligns with the expected output.
@@ -629,13 +631,13 @@
// Write the section contents.
if (Sec.Header.PointerToRawData != 0) {
- assert(getStream().tell() <= Sec.Header.PointerToRawData &&
+ assert(W.OS.tell() <= Sec.Header.PointerToRawData &&
"Section::PointerToRawData is insane!");
- unsigned PaddingSize = Sec.Header.PointerToRawData - getStream().tell();
+ unsigned PaddingSize = Sec.Header.PointerToRawData - W.OS.tell();
assert(PaddingSize < 4 &&
"Should only need at most three bytes of padding!");
- WriteZeros(PaddingSize);
+ W.OS.write_zeros(PaddingSize);
uint32_t CRC = writeSectionContents(Asm, Layout, MCSec);
@@ -654,7 +656,7 @@
return;
}
- assert(getStream().tell() == Sec.Header.PointerToRelocations &&
+ assert(W.OS.tell() == Sec.Header.PointerToRelocations &&
"Section::PointerToRelocations is insane!");
if (Sec.Relocations.size() >= 0xffff) {
@@ -900,7 +902,7 @@
// Assign file offsets to COFF object file structures.
void WinCOFFObjectWriter::assignFileOffsets(MCAssembler &Asm,
const MCAsmLayout &Layout) {
- unsigned Offset = getInitialOffset();
+ unsigned Offset = W.OS.tell();
Offset += UseBigObj ? COFF::Header32Size : COFF::Header16Size;
Offset += COFF::SectionSize * Header.NumberOfSections;
@@ -1058,7 +1060,7 @@
for (; I != IE && J != JE; ++I, ++J)
writeSection(Asm, Layout, **I, *J);
- assert(getStream().tell() == Header.PointerToSymbolTable &&
+ assert(W.OS.tell() == Header.PointerToSymbolTable &&
"Header::PointerToSymbolTable is insane!");
// Write a symbol table.
@@ -1067,7 +1069,7 @@
WriteSymbol(*Symbol);
// Write a string table, which completes the entire COFF file.
- Strings.write(getStream());
+ Strings.write(W.OS);
}
MCWinCOFFObjectTargetWriter::MCWinCOFFObjectTargetWriter(unsigned Machine_)