tools/yaml2obj/yaml2coff.cpp

   1 //===- yaml2coff - Convert YAML to a COFF object file ---------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 ///
  10 /// \file
  11 /// \brief The COFF component of yaml2obj.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "yaml2obj.h"
  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"
  26 #include <vector>
  27
  28 using namespace llvm;
  29
  30 /// This parses a yaml stream that represents a COFF object file.
  31 /// See docs/yaml2obj for the yaml scheema.
  32 struct COFFParser {
  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));
  37   }
  38
  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;
  43
  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;
  47
  48       if (Name.size() <= COFF::NameSize) {
  49         std::copy(Name.begin(), Name.end(), Sec.Header.Name);
  50       } else {
  51         // Add string to the string table and format the index for output.
  52         unsigned Index = getStringIndex(Name);
  53         std::string str = utostr(Index);
  54         if (str.size() > 7) {
  55           errs() << "String table got too large";
  56           return false;
  57         }
  58         Sec.Header.Name[0] = '/';
  59         std::copy(str.begin(), str.end(), Sec.Header.Name + 1);
  60       }
  61
  62       Sec.Header.Characteristics |= (Log2_32(Sec.Alignment) + 1) << 20;
  63     }
  64     return true;
  65   }
  66
  67   bool parseSymbols() {
  68     for (std::vector<COFFYAML::Symbol>::iterator i = Obj.Symbols.begin(),
  69            e = Obj.Symbols.end(); i != e; ++i) {
  70       COFFYAML::Symbol &Sym = *i;
  71
  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);
  77       } else {
  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;
  82       }
  83
  84       Sym.Header.Type = Sym.SimpleType;
  85       Sym.Header.Type |= Sym.ComplexType << COFF::SCT_COMPLEX_TYPE_SHIFT;
  86     }
  87     return true;
  88   }
  89
  90   bool parse() {
  91     if (!parseSections())
  92       return false;
  93     if (!parseSymbols())
  94       return false;
  95     return true;
  96   }
  97
  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;
 105       return Index;
 106     }
 107     return i->second;
 108   }
 109
 110   COFFYAML::Object &Obj;
 111
 112   StringMap<unsigned> StringTableMap;
 113   std::string StringTable;
 114 };
 115
 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;
 121
 122   // The section table starts immediately after the header, including the
 123   // optional header.
 124   SectionTableStart = sizeof(COFF::header) + CP.Obj.Header.SizeOfOptionalHeader;
 125   SectionTableSize = sizeof(COFF::section) * CP.Obj.Sections.size();
 126
 127   uint32_t CurrentSectionDataOffset = SectionTableStart + SectionTableSize;
 128
 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();
 132                                                 i != e; ++i) {
 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;
 142       }
 143       // TODO: Handle alignment.
 144     } else {
 145       i->Header.SizeOfRawData = 0;
 146       i->Header.PointerToRawData = 0;
 147     }
 148   }
 149
 150   uint32_t SymbolTableStart = CurrentSectionDataOffset;
 151
 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();
 156                                                i != e; ++i) {
 157     uint32_t NumberOfAuxSymbols = 0;
 158     if (i->FunctionDefinition)
 159       NumberOfAuxSymbols += 1;
 160     if (i->bfAndefSymbol)
 161       NumberOfAuxSymbols += 1;
 162     if (i->WeakExternal)
 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;
 169     if (i->CLRToken)
 170       NumberOfAuxSymbols += 1;
 171     i->Header.NumberOfAuxSymbols = NumberOfAuxSymbols;
 172     NumberOfSymbols += 1 + NumberOfAuxSymbols;
 173   }
 174
 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;
 179
 180   *reinterpret_cast<support::ulittle32_t *>(&CP.StringTable[0])
 181     = CP.StringTable.size();
 182
 183   return true;
 184 }
 185
 186 template <typename value_type>
 187 struct binary_le_impl {
 188   value_type Value;
 189   binary_le_impl(value_type V) : Value(V) {}
 190 };
 191
 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>(
 197     Buffer, BLE.Value);
 198   OS.write(Buffer, sizeof(BLE.Value));
 199   return OS;
 200 }
 201
 202 template <typename value_type>
 203 binary_le_impl<value_type> binary_le(value_type V) {
 204   return binary_le_impl<value_type>(V);
 205 }
 206
 207 template <size_t NumBytes>
 208 struct zeros_impl {
 209   zeros_impl() {}
 210 };
 211
 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));
 217   return OS;
 218 }
 219
 220 template <typename T>
 221 zeros_impl<sizeof(T)> zeros(const T &) {
 222   return zeros_impl<sizeof(T)>();
 223 }
 224
 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);
 233
 234   // Output section table.
 235   for (std::vector<COFFYAML::Section>::iterator i = CP.Obj.Sections.begin(),
 236                                                 e = CP.Obj.Sections.end();
 237                                                 i != e; ++i) {
 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);
 248   }
 249
 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();
 254        I != E; ++I) {
 255     SymbolTableIndexMap[I->Name] = CurSymbol;
 256     CurSymbol += 1 + I->Header.NumberOfAuxSymbols;
 257   }
 258
 259   // Output section data.
 260   for (std::vector<COFFYAML::Section>::iterator i = CP.Obj.Sections.begin(),
 261                                                 e = CP.Obj.Sections.end();
 262                                                 i != e; ++i) {
 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);
 270     }
 271   }
 272
 273   // Output symbol table.
 274
 275   for (std::vector<COFFYAML::Symbol>::const_iterator i = CP.Obj.Symbols.begin(),
 276                                                      e = CP.Obj.Symbols.end();
 277                                                      i != e; ++i) {
 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);
 284
 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);
 297     if (i->WeakExternal)
 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)
 308         OS.write(0);
 309     }
 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);
 318     if (i->CLRToken)
 319       OS << binary_le(i->CLRToken->AuxType)
 320          << zeros(i->CLRToken->unused1)
 321          << binary_le(i->CLRToken->SymbolTableIndex)
 322          << zeros(i->CLRToken->unused2);
 323   }
 324
 325   // Output string table.
 326   OS.write(&CP.StringTable[0], CP.StringTable.size());
 327   return true;
 328 }
 329
 330 int yaml2coff(llvm::raw_ostream &Out, llvm::MemoryBuffer *Buf) {
 331   yaml::Input YIn(Buf->getBuffer());
 332   COFFYAML::Object Doc;
 333   YIn >> Doc;
 334   if (YIn.error()) {
 335     errs() << "yaml2obj: Failed to parse YAML file!\n";
 336     return 1;
 337   }
 338
 339   COFFParser CP(Doc);
 340   if (!CP.parse()) {
 341     errs() << "yaml2obj: Failed to parse YAML file!\n";
 342     return 1;
 343   }
 344
 345   if (!layoutCOFF(CP)) {
 346     errs() << "yaml2obj: Failed to layout COFF file!\n";
 347     return 1;
 348   }
 349   if (!writeCOFF(CP, Out)) {
 350     errs() << "yaml2obj: Failed to write COFF file!\n";
 351     return 1;
 352   }
 353   return 0;
 354 }