summaryrefslogtreecommitdiff
path: root/tools/yaml2obj/yaml2elf.cpp
blob: 3ddbe0afee2b6c613259a1aa02124d23ce859969 (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
//===- 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;
  raw_svector_ostream OS;

public:
  ContiguousBlobAccumulator(uint64_t InitialOffset_, SmallVectorImpl<char> &Buf)
      : InitialOffset(InitialOffset_), 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;
}

// FIXME: This function is hideous. Between the sheer number of parameters
// and the hideous ELF typenames, it's just a travesty. Factor the ELF
// output into a class (templated on ELFT) and share some typedefs.
template <class ELFT>
static void handleSymtabSectionHeader(
    const ELFYAML::Section &Sec,
    const typename object::ELFObjectFile<ELFT>::Elf_Ehdr &Header,
    typename object::ELFObjectFile<ELFT>::Elf_Shdr &SHeader,
    StringTableBuilder &StrTab, ContiguousBlobAccumulator &CBA,
    unsigned DotStrtabSecNo) {

  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 = DotStrtabSecNo;
  // TODO: Once we handle symbol binding, this should be one greater than
  // symbol table index of the last local symbol.
  SHeader.sh_info = 0;
  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);
  }
  for (unsigned i = 0, e = Sec.Symbols.size(); i != e; ++i) {
    const ELFYAML::Symbol &Sym = Sec.Symbols[i];
    Elf_Sym Symbol;
    zero(Symbol);
    if (!Sym.Name.empty())
      Symbol.st_name = StrTab.addString(Sym.Name);
    Syms.push_back(Symbol);
  }

  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;
  using namespace llvm::object;
  typedef typename ELFObjectFile<ELFT>::Elf_Ehdr Elf_Ehdr;
  typedef typename 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;
  // TODO: Implement ELF_ELFOSABI enum.
  Header.e_ident[EI_OSABI] = ELFOSABI_NONE;
  // TODO: Implement ELF_ABIVERSION enum.
  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;

  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;
    }
  }

  StringTableBuilder SHStrTab;
  SmallVector<char, 128> Buf;
  // 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, Buf);
  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);
  }
  StringTableBuilder DotStrTab;
  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. Need to put common state into a class.
    if (Sec.Type == ELFYAML::ELF_SHT(SHT_SYMTAB))
      handleSymtabSectionHeader<ELFT>(Sec, Header, SHeader, DotStrTab, CBA,
                                      DotStrtabSecNo);
    SHeaders.push_back(SHeader);
  }

  // .strtab string table header.
  Elf_Shdr DotStrTabSHeader;
  zero(DotStrTabSHeader);
  DotStrTabSHeader.sh_name = SHStrTab.addString(StringRef(".strtab"));
  createStringTableSectionHeader(DotStrTabSHeader, DotStrTab, 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);
  }
}