This is an archive of the discontinued LLVM Phabricator instance.

Differential D5349

MC: Add support for BigObj
ClosedPublic

Authored by majnemer on Sep 14 2014, 9:33 PM.

Details

Reviewers
ruiu
Bigcheese
rnk
Commits
rG4d57159c09b2: MC: Add support for BigObj
rL217812: MC: Add support for BigObj
Summary

Teach WinCOFFObjectWriter how to write -mbig-obj style object files;
these object files allow for more sections inside an object file.

Our support for BigObj is notable different from binutils and cl: we
implicitly upgrade object files to BigObj instead of asking the user to
compile the same file *again* but with another flag. This matches up
with how LLVM treats ELF variants.

This was tested by forcing LLVM to always emit BigObj files and running
the entire test suite. A specific test hasn't been added because I feel
it is prohibitively expensive to add such a test.

I've lowered the maximum number of sections in a normal COFF file,
VS "14" CTP 3 supports no more than 65279 sections. This is important
otherwise we might not switch to BigObj quickly enough, leaving us with
a COFF file that we couldn't link.

yaml2obj support is all that remains to implement.

Diff Detail

Repository
rL LLVM

Event Timeline

majnemer updated this revision to Diff 13691.Sep 14 2014, 9:33 PM
majnemer retitled this revision from to MC: Add support for BigObj.
majnemer updated this object.
majnemer added reviewers: ruiu, rnk, Bigcheese.
majnemer added a subscriber: Unknown Object (MLST).
rnk accepted this revision.Sep 15 2014, 9:58 AM
rnk edited edge metadata.

Looks fine to me. Up to you if you want to wait for Rui for a more object-file oriented review.

lib/MC/WinCOFFObjectWriter.cpp
658 ↗(On Diff #13691)

Write8(0) doesn't have a loop? *shrug*

662 ↗(On Diff #13691)

WriteLE16(0)?

This revision is now accepted and ready to land.Sep 15 2014, 9:58 AM
rnk added a comment.Sep 15 2014, 10:00 AM

Actually, can you test this from a .s file with 65K sections? Would that be cheap enough?

ruiu edited edge metadata.Sep 15 2014, 10:02 AM

LGTM

Because BigObj is only for object files and not for executables, we are not
going to use the writer for the linker, though.

lib/MC/WinCOFFObjectWriter.cpp
884 ↗(On Diff #13691)

You can just break here.

887 ↗(On Diff #13691)

Offset += SymbolSize?

majnemer added a comment.Sep 15 2014, 10:29 AM
In D5349#7, @rnk wrote:

Actually, can you test this from a .s file with 65K sections? Would that be cheap enough?

That takes a solid second on my beefy machine. If you feel like that's acceptable, I'll add one.

majnemer closed this revision.Sep 15 2014, 12:52 PM
majnemer updated this revision to Diff 13728.

Closed by commit rL217812 (authored by @majnemer).

yaron.keren added a subscriber: yaron.keren.Sep 15 2014, 1:31 PM

Hi,

Visual C++ 2013 Update 2 does not like this change:

1> WinCOFFObjectWriter.cpp
1>..\..\..\lib\MC\WinCOFFObjectWriter.cpp(601): error C2070: 'unknown':
illegal sizeof operand
1>..\..\..\lib\MC\WinCOFFObjectWriter.cpp(602): error C2070: 'unknown':
illegal sizeof operand
1>..\..\..\lib\MC\WinCOFFObjectWriter.cpp(603): error C2070: 'unknown':
illegal sizeof operand
1>..\..\..\lib\MC\WinCOFFObjectWriter.cpp(604): error C2070: 'unknown':
illegal sizeof operand

Yaron

2014-09-15 22:52 GMT+03:00 David Majnemer <david.majnemer@gmail.com>:

Closed by commit rL217812 (authored by @majnemer).

REPOSITORY

rL LLVM

http://reviews.llvm.org/D5349

Files:

llvm/trunk/include/llvm/Object/COFF.h
llvm/trunk/include/llvm/Support/COFF.h
llvm/trunk/lib/MC/WinCOFFObjectWriter.cpp
llvm/trunk/tools/llvm-objdump/llvm-objdump.cpp
llvm/trunk/tools/llvm-readobj/COFFDumper.cpp
llvm/trunk/tools/obj2yaml/coff2yaml.cpp
llvm/trunk/tools/yaml2obj/yaml2coff.cpp

llvm-commits mailing list
llvm-commits@cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits

Revision Contents

PathSize
llvm/
trunk/
include/
llvm/
Object/
18 lines
Support/
21 lines
lib/
MC/
150 lines
tools/
llvm-objdump/
4 lines
llvm-readobj/
8 lines
obj2yaml/
8 lines
yaml2obj/
19 lines

Diff 13728

llvm/trunk/include/llvm/Object/COFF.h

Show First 20 Lines • Show All 230 Lines • ▼ Show 20 Linespublic:
const void *getRawPtr() const { const void *getRawPtr() const {
return CS16 ? static_cast<const void *>(CS16) : CS32; return CS16 ? static_cast<const void *>(CS16) : CS32;
} }
friend bool operator<(COFFSymbolRef A, COFFSymbolRef B) { friend bool operator<(COFFSymbolRef A, COFFSymbolRef B) {
return A.getRawPtr() < B.getRawPtr(); return A.getRawPtr() < B.getRawPtr();
} }
bool isBigObj() const {
if (CS16)
return false;
if (CS32)
return true;
llvm_unreachable("COFFSymbolRef points to nothing!");
}
const char *getShortName() const { const char *getShortName() const {
return CS16 ? CS16->Name.ShortName : CS32->Name.ShortName; return CS16 ? CS16->Name.ShortName : CS32->Name.ShortName;
} }
const StringTableOffset &getStringTableOffset() const { const StringTableOffset &getStringTableOffset() const {
return CS16 ? CS16->Name.Offset : CS32->Name.Offset; return CS16 ? CS16->Name.Offset : CS32->Name.Offset;
} }
▲ Show 20 Lines • Show All 109 Lines • ▼ Show 20 Linesstruct coff_aux_weak_external {
support::ulittle32_t Characteristics; support::ulittle32_t Characteristics;
}; };
struct coff_aux_section_definition { struct coff_aux_section_definition {
support::ulittle32_t Length; support::ulittle32_t Length;
support::ulittle16_t NumberOfRelocations; support::ulittle16_t NumberOfRelocations;
support::ulittle16_t NumberOfLinenumbers; support::ulittle16_t NumberOfLinenumbers;
support::ulittle32_t CheckSum; support::ulittle32_t CheckSum;
support::ulittle16_t Number; support::ulittle16_t NumberLowPart;
uint8_t Selection; uint8_t Selection;
uint8_t Unused;
support::ulittle16_t NumberHighPart;
int32_t getNumber(bool IsBigObj) const {
uint32_t Number = static_cast<uint32_t>(NumberLowPart);
if (IsBigObj)
Number |= static_cast<uint32_t>(NumberHighPart) << 16;
return static_cast<int32_t>(Number);
}
}; };
struct coff_aux_clr_token { struct coff_aux_clr_token {
uint8_t AuxType; uint8_t AuxType;
uint8_t Reserved; uint8_t Reserved;
support::ulittle32_t SymbolTableIndex; support::ulittle32_t SymbolTableIndex;
}; };
▲ Show 20 Lines • Show All 303 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/Support/COFF.h

Show All 25 Lines
#include "llvm/Support/DataTypes.h" #include "llvm/Support/DataTypes.h"
#include <cassert> #include <cassert>
#include <cstring> #include <cstring>
namespace llvm { namespace llvm {
namespace COFF { namespace COFF {
// The maximum number of sections that a COFF object can have (inclusive). // The maximum number of sections that a COFF object can have (inclusive).
const uint16_t MaxNumberOfSections16 = 65299; const int32_t MaxNumberOfSections16 = 65279;
// The PE signature bytes that follows the DOS stub header. // The PE signature bytes that follows the DOS stub header.
static const char PEMagic[] = { 'P', 'E', '\0', '\0' }; static const char PEMagic[] = { 'P', 'E', '\0', '\0' };
static const char BigObjMagic[] = { static const char BigObjMagic[] = {
'\xc7', '\xa1', '\xba', '\xd1', '\xee', '\xba', '\xa9', '\x4b', '\xc7', '\xa1', '\xba', '\xd1', '\xee', '\xba', '\xa9', '\x4b',
'\xaf', '\x20', '\xfa', '\xf6', '\x6a', '\xa4', '\xdc', '\xb8', '\xaf', '\x20', '\xfa', '\xf6', '\x6a', '\xa4', '\xdc', '\xb8',
}; };
// Sizes in bytes of various things in the COFF format. // Sizes in bytes of various things in the COFF format.
enum { enum {
HeaderSize = 20, Header16Size = 20,
Header32Size = 56,
NameSize = 8, NameSize = 8,
SymbolSize = 18, Symbol16Size = 18,
Symbol32Size = 20,
SectionSize = 40, SectionSize = 40,
RelocationSize = 10 RelocationSize = 10
}; };
struct header { struct header {
uint16_t Machine; uint16_t Machine;
uint16_t NumberOfSections; int32_t NumberOfSections;
uint32_t TimeDateStamp; uint32_t TimeDateStamp;
uint32_t PointerToSymbolTable; uint32_t PointerToSymbolTable;
uint32_t NumberOfSymbols; uint32_t NumberOfSymbols;
uint16_t SizeOfOptionalHeader; uint16_t SizeOfOptionalHeader;
uint16_t Characteristics; uint16_t Characteristics;
}; };
struct BigObjHeader { struct BigObjHeader {
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines enum Characteristics {
/// Big endian: the MSB precedes the LSB in memory. This is deprecated /// Big endian: the MSB precedes the LSB in memory. This is deprecated
/// and should be 0. /// and should be 0.
IMAGE_FILE_BYTES_REVERSED_HI = 0x8000 IMAGE_FILE_BYTES_REVERSED_HI = 0x8000
}; };
struct symbol { struct symbol {
char Name[NameSize]; char Name[NameSize];
uint32_t Value; uint32_t Value;
uint16_t SectionNumber; int32_t SectionNumber;
uint16_t Type; uint16_t Type;
uint8_t StorageClass; uint8_t StorageClass;
uint8_t NumberOfAuxSymbols; uint8_t NumberOfAuxSymbols;
}; };
enum SymbolFlags { enum SymbolFlags {
SF_TypeMask = 0x0000FFFF, SF_TypeMask = 0x0000FFFF,
SF_TypeShift = 0, SF_TypeShift = 0,
▲ Show 20 Lines • Show All 226 Lines • ▼ Show 20 Linesnamespace COFF {
/// These are not documented in the spec, but are located in WinNT.h. /// These are not documented in the spec, but are located in WinNT.h.
enum WeakExternalCharacteristics { enum WeakExternalCharacteristics {
IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY = 1, IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY = 1,
IMAGE_WEAK_EXTERN_SEARCH_LIBRARY = 2, IMAGE_WEAK_EXTERN_SEARCH_LIBRARY = 2,
IMAGE_WEAK_EXTERN_SEARCH_ALIAS = 3 IMAGE_WEAK_EXTERN_SEARCH_ALIAS = 3
}; };
struct AuxiliaryFile {
uint8_t FileName[18];
};
struct AuxiliarySectionDefinition { struct AuxiliarySectionDefinition {
uint32_t Length; uint32_t Length;
uint16_t NumberOfRelocations; uint16_t NumberOfRelocations;
uint16_t NumberOfLinenumbers; uint16_t NumberOfLinenumbers;
uint32_t CheckSum; uint32_t CheckSum;
uint16_t Number; uint32_t Number;
uint8_t Selection; uint8_t Selection;
char unused[3]; char unused;
}; };
struct AuxiliaryCLRToken { struct AuxiliaryCLRToken {
uint8_t AuxType; uint8_t AuxType;
uint8_t unused1; uint8_t unused1;
uint32_t SymbolTableIndex; uint32_t SymbolTableIndex;
char unused2[12]; char unused2[12];
}; };
union Auxiliary { union Auxiliary {
AuxiliaryFunctionDefinition FunctionDefinition; AuxiliaryFunctionDefinition FunctionDefinition;
AuxiliarybfAndefSymbol bfAndefSymbol; AuxiliarybfAndefSymbol bfAndefSymbol;
AuxiliaryWeakExternal WeakExternal; AuxiliaryWeakExternal WeakExternal;
AuxiliaryFile File;
AuxiliarySectionDefinition SectionDefinition; AuxiliarySectionDefinition SectionDefinition;
}; };
/// @brief The Import Directory Table. /// @brief The Import Directory Table.
/// ///
/// There is a single array of these and one entry per imported DLL. /// There is a single array of these and one entry per imported DLL.
struct ImportDirectoryTableEntry { struct ImportDirectoryTableEntry {
uint32_t ImportLookupTableRVA; uint32_t ImportLookupTableRVA;
▲ Show 20 Lines • Show All 254 Lines • Show Last 20 Lines

llvm/trunk/lib/MC/WinCOFFObjectWriter.cpp

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Linespublic:
AuxiliarySymbols Aux; AuxiliarySymbols Aux;
COFFSymbol *Other; COFFSymbol *Other;
COFFSection *Section; COFFSection *Section;
int Relocations; int Relocations;
MCSymbolData const *MCData; MCSymbolData const *MCData;
COFFSymbol(StringRef name); COFFSymbol(StringRef name);
size_t size() const;
void set_name_offset(uint32_t Offset); void set_name_offset(uint32_t Offset);
bool should_keep() const; bool should_keep() const;
}; };
// This class contains staging data for a COFF relocation entry. // This class contains staging data for a COFF relocation entry.
struct COFFRelocation { struct COFFRelocation {
COFF::relocation Data; COFF::relocation Data;
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linespublic:
sections Sections; sections Sections;
symbols Symbols; symbols Symbols;
StringTable Strings; StringTable Strings;
// Maps used during object file creation. // Maps used during object file creation.
section_map SectionMap; section_map SectionMap;
symbol_map SymbolMap; symbol_map SymbolMap;
bool UseBigObj;
WinCOFFObjectWriter(MCWinCOFFObjectTargetWriter *MOTW, raw_ostream &OS); WinCOFFObjectWriter(MCWinCOFFObjectTargetWriter *MOTW, raw_ostream &OS);
COFFSymbol *createSymbol(StringRef Name); COFFSymbol *createSymbol(StringRef Name);
COFFSymbol *GetOrCreateCOFFSymbol(const MCSymbol * Symbol); COFFSymbol *GetOrCreateCOFFSymbol(const MCSymbol * Symbol);
COFFSection *createSection(StringRef Name); COFFSection *createSection(StringRef Name);
template <typename object_t, typename list_t> template <typename object_t, typename list_t>
object_t *createCOFFEntity(StringRef Name, list_t &List); object_t *createCOFFEntity(StringRef Name, list_t &List);
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 LinesCOFFSymbol::COFFSymbol(StringRef name)
: Name(name.begin(), name.end()) : Name(name.begin(), name.end())
, Other(nullptr) , Other(nullptr)
, Section(nullptr) , Section(nullptr)
, Relocations(0) , Relocations(0)
, MCData(nullptr) { , MCData(nullptr) {
memset(&Data, 0, sizeof(Data)); memset(&Data, 0, sizeof(Data));
} }
size_t COFFSymbol::size() const {
return COFF::SymbolSize + (Data.NumberOfAuxSymbols * COFF::SymbolSize);
}
// In the case that the name does not fit within 8 bytes, the offset // In the case that the name does not fit within 8 bytes, the offset
// into the string table is stored in the last 4 bytes instead, leaving // into the string table is stored in the last 4 bytes instead, leaving
// the first 4 bytes as 0. // the first 4 bytes as 0.
void COFFSymbol::set_name_offset(uint32_t Offset) { void COFFSymbol::set_name_offset(uint32_t Offset) {
write_uint32_le(Data.Name + 0, 0); write_uint32_le(Data.Name + 0, 0);
write_uint32_le(Data.Name + 4, Offset); write_uint32_le(Data.Name + 4, Offset);
} }
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Linessize_t StringTable::insert(StringRef String) {
return Offset; return Offset;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// WinCOFFObjectWriter class implementation // WinCOFFObjectWriter class implementation
WinCOFFObjectWriter::WinCOFFObjectWriter(MCWinCOFFObjectTargetWriter *MOTW, WinCOFFObjectWriter::WinCOFFObjectWriter(MCWinCOFFObjectTargetWriter *MOTW,
raw_ostream &OS) raw_ostream &OS)
: MCObjectWriter(OS, true) : MCObjectWriter(OS, true), TargetObjectWriter(MOTW) {
, TargetObjectWriter(MOTW) {
memset(&Header, 0, sizeof(Header)); memset(&Header, 0, sizeof(Header));
Header.Machine = TargetObjectWriter->getMachine(); Header.Machine = TargetObjectWriter->getMachine();
} }
COFFSymbol *WinCOFFObjectWriter::createSymbol(StringRef Name) { COFFSymbol *WinCOFFObjectWriter::createSymbol(StringRef Name) {
return createCOFFEntity<COFFSymbol>(Name, Symbols); return createCOFFEntity<COFFSymbol>(Name, Symbols);
} }
▲ Show 20 Lines • Show All 259 Lines • ▼ Show 20 Linesbool WinCOFFObjectWriter::IsPhysicalSection(COFFSection *S) {
return (S->Header.Characteristics return (S->Header.Characteristics
& COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA) == 0; & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA) == 0;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// entity writing methods // entity writing methods
void WinCOFFObjectWriter::WriteFileHeader(const COFF::header &Header) { void WinCOFFObjectWriter::WriteFileHeader(const COFF::header &Header) {
if (UseBigObj) {
WriteLE16(COFF::IMAGE_FILE_MACHINE_UNKNOWN);
WriteLE16(0xFFFF);
WriteLE16(COFF::BigObjHeader::MinBigObjectVersion);
WriteLE16(Header.Machine); WriteLE16(Header.Machine);
WriteLE16(Header.NumberOfSections); WriteLE32(Header.TimeDateStamp);
for (uint8_t MagicChar : COFF::BigObjMagic)
Write8(MagicChar);
WriteZeros(sizeof(COFF::BigObjHeader::unused1));
WriteZeros(sizeof(COFF::BigObjHeader::unused2));
WriteZeros(sizeof(COFF::BigObjHeader::unused3));
WriteZeros(sizeof(COFF::BigObjHeader::unused4));
WriteLE32(Header.NumberOfSections);
WriteLE32(Header.PointerToSymbolTable);
WriteLE32(Header.NumberOfSymbols);
} else {
WriteLE16(Header.Machine);
WriteLE16(static_cast<int16_t>(Header.NumberOfSections));
WriteLE32(Header.TimeDateStamp); WriteLE32(Header.TimeDateStamp);
WriteLE32(Header.PointerToSymbolTable); WriteLE32(Header.PointerToSymbolTable);
WriteLE32(Header.NumberOfSymbols); WriteLE32(Header.NumberOfSymbols);
WriteLE16(Header.SizeOfOptionalHeader); WriteLE16(Header.SizeOfOptionalHeader);
WriteLE16(Header.Characteristics); WriteLE16(Header.Characteristics);
} }
}
void WinCOFFObjectWriter::WriteSymbol(const COFFSymbol &S) { void WinCOFFObjectWriter::WriteSymbol(const COFFSymbol &S) {
WriteBytes(StringRef(S.Data.Name, COFF::NameSize)); WriteBytes(StringRef(S.Data.Name, COFF::NameSize));
WriteLE32(S.Data.Value); WriteLE32(S.Data.Value);
WriteLE16(S.Data.SectionNumber); if (UseBigObj)
WriteLE32(S.Data.SectionNumber);
else
WriteLE16(static_cast<int16_t>(S.Data.SectionNumber));
WriteLE16(S.Data.Type); WriteLE16(S.Data.Type);
Write8(S.Data.StorageClass); Write8(S.Data.StorageClass);
Write8(S.Data.NumberOfAuxSymbols); Write8(S.Data.NumberOfAuxSymbols);
WriteAuxiliarySymbols(S.Aux); WriteAuxiliarySymbols(S.Aux);
} }
void WinCOFFObjectWriter::WriteAuxiliarySymbols( void WinCOFFObjectWriter::WriteAuxiliarySymbols(
const COFFSymbol::AuxiliarySymbols &S) { const COFFSymbol::AuxiliarySymbols &S) {
for(COFFSymbol::AuxiliarySymbols::const_iterator i = S.begin(), e = S.end(); for(COFFSymbol::AuxiliarySymbols::const_iterator i = S.begin(), e = S.end();
i != e; ++i) { i != e; ++i) {
switch(i->AuxType) { switch(i->AuxType) {
case ATFunctionDefinition: case ATFunctionDefinition:
WriteLE32(i->Aux.FunctionDefinition.TagIndex); WriteLE32(i->Aux.FunctionDefinition.TagIndex);
WriteLE32(i->Aux.FunctionDefinition.TotalSize); WriteLE32(i->Aux.FunctionDefinition.TotalSize);
WriteLE32(i->Aux.FunctionDefinition.PointerToLinenumber); WriteLE32(i->Aux.FunctionDefinition.PointerToLinenumber);
WriteLE32(i->Aux.FunctionDefinition.PointerToNextFunction); WriteLE32(i->Aux.FunctionDefinition.PointerToNextFunction);
WriteZeros(sizeof(i->Aux.FunctionDefinition.unused)); WriteZeros(sizeof(i->Aux.FunctionDefinition.unused));
if (UseBigObj)
WriteZeros(COFF::Symbol32Size - COFF::Symbol16Size);
break; break;
case ATbfAndefSymbol: case ATbfAndefSymbol:
WriteZeros(sizeof(i->Aux.bfAndefSymbol.unused1)); WriteZeros(sizeof(i->Aux.bfAndefSymbol.unused1));
WriteLE16(i->Aux.bfAndefSymbol.Linenumber); WriteLE16(i->Aux.bfAndefSymbol.Linenumber);
WriteZeros(sizeof(i->Aux.bfAndefSymbol.unused2)); WriteZeros(sizeof(i->Aux.bfAndefSymbol.unused2));
WriteLE32(i->Aux.bfAndefSymbol.PointerToNextFunction); WriteLE32(i->Aux.bfAndefSymbol.PointerToNextFunction);
WriteZeros(sizeof(i->Aux.bfAndefSymbol.unused3)); WriteZeros(sizeof(i->Aux.bfAndefSymbol.unused3));
if (UseBigObj)
WriteZeros(COFF::Symbol32Size - COFF::Symbol16Size);
break; break;
case ATWeakExternal: case ATWeakExternal:
WriteLE32(i->Aux.WeakExternal.TagIndex); WriteLE32(i->Aux.WeakExternal.TagIndex);
WriteLE32(i->Aux.WeakExternal.Characteristics); WriteLE32(i->Aux.WeakExternal.Characteristics);
WriteZeros(sizeof(i->Aux.WeakExternal.unused)); WriteZeros(sizeof(i->Aux.WeakExternal.unused));
if (UseBigObj)
WriteZeros(COFF::Symbol32Size - COFF::Symbol16Size);
break; break;
case ATFile: case ATFile:
WriteBytes(StringRef(reinterpret_cast<const char *>(i->Aux.File.FileName), WriteBytes(
sizeof(i->Aux.File.FileName))); StringRef(reinterpret_cast<const char *>(&i->Aux),
UseBigObj ? COFF::Symbol32Size : COFF::Symbol16Size));
break; break;
case ATSectionDefinition: case ATSectionDefinition:
WriteLE32(i->Aux.SectionDefinition.Length); WriteLE32(i->Aux.SectionDefinition.Length);
WriteLE16(i->Aux.SectionDefinition.NumberOfRelocations); WriteLE16(i->Aux.SectionDefinition.NumberOfRelocations);
WriteLE16(i->Aux.SectionDefinition.NumberOfLinenumbers); WriteLE16(i->Aux.SectionDefinition.NumberOfLinenumbers);
WriteLE32(i->Aux.SectionDefinition.CheckSum); WriteLE32(i->Aux.SectionDefinition.CheckSum);
WriteLE16(i->Aux.SectionDefinition.Number); WriteLE16(static_cast<int16_t>(i->Aux.SectionDefinition.Number));
Write8(i->Aux.SectionDefinition.Selection); Write8(i->Aux.SectionDefinition.Selection);
WriteZeros(sizeof(i->Aux.SectionDefinition.unused)); WriteZeros(sizeof(i->Aux.SectionDefinition.unused));
WriteLE16(static_cast<int16_t>(i->Aux.SectionDefinition.Number >> 16));
if (UseBigObj)
WriteZeros(COFF::Symbol32Size - COFF::Symbol16Size);
break; break;
} }
} }
} }
void WinCOFFObjectWriter::WriteSectionHeader(const COFF::section &S) { void WinCOFFObjectWriter::WriteSectionHeader(const COFF::section &S) {
WriteBytes(StringRef(S.Name, COFF::NameSize)); WriteBytes(StringRef(S.Name, COFF::NameSize));
Show All 16 Lines
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// MCObjectWriter interface implementations // MCObjectWriter interface implementations
void WinCOFFObjectWriter::ExecutePostLayoutBinding(MCAssembler &Asm, void WinCOFFObjectWriter::ExecutePostLayoutBinding(MCAssembler &Asm,
const MCAsmLayout &Layout) { const MCAsmLayout &Layout) {
// "Define" each section & symbol. This creates section & symbol // "Define" each section & symbol. This creates section & symbol
// entries in the staging area. // entries in the staging area.
static_assert(sizeof(((COFF::AuxiliaryFile *)nullptr)->FileName) == COFF::SymbolSize,
"size mismatch for COFF::AuxiliaryFile::FileName");
for (auto FI = Asm.file_names_begin(), FE = Asm.file_names_end();
FI != FE; ++FI) {
// round up to calculate the number of auxiliary symbols required
unsigned Count = (FI->size() + COFF::SymbolSize - 1) / COFF::SymbolSize;
COFFSymbol *file = createSymbol(".file");
file->Data.SectionNumber = COFF::IMAGE_SYM_DEBUG;
file->Data.StorageClass = COFF::IMAGE_SYM_CLASS_FILE;
file->Aux.resize(Count);
unsigned Offset = 0;
unsigned Length = FI->size();
for (auto & Aux : file->Aux) {
Aux.AuxType = ATFile;
if (Length > COFF::SymbolSize) {
memcpy(Aux.Aux.File.FileName, FI->c_str() + Offset, COFF::SymbolSize);
Length = Length - COFF::SymbolSize;
} else {
memcpy(Aux.Aux.File.FileName, FI->c_str() + Offset, Length);
memset(&Aux.Aux.File.FileName[Length], 0, COFF::SymbolSize - Length);
Length = 0;
}
Offset = Offset + COFF::SymbolSize;
}
}
for (const auto & Section : Asm) for (const auto & Section : Asm)
DefineSection(Section); DefineSection(Section);
for (MCSymbolData &SD : Asm.symbols()) for (MCSymbolData &SD : Asm.symbols())
if (ExportSymbol(SD.getSymbol(), Asm)) if (ExportSymbol(SD.getSymbol(), Asm))
DefineSymbol(SD, Asm, Layout); DefineSymbol(SD, Asm, Layout);
} }
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 Linesvoid WinCOFFObjectWriter::RecordRelocation(const MCAssembler &Asm,
} }
if (TargetObjectWriter->recordRelocation(Fixup)) if (TargetObjectWriter->recordRelocation(Fixup))
coff_section->Relocations.push_back(Reloc); coff_section->Relocations.push_back(Reloc);
} }
void WinCOFFObjectWriter::WriteObject(MCAssembler &Asm, void WinCOFFObjectWriter::WriteObject(MCAssembler &Asm,
const MCAsmLayout &Layout) { const MCAsmLayout &Layout) {
size_t SectionsSize = Sections.size();
if (SectionsSize > static_cast<size_t>(INT32_MAX))
report_fatal_error(
"PE COFF object files can't have more than 2147483647 sections");
// Assign symbol and section indexes and offsets. // Assign symbol and section indexes and offsets.
size_t NumberOfSections = 0; int32_t NumberOfSections = static_cast<int32_t>(SectionsSize);
DenseMap<COFFSection *, uint16_t> SectionIndices; UseBigObj = NumberOfSections > COFF::MaxNumberOfSections16;
DenseMap<COFFSection *, int32_t> SectionIndices(
NextPowerOf2(NumberOfSections));
size_t Number = 1;
for (const auto &Section : Sections) { for (const auto &Section : Sections) {
size_t Number = ++NumberOfSections; SectionIndices[Section.get()] = Number;
SectionIndices[Section.get()] = static_cast<uint16_t>(Number);
MakeSectionReal(*Section, Number); MakeSectionReal(*Section, Number);
++Number;
} }
if (NumberOfSections > static_cast<size_t>(COFF::MaxNumberOfSections16)) Header.NumberOfSections = NumberOfSections;
report_fatal_error(
"PE COFF object files can't have more than 65,299 sections");
Header.NumberOfSections = static_cast<uint16_t>(NumberOfSections);
Header.NumberOfSymbols = 0; Header.NumberOfSymbols = 0;
for (auto FI = Asm.file_names_begin(), FE = Asm.file_names_end();
FI != FE; ++FI) {
// round up to calculate the number of auxiliary symbols required
unsigned SymbolSize = UseBigObj ? COFF::Symbol32Size : COFF::Symbol16Size;
unsigned Count = (FI->size() + SymbolSize - 1) / SymbolSize;
COFFSymbol *file = createSymbol(".file");
file->Data.SectionNumber = COFF::IMAGE_SYM_DEBUG;
file->Data.StorageClass = COFF::IMAGE_SYM_CLASS_FILE;
file->Aux.resize(Count);
unsigned Offset = 0;
unsigned Length = FI->size();
for (auto & Aux : file->Aux) {
Aux.AuxType = ATFile;
if (Length > SymbolSize) {
memcpy(&Aux.Aux, FI->c_str() + Offset, SymbolSize);
Length = Length - SymbolSize;
} else {
memcpy(&Aux.Aux, FI->c_str() + Offset, Length);
memset((char *)&Aux.Aux + Length, 0, SymbolSize - Length);
break;
}
Offset += SymbolSize;
}
}
for (auto &Symbol : Symbols) { for (auto &Symbol : Symbols) {
// Update section number & offset for symbols that have them. // Update section number & offset for symbols that have them.
if (Symbol->Section) if (Symbol->Section)
Symbol->Data.SectionNumber = Symbol->Section->Number; Symbol->Data.SectionNumber = Symbol->Section->Number;
if (Symbol->should_keep()) { if (Symbol->should_keep()) {
MakeSymbolReal(*Symbol, Header.NumberOfSymbols++); MakeSymbolReal(*Symbol, Header.NumberOfSymbols++);
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines for (auto & Section : Sections) {
Section->Symbol->Aux[0].Aux.SectionDefinition.Number = SectionIndices[Assoc]; Section->Symbol->Aux[0].Aux.SectionDefinition.Number = SectionIndices[Assoc];
} }
// Assign file offsets to COFF object file structures. // Assign file offsets to COFF object file structures.
unsigned offset = 0; unsigned offset = 0;
offset += COFF::HeaderSize; if (UseBigObj)
offset += COFF::Header32Size;
else
offset += COFF::Header16Size;
offset += COFF::SectionSize * Header.NumberOfSections; offset += COFF::SectionSize * Header.NumberOfSections;
for (const auto & Section : Asm) { for (const auto & Section : Asm) {
COFFSection *Sec = SectionMap[&Section.getSection()]; COFFSection *Sec = SectionMap[&Section.getSection()];
if (Sec->Number == -1) if (Sec->Number == -1)
continue; continue;
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

llvm/trunk/tools/llvm-objdump/llvm-objdump.cpp

Show First 20 Lines • Show All 585 Lines • ▼ Show 20 Lines outs() << "[" << format("%2d", SI) << "]"
<< Name << "\n"; << Name << "\n";
for (unsigned AI = 0, AE = Symbol->getNumberOfAuxSymbols(); AI < AE; ++AI, ++SI) { for (unsigned AI = 0, AE = Symbol->getNumberOfAuxSymbols(); AI < AE; ++AI, ++SI) {
if (Symbol->isSectionDefinition()) { if (Symbol->isSectionDefinition()) {
const coff_aux_section_definition *asd; const coff_aux_section_definition *asd;
if (error(coff->getAuxSymbol<coff_aux_section_definition>(SI + 1, asd))) if (error(coff->getAuxSymbol<coff_aux_section_definition>(SI + 1, asd)))
return; return;
int32_t AuxNumber = asd->getNumber(Symbol->isBigObj());
outs() << "AUX " outs() << "AUX "
<< format("scnlen 0x%x nreloc %d nlnno %d checksum 0x%x " << format("scnlen 0x%x nreloc %d nlnno %d checksum 0x%x "
, unsigned(asd->Length) , unsigned(asd->Length)
, unsigned(asd->NumberOfRelocations) , unsigned(asd->NumberOfRelocations)
, unsigned(asd->NumberOfLinenumbers) , unsigned(asd->NumberOfLinenumbers)
, unsigned(asd->CheckSum)) , unsigned(asd->CheckSum))
<< format("assoc %d comdat %d\n" << format("assoc %d comdat %d\n"
, unsigned(asd->Number) , unsigned(AuxNumber)
, unsigned(asd->Selection)); , unsigned(asd->Selection));
} else if (Symbol->isFileRecord()) { } else if (Symbol->isFileRecord()) {
const char *FileName; const char *FileName;
if (error(coff->getAuxSymbol<char>(SI + 1, FileName))) if (error(coff->getAuxSymbol<char>(SI + 1, FileName)))
return; return;
StringRef Name(FileName, Symbol->getNumberOfAuxSymbols() * StringRef Name(FileName, Symbol->getNumberOfAuxSymbols() *
coff->getSymbolTableEntrySize()); coff->getSymbolTableEntrySize());
▲ Show 20 Lines • Show All 254 Lines • Show Last 20 Lines

llvm/trunk/tools/llvm-readobj/COFFDumper.cpp

Show First 20 Lines • Show All 784 Lines • ▼ Show 20 Lines if (Symbol.isFunctionDefinition()) {
Obj->getSymbolTableEntrySize()); Obj->getSymbolTableEntrySize());
W.printString("FileName", Name.rtrim(StringRef("\0", 1))); W.printString("FileName", Name.rtrim(StringRef("\0", 1)));
break; break;
} else if (Symbol.isSectionDefinition()) { } else if (Symbol.isSectionDefinition()) {
const coff_aux_section_definition *Aux; const coff_aux_section_definition *Aux;
if (error(getSymbolAuxData(Obj, Symbol, I, Aux))) if (error(getSymbolAuxData(Obj, Symbol, I, Aux)))
break; break;
int32_t AuxNumber = Aux->getNumber(Symbol.isBigObj());
DictScope AS(W, "AuxSectionDef"); DictScope AS(W, "AuxSectionDef");
W.printNumber("Length", Aux->Length); W.printNumber("Length", Aux->Length);
W.printNumber("RelocationCount", Aux->NumberOfRelocations); W.printNumber("RelocationCount", Aux->NumberOfRelocations);
W.printNumber("LineNumberCount", Aux->NumberOfLinenumbers); W.printNumber("LineNumberCount", Aux->NumberOfLinenumbers);
W.printHex("Checksum", Aux->CheckSum); W.printHex("Checksum", Aux->CheckSum);
W.printNumber("Number", Aux->Number); W.printNumber("Number", AuxNumber);
W.printEnum("Selection", Aux->Selection, makeArrayRef(ImageCOMDATSelect)); W.printEnum("Selection", Aux->Selection, makeArrayRef(ImageCOMDATSelect));
if (Section && Section->Characteristics & COFF::IMAGE_SCN_LNK_COMDAT if (Section && Section->Characteristics & COFF::IMAGE_SCN_LNK_COMDAT
&& Aux->Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) { && Aux->Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) {
const coff_section *Assoc; const coff_section *Assoc;
StringRef AssocName; StringRef AssocName;
std::error_code EC; std::error_code EC;
if ((EC = Obj->getSection(Aux->Number, Assoc)) || if ((EC = Obj->getSection(AuxNumber, Assoc)) ||
(EC = Obj->getSectionName(Assoc, AssocName))) { (EC = Obj->getSectionName(Assoc, AssocName))) {
AssocName = ""; AssocName = "";
error(EC); error(EC);
} }
W.printNumber("AssocSection", AssocName, Aux->Number); W.printNumber("AssocSection", AssocName, AuxNumber);
} }
} else if (Symbol.isCLRToken()) { } else if (Symbol.isCLRToken()) {
const coff_aux_clr_token *Aux; const coff_aux_clr_token *Aux;
if (error(getSymbolAuxData(Obj, Symbol, I, Aux))) if (error(getSymbolAuxData(Obj, Symbol, I, Aux)))
break; break;
ErrorOr<COFFSymbolRef> ReferredSym = ErrorOr<COFFSymbolRef> ReferredSym =
Obj->getSymbol(Aux->SymbolTableIndex); Obj->getSymbol(Aux->SymbolTableIndex);
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/trunk/tools/obj2yaml/coff2yaml.cpp

Show First 20 Lines • Show All 98 Lines • ▼ Show 20 Linesstatic void dumpWeakExternal(COFFYAML::Symbol *Sym,
YAMLWE.TagIndex = ObjWE->TagIndex; YAMLWE.TagIndex = ObjWE->TagIndex;
YAMLWE.Characteristics = ObjWE->Characteristics; YAMLWE.Characteristics = ObjWE->Characteristics;
Sym->WeakExternal = YAMLWE; Sym->WeakExternal = YAMLWE;
} }
static void static void
dumpSectionDefinition(COFFYAML::Symbol *Sym, dumpSectionDefinition(COFFYAML::Symbol *Sym,
const object::coff_aux_section_definition *ObjSD) { const object::coff_aux_section_definition *ObjSD,
bool IsBigObj) {
COFF::AuxiliarySectionDefinition YAMLASD; COFF::AuxiliarySectionDefinition YAMLASD;
int32_t AuxNumber = ObjSD->getNumber(IsBigObj);
YAMLASD.Length = ObjSD->Length; YAMLASD.Length = ObjSD->Length;
YAMLASD.NumberOfRelocations = ObjSD->NumberOfRelocations; YAMLASD.NumberOfRelocations = ObjSD->NumberOfRelocations;
YAMLASD.NumberOfLinenumbers = ObjSD->NumberOfLinenumbers; YAMLASD.NumberOfLinenumbers = ObjSD->NumberOfLinenumbers;
YAMLASD.CheckSum = ObjSD->CheckSum; YAMLASD.CheckSum = ObjSD->CheckSum;
YAMLASD.Number = ObjSD->Number; YAMLASD.Number = AuxNumber;
YAMLASD.Selection = ObjSD->Selection; YAMLASD.Selection = ObjSD->Selection;
Sym->SectionDefinition = YAMLASD; Sym->SectionDefinition = YAMLASD;
} }
static void static void
dumpCLRTokenDefinition(COFFYAML::Symbol *Sym, dumpCLRTokenDefinition(COFFYAML::Symbol *Sym,
const object::coff_aux_clr_token *ObjCLRToken) { const object::coff_aux_clr_token *ObjCLRToken) {
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines if (Symbol.getNumberOfAuxSymbols() > 0) {
} else if (Symbol.isSectionDefinition()) { } else if (Symbol.isSectionDefinition()) {
// This symbol represents a section definition. // This symbol represents a section definition.
assert(Symbol.getNumberOfAuxSymbols() == 1 && assert(Symbol.getNumberOfAuxSymbols() == 1 &&
"Expected a single aux symbol to describe this section!"); "Expected a single aux symbol to describe this section!");
const object::coff_aux_section_definition *ObjSD = const object::coff_aux_section_definition *ObjSD =
reinterpret_cast<const object::coff_aux_section_definition *>( reinterpret_cast<const object::coff_aux_section_definition *>(
AuxData.data()); AuxData.data());
dumpSectionDefinition(&Sym, ObjSD); dumpSectionDefinition(&Sym, ObjSD, Symbol.isBigObj());
} else if (Symbol.isCLRToken()) { } else if (Symbol.isCLRToken()) {
// This symbol represents a CLR token definition. // This symbol represents a CLR token definition.
assert(Symbol.getNumberOfAuxSymbols() == 1 && assert(Symbol.getNumberOfAuxSymbols() == 1 &&
"Expected a single aux symbol to describe this CLR Token!"); "Expected a single aux symbol to describe this CLR Token!");
const object::coff_aux_clr_token *ObjCLRToken = const object::coff_aux_clr_token *ObjCLRToken =
reinterpret_cast<const object::coff_aux_clr_token *>( reinterpret_cast<const object::coff_aux_clr_token *>(
AuxData.data()); AuxData.data());
Show All 21 Lines

llvm/trunk/tools/yaml2obj/yaml2coff.cpp

Show First 20 Lines • Show All 115 Lines • ▼ Show 20 Lines
// Take a CP and assign addresses and sizes to everything. Returns false if the // Take a CP and assign addresses and sizes to everything. Returns false if the
// layout is not valid to do. // layout is not valid to do.
static bool layoutCOFF(COFFParser &CP) { static bool layoutCOFF(COFFParser &CP) {
uint32_t SectionTableStart = 0; uint32_t SectionTableStart = 0;
uint32_t SectionTableSize = 0; uint32_t SectionTableSize = 0;
// The section table starts immediately after the header, including the // The section table starts immediately after the header, including the
// optional header. // optional header.
SectionTableStart = sizeof(COFF::header) + CP.Obj.Header.SizeOfOptionalHeader; SectionTableStart = COFF::Header16Size + CP.Obj.Header.SizeOfOptionalHeader;
SectionTableSize = sizeof(COFF::section) * CP.Obj.Sections.size(); SectionTableSize = COFF::SectionSize * CP.Obj.Sections.size();
uint32_t CurrentSectionDataOffset = SectionTableStart + SectionTableSize; uint32_t CurrentSectionDataOffset = SectionTableStart + SectionTableSize;
// Assign each section data address consecutively. // Assign each section data address consecutively.
for (std::vector<COFFYAML::Section>::iterator i = CP.Obj.Sections.begin(), for (std::vector<COFFYAML::Section>::iterator i = CP.Obj.Sections.begin(),
e = CP.Obj.Sections.end(); e = CP.Obj.Sections.end();
i != e; ++i) { i != e; ++i) {
if (i->SectionData.binary_size() > 0) { if (i->SectionData.binary_size() > 0) {
Show All 24 Lines for (std::vector<COFFYAML::Symbol>::iterator i = CP.Obj.Symbols.begin(),
if (i->FunctionDefinition) if (i->FunctionDefinition)
NumberOfAuxSymbols += 1; NumberOfAuxSymbols += 1;
if (i->bfAndefSymbol) if (i->bfAndefSymbol)
NumberOfAuxSymbols += 1; NumberOfAuxSymbols += 1;
if (i->WeakExternal) if (i->WeakExternal)
NumberOfAuxSymbols += 1; NumberOfAuxSymbols += 1;
if (!i->File.empty()) if (!i->File.empty())
NumberOfAuxSymbols += NumberOfAuxSymbols +=
(i->File.size() + COFF::SymbolSize - 1) / COFF::SymbolSize; (i->File.size() + COFF::Symbol16Size - 1) / COFF::Symbol16Size;
if (i->SectionDefinition) if (i->SectionDefinition)
NumberOfAuxSymbols += 1; NumberOfAuxSymbols += 1;
if (i->CLRToken) if (i->CLRToken)
NumberOfAuxSymbols += 1; NumberOfAuxSymbols += 1;
i->Header.NumberOfAuxSymbols = NumberOfAuxSymbols; i->Header.NumberOfAuxSymbols = NumberOfAuxSymbols;
NumberOfSymbols += 1 + NumberOfAuxSymbols; NumberOfSymbols += 1 + NumberOfAuxSymbols;
} }
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
template <typename T> template <typename T>
zeros_impl<sizeof(T)> zeros(const T &) { zeros_impl<sizeof(T)> zeros(const T &) {
return zeros_impl<sizeof(T)>(); return zeros_impl<sizeof(T)>();
} }
bool writeCOFF(COFFParser &CP, raw_ostream &OS) { bool writeCOFF(COFFParser &CP, raw_ostream &OS) {
OS << binary_le(CP.Obj.Header.Machine) OS << binary_le(CP.Obj.Header.Machine)
<< binary_le(CP.Obj.Header.NumberOfSections) << binary_le(static_cast<int16_t>(CP.Obj.Header.NumberOfSections))
<< binary_le(CP.Obj.Header.TimeDateStamp) << binary_le(CP.Obj.Header.TimeDateStamp)
<< binary_le(CP.Obj.Header.PointerToSymbolTable) << binary_le(CP.Obj.Header.PointerToSymbolTable)
<< binary_le(CP.Obj.Header.NumberOfSymbols) << binary_le(CP.Obj.Header.NumberOfSymbols)
<< binary_le(CP.Obj.Header.SizeOfOptionalHeader) << binary_le(CP.Obj.Header.SizeOfOptionalHeader)
<< binary_le(CP.Obj.Header.Characteristics); << binary_le(CP.Obj.Header.Characteristics);
// Output section table. // Output section table.
for (std::vector<COFFYAML::Section>::iterator i = CP.Obj.Sections.begin(), for (std::vector<COFFYAML::Section>::iterator i = CP.Obj.Sections.begin(),
Show All 36 Linesbool writeCOFF(COFFParser &CP, raw_ostream &OS) {
// Output symbol table. // Output symbol table.
for (std::vector<COFFYAML::Symbol>::const_iterator i = CP.Obj.Symbols.begin(), for (std::vector<COFFYAML::Symbol>::const_iterator i = CP.Obj.Symbols.begin(),
e = CP.Obj.Symbols.end(); e = CP.Obj.Symbols.end();
i != e; ++i) { i != e; ++i) {
OS.write(i->Header.Name, COFF::NameSize); OS.write(i->Header.Name, COFF::NameSize);
OS << binary_le(i->Header.Value) OS << binary_le(i->Header.Value)
<< binary_le(i->Header.SectionNumber) << binary_le(static_cast<int16_t>(i->Header.SectionNumber))
<< binary_le(i->Header.Type) << binary_le(i->Header.Type)
<< binary_le(i->Header.StorageClass) << binary_le(i->Header.StorageClass)
<< binary_le(i->Header.NumberOfAuxSymbols); << binary_le(i->Header.NumberOfAuxSymbols);
if (i->FunctionDefinition) if (i->FunctionDefinition)
OS << binary_le(i->FunctionDefinition->TagIndex) OS << binary_le(i->FunctionDefinition->TagIndex)
<< binary_le(i->FunctionDefinition->TotalSize) << binary_le(i->FunctionDefinition->TotalSize)
<< binary_le(i->FunctionDefinition->PointerToLinenumber) << binary_le(i->FunctionDefinition->PointerToLinenumber)
<< binary_le(i->FunctionDefinition->PointerToNextFunction) << binary_le(i->FunctionDefinition->PointerToNextFunction)
<< zeros(i->FunctionDefinition->unused); << zeros(i->FunctionDefinition->unused);
if (i->bfAndefSymbol) if (i->bfAndefSymbol)
OS << zeros(i->bfAndefSymbol->unused1) OS << zeros(i->bfAndefSymbol->unused1)
<< binary_le(i->bfAndefSymbol->Linenumber) << binary_le(i->bfAndefSymbol->Linenumber)
<< zeros(i->bfAndefSymbol->unused2) << zeros(i->bfAndefSymbol->unused2)
<< binary_le(i->bfAndefSymbol->PointerToNextFunction) << binary_le(i->bfAndefSymbol->PointerToNextFunction)
<< zeros(i->bfAndefSymbol->unused3); << zeros(i->bfAndefSymbol->unused3);
if (i->WeakExternal) if (i->WeakExternal)
OS << binary_le(i->WeakExternal->TagIndex) OS << binary_le(i->WeakExternal->TagIndex)
<< binary_le(i->WeakExternal->Characteristics) << binary_le(i->WeakExternal->Characteristics)
<< zeros(i->WeakExternal->unused); << zeros(i->WeakExternal->unused);
if (!i->File.empty()) { if (!i->File.empty()) {
uint32_t NumberOfAuxRecords = uint32_t NumberOfAuxRecords =
(i->File.size() + COFF::SymbolSize - 1) / COFF::SymbolSize; (i->File.size() + COFF::Symbol16Size - 1) / COFF::Symbol16Size;
uint32_t NumberOfAuxBytes = NumberOfAuxRecords * COFF::SymbolSize; uint32_t NumberOfAuxBytes = NumberOfAuxRecords * COFF::Symbol16Size;
uint32_t NumZeros = NumberOfAuxBytes - i->File.size(); uint32_t NumZeros = NumberOfAuxBytes - i->File.size();
OS.write(i->File.data(), i->File.size()); OS.write(i->File.data(), i->File.size());
for (uint32_t Padding = 0; Padding < NumZeros; ++Padding) for (uint32_t Padding = 0; Padding < NumZeros; ++Padding)
OS.write(0); OS.write(0);
} }
if (i->SectionDefinition) if (i->SectionDefinition)
OS << binary_le(i->SectionDefinition->Length) OS << binary_le(i->SectionDefinition->Length)
<< binary_le(i->SectionDefinition->NumberOfRelocations) << binary_le(i->SectionDefinition->NumberOfRelocations)
<< binary_le(i->SectionDefinition->NumberOfLinenumbers) << binary_le(i->SectionDefinition->NumberOfLinenumbers)
<< binary_le(i->SectionDefinition->CheckSum) << binary_le(i->SectionDefinition->CheckSum)
<< binary_le(i->SectionDefinition->Number) << binary_le(static_cast<int16_t>(i->SectionDefinition->Number))
<< binary_le(i->SectionDefinition->Selection) << binary_le(i->SectionDefinition->Selection)
<< zeros(i->SectionDefinition->unused); << zeros(i->SectionDefinition->unused)
<< binary_le(static_cast<int16_t>(i->SectionDefinition->Number >> 16));
if (i->CLRToken) if (i->CLRToken)
OS << binary_le(i->CLRToken->AuxType) OS << binary_le(i->CLRToken->AuxType)
<< zeros(i->CLRToken->unused1) << zeros(i->CLRToken->unused1)
<< binary_le(i->CLRToken->SymbolTableIndex) << binary_le(i->CLRToken->SymbolTableIndex)
<< zeros(i->CLRToken->unused2); << zeros(i->CLRToken->unused2);
} }
// Output string table. // Output string table.
Show All 28 Lines