[llvm] r332861 - MC: Change object writers to use endian::Writer. NFCI.
Peter Collingbourne via llvm-commits
llvm-commits at lists.llvm.org
Mon May 21 11:17:42 PDT 2018
Author: pcc
Date: Mon May 21 11:17:42 2018
New Revision: 332861
URL: http://llvm.org/viewvc/llvm-project?rev=332861&view=rev
Log:
MC: Change object writers to use endian::Writer. NFCI.
Part of PR37466.
Differential Revision: https://reviews.llvm.org/D47040
Modified:
llvm/trunk/include/llvm/MC/MCMachObjectWriter.h
llvm/trunk/lib/MC/ELFObjectWriter.cpp
llvm/trunk/lib/MC/MCLinkerOptimizationHint.cpp
llvm/trunk/lib/MC/MachObjectWriter.cpp
llvm/trunk/lib/MC/WasmObjectWriter.cpp
llvm/trunk/lib/MC/WinCOFFObjectWriter.cpp
llvm/trunk/tools/dsymutil/MachOUtils.cpp
Modified: llvm/trunk/include/llvm/MC/MCMachObjectWriter.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/MC/MCMachObjectWriter.h?rev=332861&r1=332860&r2=332861&view=diff
==============================================================================
--- llvm/trunk/include/llvm/MC/MCMachObjectWriter.h (original)
+++ llvm/trunk/include/llvm/MC/MCMachObjectWriter.h Mon May 21 11:17:42 2018
@@ -116,11 +116,16 @@ class MachObjectWriter : public MCObject
MachSymbolData *findSymbolData(const MCSymbol &Sym);
+ void writeWithPadding(StringRef Str, uint64_t Size);
+
public:
MachObjectWriter(std::unique_ptr<MCMachObjectTargetWriter> MOTW,
raw_pwrite_stream &OS, bool IsLittleEndian)
: MCObjectWriter(OS, IsLittleEndian),
- TargetObjectWriter(std::move(MOTW)) {}
+ TargetObjectWriter(std::move(MOTW)),
+ W(OS, IsLittleEndian ? support::little : support::big) {}
+
+ support::endian::Writer W;
const MCSymbol &findAliasedSymbol(const MCSymbol &Sym) const;
Modified: llvm/trunk/lib/MC/ELFObjectWriter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/MC/ELFObjectWriter.cpp?rev=332861&r1=332860&r2=332861&view=diff
==============================================================================
--- llvm/trunk/lib/MC/ELFObjectWriter.cpp (original)
+++ llvm/trunk/lib/MC/ELFObjectWriter.cpp Mon May 21 11:17:42 2018
@@ -160,10 +160,12 @@ class ELFObjectWriter : public MCObjectW
bool ZLibStyle, unsigned Alignment);
public:
+ support::endian::Writer W;
+
ELFObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW,
raw_pwrite_stream &OS, bool IsLittleEndian)
- : MCObjectWriter(OS, IsLittleEndian),
- TargetObjectWriter(std::move(MOTW)) {}
+ : MCObjectWriter(OS, IsLittleEndian), TargetObjectWriter(std::move(MOTW)),
+ W(OS, IsLittleEndian ? support::little : support::big) {}
~ELFObjectWriter() override = default;
@@ -175,16 +177,15 @@ public:
MCObjectWriter::reset();
}
- void WriteWord(uint64_t W) {
+ void WriteWord(uint64_t Word) {
if (is64Bit())
- write64(W);
+ W.write<uint64_t>(Word);
else
- write32(W);
+ W.write<uint32_t>(Word);
}
template <typename T> void write(T Val) {
- support::endian::write(getStream(), Val,
- IsLittleEndian ? support::little : support::big);
+ W.write(Val);
}
void writeHeader(const MCAssembler &Asm);
@@ -255,8 +256,8 @@ public:
} // end anonymous namespace
void ELFObjectWriter::align(unsigned Alignment) {
- uint64_t Padding = OffsetToAlignment(getStream().tell(), Alignment);
- WriteZeros(Padding);
+ uint64_t Padding = OffsetToAlignment(W.OS.tell(), Alignment);
+ W.OS.write_zeros(Padding);
}
unsigned ELFObjectWriter::addToSectionTable(const MCSectionELF *Sec) {
@@ -325,47 +326,50 @@ void ELFObjectWriter::writeHeader(const
// emitWord method behaves differently for ELF32 and ELF64, writing
// 4 bytes in the former and 8 in the latter.
- writeBytes(ELF::ElfMagic); // e_ident[EI_MAG0] to e_ident[EI_MAG3]
+ W.OS << ELF::ElfMagic; // e_ident[EI_MAG0] to e_ident[EI_MAG3]
- write8(is64Bit() ? ELF::ELFCLASS64 : ELF::ELFCLASS32); // e_ident[EI_CLASS]
+ W.OS << char(is64Bit() ? ELF::ELFCLASS64 : ELF::ELFCLASS32); // e_ident[EI_CLASS]
// e_ident[EI_DATA]
- write8(isLittleEndian() ? ELF::ELFDATA2LSB : ELF::ELFDATA2MSB);
+ W.OS << char(W.Endian == support::little ? ELF::ELFDATA2LSB
+ : ELF::ELFDATA2MSB);
- write8(ELF::EV_CURRENT); // e_ident[EI_VERSION]
+ W.OS << char(ELF::EV_CURRENT); // e_ident[EI_VERSION]
// e_ident[EI_OSABI]
- write8(TargetObjectWriter->getOSABI());
- write8(0); // e_ident[EI_ABIVERSION]
+ W.OS << char(TargetObjectWriter->getOSABI());
+ W.OS << char(0); // e_ident[EI_ABIVERSION]
- WriteZeros(ELF::EI_NIDENT - ELF::EI_PAD);
+ W.OS.write_zeros(ELF::EI_NIDENT - ELF::EI_PAD);
- write16(ELF::ET_REL); // e_type
+ W.write<uint16_t>(ELF::ET_REL); // e_type
- write16(TargetObjectWriter->getEMachine()); // e_machine = target
+ W.write<uint16_t>(TargetObjectWriter->getEMachine()); // e_machine = target
- write32(ELF::EV_CURRENT); // e_version
+ W.write<uint32_t>(ELF::EV_CURRENT); // e_version
WriteWord(0); // e_entry, no entry point in .o file
WriteWord(0); // e_phoff, no program header for .o
WriteWord(0); // e_shoff = sec hdr table off in bytes
// e_flags = whatever the target wants
- write32(Asm.getELFHeaderEFlags());
+ W.write<uint32_t>(Asm.getELFHeaderEFlags());
// e_ehsize = ELF header size
- write16(is64Bit() ? sizeof(ELF::Elf64_Ehdr) : sizeof(ELF::Elf32_Ehdr));
+ W.write<uint16_t>(is64Bit() ? sizeof(ELF::Elf64_Ehdr)
+ : sizeof(ELF::Elf32_Ehdr));
- write16(0); // e_phentsize = prog header entry size
- write16(0); // e_phnum = # prog header entries = 0
+ W.write<uint16_t>(0); // e_phentsize = prog header entry size
+ W.write<uint16_t>(0); // e_phnum = # prog header entries = 0
// e_shentsize = Section header entry size
- write16(is64Bit() ? sizeof(ELF::Elf64_Shdr) : sizeof(ELF::Elf32_Shdr));
+ W.write<uint16_t>(is64Bit() ? sizeof(ELF::Elf64_Shdr)
+ : sizeof(ELF::Elf32_Shdr));
// e_shnum = # of section header ents
- write16(0);
+ W.write<uint16_t>(0);
// e_shstrndx = Section # of '.shstrtab'
assert(StringTableIndex < ELF::SHN_LORESERVE);
- write16(StringTableIndex);
+ W.write<uint16_t>(StringTableIndex);
}
uint64_t ELFObjectWriter::SymbolValue(const MCSymbol &Sym,
@@ -784,7 +788,7 @@ void ELFObjectWriter::computeSymbolTable
SymbolTableIndex = addToSectionTable(SymtabSection);
align(SymtabSection->getAlignment());
- uint64_t SecStart = getStream().tell();
+ uint64_t SecStart = W.OS.tell();
// The first entry is the undefined symbol entry.
Writer.writeSymbol(0, 0, 0, 0, 0, 0, false);
@@ -900,7 +904,7 @@ void ELFObjectWriter::computeSymbolTable
assert(MSD.Symbol->getBinding() != ELF::STB_LOCAL);
}
- uint64_t SecEnd = getStream().tell();
+ uint64_t SecEnd = W.OS.tell();
SectionOffsets[SymtabSection] = std::make_pair(SecStart, SecEnd);
ArrayRef<uint32_t> ShndxIndexes = Writer.getShndxIndexes();
@@ -910,12 +914,12 @@ void ELFObjectWriter::computeSymbolTable
}
assert(SymtabShndxSectionIndex != 0);
- SecStart = getStream().tell();
+ SecStart = W.OS.tell();
const MCSectionELF *SymtabShndxSection =
SectionTable[SymtabShndxSectionIndex - 1];
for (uint32_t Index : ShndxIndexes)
write(Index);
- SecEnd = getStream().tell();
+ SecEnd = W.OS.tell();
SectionOffsets[SymtabShndxSection] = std::make_pair(SecStart, SecEnd);
}
@@ -976,8 +980,8 @@ bool ELFObjectWriter::maybeWriteCompress
const StringRef Magic = "ZLIB";
if (Size <= Magic.size() + sizeof(Size) + CompressedContents.size())
return false;
- write(ArrayRef<char>(Magic.begin(), Magic.size()));
- writeBE64(Size);
+ W.OS << Magic;
+ support::endian::write(W.OS, Size, support::big);
return true;
}
@@ -996,7 +1000,7 @@ void ELFObjectWriter::writeSectionData(c
MAI->compressDebugSections() != DebugCompressionType::None;
if (!CompressionEnabled || !SectionName.startswith(".debug_") ||
SectionName == ".debug_frame") {
- Asm.writeSectionData(getStream(), &Section, Layout);
+ Asm.writeSectionData(W.OS, &Section, Layout);
return;
}
@@ -1013,14 +1017,14 @@ void ELFObjectWriter::writeSectionData(c
StringRef(UncompressedData.data(), UncompressedData.size()),
CompressedContents)) {
consumeError(std::move(E));
- getStream() << UncompressedData;
+ W.OS << UncompressedData;
return;
}
bool ZlibStyle = MAI->compressDebugSections() == DebugCompressionType::Z;
if (!maybeWriteCompression(UncompressedData.size(), CompressedContents,
ZlibStyle, Sec.getAlignment())) {
- getStream() << UncompressedData;
+ W.OS << UncompressedData;
return;
}
@@ -1030,7 +1034,7 @@ void ELFObjectWriter::writeSectionData(c
else
// Add "z" prefix to section name. This is zlib-gnu style.
MC.renameELFSection(&Section, (".z" + SectionName.drop_front(1)).str());
- getStream() << CompressedContents;
+ W.OS << CompressedContents;
}
void ELFObjectWriter::WriteSecHdrEntry(uint32_t Name, uint32_t Type,
@@ -1039,14 +1043,14 @@ void ELFObjectWriter::WriteSecHdrEntry(u
uint32_t Link, uint32_t Info,
uint64_t Alignment,
uint64_t EntrySize) {
- write32(Name); // sh_name: index into string table
- write32(Type); // sh_type
+ W.write<uint32_t>(Name); // sh_name: index into string table
+ W.write<uint32_t>(Type); // sh_type
WriteWord(Flags); // sh_flags
WriteWord(Address); // sh_addr
WriteWord(Offset); // sh_offset
WriteWord(Size); // sh_size
- write32(Link); // sh_link
- write32(Info); // sh_info
+ W.write<uint32_t>(Link); // sh_link
+ W.write<uint32_t>(Info); // sh_info
WriteWord(Alignment); // sh_addralign
WriteWord(EntrySize); // sh_entsize
}
@@ -1116,7 +1120,7 @@ void ELFObjectWriter::writeRelocations(c
const MCSectionELF *ELFObjectWriter::createStringTable(MCContext &Ctx) {
const MCSectionELF *StrtabSection = SectionTable[StringTableIndex - 1];
- StrTabBuilder.write(getStream());
+ StrTabBuilder.write(W.OS);
return StrtabSection;
}
@@ -1226,12 +1230,12 @@ void ELFObjectWriter::writeObject(MCAsse
align(Section.getAlignment());
// Remember the offset into the file for this section.
- uint64_t SecStart = getStream().tell();
+ uint64_t SecStart = W.OS.tell();
const MCSymbolELF *SignatureSymbol = Section.getGroup();
writeSectionData(Asm, Section, Layout);
- uint64_t SecEnd = getStream().tell();
+ uint64_t SecEnd = W.OS.tell();
SectionOffsets[&Section] = std::make_pair(SecStart, SecEnd);
MCSectionELF *RelSection = createRelocationSection(Ctx, Section);
@@ -1263,7 +1267,7 @@ void ELFObjectWriter::writeObject(MCAsse
align(Group->getAlignment());
// Remember the offset into the file for this section.
- uint64_t SecStart = getStream().tell();
+ uint64_t SecStart = W.OS.tell();
const MCSymbol *SignatureSymbol = Group->getGroup();
assert(SignatureSymbol);
@@ -1273,7 +1277,7 @@ void ELFObjectWriter::writeObject(MCAsse
write(SecIndex);
}
- uint64_t SecEnd = getStream().tell();
+ uint64_t SecEnd = W.OS.tell();
SectionOffsets[Group] = std::make_pair(SecStart, SecEnd);
}
@@ -1284,54 +1288,52 @@ void ELFObjectWriter::writeObject(MCAsse
align(RelSection->getAlignment());
// Remember the offset into the file for this section.
- uint64_t SecStart = getStream().tell();
+ uint64_t SecStart = W.OS.tell();
writeRelocations(Asm,
cast<MCSectionELF>(*RelSection->getAssociatedSection()));
- uint64_t SecEnd = getStream().tell();
+ uint64_t SecEnd = W.OS.tell();
SectionOffsets[RelSection] = std::make_pair(SecStart, SecEnd);
}
{
- uint64_t SecStart = getStream().tell();
+ uint64_t SecStart = W.OS.tell();
const MCSectionELF *Sec = createStringTable(Ctx);
- uint64_t SecEnd = getStream().tell();
+ uint64_t SecEnd = W.OS.tell();
SectionOffsets[Sec] = std::make_pair(SecStart, SecEnd);
}
uint64_t NaturalAlignment = is64Bit() ? 8 : 4;
align(NaturalAlignment);
- const uint64_t SectionHeaderOffset = getStream().tell();
+ const uint64_t SectionHeaderOffset = W.OS.tell();
// ... then the section header table ...
writeSectionHeader(Layout, SectionIndexMap, SectionOffsets);
- uint16_t NumSections = (SectionTable.size() + 1 >= ELF::SHN_LORESERVE)
- ? (uint16_t)ELF::SHN_UNDEF
- : SectionTable.size() + 1;
- if (sys::IsLittleEndianHost != IsLittleEndian)
- sys::swapByteOrder(NumSections);
+ uint16_t NumSections = support::endian::byte_swap<uint16_t>(
+ (SectionTable.size() + 1 >= ELF::SHN_LORESERVE) ? (uint16_t)ELF::SHN_UNDEF
+ : SectionTable.size() + 1,
+ W.Endian);
unsigned NumSectionsOffset;
+ auto &Stream = static_cast<raw_pwrite_stream &>(W.OS);
if (is64Bit()) {
- uint64_t Val = SectionHeaderOffset;
- if (sys::IsLittleEndianHost != IsLittleEndian)
- sys::swapByteOrder(Val);
- getStream().pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
- offsetof(ELF::Elf64_Ehdr, e_shoff));
+ uint64_t Val =
+ support::endian::byte_swap<uint64_t>(SectionHeaderOffset, W.Endian);
+ Stream.pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
+ offsetof(ELF::Elf64_Ehdr, e_shoff));
NumSectionsOffset = offsetof(ELF::Elf64_Ehdr, e_shnum);
} else {
- uint32_t Val = SectionHeaderOffset;
- if (sys::IsLittleEndianHost != IsLittleEndian)
- sys::swapByteOrder(Val);
- getStream().pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
- offsetof(ELF::Elf32_Ehdr, e_shoff));
+ uint32_t Val =
+ support::endian::byte_swap<uint32_t>(SectionHeaderOffset, W.Endian);
+ Stream.pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
+ offsetof(ELF::Elf32_Ehdr, e_shoff));
NumSectionsOffset = offsetof(ELF::Elf32_Ehdr, e_shnum);
}
- getStream().pwrite(reinterpret_cast<char *>(&NumSections),
- sizeof(NumSections), NumSectionsOffset);
+ Stream.pwrite(reinterpret_cast<char *>(&NumSections), sizeof(NumSections),
+ NumSectionsOffset);
}
bool ELFObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(
Modified: llvm/trunk/lib/MC/MCLinkerOptimizationHint.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/MC/MCLinkerOptimizationHint.cpp?rev=332861&r1=332860&r2=332861&view=diff
==============================================================================
--- llvm/trunk/lib/MC/MCLinkerOptimizationHint.cpp (original)
+++ llvm/trunk/lib/MC/MCLinkerOptimizationHint.cpp Mon May 21 11:17:42 2018
@@ -36,7 +36,7 @@ void MCLOHDirective::emit_impl(raw_ostre
void MCLOHDirective::emit(MachObjectWriter &ObjWriter,
const MCAsmLayout &Layout) const {
- raw_ostream &OutStream = ObjWriter.getStream();
+ raw_ostream &OutStream = ObjWriter.W.OS;
emit_impl(OutStream, ObjWriter, Layout);
}
Modified: llvm/trunk/lib/MC/MachObjectWriter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/MC/MachObjectWriter.cpp?rev=332861&r1=332860&r2=332861&view=diff
==============================================================================
--- llvm/trunk/lib/MC/MachObjectWriter.cpp (original)
+++ llvm/trunk/lib/MC/MachObjectWriter.cpp Mon May 21 11:17:42 2018
@@ -141,24 +141,29 @@ void MachObjectWriter::writeHeader(MachO
// struct mach_header (28 bytes) or
// struct mach_header_64 (32 bytes)
- uint64_t Start = getStream().tell();
+ uint64_t Start = W.OS.tell();
(void) Start;
- write32(is64Bit() ? MachO::MH_MAGIC_64 : MachO::MH_MAGIC);
+ W.write<uint32_t>(is64Bit() ? MachO::MH_MAGIC_64 : MachO::MH_MAGIC);
- write32(TargetObjectWriter->getCPUType());
- write32(TargetObjectWriter->getCPUSubtype());
+ W.write<uint32_t>(TargetObjectWriter->getCPUType());
+ W.write<uint32_t>(TargetObjectWriter->getCPUSubtype());
- write32(Type);
- write32(NumLoadCommands);
- write32(LoadCommandsSize);
- write32(Flags);
+ W.write<uint32_t>(Type);
+ W.write<uint32_t>(NumLoadCommands);
+ W.write<uint32_t>(LoadCommandsSize);
+ W.write<uint32_t>(Flags);
if (is64Bit())
- write32(0); // reserved
+ W.write<uint32_t>(0); // reserved
- assert(
- getStream().tell() - Start ==
- (is64Bit() ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header)));
+ assert(W.OS.tell() - Start == (is64Bit() ? sizeof(MachO::mach_header_64)
+ : sizeof(MachO::mach_header)));
+}
+
+void MachObjectWriter::writeWithPadding(StringRef Str, uint64_t Size) {
+ assert(Size >= Str.size());
+ W.OS << Str;
+ W.OS.write_zeros(Size - Str.size());
}
/// writeSegmentLoadCommand - Write a segment load command.
@@ -172,38 +177,37 @@ void MachObjectWriter::writeSegmentLoadC
// struct segment_command (56 bytes) or
// struct segment_command_64 (72 bytes)
- uint64_t Start = getStream().tell();
+ uint64_t Start = W.OS.tell();
(void) Start;
unsigned SegmentLoadCommandSize =
is64Bit() ? sizeof(MachO::segment_command_64):
sizeof(MachO::segment_command);
- write32(is64Bit() ? MachO::LC_SEGMENT_64 : MachO::LC_SEGMENT);
- write32(SegmentLoadCommandSize +
+ W.write<uint32_t>(is64Bit() ? MachO::LC_SEGMENT_64 : MachO::LC_SEGMENT);
+ W.write<uint32_t>(SegmentLoadCommandSize +
NumSections * (is64Bit() ? sizeof(MachO::section_64) :
sizeof(MachO::section)));
- assert(Name.size() <= 16);
- writeBytes(Name, 16);
+ writeWithPadding(Name, 16);
if (is64Bit()) {
- write64(VMAddr); // vmaddr
- write64(VMSize); // vmsize
- write64(SectionDataStartOffset); // file offset
- write64(SectionDataSize); // file size
+ W.write<uint64_t>(VMAddr); // vmaddr
+ W.write<uint64_t>(VMSize); // vmsize
+ W.write<uint64_t>(SectionDataStartOffset); // file offset
+ W.write<uint64_t>(SectionDataSize); // file size
} else {
- write32(VMAddr); // vmaddr
- write32(VMSize); // vmsize
- write32(SectionDataStartOffset); // file offset
- write32(SectionDataSize); // file size
+ W.write<uint32_t>(VMAddr); // vmaddr
+ W.write<uint32_t>(VMSize); // vmsize
+ W.write<uint32_t>(SectionDataStartOffset); // file offset
+ W.write<uint32_t>(SectionDataSize); // file size
}
// maxprot
- write32(MaxProt);
+ W.write<uint32_t>(MaxProt);
// initprot
- write32(InitProt);
- write32(NumSections);
- write32(0); // flags
+ W.write<uint32_t>(InitProt);
+ W.write<uint32_t>(NumSections);
+ W.write<uint32_t>(0); // flags
- assert(getStream().tell() - Start == SegmentLoadCommandSize);
+ assert(W.OS.tell() - Start == SegmentLoadCommandSize);
}
void MachObjectWriter::writeSection(const MCAsmLayout &Layout,
@@ -223,31 +227,31 @@ void MachObjectWriter::writeSection(cons
// struct section (68 bytes) or
// struct section_64 (80 bytes)
- uint64_t Start = getStream().tell();
+ uint64_t Start = W.OS.tell();
(void) Start;
- writeBytes(Section.getSectionName(), 16);
- writeBytes(Section.getSegmentName(), 16);
+ writeWithPadding(Section.getSectionName(), 16);
+ writeWithPadding(Section.getSegmentName(), 16);
if (is64Bit()) {
- write64(VMAddr); // address
- write64(SectionSize); // size
+ W.write<uint64_t>(VMAddr); // address
+ W.write<uint64_t>(SectionSize); // size
} else {
- write32(VMAddr); // address
- write32(SectionSize); // size
+ W.write<uint32_t>(VMAddr); // address
+ W.write<uint32_t>(SectionSize); // size
}
- write32(FileOffset);
+ W.write<uint32_t>(FileOffset);
assert(isPowerOf2_32(Section.getAlignment()) && "Invalid alignment!");
- write32(Log2_32(Section.getAlignment()));
- write32(NumRelocations ? RelocationsStart : 0);
- write32(NumRelocations);
- write32(Flags);
- write32(IndirectSymBase.lookup(&Sec)); // reserved1
- write32(Section.getStubSize()); // reserved2
+ W.write<uint32_t>(Log2_32(Section.getAlignment()));
+ W.write<uint32_t>(NumRelocations ? RelocationsStart : 0);
+ W.write<uint32_t>(NumRelocations);
+ W.write<uint32_t>(Flags);
+ W.write<uint32_t>(IndirectSymBase.lookup(&Sec)); // reserved1
+ W.write<uint32_t>(Section.getStubSize()); // reserved2
if (is64Bit())
- write32(0); // reserved3
+ W.write<uint32_t>(0); // reserved3
- assert(getStream().tell() - Start ==
+ assert(W.OS.tell() - Start ==
(is64Bit() ? sizeof(MachO::section_64) : sizeof(MachO::section)));
}
@@ -257,17 +261,17 @@ void MachObjectWriter::writeSymtabLoadCo
uint32_t StringTableSize) {
// struct symtab_command (24 bytes)
- uint64_t Start = getStream().tell();
+ uint64_t Start = W.OS.tell();
(void) Start;
- write32(MachO::LC_SYMTAB);
- write32(sizeof(MachO::symtab_command));
- write32(SymbolOffset);
- write32(NumSymbols);
- write32(StringTableOffset);
- write32(StringTableSize);
+ W.write<uint32_t>(MachO::LC_SYMTAB);
+ W.write<uint32_t>(sizeof(MachO::symtab_command));
+ W.write<uint32_t>(SymbolOffset);
+ W.write<uint32_t>(NumSymbols);
+ W.write<uint32_t>(StringTableOffset);
+ W.write<uint32_t>(StringTableSize);
- assert(getStream().tell() - Start == sizeof(MachO::symtab_command));
+ assert(W.OS.tell() - Start == sizeof(MachO::symtab_command));
}
void MachObjectWriter::writeDysymtabLoadCommand(uint32_t FirstLocalSymbol,
@@ -280,31 +284,31 @@ void MachObjectWriter::writeDysymtabLoad
uint32_t NumIndirectSymbols) {
// struct dysymtab_command (80 bytes)
- uint64_t Start = getStream().tell();
+ uint64_t Start = W.OS.tell();
(void) Start;
- write32(MachO::LC_DYSYMTAB);
- write32(sizeof(MachO::dysymtab_command));
- write32(FirstLocalSymbol);
- write32(NumLocalSymbols);
- write32(FirstExternalSymbol);
- write32(NumExternalSymbols);
- write32(FirstUndefinedSymbol);
- write32(NumUndefinedSymbols);
- write32(0); // tocoff
- write32(0); // ntoc
- write32(0); // modtaboff
- write32(0); // nmodtab
- write32(0); // extrefsymoff
- write32(0); // nextrefsyms
- write32(IndirectSymbolOffset);
- write32(NumIndirectSymbols);
- write32(0); // extreloff
- write32(0); // nextrel
- write32(0); // locreloff
- write32(0); // nlocrel
+ W.write<uint32_t>(MachO::LC_DYSYMTAB);
+ W.write<uint32_t>(sizeof(MachO::dysymtab_command));
+ W.write<uint32_t>(FirstLocalSymbol);
+ W.write<uint32_t>(NumLocalSymbols);
+ W.write<uint32_t>(FirstExternalSymbol);
+ W.write<uint32_t>(NumExternalSymbols);
+ W.write<uint32_t>(FirstUndefinedSymbol);
+ W.write<uint32_t>(NumUndefinedSymbols);
+ W.write<uint32_t>(0); // tocoff
+ W.write<uint32_t>(0); // ntoc
+ W.write<uint32_t>(0); // modtaboff
+ W.write<uint32_t>(0); // nmodtab
+ W.write<uint32_t>(0); // extrefsymoff
+ W.write<uint32_t>(0); // nextrefsyms
+ W.write<uint32_t>(IndirectSymbolOffset);
+ W.write<uint32_t>(NumIndirectSymbols);
+ W.write<uint32_t>(0); // extreloff
+ W.write<uint32_t>(0); // nextrel
+ W.write<uint32_t>(0); // locreloff
+ W.write<uint32_t>(0); // nlocrel
- assert(getStream().tell() - Start == sizeof(MachO::dysymtab_command));
+ assert(W.OS.tell() - Start == sizeof(MachO::dysymtab_command));
}
MachObjectWriter::MachSymbolData *
@@ -384,33 +388,33 @@ void MachObjectWriter::writeNlist(MachSy
// struct nlist (12 bytes)
- write32(MSD.StringIndex);
- write8(Type);
- write8(SectionIndex);
+ W.write<uint32_t>(MSD.StringIndex);
+ W.OS << char(Type);
+ W.OS << char(SectionIndex);
// The Mach-O streamer uses the lowest 16-bits of the flags for the 'desc'
// value.
bool EncodeAsAltEntry =
IsAlias && cast<MCSymbolMachO>(OrigSymbol).isAltEntry();
- write16(cast<MCSymbolMachO>(Symbol)->getEncodedFlags(EncodeAsAltEntry));
+ W.write<uint16_t>(cast<MCSymbolMachO>(Symbol)->getEncodedFlags(EncodeAsAltEntry));
if (is64Bit())
- write64(Address);
+ W.write<uint64_t>(Address);
else
- write32(Address);
+ W.write<uint32_t>(Address);
}
void MachObjectWriter::writeLinkeditLoadCommand(uint32_t Type,
uint32_t DataOffset,
uint32_t DataSize) {
- uint64_t Start = getStream().tell();
+ uint64_t Start = W.OS.tell();
(void) Start;
- write32(Type);
- write32(sizeof(MachO::linkedit_data_command));
- write32(DataOffset);
- write32(DataSize);
+ W.write<uint32_t>(Type);
+ W.write<uint32_t>(sizeof(MachO::linkedit_data_command));
+ W.write<uint32_t>(DataOffset);
+ W.write<uint32_t>(DataSize);
- assert(getStream().tell() - Start == sizeof(MachO::linkedit_data_command));
+ assert(W.OS.tell() - Start == sizeof(MachO::linkedit_data_command));
}
static unsigned ComputeLinkerOptionsLoadCommandSize(
@@ -426,23 +430,23 @@ void MachObjectWriter::writeLinkerOption
const std::vector<std::string> &Options)
{
unsigned Size = ComputeLinkerOptionsLoadCommandSize(Options, is64Bit());
- uint64_t Start = getStream().tell();
+ uint64_t Start = W.OS.tell();
(void) Start;
- write32(MachO::LC_LINKER_OPTION);
- write32(Size);
- write32(Options.size());
+ W.write<uint32_t>(MachO::LC_LINKER_OPTION);
+ W.write<uint32_t>(Size);
+ W.write<uint32_t>(Options.size());
uint64_t BytesWritten = sizeof(MachO::linker_option_command);
for (const std::string &Option : Options) {
// Write each string, including the null byte.
- writeBytes(Option, Option.size() + 1);
+ W.OS << Option << '\0';
BytesWritten += Option.size() + 1;
}
// Pad to a multiple of the pointer size.
- writeBytes("", OffsetToAlignment(BytesWritten, is64Bit() ? 8 : 4));
+ W.OS.write_zeros(OffsetToAlignment(BytesWritten, is64Bit() ? 8 : 4));
- assert(getStream().tell() - Start == Size);
+ assert(W.OS.tell() - Start == Size);
}
void MachObjectWriter::recordRelocation(MCAssembler &Asm,
@@ -611,7 +615,7 @@ void MachObjectWriter::computeSymbolTabl
// Set the Index and the IsExtern bit.
unsigned Index = Rel.Sym->getIndex();
assert(isInt<24>(Index));
- if (IsLittleEndian)
+ if (W.Endian == support::little)
Rel.MRE.r_word1 = (Rel.MRE.r_word1 & (~0U << 24)) | Index | (1 << 27);
else
Rel.MRE.r_word1 = (Rel.MRE.r_word1 & 0xff) | Index << 8 | (1 << 4);
@@ -847,19 +851,19 @@ void MachObjectWriter::writeObject(MCAss
(VersionInfo.Major << 16);
if (VersionInfo.EmitBuildVersion) {
// FIXME: Currently empty tools. Add clang version in the future.
- write32(MachO::LC_BUILD_VERSION);
- write32(sizeof(MachO::build_version_command));
- write32(VersionInfo.TypeOrPlatform.Platform);
- write32(EncodedVersion);
- write32(0); // SDK version.
- write32(0); // Empty tools list.
+ W.write<uint32_t>(MachO::LC_BUILD_VERSION);
+ W.write<uint32_t>(sizeof(MachO::build_version_command));
+ W.write<uint32_t>(VersionInfo.TypeOrPlatform.Platform);
+ W.write<uint32_t>(EncodedVersion);
+ W.write<uint32_t>(0); // SDK version.
+ W.write<uint32_t>(0); // Empty tools list.
} else {
MachO::LoadCommandType LCType
= getLCFromMCVM(VersionInfo.TypeOrPlatform.Type);
- write32(LCType);
- write32(sizeof(MachO::version_min_command));
- write32(EncodedVersion);
- write32(0); // reserved.
+ W.write<uint32_t>(LCType);
+ W.write<uint32_t>(sizeof(MachO::version_min_command));
+ W.write<uint32_t>(EncodedVersion);
+ W.write<uint32_t>(0); // reserved.
}
}
@@ -919,14 +923,14 @@ void MachObjectWriter::writeObject(MCAss
// Write the actual section data.
for (const MCSection &Sec : Asm) {
- Asm.writeSectionData(getStream(), &Sec, Layout);
+ Asm.writeSectionData(W.OS, &Sec, Layout);
uint64_t Pad = getPaddingSize(&Sec, Layout);
- WriteZeros(Pad);
+ W.OS.write_zeros(Pad);
}
// Write the extra padding.
- WriteZeros(SectionDataPadding);
+ W.OS.write_zeros(SectionDataPadding);
// Write the relocation entries.
for (const MCSection &Sec : Asm) {
@@ -934,8 +938,8 @@ void MachObjectWriter::writeObject(MCAss
// (approximately, the exact algorithm is more complicated than this).
std::vector<RelAndSymbol> &Relocs = Relocations[&Sec];
for (const RelAndSymbol &Rel : make_range(Relocs.rbegin(), Relocs.rend())) {
- write32(Rel.MRE.r_word0);
- write32(Rel.MRE.r_word1);
+ W.write<uint32_t>(Rel.MRE.r_word0);
+ W.write<uint32_t>(Rel.MRE.r_word1);
}
}
@@ -956,20 +960,20 @@ void MachObjectWriter::writeObject(MCAss
<< ")"
<< " end: " << End << "(" << Data->End->getName() << ")"
<< " size: " << End - Start << "\n");
- write32(Start);
- write16(End - Start);
- write16(Data->Kind);
+ W.write<uint32_t>(Start);
+ W.write<uint16_t>(End - Start);
+ W.write<uint16_t>(Data->Kind);
}
// Write out the loh commands, if there is one.
if (LOHSize) {
#ifndef NDEBUG
- unsigned Start = getStream().tell();
+ unsigned Start = W.OS.tell();
#endif
Asm.getLOHContainer().emit(*this, Layout);
// Pad to a multiple of the pointer size.
- writeBytes("", OffsetToAlignment(LOHRawSize, is64Bit() ? 8 : 4));
- assert(getStream().tell() - Start == LOHSize);
+ W.OS.write_zeros(OffsetToAlignment(LOHRawSize, is64Bit() ? 8 : 4));
+ assert(W.OS.tell() - Start == LOHSize);
}
// Write the symbol table data, if used.
@@ -988,12 +992,12 @@ void MachObjectWriter::writeObject(MCAss
uint32_t Flags = MachO::INDIRECT_SYMBOL_LOCAL;
if (it->Symbol->isAbsolute())
Flags |= MachO::INDIRECT_SYMBOL_ABS;
- write32(Flags);
+ W.write<uint32_t>(Flags);
continue;
}
}
- write32(it->Symbol->getIndex());
+ W.write<uint32_t>(it->Symbol->getIndex());
}
// FIXME: Check that offsets match computed ones.
@@ -1005,7 +1009,7 @@ void MachObjectWriter::writeObject(MCAss
writeNlist(Entry, Layout);
// Write the string table.
- StringTable.write(getStream());
+ StringTable.write(W.OS);
}
}
Modified: llvm/trunk/lib/MC/WasmObjectWriter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/MC/WasmObjectWriter.cpp?rev=332861&r1=332860&r2=332861&view=diff
==============================================================================
--- llvm/trunk/lib/MC/WasmObjectWriter.cpp (original)
+++ llvm/trunk/lib/MC/WasmObjectWriter.cpp Mon May 21 11:17:42 2018
@@ -196,6 +196,8 @@ raw_ostream &operator<<(raw_ostream &OS,
#endif
class WasmObjectWriter : public MCObjectWriter {
+ support::endian::Writer W;
+
/// The target specific Wasm writer instance.
std::unique_ptr<MCWasmObjectTargetWriter> TargetObjectWriter;
@@ -250,7 +252,7 @@ class WasmObjectWriter : public MCObject
public:
WasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
raw_pwrite_stream &OS)
- : MCObjectWriter(OS, /*IsLittleEndian=*/true),
+ : MCObjectWriter(OS, /*IsLittleEndian=*/true), W(OS, support::little),
TargetObjectWriter(std::move(MOTW)) {}
~WasmObjectWriter() override;
@@ -286,12 +288,12 @@ private:
void writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
void writeString(const StringRef Str) {
- encodeULEB128(Str.size(), getStream());
- writeBytes(Str);
+ encodeULEB128(Str.size(), W.OS);
+ W.OS << Str;
}
void writeValueType(wasm::ValType Ty) {
- write8(static_cast<uint8_t>(Ty));
+ W.OS << static_cast<char>(Ty);
}
void writeTypeSection(ArrayRef<WasmFunctionType> FunctionTypes);
@@ -333,17 +335,17 @@ WasmObjectWriter::~WasmObjectWriter() {}
void WasmObjectWriter::startSection(SectionBookkeeping &Section,
unsigned SectionId) {
LLVM_DEBUG(dbgs() << "startSection " << SectionId << "\n");
- write8(SectionId);
+ W.OS << char(SectionId);
- Section.SizeOffset = getStream().tell();
+ Section.SizeOffset = W.OS.tell();
// The section size. We don't know the size yet, so reserve enough space
// for any 32-bit value; we'll patch it later.
- encodeULEB128(UINT32_MAX, getStream());
+ encodeULEB128(UINT32_MAX, W.OS);
// The position where the section starts, for measuring its size.
- Section.ContentsOffset = getStream().tell();
- Section.PayloadOffset = getStream().tell();
+ Section.ContentsOffset = W.OS.tell();
+ Section.PayloadOffset = W.OS.tell();
Section.Index = SectionCount++;
}
@@ -353,19 +355,19 @@ void WasmObjectWriter::startCustomSectio
startSection(Section, wasm::WASM_SEC_CUSTOM);
// The position where the section header ends, for measuring its size.
- Section.PayloadOffset = getStream().tell();
+ Section.PayloadOffset = W.OS.tell();
// Custom sections in wasm also have a string identifier.
writeString(Name);
// The position where the custom section starts.
- Section.ContentsOffset = getStream().tell();
+ Section.ContentsOffset = W.OS.tell();
}
// Now that the section is complete and we know how big it is, patch up the
// section size field at the start of the section.
void WasmObjectWriter::endSection(SectionBookkeeping &Section) {
- uint64_t Size = getStream().tell() - Section.PayloadOffset;
+ uint64_t Size = W.OS.tell() - Section.PayloadOffset;
if (uint32_t(Size) != Size)
report_fatal_error("section size does not fit in a uint32_t");
@@ -376,13 +378,14 @@ void WasmObjectWriter::endSection(Sectio
uint8_t Buffer[16];
unsigned SizeLen = encodeULEB128(Size, Buffer, 5);
assert(SizeLen == 5);
- getStream().pwrite((char *)Buffer, SizeLen, Section.SizeOffset);
+ static_cast<raw_pwrite_stream &>(W.OS).pwrite((char *)Buffer, SizeLen,
+ Section.SizeOffset);
}
// Emit the Wasm header.
void WasmObjectWriter::writeHeader(const MCAssembler &Asm) {
- writeBytes(StringRef(wasm::WasmMagic, sizeof(wasm::WasmMagic)));
- writeLE32(wasm::WasmVersion);
+ W.OS.write(wasm::WasmMagic, sizeof(wasm::WasmMagic));
+ W.write<uint32_t>(wasm::WasmVersion);
}
void WasmObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
@@ -662,7 +665,7 @@ WasmObjectWriter::getRelocationIndexValu
// directly.
void WasmObjectWriter::applyRelocations(
ArrayRef<WasmRelocationEntry> Relocations, uint64_t ContentsOffset) {
- raw_pwrite_stream &Stream = getStream();
+ auto &Stream = static_cast<raw_pwrite_stream &>(W.OS);
for (const WasmRelocationEntry &RelEntry : Relocations) {
uint64_t Offset = ContentsOffset +
RelEntry.FixupSection->getSectionOffset() +
@@ -702,14 +705,14 @@ void WasmObjectWriter::writeTypeSection(
SectionBookkeeping Section;
startSection(Section, wasm::WASM_SEC_TYPE);
- encodeULEB128(FunctionTypes.size(), getStream());
+ encodeULEB128(FunctionTypes.size(), W.OS);
for (const WasmFunctionType &FuncTy : FunctionTypes) {
- write8(wasm::WASM_TYPE_FUNC);
- encodeULEB128(FuncTy.Params.size(), getStream());
+ W.OS << char(wasm::WASM_TYPE_FUNC);
+ encodeULEB128(FuncTy.Params.size(), W.OS);
for (wasm::ValType Ty : FuncTy.Params)
writeValueType(Ty);
- encodeULEB128(FuncTy.Returns.size(), getStream());
+ encodeULEB128(FuncTy.Returns.size(), W.OS);
for (wasm::ValType Ty : FuncTy.Returns)
writeValueType(Ty);
}
@@ -728,28 +731,28 @@ void WasmObjectWriter::writeImportSectio
SectionBookkeeping Section;
startSection(Section, wasm::WASM_SEC_IMPORT);
- encodeULEB128(Imports.size(), getStream());
+ encodeULEB128(Imports.size(), W.OS);
for (const wasm::WasmImport &Import : Imports) {
writeString(Import.Module);
writeString(Import.Field);
- write8(Import.Kind);
+ W.OS << char(Import.Kind);
switch (Import.Kind) {
case wasm::WASM_EXTERNAL_FUNCTION:
- encodeULEB128(Import.SigIndex, getStream());
+ encodeULEB128(Import.SigIndex, W.OS);
break;
case wasm::WASM_EXTERNAL_GLOBAL:
- write8(Import.Global.Type);
- write8(Import.Global.Mutable ? 1 : 0);
+ W.OS << char(Import.Global.Type);
+ W.OS << char(Import.Global.Mutable ? 1 : 0);
break;
case wasm::WASM_EXTERNAL_MEMORY:
- encodeULEB128(0, getStream()); // flags
- encodeULEB128(NumPages, getStream()); // initial
+ encodeULEB128(0, W.OS); // flags
+ encodeULEB128(NumPages, W.OS); // initial
break;
case wasm::WASM_EXTERNAL_TABLE:
- write8(Import.Table.ElemType);
- encodeULEB128(0, getStream()); // flags
- encodeULEB128(NumElements, getStream()); // initial
+ W.OS << char(Import.Table.ElemType);
+ encodeULEB128(0, W.OS); // flags
+ encodeULEB128(NumElements, W.OS); // initial
break;
default:
llvm_unreachable("unsupported import kind");
@@ -766,9 +769,9 @@ void WasmObjectWriter::writeFunctionSect
SectionBookkeeping Section;
startSection(Section, wasm::WASM_SEC_FUNCTION);
- encodeULEB128(Functions.size(), getStream());
+ encodeULEB128(Functions.size(), W.OS);
for (const WasmFunction &Func : Functions)
- encodeULEB128(Func.Type, getStream());
+ encodeULEB128(Func.Type, W.OS);
endSection(Section);
}
@@ -780,14 +783,14 @@ void WasmObjectWriter::writeGlobalSectio
SectionBookkeeping Section;
startSection(Section, wasm::WASM_SEC_GLOBAL);
- encodeULEB128(Globals.size(), getStream());
+ encodeULEB128(Globals.size(), W.OS);
for (const WasmGlobal &Global : Globals) {
writeValueType(static_cast<wasm::ValType>(Global.Type.Type));
- write8(Global.Type.Mutable);
+ W.OS << char(Global.Type.Mutable);
- write8(wasm::WASM_OPCODE_I32_CONST);
- encodeSLEB128(Global.InitialValue, getStream());
- write8(wasm::WASM_OPCODE_END);
+ W.OS << char(wasm::WASM_OPCODE_I32_CONST);
+ encodeSLEB128(Global.InitialValue, W.OS);
+ W.OS << char(wasm::WASM_OPCODE_END);
}
endSection(Section);
@@ -800,11 +803,11 @@ void WasmObjectWriter::writeExportSectio
SectionBookkeeping Section;
startSection(Section, wasm::WASM_SEC_EXPORT);
- encodeULEB128(Exports.size(), getStream());
+ encodeULEB128(Exports.size(), W.OS);
for (const wasm::WasmExport &Export : Exports) {
writeString(Export.Name);
- write8(Export.Kind);
- encodeULEB128(Export.Index, getStream());
+ W.OS << char(Export.Kind);
+ encodeULEB128(Export.Index, W.OS);
}
endSection(Section);
@@ -817,17 +820,17 @@ void WasmObjectWriter::writeElemSection(
SectionBookkeeping Section;
startSection(Section, wasm::WASM_SEC_ELEM);
- encodeULEB128(1, getStream()); // number of "segments"
- encodeULEB128(0, getStream()); // the table index
+ encodeULEB128(1, W.OS); // number of "segments"
+ encodeULEB128(0, W.OS); // the table index
// init expr for starting offset
- write8(wasm::WASM_OPCODE_I32_CONST);
- encodeSLEB128(kInitialTableOffset, getStream());
- write8(wasm::WASM_OPCODE_END);
+ W.OS << char(wasm::WASM_OPCODE_I32_CONST);
+ encodeSLEB128(kInitialTableOffset, W.OS);
+ W.OS << char(wasm::WASM_OPCODE_END);
- encodeULEB128(TableElems.size(), getStream());
+ encodeULEB128(TableElems.size(), W.OS);
for (uint32_t Elem : TableElems)
- encodeULEB128(Elem, getStream());
+ encodeULEB128(Elem, W.OS);
endSection(Section);
}
@@ -842,7 +845,7 @@ void WasmObjectWriter::writeCodeSection(
startSection(Section, wasm::WASM_SEC_CODE);
CodeSectionIndex = Section.Index;
- encodeULEB128(Functions.size(), getStream());
+ encodeULEB128(Functions.size(), W.OS);
for (const WasmFunction &Func : Functions) {
auto &FuncSection = static_cast<MCSectionWasm &>(Func.Sym->getSection());
@@ -851,9 +854,9 @@ void WasmObjectWriter::writeCodeSection(
if (!Func.Sym->getSize()->evaluateAsAbsolute(Size, Layout))
report_fatal_error(".size expression must be evaluatable");
- encodeULEB128(Size, getStream());
- FuncSection.setSectionOffset(getStream().tell() - Section.ContentsOffset);
- Asm.writeSectionData(getStream(), &FuncSection, Layout);
+ encodeULEB128(Size, W.OS);
+ FuncSection.setSectionOffset(W.OS.tell() - Section.ContentsOffset);
+ Asm.writeSectionData(W.OS, &FuncSection, Layout);
}
// Apply fixups.
@@ -870,16 +873,16 @@ void WasmObjectWriter::writeDataSection(
startSection(Section, wasm::WASM_SEC_DATA);
DataSectionIndex = Section.Index;
- encodeULEB128(DataSegments.size(), getStream()); // count
+ encodeULEB128(DataSegments.size(), W.OS); // count
for (const WasmDataSegment &Segment : DataSegments) {
- encodeULEB128(0, getStream()); // memory index
- write8(wasm::WASM_OPCODE_I32_CONST);
- encodeSLEB128(Segment.Offset, getStream()); // offset
- write8(wasm::WASM_OPCODE_END);
- encodeULEB128(Segment.Data.size(), getStream()); // size
- Segment.Section->setSectionOffset(getStream().tell() - Section.ContentsOffset);
- writeBytes(Segment.Data); // data
+ encodeULEB128(0, W.OS); // memory index
+ W.OS << char(wasm::WASM_OPCODE_I32_CONST);
+ encodeSLEB128(Segment.Offset, W.OS); // offset
+ W.OS << char(wasm::WASM_OPCODE_END);
+ encodeULEB128(Segment.Data.size(), W.OS); // size
+ Segment.Section->setSectionOffset(W.OS.tell() - Section.ContentsOffset);
+ W.OS << Segment.Data; // data
}
// Apply fixups.
@@ -900,20 +903,18 @@ void WasmObjectWriter::writeRelocSection
SectionBookkeeping Section;
startCustomSection(Section, std::string("reloc.") + Name.str());
- raw_pwrite_stream &Stream = getStream();
-
- encodeULEB128(SectionIndex, Stream);
- encodeULEB128(Relocations.size(), Stream);
+ encodeULEB128(SectionIndex, W.OS);
+ encodeULEB128(Relocations.size(), W.OS);
for (const WasmRelocationEntry& RelEntry : Relocations) {
uint64_t Offset = RelEntry.Offset +
RelEntry.FixupSection->getSectionOffset();
uint32_t Index = getRelocationIndexValue(RelEntry);
- write8(RelEntry.Type);
- encodeULEB128(Offset, Stream);
- encodeULEB128(Index, Stream);
+ W.OS << char(RelEntry.Type);
+ encodeULEB128(Offset, W.OS);
+ encodeULEB128(Index, W.OS);
if (RelEntry.hasAddend())
- encodeSLEB128(RelEntry.Addend, Stream);
+ encodeSLEB128(RelEntry.Addend, W.OS);
}
endSection(Section);
@@ -932,34 +933,34 @@ void WasmObjectWriter::writeLinkingMetaD
const std::map<StringRef, std::vector<WasmComdatEntry>> &Comdats) {
SectionBookkeeping Section;
startCustomSection(Section, "linking");
- encodeULEB128(wasm::WasmMetadataVersion, getStream());
+ encodeULEB128(wasm::WasmMetadataVersion, W.OS);
SectionBookkeeping SubSection;
if (SymbolInfos.size() != 0) {
startSection(SubSection, wasm::WASM_SYMBOL_TABLE);
- encodeULEB128(SymbolInfos.size(), getStream());
+ encodeULEB128(SymbolInfos.size(), W.OS);
for (const wasm::WasmSymbolInfo &Sym : SymbolInfos) {
- encodeULEB128(Sym.Kind, getStream());
- encodeULEB128(Sym.Flags, getStream());
+ encodeULEB128(Sym.Kind, W.OS);
+ encodeULEB128(Sym.Flags, W.OS);
switch (Sym.Kind) {
case wasm::WASM_SYMBOL_TYPE_FUNCTION:
case wasm::WASM_SYMBOL_TYPE_GLOBAL:
- encodeULEB128(Sym.ElementIndex, getStream());
+ encodeULEB128(Sym.ElementIndex, W.OS);
if ((Sym.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0)
writeString(Sym.Name);
break;
case wasm::WASM_SYMBOL_TYPE_DATA:
writeString(Sym.Name);
if ((Sym.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0) {
- encodeULEB128(Sym.DataRef.Segment, getStream());
- encodeULEB128(Sym.DataRef.Offset, getStream());
- encodeULEB128(Sym.DataRef.Size, getStream());
+ encodeULEB128(Sym.DataRef.Segment, W.OS);
+ encodeULEB128(Sym.DataRef.Offset, W.OS);
+ encodeULEB128(Sym.DataRef.Size, W.OS);
}
break;
case wasm::WASM_SYMBOL_TYPE_SECTION: {
const uint32_t SectionIndex =
CustomSections[Sym.ElementIndex].OutputIndex;
- encodeULEB128(SectionIndex, getStream());
+ encodeULEB128(SectionIndex, W.OS);
break;
}
default:
@@ -971,35 +972,35 @@ void WasmObjectWriter::writeLinkingMetaD
if (DataSegments.size()) {
startSection(SubSection, wasm::WASM_SEGMENT_INFO);
- encodeULEB128(DataSegments.size(), getStream());
+ encodeULEB128(DataSegments.size(), W.OS);
for (const WasmDataSegment &Segment : DataSegments) {
writeString(Segment.Name);
- encodeULEB128(Segment.Alignment, getStream());
- encodeULEB128(Segment.Flags, getStream());
+ encodeULEB128(Segment.Alignment, W.OS);
+ encodeULEB128(Segment.Flags, W.OS);
}
endSection(SubSection);
}
if (!InitFuncs.empty()) {
startSection(SubSection, wasm::WASM_INIT_FUNCS);
- encodeULEB128(InitFuncs.size(), getStream());
+ encodeULEB128(InitFuncs.size(), W.OS);
for (auto &StartFunc : InitFuncs) {
- encodeULEB128(StartFunc.first, getStream()); // priority
- encodeULEB128(StartFunc.second, getStream()); // function index
+ encodeULEB128(StartFunc.first, W.OS); // priority
+ encodeULEB128(StartFunc.second, W.OS); // function index
}
endSection(SubSection);
}
if (Comdats.size()) {
startSection(SubSection, wasm::WASM_COMDAT_INFO);
- encodeULEB128(Comdats.size(), getStream());
+ encodeULEB128(Comdats.size(), W.OS);
for (const auto &C : Comdats) {
writeString(C.first);
- encodeULEB128(0, getStream()); // flags for future use
- encodeULEB128(C.second.size(), getStream());
+ encodeULEB128(0, W.OS); // flags for future use
+ encodeULEB128(C.second.size(), W.OS);
for (const WasmComdatEntry &Entry : C.second) {
- encodeULEB128(Entry.Kind, getStream());
- encodeULEB128(Entry.Index, getStream());
+ encodeULEB128(Entry.Kind, W.OS);
+ encodeULEB128(Entry.Index, W.OS);
}
}
endSection(SubSection);
@@ -1015,8 +1016,8 @@ void WasmObjectWriter::writeCustomSectio
auto *Sec = CustomSection.Section;
startCustomSection(Section, CustomSection.Name);
- Sec->setSectionOffset(getStream().tell() - Section.ContentsOffset);
- Asm.writeSectionData(getStream(), Sec, Layout);
+ Sec->setSectionOffset(W.OS.tell() - Section.ContentsOffset);
+ Asm.writeSectionData(W.OS, Sec, Layout);
CustomSection.OutputContentsOffset = Section.ContentsOffset;
CustomSection.OutputIndex = Section.Index;
Modified: llvm/trunk/lib/MC/WinCOFFObjectWriter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/MC/WinCOFFObjectWriter.cpp?rev=332861&r1=332860&r2=332861&view=diff
==============================================================================
--- llvm/trunk/lib/MC/WinCOFFObjectWriter.cpp (original)
+++ llvm/trunk/lib/MC/WinCOFFObjectWriter.cpp Mon May 21 11:17:42 2018
@@ -125,6 +125,8 @@ public:
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 @@ void COFFSymbol::set_name_offset(uint32_
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 @@ bool WinCOFFObjectWriter::IsPhysicalSect
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 @@ void WinCOFFObjectWriter::WriteAuxiliary
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 @@ void WinCOFFObjectWriter::writeSectionHe
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 @@ uint32_t WinCOFFObjectWriter::writeSecti
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 @@ void WinCOFFObjectWriter::writeSection(M
// 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 @@ void WinCOFFObjectWriter::writeSection(M
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 @@ void WinCOFFObjectWriter::assignSectionN
// 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 @@ void WinCOFFObjectWriter::writeObject(MC
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 @@ void WinCOFFObjectWriter::writeObject(MC
WriteSymbol(*Symbol);
// Write a string table, which completes the entire COFF file.
- Strings.write(getStream());
+ Strings.write(W.OS);
}
MCWinCOFFObjectTargetWriter::MCWinCOFFObjectTargetWriter(unsigned Machine_)
Modified: llvm/trunk/tools/dsymutil/MachOUtils.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/dsymutil/MachOUtils.cpp?rev=332861&r1=332860&r2=332861&view=diff
==============================================================================
--- llvm/trunk/tools/dsymutil/MachOUtils.cpp (original)
+++ llvm/trunk/tools/dsymutil/MachOUtils.cpp Mon May 21 11:17:42 2018
@@ -225,7 +225,7 @@ getSection(const object::MachOObjectFile
template <typename SegmentTy>
static void transferSegmentAndSections(
const object::MachOObjectFile::LoadCommandInfo &LCI, SegmentTy Segment,
- const object::MachOObjectFile &Obj, MCObjectWriter &Writer,
+ const object::MachOObjectFile &Obj, MachObjectWriter &Writer,
uint64_t LinkeditOffset, uint64_t LinkeditSize, uint64_t DwarfSegmentSize,
uint64_t &GapForDwarf, uint64_t &EndAddress) {
if (StringRef("__DWARF") == Segment.segname)
@@ -255,14 +255,13 @@ static void transferSegmentAndSections(
unsigned nsects = Segment.nsects;
if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
MachO::swapStruct(Segment);
- Writer.writeBytes(
- StringRef(reinterpret_cast<char *>(&Segment), sizeof(Segment)));
+ Writer.W.OS.write(reinterpret_cast<char *>(&Segment), sizeof(Segment));
for (unsigned i = 0; i < nsects; ++i) {
auto Sect = getSection(Obj, Segment, LCI, i);
Sect.offset = Sect.reloff = Sect.nreloc = 0;
if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
MachO::swapStruct(Sect);
- Writer.writeBytes(StringRef(reinterpret_cast<char *>(&Sect), sizeof(Sect)));
+ Writer.W.OS.write(reinterpret_cast<char *>(&Sect), sizeof(Sect));
}
}
@@ -429,10 +428,9 @@ bool generateDsymCompanion(const DebugMa
// Write the load commands.
assert(OutFile.tell() == HeaderSize);
if (UUIDCmd.cmd != 0) {
- Writer.write32(UUIDCmd.cmd);
- Writer.write32(UUIDCmd.cmdsize);
- Writer.writeBytes(
- StringRef(reinterpret_cast<const char *>(UUIDCmd.uuid), 16));
+ Writer.W.write<uint32_t>(UUIDCmd.cmd);
+ Writer.W.write<uint32_t>(UUIDCmd.cmdsize);
+ OutFile.write(reinterpret_cast<const char *>(UUIDCmd.uuid), 16);
assert(OutFile.tell() == HeaderSize + sizeof(UUIDCmd));
}
@@ -479,12 +477,12 @@ bool generateDsymCompanion(const DebugMa
NumDwarfSections, Layout, Writer);
assert(OutFile.tell() == LoadCommandSize + HeaderSize);
- Writer.WriteZeros(SymtabStart - (LoadCommandSize + HeaderSize));
+ OutFile.write_zeros(SymtabStart - (LoadCommandSize + HeaderSize));
assert(OutFile.tell() == SymtabStart);
// Transfer symbols.
if (ShouldEmitSymtab) {
- Writer.writeBytes(NewSymtab.str());
+ OutFile << NewSymtab.str();
assert(OutFile.tell() == StringStart);
// Transfer string table.
@@ -492,21 +490,20 @@ bool generateDsymCompanion(const DebugMa
// dsymutil-classic starts the reconstructed string table with 2 of these.
// Reproduce that behavior for now (there is corresponding code in
// transferSymbol).
- Writer.WriteZeros(1);
+ OutFile << '\0';
std::vector<DwarfStringPoolEntryRef> Strings = NewStrings.getEntries();
for (auto EntryRef : Strings) {
if (EntryRef.getIndex() == -1U)
break;
- StringRef ZeroTerminated(EntryRef.getString().data(),
- EntryRef.getString().size() + 1);
- Writer.writeBytes(ZeroTerminated);
+ OutFile.write(EntryRef.getString().data(),
+ EntryRef.getString().size() + 1);
}
}
assert(OutFile.tell() == StringStart + NewStringsSize);
// Pad till the Dwarf segment start.
- Writer.WriteZeros(DwarfSegmentStart - (StringStart + NewStringsSize));
+ OutFile.write_zeros(DwarfSegmentStart - (StringStart + NewStringsSize));
assert(OutFile.tell() == DwarfSegmentStart);
// Emit the Dwarf sections contents.
@@ -515,7 +512,7 @@ bool generateDsymCompanion(const DebugMa
continue;
uint64_t Pos = OutFile.tell();
- Writer.WriteZeros(alignTo(Pos, Sec.getAlignment()) - Pos);
+ OutFile.write_zeros(alignTo(Pos, Sec.getAlignment()) - Pos);
MCAsm.writeSectionData(OutFile, &Sec, Layout);
}
More information about the llvm-commits
mailing list