1 //===- yaml2obj - Convert YAML to a binary 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 //===----------------------------------------------------------------------===//
10 // This program takes a YAML description of an object file and outputs the
13 // This is used for writing tests that require binary files.
15 //===----------------------------------------------------------------------===//
17 #include "llvm/ADT/SmallString.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/Casting.h"
23 #include "llvm/Support/CommandLine.h"
24 #include "llvm/Support/Endian.h"
25 #include "llvm/Support/ManagedStatic.h"
26 #include "llvm/Support/MemoryBuffer.h"
27 #include "llvm/Support/PrettyStackTrace.h"
28 #include "llvm/Support/Signals.h"
29 #include "llvm/Support/SourceMgr.h"
30 #include "llvm/Support/raw_ostream.h"
31 #include "llvm/Support/system_error.h"
36 static cl::opt<std::string>
37 Input(cl::Positional, cl::desc("<input>"), cl::init("-"));
39 /// This parses a yaml stream that represents a COFF object file.
40 /// See docs/yaml2obj for the yaml scheema.
42 COFFParser(COFFYAML::Object &Obj) : Obj(Obj) {
43 // A COFF string table always starts with a 4 byte size field. Offsets into
44 // it include this size, so allocate it now.
45 StringTable.append(4, 0);
48 bool parseSections() {
49 for (std::vector<COFFYAML::Section>::iterator i = Obj.Sections.begin(),
50 e = Obj.Sections.end(); i != e; ++i) {
51 COFFYAML::Section &Sec = *i;
53 // If the name is less than 8 bytes, store it in place, otherwise
54 // store it in the string table.
55 StringRef Name = Sec.Name;
57 if (Name.size() <= COFF::NameSize) {
58 std::copy(Name.begin(), Name.end(), Sec.Header.Name);
60 // Add string to the string table and format the index for output.
61 unsigned Index = getStringIndex(Name);
62 std::string str = utostr(Index);
64 errs() << "String table got too large";
67 Sec.Header.Name[0] = '/';
68 std::copy(str.begin(), str.end(), Sec.Header.Name + 1);
71 Sec.Header.Characteristics |= (Log2_32(Sec.Alignment) + 1) << 20;
77 for (std::vector<COFFYAML::Symbol>::iterator i = Obj.Symbols.begin(),
78 e = Obj.Symbols.end(); i != e; ++i) {
79 COFFYAML::Symbol &Sym = *i;
81 // If the name is less than 8 bytes, store it in place, otherwise
82 // store it in the string table.
83 StringRef Name = Sym.Name;
84 if (Name.size() <= COFF::NameSize) {
85 std::copy(Name.begin(), Name.end(), Sym.Header.Name);
87 // Add string to the string table and format the index for output.
88 unsigned Index = getStringIndex(Name);
89 *reinterpret_cast<support::aligned_ulittle32_t*>(
90 Sym.Header.Name + 4) = Index;
93 Sym.Header.Type = Sym.SimpleType;
94 Sym.Header.Type |= Sym.ComplexType << COFF::SCT_COMPLEX_TYPE_SHIFT;
100 if (!parseSections())
107 unsigned getStringIndex(StringRef Str) {
108 StringMap<unsigned>::iterator i = StringTableMap.find(Str);
109 if (i == StringTableMap.end()) {
110 unsigned Index = StringTable.size();
111 StringTable.append(Str.begin(), Str.end());
112 StringTable.push_back(0);
113 StringTableMap[Str] = Index;
119 COFFYAML::Object &Obj;
121 StringMap<unsigned> StringTableMap;
122 std::string StringTable;
125 // Take a CP and assign addresses and sizes to everything. Returns false if the
126 // layout is not valid to do.
127 static bool layoutCOFF(COFFParser &CP) {
128 uint32_t SectionTableStart = 0;
129 uint32_t SectionTableSize = 0;
131 // The section table starts immediately after the header, including the
133 SectionTableStart = sizeof(COFF::header) + CP.Obj.Header.SizeOfOptionalHeader;
134 SectionTableSize = sizeof(COFF::section) * CP.Obj.Sections.size();
136 uint32_t CurrentSectionDataOffset = SectionTableStart + SectionTableSize;
138 // Assign each section data address consecutively.
139 for (std::vector<COFFYAML::Section>::iterator i = CP.Obj.Sections.begin(),
140 e = CP.Obj.Sections.end();
142 StringRef SecData = i->SectionData.getHex();
143 if (!SecData.empty()) {
144 i->Header.SizeOfRawData = SecData.size()/2;
145 i->Header.PointerToRawData = CurrentSectionDataOffset;
146 CurrentSectionDataOffset += i->Header.SizeOfRawData;
147 if (!i->Relocations.empty()) {
148 i->Header.PointerToRelocations = CurrentSectionDataOffset;
149 i->Header.NumberOfRelocations = i->Relocations.size();
150 CurrentSectionDataOffset += i->Header.NumberOfRelocations *
151 COFF::RelocationSize;
153 // TODO: Handle alignment.
155 i->Header.SizeOfRawData = 0;
156 i->Header.PointerToRawData = 0;
160 uint32_t SymbolTableStart = CurrentSectionDataOffset;
162 // Calculate number of symbols.
163 uint32_t NumberOfSymbols = 0;
164 for (std::vector<COFFYAML::Symbol>::iterator i = CP.Obj.Symbols.begin(),
165 e = CP.Obj.Symbols.end();
167 unsigned AuxBytes = i->AuxiliaryData.getHex().size() / 2;
168 if (AuxBytes % COFF::SymbolSize != 0) {
169 errs() << "AuxiliaryData size not a multiple of symbol size!\n";
172 i->Header.NumberOfAuxSymbols = AuxBytes / COFF::SymbolSize;
173 NumberOfSymbols += 1 + i->Header.NumberOfAuxSymbols;
176 // Store all the allocated start addresses in the header.
177 CP.Obj.Header.NumberOfSections = CP.Obj.Sections.size();
178 CP.Obj.Header.NumberOfSymbols = NumberOfSymbols;
179 CP.Obj.Header.PointerToSymbolTable = SymbolTableStart;
181 *reinterpret_cast<support::ulittle32_t *>(&CP.StringTable[0])
182 = CP.StringTable.size();
187 template <typename value_type>
188 struct binary_le_impl {
190 binary_le_impl(value_type V) : Value(V) {}
193 template <typename value_type>
194 raw_ostream &operator <<( raw_ostream &OS
195 , const binary_le_impl<value_type> &BLE) {
196 char Buffer[sizeof(BLE.Value)];
197 support::endian::write<value_type, support::little, support::unaligned>(
199 OS.write(Buffer, sizeof(BLE.Value));
203 template <typename value_type>
204 binary_le_impl<value_type> binary_le(value_type V) {
205 return binary_le_impl<value_type>(V);
208 static bool writeHexData(StringRef Data, raw_ostream &OS) {
209 unsigned Size = Data.size();
213 for (unsigned I = 0; I != Size; I += 2) {
215 if (Data.substr(I, 2).getAsInteger(16, Byte))
223 bool writeCOFF(COFFParser &CP, raw_ostream &OS) {
224 OS << binary_le(CP.Obj.Header.Machine)
225 << binary_le(CP.Obj.Header.NumberOfSections)
226 << binary_le(CP.Obj.Header.TimeDateStamp)
227 << binary_le(CP.Obj.Header.PointerToSymbolTable)
228 << binary_le(CP.Obj.Header.NumberOfSymbols)
229 << binary_le(CP.Obj.Header.SizeOfOptionalHeader)
230 << binary_le(CP.Obj.Header.Characteristics);
232 // Output section table.
233 for (std::vector<COFFYAML::Section>::iterator i = CP.Obj.Sections.begin(),
234 e = CP.Obj.Sections.end();
236 OS.write(i->Header.Name, COFF::NameSize);
237 OS << binary_le(i->Header.VirtualSize)
238 << binary_le(i->Header.VirtualAddress)
239 << binary_le(i->Header.SizeOfRawData)
240 << binary_le(i->Header.PointerToRawData)
241 << binary_le(i->Header.PointerToRelocations)
242 << binary_le(i->Header.PointerToLineNumbers)
243 << binary_le(i->Header.NumberOfRelocations)
244 << binary_le(i->Header.NumberOfLineNumbers)
245 << binary_le(i->Header.Characteristics);
248 // Output section data.
249 for (std::vector<COFFYAML::Section>::iterator i = CP.Obj.Sections.begin(),
250 e = CP.Obj.Sections.end();
252 StringRef SecData = i->SectionData.getHex();
253 if (!SecData.empty()) {
254 if (!writeHexData(SecData, OS)) {
255 errs() << "SectionData must be a collection of pairs of hex bytes";
259 for (unsigned I2 = 0, E2 = i->Relocations.size(); I2 != E2; ++I2) {
260 const COFF::relocation &R = i->Relocations[I2];
261 OS << binary_le(R.VirtualAddress)
262 << binary_le(R.SymbolTableIndex)
263 << binary_le(R.Type);
267 // Output symbol table.
269 for (std::vector<COFFYAML::Symbol>::const_iterator i = CP.Obj.Symbols.begin(),
270 e = CP.Obj.Symbols.end();
272 OS.write(i->Header.Name, COFF::NameSize);
273 OS << binary_le(i->Header.Value)
274 << binary_le(i->Header.SectionNumber)
275 << binary_le(i->Header.Type)
276 << binary_le(i->Header.StorageClass)
277 << binary_le(i->Header.NumberOfAuxSymbols);
278 StringRef Data = i->AuxiliaryData.getHex();
280 if (!writeHexData(Data, OS)) {
281 errs() << "AuxiliaryData must be a collection of pairs of hex bytes";
287 // Output string table.
288 OS.write(&CP.StringTable[0], CP.StringTable.size());
292 int main(int argc, char **argv) {
293 cl::ParseCommandLineOptions(argc, argv);
294 sys::PrintStackTraceOnErrorSignal();
295 PrettyStackTraceProgram X(argc, argv);
296 llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
298 OwningPtr<MemoryBuffer> Buf;
299 if (MemoryBuffer::getFileOrSTDIN(Input, Buf))
302 yaml::Input YIn(Buf->getBuffer());
303 COFFYAML::Object Doc;
306 errs() << "yaml2obj: Failed to parse YAML file!\n";
312 errs() << "yaml2obj: Failed to parse YAML file!\n";
316 if (!layoutCOFF(CP)) {
317 errs() << "yaml2obj: Failed to layout COFF file!\n";
320 if (!writeCOFF(CP, outs())) {
321 errs() << "yaml2obj: Failed to write COFF file!\n";