//===- yaml2coff - Convert YAML to a COFF object file ---------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// /// /// \file /// \brief The COFF component of yaml2obj. /// //===----------------------------------------------------------------------===// #include "yaml2obj.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringSwitch.h" #include "llvm/Object/COFFYAML.h" #include "llvm/Support/Endian.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/SourceMgr.h" #include "llvm/Support/raw_ostream.h" #include using namespace llvm; /// This parses a yaml stream that represents a COFF object file. /// See docs/yaml2obj for the yaml scheema. struct COFFParser { COFFParser(COFFYAML::Object &Obj) : Obj(Obj) { // A COFF string table always starts with a 4 byte size field. Offsets into // it include this size, so allocate it now. StringTable.append(4, char(0)); } bool useBigObj() const { return static_cast(Obj.Sections.size()) > COFF::MaxNumberOfSections16; } unsigned getHeaderSize() const { return useBigObj() ? COFF::Header32Size : COFF::Header16Size; } unsigned getSymbolSize() const { return useBigObj() ? COFF::Symbol32Size : COFF::Symbol16Size; } bool parseSections() { for (std::vector::iterator i = Obj.Sections.begin(), e = Obj.Sections.end(); i != e; ++i) { COFFYAML::Section &Sec = *i; // If the name is less than 8 bytes, store it in place, otherwise // store it in the string table. StringRef Name = Sec.Name; if (Name.size() <= COFF::NameSize) { std::copy(Name.begin(), Name.end(), Sec.Header.Name); } else { // Add string to the string table and format the index for output. unsigned Index = getStringIndex(Name); std::string str = utostr(Index); if (str.size() > 7) { errs() << "String table got too large"; return false; } Sec.Header.Name[0] = '/'; std::copy(str.begin(), str.end(), Sec.Header.Name + 1); } Sec.Header.Characteristics |= (Log2_32(Sec.Alignment) + 1) << 20; } return true; } bool parseSymbols() { for (std::vector::iterator i = Obj.Symbols.begin(), e = Obj.Symbols.end(); i != e; ++i) { COFFYAML::Symbol &Sym = *i; // If the name is less than 8 bytes, store it in place, otherwise // store it in the string table. StringRef Name = Sym.Name; if (Name.size() <= COFF::NameSize) { std::copy(Name.begin(), Name.end(), Sym.Header.Name); } else { // Add string to the string table and format the index for output. unsigned Index = getStringIndex(Name); *reinterpret_cast( Sym.Header.Name + 4) = Index; } Sym.Header.Type = Sym.SimpleType; Sym.Header.Type |= Sym.ComplexType << COFF::SCT_COMPLEX_TYPE_SHIFT; } return true; } bool parse() { if (!parseSections()) return false; if (!parseSymbols()) return false; return true; } unsigned getStringIndex(StringRef Str) { StringMap::iterator i = StringTableMap.find(Str); if (i == StringTableMap.end()) { unsigned Index = StringTable.size(); StringTable.append(Str.begin(), Str.end()); StringTable.push_back(0); StringTableMap[Str] = Index; return Index; } return i->second; } COFFYAML::Object &Obj; StringMap StringTableMap; std::string StringTable; }; // Take a CP and assign addresses and sizes to everything. Returns false if the // layout is not valid to do. static bool layoutCOFF(COFFParser &CP) { uint32_t SectionTableStart = 0; uint32_t SectionTableSize = 0; // The section table starts immediately after the header, including the // optional header. SectionTableStart = CP.getHeaderSize() + CP.Obj.Header.SizeOfOptionalHeader; SectionTableSize = COFF::SectionSize * CP.Obj.Sections.size(); uint32_t CurrentSectionDataOffset = SectionTableStart + SectionTableSize; // Assign each section data address consecutively. for (std::vector::iterator i = CP.Obj.Sections.begin(), e = CP.Obj.Sections.end(); i != e; ++i) { if (i->SectionData.binary_size() > 0) { i->Header.SizeOfRawData = i->SectionData.binary_size(); i->Header.PointerToRawData = CurrentSectionDataOffset; CurrentSectionDataOffset += i->Header.SizeOfRawData; if (!i->Relocations.empty()) { i->Header.PointerToRelocations = CurrentSectionDataOffset; i->Header.NumberOfRelocations = i->Relocations.size(); CurrentSectionDataOffset += i->Header.NumberOfRelocations * COFF::RelocationSize; } // TODO: Handle alignment. } else { i->Header.SizeOfRawData = 0; i->Header.PointerToRawData = 0; } } uint32_t SymbolTableStart = CurrentSectionDataOffset; // Calculate number of symbols. uint32_t NumberOfSymbols = 0; for (std::vector::iterator i = CP.Obj.Symbols.begin(), e = CP.Obj.Symbols.end(); i != e; ++i) { uint32_t NumberOfAuxSymbols = 0; if (i->FunctionDefinition) NumberOfAuxSymbols += 1; if (i->bfAndefSymbol) NumberOfAuxSymbols += 1; if (i->WeakExternal) NumberOfAuxSymbols += 1; if (!i->File.empty()) NumberOfAuxSymbols += (i->File.size() + CP.getSymbolSize() - 1) / CP.getSymbolSize(); if (i->SectionDefinition) NumberOfAuxSymbols += 1; if (i->CLRToken) NumberOfAuxSymbols += 1; i->Header.NumberOfAuxSymbols = NumberOfAuxSymbols; NumberOfSymbols += 1 + NumberOfAuxSymbols; } // Store all the allocated start addresses in the header. CP.Obj.Header.NumberOfSections = CP.Obj.Sections.size(); CP.Obj.Header.NumberOfSymbols = NumberOfSymbols; CP.Obj.Header.PointerToSymbolTable = SymbolTableStart; *reinterpret_cast(&CP.StringTable[0]) = CP.StringTable.size(); return true; } template struct binary_le_impl { value_type Value; binary_le_impl(value_type V) : Value(V) {} }; template raw_ostream &operator <<( raw_ostream &OS , const binary_le_impl &BLE) { char Buffer[sizeof(BLE.Value)]; support::endian::write( Buffer, BLE.Value); OS.write(Buffer, sizeof(BLE.Value)); return OS; } template binary_le_impl binary_le(value_type V) { return binary_le_impl(V); } template struct zeros_impl { zeros_impl() {} }; template raw_ostream &operator<<(raw_ostream &OS, const zeros_impl &) { char Buffer[NumBytes]; memset(Buffer, 0, sizeof(Buffer)); OS.write(Buffer, sizeof(Buffer)); return OS; } template zeros_impl zeros(const T &) { return zeros_impl(); } struct num_zeros_impl { size_t N; num_zeros_impl(size_t N) : N(N) {} }; raw_ostream &operator<<(raw_ostream &OS, const num_zeros_impl &NZI) { for (size_t I = 0; I != NZI.N; ++I) OS.write(0); return OS; } num_zeros_impl num_zeros(size_t N) { num_zeros_impl NZI(N); return NZI; } bool writeCOFF(COFFParser &CP, raw_ostream &OS) { if (CP.useBigObj()) { OS << binary_le(static_cast(COFF::IMAGE_FILE_MACHINE_UNKNOWN)) << binary_le(static_cast(0xffff)) << binary_le(static_cast(COFF::BigObjHeader::MinBigObjectVersion)) << binary_le(CP.Obj.Header.Machine) << binary_le(CP.Obj.Header.TimeDateStamp); OS.write(COFF::BigObjMagic, sizeof(COFF::BigObjMagic)); OS << zeros(uint32_t(0)) << zeros(uint32_t(0)) << zeros(uint32_t(0)) << zeros(uint32_t(0)) << binary_le(CP.Obj.Header.NumberOfSections) << binary_le(CP.Obj.Header.PointerToSymbolTable) << binary_le(CP.Obj.Header.NumberOfSymbols); } else { OS << binary_le(CP.Obj.Header.Machine) << binary_le(static_cast(CP.Obj.Header.NumberOfSections)) << binary_le(CP.Obj.Header.TimeDateStamp) << binary_le(CP.Obj.Header.PointerToSymbolTable) << binary_le(CP.Obj.Header.NumberOfSymbols) << binary_le(CP.Obj.Header.SizeOfOptionalHeader) << binary_le(CP.Obj.Header.Characteristics); } // Output section table. for (std::vector::iterator i = CP.Obj.Sections.begin(), e = CP.Obj.Sections.end(); i != e; ++i) { OS.write(i->Header.Name, COFF::NameSize); OS << binary_le(i->Header.VirtualSize) << binary_le(i->Header.VirtualAddress) << binary_le(i->Header.SizeOfRawData) << binary_le(i->Header.PointerToRawData) << binary_le(i->Header.PointerToRelocations) << binary_le(i->Header.PointerToLineNumbers) << binary_le(i->Header.NumberOfRelocations) << binary_le(i->Header.NumberOfLineNumbers) << binary_le(i->Header.Characteristics); } unsigned CurSymbol = 0; StringMap SymbolTableIndexMap; for (std::vector::iterator I = CP.Obj.Symbols.begin(), E = CP.Obj.Symbols.end(); I != E; ++I) { SymbolTableIndexMap[I->Name] = CurSymbol; CurSymbol += 1 + I->Header.NumberOfAuxSymbols; } // Output section data. for (std::vector::iterator i = CP.Obj.Sections.begin(), e = CP.Obj.Sections.end(); i != e; ++i) { i->SectionData.writeAsBinary(OS); for (unsigned I2 = 0, E2 = i->Relocations.size(); I2 != E2; ++I2) { const COFFYAML::Relocation &R = i->Relocations[I2]; uint32_t SymbolTableIndex = SymbolTableIndexMap[R.SymbolName]; OS << binary_le(R.VirtualAddress) << binary_le(SymbolTableIndex) << binary_le(R.Type); } } // Output symbol table. for (std::vector::const_iterator i = CP.Obj.Symbols.begin(), e = CP.Obj.Symbols.end(); i != e; ++i) { OS.write(i->Header.Name, COFF::NameSize); OS << binary_le(i->Header.Value); if (CP.useBigObj()) OS << binary_le(i->Header.SectionNumber); else OS << binary_le(static_cast(i->Header.SectionNumber)); OS << binary_le(i->Header.Type) << binary_le(i->Header.StorageClass) << binary_le(i->Header.NumberOfAuxSymbols); if (i->FunctionDefinition) OS << binary_le(i->FunctionDefinition->TagIndex) << binary_le(i->FunctionDefinition->TotalSize) << binary_le(i->FunctionDefinition->PointerToLinenumber) << binary_le(i->FunctionDefinition->PointerToNextFunction) << zeros(i->FunctionDefinition->unused) << num_zeros(CP.getSymbolSize() - COFF::Symbol16Size); if (i->bfAndefSymbol) OS << zeros(i->bfAndefSymbol->unused1) << binary_le(i->bfAndefSymbol->Linenumber) << zeros(i->bfAndefSymbol->unused2) << binary_le(i->bfAndefSymbol->PointerToNextFunction) << zeros(i->bfAndefSymbol->unused3) << num_zeros(CP.getSymbolSize() - COFF::Symbol16Size); if (i->WeakExternal) OS << binary_le(i->WeakExternal->TagIndex) << binary_le(i->WeakExternal->Characteristics) << zeros(i->WeakExternal->unused) << num_zeros(CP.getSymbolSize() - COFF::Symbol16Size); if (!i->File.empty()) { unsigned SymbolSize = CP.getSymbolSize(); uint32_t NumberOfAuxRecords = (i->File.size() + SymbolSize - 1) / SymbolSize; uint32_t NumberOfAuxBytes = NumberOfAuxRecords * SymbolSize; uint32_t NumZeros = NumberOfAuxBytes - i->File.size(); OS.write(i->File.data(), i->File.size()); OS << num_zeros(NumZeros); } if (i->SectionDefinition) OS << binary_le(i->SectionDefinition->Length) << binary_le(i->SectionDefinition->NumberOfRelocations) << binary_le(i->SectionDefinition->NumberOfLinenumbers) << binary_le(i->SectionDefinition->CheckSum) << binary_le(static_cast(i->SectionDefinition->Number)) << binary_le(i->SectionDefinition->Selection) << zeros(i->SectionDefinition->unused) << binary_le(static_cast(i->SectionDefinition->Number >> 16)) << num_zeros(CP.getSymbolSize() - COFF::Symbol16Size); if (i->CLRToken) OS << binary_le(i->CLRToken->AuxType) << zeros(i->CLRToken->unused1) << binary_le(i->CLRToken->SymbolTableIndex) << zeros(i->CLRToken->unused2) << num_zeros(CP.getSymbolSize() - COFF::Symbol16Size); } // Output string table. OS.write(&CP.StringTable[0], CP.StringTable.size()); return true; } int yaml2coff(yaml::Input &YIn, raw_ostream &Out) { COFFYAML::Object Doc; YIn >> Doc; if (YIn.error()) { errs() << "yaml2obj: Failed to parse YAML file!\n"; return 1; } COFFParser CP(Doc); if (!CP.parse()) { errs() << "yaml2obj: Failed to parse YAML file!\n"; return 1; } if (!layoutCOFF(CP)) { errs() << "yaml2obj: Failed to layout COFF file!\n"; return 1; } if (!writeCOFF(CP, Out)) { errs() << "yaml2obj: Failed to write COFF file!\n"; return 1; } return 0; }