1 //===- yaml2coff - Convert YAML to a COFF object file ---------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
11 /// \brief The COFF component of yaml2obj.
13 //===----------------------------------------------------------------------===//
16 #include "llvm/ADT/SmallString.h"
17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/ADT/StringExtras.h"
19 #include "llvm/ADT/StringMap.h"
20 #include "llvm/ADT/StringSwitch.h"
21 #include "llvm/Object/COFFYAML.h"
22 #include "llvm/Support/Endian.h"
23 #include "llvm/Support/MemoryBuffer.h"
24 #include "llvm/Support/SourceMgr.h"
25 #include "llvm/Support/raw_ostream.h"
30 /// This parses a yaml stream that represents a COFF object file.
31 /// See docs/yaml2obj for the yaml scheema.
33 COFFParser(COFFYAML::Object &Obj) : Obj(Obj) {
34 // A COFF string table always starts with a 4 byte size field. Offsets into
35 // it include this size, so allocate it now.
36 StringTable.append(4, char(0));
39 bool parseSections() {
40 for (std::vector<COFFYAML::Section>::iterator i = Obj.Sections.begin(),
41 e = Obj.Sections.end(); i != e; ++i) {
42 COFFYAML::Section &Sec = *i;
44 // If the name is less than 8 bytes, store it in place, otherwise
45 // store it in the string table.
46 StringRef Name = Sec.Name;
48 if (Name.size() <= COFF::NameSize) {
49 std::copy(Name.begin(), Name.end(), Sec.Header.Name);
51 // Add string to the string table and format the index for output.
52 unsigned Index = getStringIndex(Name);
53 std::string str = utostr(Index);
55 errs() << "String table got too large";
58 Sec.Header.Name[0] = '/';
59 std::copy(str.begin(), str.end(), Sec.Header.Name + 1);
62 Sec.Header.Characteristics |= (Log2_32(Sec.Alignment) + 1) << 20;
68 for (std::vector<COFFYAML::Symbol>::iterator i = Obj.Symbols.begin(),
69 e = Obj.Symbols.end(); i != e; ++i) {
70 COFFYAML::Symbol &Sym = *i;
72 // If the name is less than 8 bytes, store it in place, otherwise
73 // store it in the string table.
74 StringRef Name = Sym.Name;
75 if (Name.size() <= COFF::NameSize) {
76 std::copy(Name.begin(), Name.end(), Sym.Header.Name);
78 // Add string to the string table and format the index for output.
79 unsigned Index = getStringIndex(Name);
80 *reinterpret_cast<support::aligned_ulittle32_t*>(
81 Sym.Header.Name + 4) = Index;
84 Sym.Header.Type = Sym.SimpleType;
85 Sym.Header.Type |= Sym.ComplexType << COFF::SCT_COMPLEX_TYPE_SHIFT;
98 unsigned getStringIndex(StringRef Str) {
99 StringMap<unsigned>::iterator i = StringTableMap.find(Str);
100 if (i == StringTableMap.end()) {
101 unsigned Index = StringTable.size();
102 StringTable.append(Str.begin(), Str.end());
103 StringTable.push_back(0);
104 StringTableMap[Str] = Index;
110 COFFYAML::Object &Obj;
112 StringMap<unsigned> StringTableMap;
113 std::string StringTable;
116 // Take a CP and assign addresses and sizes to everything. Returns false if the
117 // layout is not valid to do.
118 static bool layoutCOFF(COFFParser &CP) {
119 uint32_t SectionTableStart = 0;
120 uint32_t SectionTableSize = 0;
122 // The section table starts immediately after the header, including the
124 SectionTableStart = sizeof(COFF::header) + CP.Obj.Header.SizeOfOptionalHeader;
125 SectionTableSize = sizeof(COFF::section) * CP.Obj.Sections.size();
127 uint32_t CurrentSectionDataOffset = SectionTableStart + SectionTableSize;
129 // Assign each section data address consecutively.
130 for (std::vector<COFFYAML::Section>::iterator i = CP.Obj.Sections.begin(),
131 e = CP.Obj.Sections.end();
133 if (i->SectionData.binary_size() > 0) {
134 i->Header.SizeOfRawData = i->SectionData.binary_size();
135 i->Header.PointerToRawData = CurrentSectionDataOffset;
136 CurrentSectionDataOffset += i->Header.SizeOfRawData;
137 if (!i->Relocations.empty()) {
138 i->Header.PointerToRelocations = CurrentSectionDataOffset;
139 i->Header.NumberOfRelocations = i->Relocations.size();
140 CurrentSectionDataOffset += i->Header.NumberOfRelocations *
141 COFF::RelocationSize;
143 // TODO: Handle alignment.
145 i->Header.SizeOfRawData = 0;
146 i->Header.PointerToRawData = 0;
150 uint32_t SymbolTableStart = CurrentSectionDataOffset;
152 // Calculate number of symbols.
153 uint32_t NumberOfSymbols = 0;
154 for (std::vector<COFFYAML::Symbol>::iterator i = CP.Obj.Symbols.begin(),
155 e = CP.Obj.Symbols.end();
157 uint32_t NumberOfAuxSymbols = 0;
158 if (i->FunctionDefinition)
159 NumberOfAuxSymbols += 1;
160 if (i->bfAndefSymbol)
161 NumberOfAuxSymbols += 1;
163 NumberOfAuxSymbols += 1;
164 if (!i->File.empty())
165 NumberOfAuxSymbols +=
166 (i->File.size() + COFF::SymbolSize - 1) / COFF::SymbolSize;
167 if (i->SectionDefinition)
168 NumberOfAuxSymbols += 1;
170 NumberOfAuxSymbols += 1;
171 i->Header.NumberOfAuxSymbols = NumberOfAuxSymbols;
172 NumberOfSymbols += 1 + NumberOfAuxSymbols;
175 // Store all the allocated start addresses in the header.
176 CP.Obj.Header.NumberOfSections = CP.Obj.Sections.size();
177 CP.Obj.Header.NumberOfSymbols = NumberOfSymbols;
178 CP.Obj.Header.PointerToSymbolTable = SymbolTableStart;
180 *reinterpret_cast<support::ulittle32_t *>(&CP.StringTable[0])
181 = CP.StringTable.size();
186 template <typename value_type>
187 struct binary_le_impl {
189 binary_le_impl(value_type V) : Value(V) {}
192 template <typename value_type>
193 raw_ostream &operator <<( raw_ostream &OS
194 , const binary_le_impl<value_type> &BLE) {
195 char Buffer[sizeof(BLE.Value)];
196 support::endian::write<value_type, support::little, support::unaligned>(
198 OS.write(Buffer, sizeof(BLE.Value));
202 template <typename value_type>
203 binary_le_impl<value_type> binary_le(value_type V) {
204 return binary_le_impl<value_type>(V);
207 template <size_t NumBytes>
212 template <size_t NumBytes>
213 raw_ostream &operator<<(raw_ostream &OS, const zeros_impl<NumBytes> &) {
214 char Buffer[NumBytes];
215 memset(Buffer, 0, sizeof(Buffer));
216 OS.write(Buffer, sizeof(Buffer));
220 template <typename T>
221 zeros_impl<sizeof(T)> zeros(const T &) {
222 return zeros_impl<sizeof(T)>();
225 bool writeCOFF(COFFParser &CP, raw_ostream &OS) {
226 OS << binary_le(CP.Obj.Header.Machine)
227 << binary_le(CP.Obj.Header.NumberOfSections)
228 << binary_le(CP.Obj.Header.TimeDateStamp)
229 << binary_le(CP.Obj.Header.PointerToSymbolTable)
230 << binary_le(CP.Obj.Header.NumberOfSymbols)
231 << binary_le(CP.Obj.Header.SizeOfOptionalHeader)
232 << binary_le(CP.Obj.Header.Characteristics);
234 // Output section table.
235 for (std::vector<COFFYAML::Section>::iterator i = CP.Obj.Sections.begin(),
236 e = CP.Obj.Sections.end();
238 OS.write(i->Header.Name, COFF::NameSize);
239 OS << binary_le(i->Header.VirtualSize)
240 << binary_le(i->Header.VirtualAddress)
241 << binary_le(i->Header.SizeOfRawData)
242 << binary_le(i->Header.PointerToRawData)
243 << binary_le(i->Header.PointerToRelocations)
244 << binary_le(i->Header.PointerToLineNumbers)
245 << binary_le(i->Header.NumberOfRelocations)
246 << binary_le(i->Header.NumberOfLineNumbers)
247 << binary_le(i->Header.Characteristics);
250 unsigned CurSymbol = 0;
251 StringMap<unsigned> SymbolTableIndexMap;
252 for (std::vector<COFFYAML::Symbol>::iterator I = CP.Obj.Symbols.begin(),
253 E = CP.Obj.Symbols.end();
255 SymbolTableIndexMap[I->Name] = CurSymbol;
256 CurSymbol += 1 + I->Header.NumberOfAuxSymbols;
259 // Output section data.
260 for (std::vector<COFFYAML::Section>::iterator i = CP.Obj.Sections.begin(),
261 e = CP.Obj.Sections.end();
263 i->SectionData.writeAsBinary(OS);
264 for (unsigned I2 = 0, E2 = i->Relocations.size(); I2 != E2; ++I2) {
265 const COFFYAML::Relocation &R = i->Relocations[I2];
266 uint32_t SymbolTableIndex = SymbolTableIndexMap[R.SymbolName];
267 OS << binary_le(R.VirtualAddress)
268 << binary_le(SymbolTableIndex)
269 << binary_le(R.Type);
273 // Output symbol table.
275 for (std::vector<COFFYAML::Symbol>::const_iterator i = CP.Obj.Symbols.begin(),
276 e = CP.Obj.Symbols.end();
278 OS.write(i->Header.Name, COFF::NameSize);
279 OS << binary_le(i->Header.Value)
280 << binary_le(i->Header.SectionNumber)
281 << binary_le(i->Header.Type)
282 << binary_le(i->Header.StorageClass)
283 << binary_le(i->Header.NumberOfAuxSymbols);
285 if (i->FunctionDefinition)
286 OS << binary_le(i->FunctionDefinition->TagIndex)
287 << binary_le(i->FunctionDefinition->TotalSize)
288 << binary_le(i->FunctionDefinition->PointerToLinenumber)
289 << binary_le(i->FunctionDefinition->PointerToNextFunction)
290 << zeros(i->FunctionDefinition->unused);
291 if (i->bfAndefSymbol)
292 OS << zeros(i->bfAndefSymbol->unused1)
293 << binary_le(i->bfAndefSymbol->Linenumber)
294 << zeros(i->bfAndefSymbol->unused2)
295 << binary_le(i->bfAndefSymbol->PointerToNextFunction)
296 << zeros(i->bfAndefSymbol->unused3);
298 OS << binary_le(i->WeakExternal->TagIndex)
299 << binary_le(i->WeakExternal->Characteristics)
300 << zeros(i->WeakExternal->unused);
301 if (!i->File.empty()) {
302 uint32_t NumberOfAuxRecords =
303 (i->File.size() + COFF::SymbolSize - 1) / COFF::SymbolSize;
304 uint32_t NumberOfAuxBytes = NumberOfAuxRecords * COFF::SymbolSize;
305 uint32_t NumZeros = NumberOfAuxBytes - i->File.size();
306 OS.write(i->File.data(), i->File.size());
307 for (uint32_t Padding = 0; Padding < NumZeros; ++Padding)
310 if (i->SectionDefinition)
311 OS << binary_le(i->SectionDefinition->Length)
312 << binary_le(i->SectionDefinition->NumberOfRelocations)
313 << binary_le(i->SectionDefinition->NumberOfLinenumbers)
314 << binary_le(i->SectionDefinition->CheckSum)
315 << binary_le(i->SectionDefinition->Number)
316 << binary_le(i->SectionDefinition->Selection)
317 << zeros(i->SectionDefinition->unused);
319 OS << binary_le(i->CLRToken->AuxType)
320 << zeros(i->CLRToken->unused1)
321 << binary_le(i->CLRToken->SymbolTableIndex)
322 << zeros(i->CLRToken->unused2);
325 // Output string table.
326 OS.write(&CP.StringTable[0], CP.StringTable.size());
330 int yaml2coff(yaml::Input &YIn, raw_ostream &Out) {
331 COFFYAML::Object Doc;
334 errs() << "yaml2obj: Failed to parse YAML file!\n";
340 errs() << "yaml2obj: Failed to parse YAML file!\n";
344 if (!layoutCOFF(CP)) {
345 errs() << "yaml2obj: Failed to layout COFF file!\n";
348 if (!writeCOFF(CP, Out)) {
349 errs() << "yaml2obj: Failed to write COFF file!\n";