summaryrefslogtreecommitdiff
path: root/tools/yaml2obj/yaml2elf.cpp
blob: ac6b330e667ba228be4dc2c195277e483c793af7 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
//===- yaml2elf - Convert YAML to a ELF 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 ELF component of yaml2obj.
///
//===----------------------------------------------------------------------===//

#include "yaml2obj.h"
#include "llvm/Object/ELF.h"
#include "llvm/Object/ELFYAML.h"
#include "llvm/Support/ELF.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/YAMLTraits.h"
#include "llvm/Support/raw_ostream.h"

using namespace llvm;

// There is similar code in yaml2coff, but with some slight COFF-specific
// variations like different initial state. Might be able to deduplicate
// some day, but also want to make sure that the Mach-O use case is served.
//
// This class has a deliberately small interface, since a lot of
// implementation variation is possible.
//
// TODO: Use an ordered container with a suffix-based comparison in order
// to deduplicate suffixes. std::map<> with a custom comparator is likely
// to be the simplest implementation, but a suffix trie could be more
// suitable for the job.
namespace {
class StringTableBuilder {
  /// \brief Indices of strings currently present in `Buf`.
  StringMap<unsigned> StringIndices;
  /// \brief The contents of the string table as we build it.
  std::string Buf;
public:
  StringTableBuilder() {
    Buf.push_back('\0');
  }
  /// \returns Index of string in string table.
  unsigned addString(StringRef S) {
    StringMapEntry<unsigned> &Entry = StringIndices.GetOrCreateValue(S);
    unsigned &I = Entry.getValue();
    if (I != 0)
      return I;
    I = Buf.size();
    Buf.append(S.begin(), S.end());
    Buf.push_back('\0');
    return I;
  }
  size_t size() const {
    return Buf.size();
  }
  void writeToStream(raw_ostream &OS) {
    OS.write(Buf.data(), Buf.size());
  }
};
} // end anonymous namespace

// This class is used to build up a contiguous binary blob while keeping
// track of an offset in the output (which notionally begins at
// `InitialOffset`).
namespace {
class ContiguousBlobAccumulator {
  const uint64_t InitialOffset;
  SmallVector<char, 128> Buf;
  raw_svector_ostream OS;

public:
  ContiguousBlobAccumulator(uint64_t InitialOffset_)
      : InitialOffset(InitialOffset_), Buf(), OS(Buf) {}
  raw_ostream &getOS() { return OS; }
  uint64_t currentOffset() const { return InitialOffset + OS.tell(); }
  void writeBlobToStream(raw_ostream &Out) { Out << OS.str(); }
};
} // end anonymous namespace

// Used to keep track of section names, so that in the YAML file sections
// can be referenced by name instead of by index.
namespace {
class SectionNameToIdxMap {
  StringMap<int> Map;
public:
  /// \returns true if name is already present in the map.
  bool addName(StringRef SecName, unsigned i) {
    StringMapEntry<int> &Entry = Map.GetOrCreateValue(SecName, -1);
    if (Entry.getValue() != -1)
      return true;
    Entry.setValue((int)i);
    return false;
  }
  /// \returns true if name is not present in the map
  bool lookupSection(StringRef SecName, unsigned &Idx) const {
    StringMap<int>::const_iterator I = Map.find(SecName);
    if (I == Map.end())
      return true;
    Idx = I->getValue();
    return false;
  }
};
} // end anonymous namespace

template <class T>
static size_t vectorDataSize(const std::vector<T> &Vec) {
  return Vec.size() * sizeof(T);
}

template <class T>
static void writeVectorData(raw_ostream &OS, const std::vector<T> &Vec) {
  OS.write((const char *)Vec.data(), vectorDataSize(Vec));
}

template <class T>
static void zero(T &Obj) {
  memset(&Obj, 0, sizeof(Obj));
}

/// \brief Create a string table in `SHeader`, which we assume is already
/// zero'd.
template <class Elf_Shdr>
static void createStringTableSectionHeader(Elf_Shdr &SHeader,
                                           StringTableBuilder &STB,
                                           ContiguousBlobAccumulator &CBA) {
  SHeader.sh_type = ELF::SHT_STRTAB;
  SHeader.sh_offset = CBA.currentOffset();
  SHeader.sh_size = STB.size();
  STB.writeToStream(CBA.getOS());
  SHeader.sh_addralign = 1;
}

namespace {
/// \brief "Single point of truth" for the ELF file construction.
/// TODO: This class still has a ways to go before it is truly a "single
/// point of truth".
template <class ELFT>
class ELFState {
  /// \brief The future ".strtab" section.
  StringTableBuilder DotStrtab;
  /// \brief The section number of the ".strtab" section.
  unsigned DotStrtabSecNo;
  /// \brief The accumulated contents of all sections so far.
  ContiguousBlobAccumulator &SectionContentAccum;
  typedef typename object::ELFObjectFile<ELFT>::Elf_Ehdr Elf_Ehdr;
  /// \brief The ELF file header.
  Elf_Ehdr &Header;

  SectionNameToIdxMap &SN2I;

public:

  ELFState(Elf_Ehdr &Header_, ContiguousBlobAccumulator &Accum,
           unsigned DotStrtabSecNo_, SectionNameToIdxMap &SN2I_)
      : DotStrtab(), DotStrtabSecNo(DotStrtabSecNo_),
        SectionContentAccum(Accum), Header(Header_), SN2I(SN2I_) {}

  unsigned getDotStrTabSecNo() const { return DotStrtabSecNo; }
  StringTableBuilder &getStringTable() { return DotStrtab; }
  ContiguousBlobAccumulator &getSectionContentAccum() {
    return SectionContentAccum;
  }
  SectionNameToIdxMap &getSN2I() { return SN2I; }
};
} // end anonymous namespace

// FIXME: At this point it is fairly clear that we need to refactor these
// static functions into methods of a class sharing some typedefs. These
// ELF type names are insane.
template <class ELFT>
static void
addSymbols(const std::vector<ELFYAML::Symbol> &Symbols, ELFState<ELFT> &State,
           std::vector<typename object::ELFObjectFile<ELFT>::Elf_Sym> &Syms,
           unsigned SymbolBinding) {
  typedef typename object::ELFObjectFile<ELFT>::Elf_Sym Elf_Sym;
  for (unsigned i = 0, e = Symbols.size(); i != e; ++i) {
    const ELFYAML::Symbol &Sym = Symbols[i];
    Elf_Sym Symbol;
    zero(Symbol);
    if (!Sym.Name.empty())
      Symbol.st_name = State.getStringTable().addString(Sym.Name);
    Symbol.setBindingAndType(SymbolBinding, Sym.Type);
    if (!Sym.Section.empty()) {
      unsigned Index;
      if (State.getSN2I().lookupSection(Sym.Section, Index)) {
        errs() << "error: Unknown section referenced: '" << Sym.Section
               << "' by YAML symbol " << Sym.Name << ".\n";
        exit(1);
      }
      Symbol.st_shndx = Index;
    } // else Symbol.st_shndex == SHN_UNDEF (== 0), since it was zero'd earlier.
    Symbol.st_value = Sym.Value;
    Symbol.st_size = Sym.Size;
    Syms.push_back(Symbol);
  }
}

template <class ELFT>
static void handleSymtabSectionHeader(
    const ELFYAML::Section &Sec, ELFState<ELFT> &State,
    typename object::ELFObjectFile<ELFT>::Elf_Shdr &SHeader) {

  typedef typename object::ELFObjectFile<ELFT>::Elf_Sym Elf_Sym;
  // TODO: Ensure that a manually specified `Link` field is diagnosed as an
  // error for SHT_SYMTAB.
  SHeader.sh_link = State.getDotStrTabSecNo();
  // One greater than symbol table index of the last local symbol.
  SHeader.sh_info = Sec.Symbols.Local.size() + 1;
  SHeader.sh_entsize = sizeof(Elf_Sym);

  std::vector<Elf_Sym> Syms;
  {
    // Ensure STN_UNDEF is present
    Elf_Sym Sym;
    zero(Sym);
    Syms.push_back(Sym);
  }
  addSymbols(Sec.Symbols.Local, State, Syms, ELF::STB_LOCAL);
  addSymbols(Sec.Symbols.Global, State, Syms, ELF::STB_GLOBAL);
  addSymbols(Sec.Symbols.Weak, State, Syms, ELF::STB_WEAK);

  ContiguousBlobAccumulator &CBA = State.getSectionContentAccum();
  SHeader.sh_offset = CBA.currentOffset();
  SHeader.sh_size = vectorDataSize(Syms);
  writeVectorData(CBA.getOS(), Syms);
}

template <class ELFT>
static int writeELF(raw_ostream &OS, const ELFYAML::Object &Doc) {
  using namespace llvm::ELF;
  typedef typename object::ELFObjectFile<ELFT>::Elf_Ehdr Elf_Ehdr;
  typedef typename object::ELFObjectFile<ELFT>::Elf_Shdr Elf_Shdr;

  const ELFYAML::FileHeader &Hdr = Doc.Header;

  Elf_Ehdr Header;
  zero(Header);
  Header.e_ident[EI_MAG0] = 0x7f;
  Header.e_ident[EI_MAG1] = 'E';
  Header.e_ident[EI_MAG2] = 'L';
  Header.e_ident[EI_MAG3] = 'F';
  Header.e_ident[EI_CLASS] = ELFT::Is64Bits ? ELFCLASS64 : ELFCLASS32;
  bool IsLittleEndian = ELFT::TargetEndianness == support::little;
  Header.e_ident[EI_DATA] = IsLittleEndian ? ELFDATA2LSB : ELFDATA2MSB;
  Header.e_ident[EI_VERSION] = EV_CURRENT;
  Header.e_ident[EI_OSABI] = Hdr.OSABI;
  Header.e_ident[EI_ABIVERSION] = 0;
  Header.e_type = Hdr.Type;
  Header.e_machine = Hdr.Machine;
  Header.e_version = EV_CURRENT;
  Header.e_entry = Hdr.Entry;
  Header.e_ehsize = sizeof(Elf_Ehdr);

  // TODO: Flesh out section header support.
  // TODO: Program headers.

  Header.e_shentsize = sizeof(Elf_Shdr);
  // Immediately following the ELF header.
  Header.e_shoff = sizeof(Header);
  const std::vector<ELFYAML::Section> &Sections = Doc.Sections;
  // "+ 3" for
  // - SHT_NULL entry (placed first, i.e. 0'th entry)
  // - string table (.strtab) (placed second to last)
  // - section header string table. (placed last)
  Header.e_shnum = Sections.size() + 3;
  // Place section header string table last.
  Header.e_shstrndx = Header.e_shnum - 1;
  const unsigned DotStrtabSecNo = Header.e_shnum - 2;

  // XXX: This offset is tightly coupled with the order that we write
  // things to `OS`.
  const size_t SectionContentBeginOffset =
      Header.e_ehsize + Header.e_shentsize * Header.e_shnum;
  ContiguousBlobAccumulator CBA(SectionContentBeginOffset);
  SectionNameToIdxMap SN2I;
  for (unsigned i = 0, e = Sections.size(); i != e; ++i) {
    StringRef Name = Sections[i].Name;
    if (Name.empty())
      continue;
    // "+ 1" to take into account the SHT_NULL entry.
    if (SN2I.addName(Name, i + 1)) {
      errs() << "error: Repeated section name: '" << Name
             << "' at YAML section number " << i << ".\n";
      return 1;
    }
  }

  ELFState<ELFT> State(Header, CBA, DotStrtabSecNo, SN2I);

  StringTableBuilder SHStrTab;
  std::vector<Elf_Shdr> SHeaders;
  {
    // Ensure SHN_UNDEF entry is present. An all-zero section header is a
    // valid SHN_UNDEF entry since SHT_NULL == 0.
    Elf_Shdr SHdr;
    zero(SHdr);
    SHeaders.push_back(SHdr);
  }
  for (unsigned i = 0, e = Sections.size(); i != e; ++i) {
    const ELFYAML::Section &Sec = Sections[i];
    Elf_Shdr SHeader;
    zero(SHeader);
    SHeader.sh_name = SHStrTab.addString(Sec.Name);
    SHeader.sh_type = Sec.Type;
    SHeader.sh_flags = Sec.Flags;
    SHeader.sh_addr = Sec.Address;

    SHeader.sh_offset = CBA.currentOffset();
    SHeader.sh_size = Sec.Content.binary_size();
    Sec.Content.writeAsBinary(CBA.getOS());

    if (!Sec.Link.empty()) {
      unsigned Index;
      if (SN2I.lookupSection(Sec.Link, Index)) {
        errs() << "error: Unknown section referenced: '" << Sec.Link
               << "' at YAML section number " << i << ".\n";
        return 1;
      }
      SHeader.sh_link = Index;
    }
    SHeader.sh_info = 0;
    SHeader.sh_addralign = Sec.AddressAlign;
    SHeader.sh_entsize = 0;
    // XXX: Really ugly right now. Should not be writing to `CBA` above
    // (and setting sh_offset and sh_size) when going through this branch
    // here.
    if (Sec.Type == ELFYAML::ELF_SHT(SHT_SYMTAB))
      handleSymtabSectionHeader<ELFT>(Sec, State, SHeader);
    SHeaders.push_back(SHeader);
  }

  // .strtab string table header.
  Elf_Shdr DotStrTabSHeader;
  zero(DotStrTabSHeader);
  DotStrTabSHeader.sh_name = SHStrTab.addString(StringRef(".strtab"));
  createStringTableSectionHeader(DotStrTabSHeader, State.getStringTable(), CBA);

  // Section header string table header.
  Elf_Shdr SHStrTabSHeader;
  zero(SHStrTabSHeader);
  createStringTableSectionHeader(SHStrTabSHeader, SHStrTab, CBA);

  OS.write((const char *)&Header, sizeof(Header));
  writeVectorData(OS, SHeaders);
  OS.write((const char *)&DotStrTabSHeader, sizeof(DotStrTabSHeader));
  OS.write((const char *)&SHStrTabSHeader, sizeof(SHStrTabSHeader));
  CBA.writeBlobToStream(OS);
  return 0;
}

int yaml2elf(llvm::raw_ostream &Out, llvm::MemoryBuffer *Buf) {
  yaml::Input YIn(Buf->getBuffer());
  ELFYAML::Object Doc;
  YIn >> Doc;
  if (YIn.error()) {
    errs() << "yaml2obj: Failed to parse YAML file!\n";
    return 1;
  }
  if (Doc.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64)) {
    if (Doc.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB))
      return writeELF<object::ELFType<support::little, 8, true> >(outs(), Doc);
    else
      return writeELF<object::ELFType<support::big, 8, true> >(outs(), Doc);
  } else {
    if (Doc.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB))
      return writeELF<object::ELFType<support::little, 4, false> >(outs(), Doc);
    else
      return writeELF<object::ELFType<support::big, 4, false> >(outs(), Doc);
  }
}