aboutsummaryrefslogtreecommitdiffstats
path: root/lib/MC/WinCOFFObjectWriter.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'lib/MC/WinCOFFObjectWriter.cpp')
-rw-r--r--lib/MC/WinCOFFObjectWriter.cpp338
1 files changed, 183 insertions, 155 deletions
diff --git a/lib/MC/WinCOFFObjectWriter.cpp b/lib/MC/WinCOFFObjectWriter.cpp
index a462c0d..1046e04 100644
--- a/lib/MC/WinCOFFObjectWriter.cpp
+++ b/lib/MC/WinCOFFObjectWriter.cpp
@@ -26,8 +26,10 @@
#include "llvm/MC/MCSectionCOFF.h"
#include "llvm/MC/MCSymbol.h"
#include "llvm/MC/MCValue.h"
+#include "llvm/MC/StringTableBuilder.h"
#include "llvm/Support/COFF.h"
#include "llvm/Support/Debug.h"
+#include "llvm/Support/Endian.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/TimeValue.h"
#include <cstdio>
@@ -71,7 +73,6 @@ public:
MCSymbolData const *MCData;
COFFSymbol(StringRef name);
- size_t size() const;
void set_name_offset(uint32_t Offset);
bool should_keep() const;
@@ -102,20 +103,6 @@ public:
static size_t size();
};
-// This class holds the COFF string table.
-class StringTable {
- typedef StringMap<size_t> map;
- map Map;
-
- void update_length();
-public:
- std::vector<char> Data;
-
- StringTable();
- size_t size() const;
- size_t insert(StringRef String);
-};
-
class WinCOFFObjectWriter : public MCObjectWriter {
public:
@@ -131,13 +118,26 @@ public:
COFF::header Header;
sections Sections;
symbols Symbols;
- StringTable Strings;
+ StringTableBuilder Strings;
// Maps used during object file creation.
section_map SectionMap;
symbol_map SymbolMap;
+ bool UseBigObj;
+
WinCOFFObjectWriter(MCWinCOFFObjectTargetWriter *MOTW, raw_ostream &OS);
+
+ void reset() override {
+ memset(&Header, 0, sizeof(Header));
+ Header.Machine = TargetObjectWriter->getMachine();
+ Sections.clear();
+ Symbols.clear();
+ Strings.clear();
+ SectionMap.clear();
+ SymbolMap.clear();
+ MCObjectWriter::reset();
+ }
COFFSymbol *createSymbol(StringRef Name);
COFFSymbol *GetOrCreateCOFFSymbol(const MCSymbol * Symbol);
@@ -150,10 +150,10 @@ public:
void DefineSymbol(MCSymbolData const &SymbolData, MCAssembler &Assembler,
const MCAsmLayout &Layout);
- void MakeSymbolReal(COFFSymbol &S, size_t Index);
- void MakeSectionReal(COFFSection &S, size_t Number);
+ void SetSymbolName(COFFSymbol &S);
+ void SetSectionName(COFFSection &S);
- bool ExportSymbol(MCSymbolData const &SymbolData, MCAssembler &Asm);
+ bool ExportSymbol(const MCSymbol &Symbol, MCAssembler &Asm);
bool IsPhysicalSection(COFFSection *S);
@@ -170,6 +170,11 @@ public:
void ExecutePostLayoutBinding(MCAssembler &Asm,
const MCAsmLayout &Layout) override;
+ bool IsSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
+ const MCSymbolData &DataA,
+ const MCFragment &FB, bool InSet,
+ bool IsPCRel) const override;
+
void RecordRelocation(const MCAssembler &Asm, const MCAsmLayout &Layout,
const MCFragment *Fragment, const MCFixup &Fixup,
MCValue Target, bool &IsPCRel,
@@ -179,12 +184,9 @@ public:
};
}
-static inline void write_uint32_le(void *Data, uint32_t const &Value) {
- uint8_t *Ptr = reinterpret_cast<uint8_t *>(Data);
- Ptr[0] = (Value & 0x000000FF) >> 0;
- Ptr[1] = (Value & 0x0000FF00) >> 8;
- Ptr[2] = (Value & 0x00FF0000) >> 16;
- Ptr[3] = (Value & 0xFF000000) >> 24;
+static inline void write_uint32_le(void *Data, uint32_t Value) {
+ support::endian::write<uint32_t, support::little, support::unaligned>(Data,
+ Value);
}
//------------------------------------------------------------------------------
@@ -199,10 +201,6 @@ COFFSymbol::COFFSymbol(StringRef name)
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
// into the string table is stored in the last 4 bytes instead, leaving
// the first 4 bytes as 0.
@@ -254,55 +252,11 @@ size_t COFFSection::size() {
}
//------------------------------------------------------------------------------
-// StringTable class implementation
-
-/// Write the length of the string table into Data.
-/// The length of the string table includes uint32 length header.
-void StringTable::update_length() {
- write_uint32_le(&Data.front(), Data.size());
-}
-
-StringTable::StringTable() {
- // The string table data begins with the length of the entire string table
- // including the length header. Allocate space for this header.
- Data.resize(4);
- update_length();
-}
-
-size_t StringTable::size() const {
- return Data.size();
-}
-
-/// Add String to the table iff it is not already there.
-/// @returns the index into the string table where the string is now located.
-size_t StringTable::insert(StringRef String) {
- map::iterator i = Map.find(String);
-
- if (i != Map.end())
- return i->second;
-
- size_t Offset = Data.size();
-
- // Insert string data into string table.
- Data.insert(Data.end(), String.begin(), String.end());
- Data.push_back('\0');
-
- // Put a reference to it in the map.
- Map[String] = Offset;
-
- // Update the internal length field.
- update_length();
-
- return Offset;
-}
-
-//------------------------------------------------------------------------------
// WinCOFFObjectWriter class implementation
WinCOFFObjectWriter::WinCOFFObjectWriter(MCWinCOFFObjectTargetWriter *MOTW,
raw_ostream &OS)
- : MCObjectWriter(OS, true)
- , TargetObjectWriter(MOTW) {
+ : MCObjectWriter(OS, true), TargetObjectWriter(MOTW) {
memset(&Header, 0, sizeof(Header));
Header.Machine = TargetObjectWriter->getMachine();
@@ -456,19 +410,22 @@ void WinCOFFObjectWriter::DefineSymbol(MCSymbolData const &SymbolData,
// If no storage class was specified in the streamer, define it here.
if (coff_symbol->Data.StorageClass == 0) {
- bool external = ResSymData.isExternal() || !ResSymData.Fragment;
+ bool IsExternal =
+ ResSymData.isExternal() ||
+ (!ResSymData.getFragment() && !ResSymData.getSymbol().isVariable());
- coff_symbol->Data.StorageClass =
- external ? COFF::IMAGE_SYM_CLASS_EXTERNAL : COFF::IMAGE_SYM_CLASS_STATIC;
+ coff_symbol->Data.StorageClass = IsExternal
+ ? COFF::IMAGE_SYM_CLASS_EXTERNAL
+ : COFF::IMAGE_SYM_CLASS_STATIC;
}
if (!Base) {
coff_symbol->Data.SectionNumber = COFF::IMAGE_SYM_ABSOLUTE;
} else {
const MCSymbolData &BaseData = Assembler.getSymbolData(*Base);
- if (BaseData.Fragment) {
+ if (BaseData.getFragment()) {
COFFSection *Sec =
- SectionMap[&BaseData.Fragment->getParent()->getSection()];
+ SectionMap[&BaseData.getFragment()->getParent()->getSection()];
if (coff_symbol->Section && coff_symbol->Section != Sec)
report_fatal_error("conflicting sections for symbol");
@@ -508,11 +465,9 @@ static void encodeBase64StringEntry(char* Buffer, uint64_t Value) {
}
}
-/// making a section real involves assigned it a number and putting
-/// name into the string table if needed
-void WinCOFFObjectWriter::MakeSectionReal(COFFSection &S, size_t Number) {
+void WinCOFFObjectWriter::SetSectionName(COFFSection &S) {
if (S.Name.size() > COFF::NameSize) {
- uint64_t StringTableEntry = Strings.insert(S.Name.c_str());
+ uint64_t StringTableEntry = Strings.getOffset(S.Name);
if (StringTableEntry <= Max6DecimalOffset) {
std::sprintf(S.Header.Name, "/%d", unsigned(StringTableEntry));
@@ -530,32 +485,33 @@ void WinCOFFObjectWriter::MakeSectionReal(COFFSection &S, size_t Number) {
}
} else
std::memcpy(S.Header.Name, S.Name.c_str(), S.Name.size());
-
- S.Number = Number;
- S.Symbol->Data.SectionNumber = S.Number;
- S.Symbol->Aux[0].Aux.SectionDefinition.Number = S.Number;
}
-void WinCOFFObjectWriter::MakeSymbolReal(COFFSymbol &S, size_t Index) {
- if (S.Name.size() > COFF::NameSize) {
- size_t StringTableEntry = Strings.insert(S.Name.c_str());
-
- S.set_name_offset(StringTableEntry);
- } else
+void WinCOFFObjectWriter::SetSymbolName(COFFSymbol &S) {
+ if (S.Name.size() > COFF::NameSize)
+ S.set_name_offset(Strings.getOffset(S.Name));
+ else
std::memcpy(S.Data.Name, S.Name.c_str(), S.Name.size());
- S.Index = Index;
}
-bool WinCOFFObjectWriter::ExportSymbol(MCSymbolData const &SymbolData,
+bool WinCOFFObjectWriter::ExportSymbol(const MCSymbol &Symbol,
MCAssembler &Asm) {
// This doesn't seem to be right. Strings referred to from the .data section
// need symbols so they can be linked to code in the .text section right?
- // return Asm.isSymbolLinkerVisible(SymbolData.getSymbol());
+ // return Asm.isSymbolLinkerVisible(Symbol);
+
+ // Non-temporary labels should always be visible to the linker.
+ if (!Symbol.isTemporary())
+ return true;
+
+ // Absolute temporary labels are never visible.
+ if (!Symbol.isInSection())
+ return false;
// For now, all non-variable symbols are exported,
// the linker will sort the rest out for us.
- return SymbolData.isExternal() || !SymbolData.getSymbol().isVariable();
+ return !Symbol.isVariable();
}
bool WinCOFFObjectWriter::IsPhysicalSection(COFFSection *S) {
@@ -567,19 +523,39 @@ bool WinCOFFObjectWriter::IsPhysicalSection(COFFSection *S) {
// entity writing methods
void WinCOFFObjectWriter::WriteFileHeader(const COFF::header &Header) {
- WriteLE16(Header.Machine);
- WriteLE16(Header.NumberOfSections);
- WriteLE32(Header.TimeDateStamp);
- WriteLE32(Header.PointerToSymbolTable);
- WriteLE32(Header.NumberOfSymbols);
- WriteLE16(Header.SizeOfOptionalHeader);
- WriteLE16(Header.Characteristics);
+ if (UseBigObj) {
+ WriteLE16(COFF::IMAGE_FILE_MACHINE_UNKNOWN);
+ WriteLE16(0xFFFF);
+ WriteLE16(COFF::BigObjHeader::MinBigObjectVersion);
+ WriteLE16(Header.Machine);
+ WriteLE32(Header.TimeDateStamp);
+ for (uint8_t MagicChar : COFF::BigObjMagic)
+ Write8(MagicChar);
+ WriteLE32(0);
+ WriteLE32(0);
+ WriteLE32(0);
+ WriteLE32(0);
+ 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.PointerToSymbolTable);
+ WriteLE32(Header.NumberOfSymbols);
+ WriteLE16(Header.SizeOfOptionalHeader);
+ WriteLE16(Header.Characteristics);
+ }
}
void WinCOFFObjectWriter::WriteSymbol(const COFFSymbol &S) {
WriteBytes(StringRef(S.Data.Name, COFF::NameSize));
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);
Write8(S.Data.StorageClass);
Write8(S.Data.NumberOfAuxSymbols);
@@ -597,6 +573,8 @@ void WinCOFFObjectWriter::WriteAuxiliarySymbols(
WriteLE32(i->Aux.FunctionDefinition.PointerToLinenumber);
WriteLE32(i->Aux.FunctionDefinition.PointerToNextFunction);
WriteZeros(sizeof(i->Aux.FunctionDefinition.unused));
+ if (UseBigObj)
+ WriteZeros(COFF::Symbol32Size - COFF::Symbol16Size);
break;
case ATbfAndefSymbol:
WriteZeros(sizeof(i->Aux.bfAndefSymbol.unused1));
@@ -604,24 +582,32 @@ void WinCOFFObjectWriter::WriteAuxiliarySymbols(
WriteZeros(sizeof(i->Aux.bfAndefSymbol.unused2));
WriteLE32(i->Aux.bfAndefSymbol.PointerToNextFunction);
WriteZeros(sizeof(i->Aux.bfAndefSymbol.unused3));
+ if (UseBigObj)
+ WriteZeros(COFF::Symbol32Size - COFF::Symbol16Size);
break;
case ATWeakExternal:
WriteLE32(i->Aux.WeakExternal.TagIndex);
WriteLE32(i->Aux.WeakExternal.Characteristics);
WriteZeros(sizeof(i->Aux.WeakExternal.unused));
+ if (UseBigObj)
+ WriteZeros(COFF::Symbol32Size - COFF::Symbol16Size);
break;
case ATFile:
- WriteBytes(StringRef(reinterpret_cast<const char *>(i->Aux.File.FileName),
- sizeof(i->Aux.File.FileName)));
+ WriteBytes(
+ StringRef(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(i->Aux.SectionDefinition.Number);
+ 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));
+ if (UseBigObj)
+ WriteZeros(COFF::Symbol32Size - COFF::Symbol16Size);
break;
}
}
@@ -654,45 +640,27 @@ void WinCOFFObjectWriter::ExecutePostLayoutBinding(MCAssembler &Asm,
const MCAsmLayout &Layout) {
// "Define" each section & symbol. This creates section & symbol
// 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)
DefineSection(Section);
for (MCSymbolData &SD : Asm.symbols())
- if (ExportSymbol(SD, Asm))
+ if (ExportSymbol(SD.getSymbol(), Asm))
DefineSymbol(SD, Asm, Layout);
}
+bool WinCOFFObjectWriter::IsSymbolRefDifferenceFullyResolvedImpl(
+ const MCAssembler &Asm, const MCSymbolData &DataA, const MCFragment &FB,
+ bool InSet, bool IsPCRel) const {
+ // MS LINK expects to be able to replace all references to a function with a
+ // thunk to implement their /INCREMENTAL feature. Make sure we don't optimize
+ // away any relocations to functions.
+ if ((((DataA.getFlags() & COFF::SF_TypeMask) >> COFF::SF_TypeShift) >>
+ COFF::SCT_COMPLEX_TYPE_SHIFT) == COFF::IMAGE_SYM_DTYPE_FUNCTION)
+ return false;
+ return MCObjectWriter::IsSymbolRefDifferenceFullyResolvedImpl(Asm, DataA, FB,
+ InSet, IsPCRel);
+}
+
void WinCOFFObjectWriter::RecordRelocation(const MCAssembler &Asm,
const MCAsmLayout &Layout,
const MCFragment *Fragment,
@@ -744,7 +712,7 @@ void WinCOFFObjectWriter::RecordRelocation(const MCAssembler &Asm,
// Offset of the symbol in the section
int64_t a = Layout.getSymbolOffset(&B_SD);
- // Ofeset of the relocation in the section
+ // Offset of the relocation in the section
int64_t b = Layout.getFragmentOffset(Fragment) + Fixup.getOffset();
FixedValue = b - a;
@@ -765,8 +733,8 @@ void WinCOFFObjectWriter::RecordRelocation(const MCAssembler &Asm,
// Turn relocations for temporary symbols into section relocations.
if (coff_symbol->MCData->getSymbol().isTemporary() || CrossSection) {
Reloc.Symb = coff_symbol->Section->Symbol;
- FixedValue += Layout.getFragmentOffset(coff_symbol->MCData->Fragment)
- + coff_symbol->MCData->getOffset();
+ FixedValue += Layout.getFragmentOffset(coff_symbol->MCData->getFragment()) +
+ coff_symbol->MCData->getOffset();
} else
Reloc.Symb = coff_symbol;
@@ -828,26 +796,67 @@ void WinCOFFObjectWriter::RecordRelocation(const MCAssembler &Asm,
void WinCOFFObjectWriter::WriteObject(MCAssembler &Asm,
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.
- Header.NumberOfSections = 0;
+ int32_t NumberOfSections = static_cast<int32_t>(SectionsSize);
- DenseMap<COFFSection *, uint16_t> SectionIndices;
- for (auto & Section : Sections) {
- size_t Number = ++Header.NumberOfSections;
+ UseBigObj = NumberOfSections > COFF::MaxNumberOfSections16;
+
+ DenseMap<COFFSection *, int32_t> SectionIndices(
+ NextPowerOf2(NumberOfSections));
+
+ // Assign section numbers.
+ size_t Number = 1;
+ for (const auto &Section : Sections) {
SectionIndices[Section.get()] = Number;
- MakeSectionReal(*Section, Number);
+ Section->Number = Number;
+ Section->Symbol->Data.SectionNumber = Number;
+ Section->Symbol->Aux[0].Aux.SectionDefinition.Number = Number;
+ ++Number;
}
+ Header.NumberOfSections = NumberOfSections;
Header.NumberOfSymbols = 0;
- for (auto & Symbol : Symbols) {
+ 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) {
// Update section number & offset for symbols that have them.
if (Symbol->Section)
Symbol->Data.SectionNumber = Symbol->Section->Number;
-
if (Symbol->should_keep()) {
- MakeSymbolReal(*Symbol, Header.NumberOfSymbols++);
-
+ Symbol->Index = Header.NumberOfSymbols++;
// Update auxiliary symbol info.
Symbol->Data.NumberOfAuxSymbols = Symbol->Aux.size();
Header.NumberOfSymbols += Symbol->Data.NumberOfAuxSymbols;
@@ -855,6 +864,22 @@ void WinCOFFObjectWriter::WriteObject(MCAssembler &Asm,
Symbol->Index = -1;
}
+ // Build string table.
+ for (const auto &S : Sections)
+ if (S->Name.size() > COFF::NameSize)
+ Strings.add(S->Name);
+ for (const auto &S : Symbols)
+ if (S->should_keep() && S->Name.size() > COFF::NameSize)
+ Strings.add(S->Name);
+ Strings.finalize(StringTableBuilder::WinCOFF);
+
+ // Set names.
+ for (const auto &S : Sections)
+ SetSectionName(*S);
+ for (auto &S : Symbols)
+ if (S->should_keep())
+ SetSymbolName(*S);
+
// Fixup weak external references.
for (auto & Symbol : Symbols) {
if (Symbol->Other) {
@@ -897,7 +922,10 @@ void WinCOFFObjectWriter::WriteObject(MCAssembler &Asm,
unsigned offset = 0;
- offset += COFF::HeaderSize;
+ if (UseBigObj)
+ offset += COFF::Header32Size;
+ else
+ offset += COFF::Header16Size;
offset += COFF::SectionSize * Header.NumberOfSections;
for (const auto & Section : Asm) {
@@ -918,7 +946,7 @@ void WinCOFFObjectWriter::WriteObject(MCAssembler &Asm,
bool RelocationsOverflow = Sec->Relocations.size() >= 0xffff;
if (RelocationsOverflow) {
- // Signal overflow by setting NumberOfSections to max value. Actual
+ // Signal overflow by setting NumberOfRelocations to max value. Actual
// size is found in reloc #0. Microsoft tools understand this.
Sec->Header.NumberOfRelocations = 0xffff;
} else {
@@ -1014,7 +1042,7 @@ void WinCOFFObjectWriter::WriteObject(MCAssembler &Asm,
if (Symbol->Index != -1)
WriteSymbol(*Symbol);
- OS.write((char const *)&Strings.Data.front(), Strings.Data.size());
+ OS.write(Strings.data().data(), Strings.data().size());
}
MCWinCOFFObjectTargetWriter::MCWinCOFFObjectTargetWriter(unsigned Machine_) :
generated by cgit v1.1 at 2024-05-17 20:22:06 +0000