ELFObjectWriter.cpp revision f8020a3978b9a56074a3a5f9821c63165e37bff7 
1//===- lib/MC/ELFObjectWriter.cpp - ELF File Writer -------------------===//
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// This file implements ELF object file writer information.
11//
12//===----------------------------------------------------------------------===//
13
14#include "llvm/MC/ELFObjectWriter.h"
15#include "llvm/ADT/STLExtras.h"
16#include "llvm/ADT/StringMap.h"
17#include "llvm/ADT/Twine.h"
18#include "llvm/MC/MCAssembler.h"
19#include "llvm/MC/MCAsmLayout.h"
20#include "llvm/MC/MCContext.h"
21#include "llvm/MC/MCELFSymbolFlags.h"
22#include "llvm/MC/MCExpr.h"
23#include "llvm/MC/MCObjectWriter.h"
24#include "llvm/MC/MCSectionELF.h"
25#include "llvm/MC/MCSymbol.h"
26#include "llvm/MC/MCValue.h"
27#include "llvm/Support/Debug.h"
28#include "llvm/Support/ErrorHandling.h"
29#include "llvm/Support/ELF.h"
30#include "llvm/Target/TargetAsmBackend.h"
31
32#include "../Target/X86/X86FixupKinds.h"
33
34#include <vector>
35using namespace llvm;
36
37namespace {
38
39  class ELFObjectWriterImpl {
40    static bool isFixupKindX86PCRel(unsigned Kind) {
41      switch (Kind) {
42      default:
43        return false;
44      case X86::reloc_pcrel_1byte:
45      case X86::reloc_pcrel_4byte:
46      case X86::reloc_riprel_4byte:
47      case X86::reloc_riprel_4byte_movq_load:
48        return true;
49      }
50    }
51
52    static bool isFixupKindX86RIPRel(unsigned Kind) {
53      return Kind == X86::reloc_riprel_4byte ||
54        Kind == X86::reloc_riprel_4byte_movq_load;
55    }
56
57
58    /// ELFSymbolData - Helper struct for containing some precomputed information
59    /// on symbols.
60    struct ELFSymbolData {
61      MCSymbolData *SymbolData;
62      uint64_t StringIndex;
63      uint32_t SectionIndex;
64
65      // Support lexicographic sorting.
66      bool operator<(const ELFSymbolData &RHS) const {
67        const std::string &Name = SymbolData->getSymbol().getName();
68        return Name < RHS.SymbolData->getSymbol().getName();
69      }
70    };
71
72    /// @name Relocation Data
73    /// @{
74
75    struct ELFRelocationEntry {
76      // Make these big enough for both 32-bit and 64-bit
77      uint64_t r_offset;
78      uint64_t r_info;
79      uint64_t r_addend;
80
81      // Support lexicographic sorting.
82      bool operator<(const ELFRelocationEntry &RE) const {
83        return RE.r_offset < r_offset;
84      }
85    };
86
87    llvm::DenseMap<const MCSectionData*,
88                   std::vector<ELFRelocationEntry> > Relocations;
89    DenseMap<const MCSection*, uint64_t> SectionStringTableIndex;
90
91    /// @}
92    /// @name Symbol Table Data
93    /// @{
94
95    SmallString<256> StringTable;
96    std::vector<ELFSymbolData> LocalSymbolData;
97    std::vector<ELFSymbolData> ExternalSymbolData;
98    std::vector<ELFSymbolData> UndefinedSymbolData;
99
100    /// @}
101
102    ELFObjectWriter *Writer;
103
104    raw_ostream &OS;
105
106    // This holds the current offset into the object file.
107    size_t FileOff;
108
109    unsigned Is64Bit : 1;
110
111    bool HasRelocationAddend;
112
113    // This holds the symbol table index of the last local symbol.
114    unsigned LastLocalSymbolIndex;
115    // This holds the .strtab section index.
116    unsigned StringTableIndex;
117
118    unsigned ShstrtabIndex;
119
120  public:
121    ELFObjectWriterImpl(ELFObjectWriter *_Writer, bool _Is64Bit,
122                        bool _HasRelAddend)
123      : Writer(_Writer), OS(Writer->getStream()), FileOff(0),
124        Is64Bit(_Is64Bit), HasRelocationAddend(_HasRelAddend) {
125    }
126
127    void Write8(uint8_t Value) { Writer->Write8(Value); }
128    void Write16(uint16_t Value) { Writer->Write16(Value); }
129    void Write32(uint32_t Value) { Writer->Write32(Value); }
130    void Write64(uint64_t Value) { Writer->Write64(Value); }
131    void WriteZeros(unsigned N) { Writer->WriteZeros(N); }
132    void WriteBytes(StringRef Str, unsigned ZeroFillSize = 0) {
133      Writer->WriteBytes(Str, ZeroFillSize);
134    }
135
136    void WriteWord(uint64_t W) {
137      if (Is64Bit) {
138        Writer->Write64(W);
139      } else {
140        Writer->Write32(W);
141      }
142    }
143
144    void String8(char *buf, uint8_t Value) {
145      buf[0] = Value;
146    }
147
148    void StringLE16(char *buf, uint16_t Value) {
149      buf[0] = char(Value >> 0);
150      buf[1] = char(Value >> 8);
151    }
152
153    void StringLE32(char *buf, uint32_t Value) {
154      buf[0] = char(Value >> 0);
155      buf[1] = char(Value >> 8);
156      buf[2] = char(Value >> 16);
157      buf[3] = char(Value >> 24);
158    }
159
160    void StringLE64(char *buf, uint64_t Value) {
161      buf[0] = char(Value >> 0);
162      buf[1] = char(Value >> 8);
163      buf[2] = char(Value >> 16);
164      buf[3] = char(Value >> 24);
165      buf[4] = char(Value >> 32);
166      buf[5] = char(Value >> 40);
167      buf[6] = char(Value >> 48);
168      buf[7] = char(Value >> 56);
169    }
170
171    void StringBE16(char *buf ,uint16_t Value) {
172      buf[0] = char(Value >> 8);
173      buf[1] = char(Value >> 0);
174    }
175
176    void StringBE32(char *buf, uint32_t Value) {
177      buf[0] = char(Value >> 24);
178      buf[1] = char(Value >> 16);
179      buf[2] = char(Value >> 8);
180      buf[3] = char(Value >> 0);
181    }
182
183    void StringBE64(char *buf, uint64_t Value) {
184      buf[0] = char(Value >> 56);
185      buf[1] = char(Value >> 48);
186      buf[2] = char(Value >> 40);
187      buf[3] = char(Value >> 32);
188      buf[4] = char(Value >> 24);
189      buf[5] = char(Value >> 16);
190      buf[6] = char(Value >> 8);
191      buf[7] = char(Value >> 0);
192    }
193
194    void String16(char *buf, uint16_t Value) {
195      if (Writer->isLittleEndian())
196        StringLE16(buf, Value);
197      else
198        StringBE16(buf, Value);
199    }
200
201    void String32(char *buf, uint32_t Value) {
202      if (Writer->isLittleEndian())
203        StringLE32(buf, Value);
204      else
205        StringBE32(buf, Value);
206    }
207
208    void String64(char *buf, uint64_t Value) {
209      if (Writer->isLittleEndian())
210        StringLE64(buf, Value);
211      else
212        StringBE64(buf, Value);
213    }
214
215    void WriteHeader(uint64_t SectionDataSize, unsigned NumberOfSections);
216
217    void WriteSymbolEntry(MCDataFragment *F, uint64_t name, uint8_t info,
218                          uint64_t value, uint64_t size,
219                          uint8_t other, uint16_t shndx);
220
221    void WriteSymbol(MCDataFragment *F, ELFSymbolData &MSD,
222                     const MCAsmLayout &Layout);
223
224    void WriteSymbolTable(MCDataFragment *F, const MCAssembler &Asm,
225                          const MCAsmLayout &Layout);
226
227    void RecordRelocation(const MCAssembler &Asm, const MCAsmLayout &Layout,
228                          const MCFragment *Fragment, const MCFixup &Fixup,
229                          MCValue Target, uint64_t &FixedValue);
230
231    // XXX-PERF: this should be cached
232    uint64_t getNumOfLocalSymbols(const MCAssembler &Asm) {
233      std::vector<const MCSymbol*> Local;
234
235      uint64_t Index = 0;
236      for (MCAssembler::const_symbol_iterator it = Asm.symbol_begin(),
237             ie = Asm.symbol_end(); it != ie; ++it) {
238        const MCSymbol &Symbol = it->getSymbol();
239
240        // Ignore non-linker visible symbols.
241        if (!Asm.isSymbolLinkerVisible(Symbol))
242          continue;
243
244        if (it->isExternal() || Symbol.isUndefined())
245          continue;
246
247        Index++;
248      }
249
250      return Index;
251    }
252
253    uint64_t getSymbolIndexInSymbolTable(MCAssembler &Asm, const MCSymbol *S);
254
255    /// ComputeSymbolTable - Compute the symbol table data
256    ///
257    /// \param StringTable [out] - The string table data.
258    /// \param StringIndexMap [out] - Map from symbol names to offsets in the
259    /// string table.
260    void ComputeSymbolTable(MCAssembler &Asm);
261
262    void WriteRelocation(MCAssembler &Asm, MCAsmLayout &Layout,
263                         const MCSectionData &SD);
264
265    void WriteRelocations(MCAssembler &Asm, MCAsmLayout &Layout) {
266      for (MCAssembler::const_iterator it = Asm.begin(),
267             ie = Asm.end(); it != ie; ++it) {
268        WriteRelocation(Asm, Layout, *it);
269      }
270    }
271
272    void CreateMetadataSections(MCAssembler &Asm, MCAsmLayout &Layout);
273
274    void ExecutePostLayoutBinding(MCAssembler &Asm) {}
275
276    void WriteSecHdrEntry(uint32_t Name, uint32_t Type, uint64_t Flags,
277                          uint64_t Address, uint64_t Offset,
278                          uint64_t Size, uint32_t Link, uint32_t Info,
279                          uint64_t Alignment, uint64_t EntrySize);
280
281    void WriteRelocationsFragment(const MCAssembler &Asm, MCDataFragment *F,
282                                  const MCSectionData *SD);
283
284    void WriteObject(const MCAssembler &Asm, const MCAsmLayout &Layout);
285  };
286
287}
288
289// Emit the ELF header.
290void ELFObjectWriterImpl::WriteHeader(uint64_t SectionDataSize,
291                                      unsigned NumberOfSections) {
292  // ELF Header
293  // ----------
294  //
295  // Note
296  // ----
297  // emitWord method behaves differently for ELF32 and ELF64, writing
298  // 4 bytes in the former and 8 in the latter.
299
300  Write8(0x7f); // e_ident[EI_MAG0]
301  Write8('E');  // e_ident[EI_MAG1]
302  Write8('L');  // e_ident[EI_MAG2]
303  Write8('F');  // e_ident[EI_MAG3]
304
305  Write8(Is64Bit ? ELF::ELFCLASS64 : ELF::ELFCLASS32); // e_ident[EI_CLASS]
306
307  // e_ident[EI_DATA]
308  Write8(Writer->isLittleEndian() ? ELF::ELFDATA2LSB : ELF::ELFDATA2MSB);
309
310  Write8(ELF::EV_CURRENT);        // e_ident[EI_VERSION]
311  Write8(ELF::ELFOSABI_LINUX);    // e_ident[EI_OSABI]
312  Write8(0);                  // e_ident[EI_ABIVERSION]
313
314  WriteZeros(ELF::EI_NIDENT - ELF::EI_PAD);
315
316  Write16(ELF::ET_REL);             // e_type
317
318  // FIXME: Make this configurable
319  Write16(ELF::EM_X86_64); // e_machine = target
320
321  Write32(ELF::EV_CURRENT);         // e_version
322  WriteWord(0);                    // e_entry, no entry point in .o file
323  WriteWord(0);                    // e_phoff, no program header for .o
324  WriteWord(SectionDataSize + 64);  // e_shoff = sec hdr table off in bytes
325
326  // FIXME: Make this configurable.
327  Write32(0);   // e_flags = whatever the target wants
328
329  // e_ehsize = ELF header size
330  Write16(Is64Bit ? sizeof(ELF::Elf64_Ehdr) : sizeof(ELF::Elf32_Ehdr));
331
332  Write16(0);                  // e_phentsize = prog header entry size
333  Write16(0);                  // e_phnum = # prog header entries = 0
334
335  // e_shentsize = Section header entry size
336  Write16(Is64Bit ? sizeof(ELF::Elf64_Shdr) : sizeof(ELF::Elf32_Shdr));
337
338  // e_shnum     = # of section header ents
339  Write16(NumberOfSections);
340
341  // e_shstrndx  = Section # of '.shstrtab'
342  Write16(ShstrtabIndex);
343}
344
345void ELFObjectWriterImpl::WriteSymbolEntry(MCDataFragment *F, uint64_t name,
346                                           uint8_t info, uint64_t value,
347                                           uint64_t size, uint8_t other,
348                                           uint16_t shndx) {
349  if (Is64Bit) {
350    char buf[8];
351
352    String32(buf, name);
353    F->getContents() += StringRef(buf, 4); // st_name
354
355    String8(buf, info);
356    F->getContents() += StringRef(buf, 1);  // st_info
357    String8(buf, other);
358    F->getContents() += StringRef(buf, 1); // st_other
359
360    String16(buf, shndx);
361    F->getContents() += StringRef(buf, 2); // st_shndx
362
363    String64(buf, value);
364    F->getContents() += StringRef(buf, 8); // st_value
365
366    String64(buf, size);
367    F->getContents() += StringRef(buf, 8);  // st_size
368  } else {
369    char buf[4];
370
371    String32(buf, name);
372    F->getContents() += StringRef(buf, 4);  // st_name
373
374    String32(buf, value);
375    F->getContents() += StringRef(buf, 4); // st_value
376
377    String32(buf, size);
378    F->getContents() += StringRef(buf, 4);  // st_size
379
380    String8(buf, info);
381    F->getContents() += StringRef(buf, 1);  // st_info
382
383    String8(buf, other);
384    F->getContents() += StringRef(buf, 1); // st_other
385
386    String16(buf, shndx);
387    F->getContents() += StringRef(buf, 2); // st_shndx
388  }
389}
390
391void ELFObjectWriterImpl::WriteSymbol(MCDataFragment *F, ELFSymbolData &MSD,
392                                      const MCAsmLayout &Layout) {
393  MCSymbolData &Data = *MSD.SymbolData;
394  uint8_t Info = (Data.getFlags() & 0xff);
395  uint8_t Other = ((Data.getFlags() & 0xf00) >> ELF_STV_Shift);
396  uint64_t Value = 0;
397  uint64_t Size = 0;
398  const MCExpr *ESize;
399
400  if (Data.isCommon() && Data.isExternal())
401    Value = Data.getCommonAlignment();
402
403  ESize = Data.getSize();
404  if (Data.getSize()) {
405    MCValue Res;
406    if (ESize->getKind() == MCExpr::Binary) {
407      const MCBinaryExpr *BE = static_cast<const MCBinaryExpr *>(ESize);
408
409      if (BE->EvaluateAsRelocatable(Res, &Layout)) {
410        MCSymbolData &A =
411          Layout.getAssembler().getSymbolData(Res.getSymA()->getSymbol());
412        MCSymbolData &B =
413          Layout.getAssembler().getSymbolData(Res.getSymB()->getSymbol());
414
415        Size = Layout.getSymbolAddress(&A) - Layout.getSymbolAddress(&B);
416        Value = Layout.getSymbolAddress(&Data);
417      }
418    } else if (ESize->getKind() == MCExpr::Constant) {
419      const MCConstantExpr *CE;
420      CE = static_cast<const MCConstantExpr *>(ESize);
421      Size = CE->getValue();
422    } else {
423      assert(0 && "Unsupported size expression");
424    }
425  }
426
427  // Write out the symbol table entry
428  WriteSymbolEntry(F, MSD.StringIndex, Info, Value,
429                   Size, Other, MSD.SectionIndex);
430}
431
432void ELFObjectWriterImpl::WriteSymbolTable(MCDataFragment *F,
433                                           const MCAssembler &Asm,
434                                           const MCAsmLayout &Layout) {
435  // The string table must be emitted first because we need the index
436  // into the string table for all the symbol names.
437  assert(StringTable.size() && "Missing string table");
438
439  // FIXME: Make sure the start of the symbol table is aligned.
440
441  // The first entry is the undefined symbol entry.
442  unsigned EntrySize = Is64Bit ? ELF::SYMENTRY_SIZE64 : ELF::SYMENTRY_SIZE32;
443  for (unsigned i = 0; i < EntrySize; ++i)
444    F->getContents() += '\x00';
445
446  // Write the symbol table entries.
447  LastLocalSymbolIndex = LocalSymbolData.size() + 1;
448  for (unsigned i = 0, e = LocalSymbolData.size(); i != e; ++i) {
449    ELFSymbolData &MSD = LocalSymbolData[i];
450    WriteSymbol(F, MSD, Layout);
451  }
452
453  // Write out a symbol table entry for each section.
454  for (unsigned Index = 1; Index < Asm.size(); ++Index)
455    WriteSymbolEntry(F, 0, ELF::STT_SECTION, 0, 0, ELF::STV_DEFAULT, Index);
456  LastLocalSymbolIndex += Asm.size() - 1;
457
458  for (unsigned i = 0, e = ExternalSymbolData.size(); i != e; ++i) {
459    ELFSymbolData &MSD = ExternalSymbolData[i];
460    MCSymbolData &Data = *MSD.SymbolData;
461    assert((Data.getFlags() & ELF_STB_Global) &&
462           "External symbol requires STB_GLOBAL flag");
463    WriteSymbol(F, MSD, Layout);
464    if (Data.getFlags() & ELF_STB_Local)
465      LastLocalSymbolIndex++;
466  }
467
468  for (unsigned i = 0, e = UndefinedSymbolData.size(); i != e; ++i) {
469    ELFSymbolData &MSD = UndefinedSymbolData[i];
470    MCSymbolData &Data = *MSD.SymbolData;
471    Data.setFlags(Data.getFlags() | ELF_STB_Global);
472    WriteSymbol(F, MSD, Layout);
473    if (Data.getFlags() & ELF_STB_Local)
474      LastLocalSymbolIndex++;
475  }
476}
477
478// FIXME: this is currently X86_64 only
479void ELFObjectWriterImpl::RecordRelocation(const MCAssembler &Asm,
480                                           const MCAsmLayout &Layout,
481                                           const MCFragment *Fragment,
482                                           const MCFixup &Fixup,
483                                           MCValue Target,
484                                           uint64_t &FixedValue) {
485  unsigned IsPCRel = isFixupKindX86PCRel(Fixup.getKind());
486  ELFRelocationEntry ERE;
487  struct ELF::Elf64_Rela ERE64;
488
489  uint64_t FixupOffset =
490    Layout.getFragmentOffset(Fragment) + Fixup.getOffset();
491  int64_t Value;
492  int64_t Addend = 0;
493  unsigned Index = 0;
494  unsigned Type;
495
496  Value = Target.getConstant();
497
498  if (Target.isAbsolute()) {
499    Type = ELF::R_X86_64_NONE;
500    Index = 0;
501  } else {
502    const MCSymbol *Symbol = &Target.getSymA()->getSymbol();
503    MCSymbolData &SD = Asm.getSymbolData(*Symbol);
504    const MCSymbolData *Base = Asm.getAtom(Layout, &SD);
505
506    if (Base) {
507      Index = getSymbolIndexInSymbolTable(const_cast<MCAssembler &>(Asm), &Base->getSymbol());
508      if (Base != &SD)
509        Value += Layout.getSymbolAddress(&SD) - Layout.getSymbolAddress(Base);
510      Addend = Value;
511      Value = 0;
512    } else {
513      MCFragment *F = SD.getFragment();
514      if (F) {
515        // Index of the section in .symtab against this symbol
516        // is being relocated + 2 (empty section + abs. symbols).
517        Index = SD.getFragment()->getParent()->getOrdinal() +
518          getNumOfLocalSymbols(Asm) + 1;
519
520        MCSectionData *FSD = F->getParent();
521        // Offset of the symbol in the section
522        Addend = Layout.getSymbolAddress(&SD) - Layout.getSectionAddress(FSD);
523      } else {
524        FixedValue = Value;
525        return;
526      }
527    }
528  }
529
530  // determine the type of the relocation
531  if (IsPCRel) {
532    Type = ELF::R_X86_64_PC32;
533  } else {
534    switch (Fixup.getKind()) {
535    case FK_Data_8: Type = ELF::R_X86_64_64; break;
536    case X86::reloc_pcrel_4byte:
537    case FK_Data_4:
538      long Offset;
539      Offset = Target.getConstant();
540      // check that the offset fits within a signed long
541      if (!(((long) -1 << 31) & Offset) || (((long) -1 << 31) & Offset) == ((long) -1 << 31))
542        Type = ELF::R_X86_64_32S;
543      else
544        Type = ELF::R_X86_64_32;
545      break;
546    case FK_Data_2: Type = ELF::R_X86_64_16; break;
547    case X86::reloc_pcrel_1byte:
548    case FK_Data_1:
549      Type = ELF::R_X86_64_8;
550      break;
551    }
552  }
553
554  FixedValue = Value;
555
556  ERE64.setSymbolAndType(Index, Type);
557
558  ERE.r_offset = FixupOffset;
559  ERE.r_info = ERE64.r_info;
560  if (HasRelocationAddend)
561    ERE.r_addend = Addend;
562
563  Relocations[Fragment->getParent()].push_back(ERE);
564}
565
566// XXX-PERF: this should be cached
567uint64_t ELFObjectWriterImpl::getSymbolIndexInSymbolTable(MCAssembler &Asm,
568                                                          const MCSymbol *S) {
569  std::vector<ELFSymbolData> Local;
570  std::vector<ELFSymbolData> External;
571  std::vector<ELFSymbolData> Undefined;
572
573  for (MCAssembler::symbol_iterator it = Asm.symbol_begin(),
574         ie = Asm.symbol_end(); it != ie; ++it) {
575    const MCSymbol &Symbol = it->getSymbol();
576
577    // Ignore non-linker visible symbols.
578    if (!Asm.isSymbolLinkerVisible(Symbol))
579      continue;
580
581    if (it->isExternal() || Symbol.isUndefined())
582      continue;
583
584    ELFSymbolData MSD;
585    MSD.SymbolData = it;
586
587    Local.push_back(MSD);
588  }
589  for (MCAssembler::symbol_iterator it = Asm.symbol_begin(),
590         ie = Asm.symbol_end(); it != ie; ++it) {
591    const MCSymbol &Symbol = it->getSymbol();
592
593    // Ignore non-linker visible symbols.
594    if (!Asm.isSymbolLinkerVisible(Symbol))
595      continue;
596
597    if (!it->isExternal() && !Symbol.isUndefined())
598      continue;
599
600    ELFSymbolData MSD;
601    MSD.SymbolData = it;
602
603    if (Symbol.isUndefined()) {
604      Undefined.push_back(MSD);
605    } else if (Symbol.isAbsolute()) {
606      External.push_back(MSD);
607    } else if (it->isCommon()) {
608      External.push_back(MSD);
609    } else {
610      External.push_back(MSD);
611    }
612  }
613
614  array_pod_sort(Local.begin(), Local.end());
615  array_pod_sort(External.begin(), External.end());
616  array_pod_sort(Undefined.begin(), Undefined.end());
617
618  for (unsigned i = 0, e = Local.size(); i != e; ++i)
619    if (&Local[i].SymbolData->getSymbol() == S)
620      return i + /* empty symbol */ 1;
621  for (unsigned i = 0, e = External.size(); i != e; ++i)
622    if (&External[i].SymbolData->getSymbol() == S)
623      return i + Local.size() + Asm.size() + /* empty symbol */ 1 +
624        /* .rela.text + .rela.eh_frame */ + 2;
625  for (unsigned i = 0, e = Undefined.size(); i != e; ++i)
626    if (&Undefined[i].SymbolData->getSymbol() == S)
627      return i + Local.size() + External.size() + Asm.size() + /* empty symbol */ 1 +
628        /* .rela.text + .rela.eh_frame */ + 2;
629
630  llvm_unreachable("Cannot find symbol which should exist!");
631}
632
633void ELFObjectWriterImpl::ComputeSymbolTable(MCAssembler &Asm) {
634  // Build section lookup table.
635  DenseMap<const MCSection*, uint8_t> SectionIndexMap;
636  unsigned Index = 1;
637  for (MCAssembler::iterator it = Asm.begin(),
638         ie = Asm.end(); it != ie; ++it, ++Index)
639    SectionIndexMap[&it->getSection()] = Index;
640
641  // Index 0 is always the empty string.
642  StringMap<uint64_t> StringIndexMap;
643  StringTable += '\x00';
644
645  // Add the data for local symbols.
646  for (MCAssembler::symbol_iterator it = Asm.symbol_begin(),
647         ie = Asm.symbol_end(); it != ie; ++it) {
648    const MCSymbol &Symbol = it->getSymbol();
649
650    // Ignore non-linker visible symbols.
651    if (!Asm.isSymbolLinkerVisible(Symbol))
652      continue;
653
654    if (it->isExternal() || Symbol.isUndefined())
655      continue;
656
657    uint64_t &Entry = StringIndexMap[Symbol.getName()];
658    if (!Entry) {
659      Entry = StringTable.size();
660      StringTable += Symbol.getName();
661      StringTable += '\x00';
662    }
663
664    ELFSymbolData MSD;
665    MSD.SymbolData = it;
666    MSD.StringIndex = Entry;
667
668    if (Symbol.isAbsolute()) {
669      MSD.SectionIndex = ELF::SHN_ABS;
670      LocalSymbolData.push_back(MSD);
671    } else {
672      MSD.SectionIndex = SectionIndexMap.lookup(&Symbol.getSection());
673      assert(MSD.SectionIndex && "Invalid section index!");
674      LocalSymbolData.push_back(MSD);
675    }
676  }
677
678  // Now add non-local symbols.
679  for (MCAssembler::symbol_iterator it = Asm.symbol_begin(),
680         ie = Asm.symbol_end(); it != ie; ++it) {
681    const MCSymbol &Symbol = it->getSymbol();
682
683    // Ignore non-linker visible symbols.
684    if (!Asm.isSymbolLinkerVisible(Symbol))
685      continue;
686
687    if (!it->isExternal() && !Symbol.isUndefined())
688      continue;
689
690    uint64_t &Entry = StringIndexMap[Symbol.getName()];
691    if (!Entry) {
692      Entry = StringTable.size();
693      StringTable += Symbol.getName();
694      StringTable += '\x00';
695    }
696
697    ELFSymbolData MSD;
698    MSD.SymbolData = it;
699    MSD.StringIndex = Entry;
700
701    if (Symbol.isUndefined()) {
702      MSD.SectionIndex = ELF::SHN_UNDEF;
703      // XXX: for some reason we dont Emit* this
704      it->setFlags(it->getFlags() | ELF_STB_Global);
705      UndefinedSymbolData.push_back(MSD);
706    } else if (Symbol.isAbsolute()) {
707      MSD.SectionIndex = ELF::SHN_ABS;
708      ExternalSymbolData.push_back(MSD);
709    } else if (it->isCommon()) {
710      MSD.SectionIndex = ELF::SHN_COMMON;
711      ExternalSymbolData.push_back(MSD);
712    } else {
713      MSD.SectionIndex = SectionIndexMap.lookup(&Symbol.getSection());
714      assert(MSD.SectionIndex && "Invalid section index!");
715      ExternalSymbolData.push_back(MSD);
716    }
717  }
718
719  // Symbols are required to be in lexicographic order.
720  array_pod_sort(LocalSymbolData.begin(), LocalSymbolData.end());
721  array_pod_sort(ExternalSymbolData.begin(), ExternalSymbolData.end());
722  array_pod_sort(UndefinedSymbolData.begin(), UndefinedSymbolData.end());
723
724  // Set the symbol indices. Local symbols must come before all other
725  // symbols with non-local bindings.
726  Index = 0;
727  for (unsigned i = 0, e = LocalSymbolData.size(); i != e; ++i)
728    LocalSymbolData[i].SymbolData->setIndex(Index++);
729  for (unsigned i = 0, e = ExternalSymbolData.size(); i != e; ++i)
730    ExternalSymbolData[i].SymbolData->setIndex(Index++);
731  for (unsigned i = 0, e = UndefinedSymbolData.size(); i != e; ++i)
732    UndefinedSymbolData[i].SymbolData->setIndex(Index++);
733}
734
735void ELFObjectWriterImpl::WriteRelocation(MCAssembler &Asm, MCAsmLayout &Layout,
736                                          const MCSectionData &SD) {
737  if (!Relocations[&SD].empty()) {
738    MCContext &Ctx = Asm.getContext();
739    const MCSection *RelaSection;
740    const MCSectionELF &Section =
741      static_cast<const MCSectionELF&>(SD.getSection());
742
743    const StringRef SectionName = Section.getSectionName();
744    std::string RelaSectionName = ".rela";
745
746    RelaSectionName += SectionName;
747    unsigned EntrySize = Is64Bit ? ELF::SYMENTRY_SIZE64 : ELF::SYMENTRY_SIZE32;
748
749    RelaSection = Ctx.getELFSection(RelaSectionName, ELF::SHT_RELA, 0,
750                                    SectionKind::getReadOnly(),
751                                    false, EntrySize);
752
753    MCSectionData &RelaSD = Asm.getOrCreateSectionData(*RelaSection);
754    RelaSD.setAlignment(1);
755
756    MCDataFragment *F = new MCDataFragment(&RelaSD);
757
758    WriteRelocationsFragment(Asm, F, &SD);
759
760    Asm.AddSectionToTheEnd(RelaSD, Layout);
761  }
762}
763
764void ELFObjectWriterImpl::WriteSecHdrEntry(uint32_t Name, uint32_t Type,
765                                           uint64_t Flags, uint64_t Address,
766                                           uint64_t Offset, uint64_t Size,
767                                           uint32_t Link, uint32_t Info,
768                                           uint64_t Alignment,
769                                           uint64_t EntrySize) {
770  Write32(Name);        // sh_name: index into string table
771  Write32(Type);        // sh_type
772  WriteWord(Flags);     // sh_flags
773  WriteWord(Address);   // sh_addr
774  WriteWord(Offset);    // sh_offset
775  WriteWord(Size);      // sh_size
776  Write32(Link);        // sh_link
777  Write32(Info);        // sh_info
778  WriteWord(Alignment); // sh_addralign
779  WriteWord(EntrySize); // sh_entsize
780}
781
782void ELFObjectWriterImpl::WriteRelocationsFragment(const MCAssembler &Asm,
783                                                   MCDataFragment *F,
784                                                   const MCSectionData *SD) {
785  std::vector<ELFRelocationEntry> &Relocs = Relocations[SD];
786  // sort by the r_offset just like gnu as does
787  array_pod_sort(Relocs.begin(), Relocs.end());
788
789  for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
790    ELFRelocationEntry entry = Relocs[e - i - 1];
791
792    if (Is64Bit) {
793      F->getContents() +=  StringRef((const char *)&entry.r_offset, 8);
794      F->getContents() +=  StringRef((const char *)&entry.r_info, 8);
795
796      if (HasRelocationAddend)
797        F->getContents() +=  StringRef((const char *)&entry.r_addend, 8);
798    } else {
799      F->getContents() +=  StringRef((const char *)&entry.r_offset, 4);
800      F->getContents() +=  StringRef((const char *)&entry.r_info, 4);
801
802      if (HasRelocationAddend)
803        F->getContents() +=  StringRef((const char *)&entry.r_addend, 4);
804    }
805  }
806}
807
808void ELFObjectWriterImpl::CreateMetadataSections(MCAssembler &Asm,
809                                                 MCAsmLayout &Layout) {
810  MCContext &Ctx = Asm.getContext();
811  MCDataFragment *F;
812
813  WriteRelocations(Asm, Layout);
814
815  const MCSection *SymtabSection;
816  unsigned EntrySize = Is64Bit ? ELF::SYMENTRY_SIZE64 : ELF::SYMENTRY_SIZE32;
817
818  SymtabSection = Ctx.getELFSection(".symtab", ELF::SHT_SYMTAB, 0,
819                                    SectionKind::getReadOnly(),
820                                    false, EntrySize);
821
822  MCSectionData &SymtabSD = Asm.getOrCreateSectionData(*SymtabSection);
823
824  SymtabSD.setAlignment(Is64Bit ? 8 : 4);
825
826  F = new MCDataFragment(&SymtabSD);
827
828  // Symbol table
829  WriteSymbolTable(F, Asm, Layout);
830  Asm.AddSectionToTheEnd(SymtabSD, Layout);
831
832  const MCSection *StrtabSection;
833  StrtabSection = Ctx.getELFSection(".strtab", ELF::SHT_STRTAB, 0,
834                                    SectionKind::getReadOnly(), false);
835
836  MCSectionData &StrtabSD = Asm.getOrCreateSectionData(*StrtabSection);
837  StrtabSD.setAlignment(1);
838
839  // FIXME: This isn't right. If the sections get rearranged this will
840  // be wrong. We need a proper lookup.
841  StringTableIndex = Asm.size();
842
843  F = new MCDataFragment(&StrtabSD);
844  F->getContents().append(StringTable.begin(), StringTable.end());
845  Asm.AddSectionToTheEnd(StrtabSD, Layout);
846
847  const MCSection *ShstrtabSection;
848  ShstrtabSection = Ctx.getELFSection(".shstrtab", ELF::SHT_STRTAB, 0,
849                                      SectionKind::getReadOnly(), false);
850
851  MCSectionData &ShstrtabSD = Asm.getOrCreateSectionData(*ShstrtabSection);
852  ShstrtabSD.setAlignment(1);
853
854  F = new MCDataFragment(&ShstrtabSD);
855
856  // FIXME: This isn't right. If the sections get rearranged this will
857  // be wrong. We need a proper lookup.
858  ShstrtabIndex = Asm.size();
859
860  // Section header string table.
861  //
862  // The first entry of a string table holds a null character so skip
863  // section 0.
864  uint64_t Index = 1;
865  F->getContents() += '\x00';
866
867  for (MCAssembler::const_iterator it = Asm.begin(),
868         ie = Asm.end(); it != ie; ++it) {
869    const MCSectionData &SD = *it;
870    const MCSectionELF &Section =
871      static_cast<const MCSectionELF&>(SD.getSection());
872
873
874    // Remember the index into the string table so we can write it
875    // into the sh_name field of the section header table.
876    SectionStringTableIndex[&it->getSection()] = Index;
877
878    Index += Section.getSectionName().size() + 1;
879    F->getContents() += Section.getSectionName();
880    F->getContents() += '\x00';
881  }
882
883  Asm.AddSectionToTheEnd(ShstrtabSD, Layout);
884}
885
886void ELFObjectWriterImpl::WriteObject(const MCAssembler &Asm,
887                                      const MCAsmLayout &Layout) {
888  // Compute symbol table information.
889  ComputeSymbolTable(const_cast<MCAssembler&>(Asm));
890
891  CreateMetadataSections(const_cast<MCAssembler&>(Asm),
892                         const_cast<MCAsmLayout&>(Layout));
893
894  // Add 1 for the null section.
895  unsigned NumSections = Asm.size() + 1;
896
897  uint64_t SectionDataSize = 0;
898
899  for (MCAssembler::const_iterator it = Asm.begin(),
900         ie = Asm.end(); it != ie; ++it) {
901    const MCSectionData &SD = *it;
902
903    // Get the size of the section in the output file (including padding).
904    uint64_t Size = Layout.getSectionFileSize(&SD);
905    SectionDataSize += Size;
906  }
907
908  // Write out the ELF header ...
909  WriteHeader(SectionDataSize, NumSections);
910  FileOff = Is64Bit ? sizeof(ELF::Elf64_Ehdr) : sizeof(ELF::Elf32_Ehdr);
911
912  // ... then all of the sections ...
913  DenseMap<const MCSection*, uint64_t> SectionOffsetMap;
914
915  for (MCAssembler::const_iterator it = Asm.begin(),
916         ie = Asm.end(); it != ie; ++it) {
917    // Remember the offset into the file for this section.
918    SectionOffsetMap[&it->getSection()] = FileOff;
919
920    const MCSectionData &SD = *it;
921    FileOff += Layout.getSectionFileSize(&SD);
922
923    Asm.WriteSectionData(it, Layout, Writer);
924  }
925
926  // ... and then the section header table.
927  // Should we align the section header table?
928  //
929  // Null section first.
930  WriteSecHdrEntry(0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
931
932  for (MCAssembler::const_iterator it = Asm.begin(),
933         ie = Asm.end(); it != ie; ++it) {
934    const MCSectionData &SD = *it;
935    const MCSectionELF &Section =
936      static_cast<const MCSectionELF&>(SD.getSection());
937
938    uint64_t sh_link = 0;
939    uint64_t sh_info = 0;
940
941    switch(Section.getType()) {
942    case ELF::SHT_DYNAMIC:
943      sh_link = SectionStringTableIndex[&it->getSection()];
944      sh_info = 0;
945      break;
946
947    case ELF::SHT_REL:
948    case ELF::SHT_RELA: {
949      const MCSection *SymtabSection;
950      const MCSection *InfoSection;
951      StringRef SectionName;
952      const MCSectionData *SymtabSD;
953      const MCSectionData *InfoSD;
954
955      SymtabSection = Asm.getContext().getELFSection(".symtab", ELF::SHT_SYMTAB, 0,
956                                                     SectionKind::getReadOnly(),
957                                                     false);
958      SymtabSD = &Asm.getSectionData(*SymtabSection);
959      // we have to count the empty section in too
960      sh_link = SymtabSD->getLayoutOrder() + 1;
961
962      SectionName = Section.getSectionName();
963      SectionName = SectionName.slice(5, SectionName.size());
964      InfoSection = Asm.getContext().getELFSection(SectionName,
965                                                   ELF::SHT_PROGBITS, 0,
966                                                   SectionKind::getReadOnly(),
967                                                   false);
968      InfoSD = &Asm.getSectionData(*InfoSection);
969      sh_info = InfoSD->getLayoutOrder() + 1;
970      break;
971    }
972
973    case ELF::SHT_SYMTAB:
974    case ELF::SHT_DYNSYM:
975      sh_link = StringTableIndex;
976      sh_info = LastLocalSymbolIndex;
977      break;
978
979    case ELF::SHT_PROGBITS:
980    case ELF::SHT_STRTAB:
981    case ELF::SHT_NOBITS:
982      // Nothing to do.
983      break;
984
985    case ELF::SHT_HASH:
986    case ELF::SHT_GROUP:
987    case ELF::SHT_SYMTAB_SHNDX:
988    default:
989      assert(0 && "FIXME: sh_type value not supported!");
990      break;
991    }
992
993    WriteSecHdrEntry(SectionStringTableIndex[&it->getSection()],
994                     Section.getType(), Section.getFlags(),
995                     Layout.getSectionAddress(&SD),
996                     SectionOffsetMap.lookup(&SD.getSection()),
997                     Layout.getSectionSize(&SD), sh_link,
998                     sh_info, SD.getAlignment(),
999                     Section.getEntrySize());
1000  }
1001}
1002
1003ELFObjectWriter::ELFObjectWriter(raw_ostream &OS,
1004                                 bool Is64Bit,
1005                                 bool IsLittleEndian,
1006                                 bool HasRelocationAddend)
1007  : MCObjectWriter(OS, IsLittleEndian)
1008{
1009  Impl = new ELFObjectWriterImpl(this, Is64Bit, HasRelocationAddend);
1010}
1011
1012ELFObjectWriter::~ELFObjectWriter() {
1013  delete (ELFObjectWriterImpl*) Impl;
1014}
1015
1016void ELFObjectWriter::ExecutePostLayoutBinding(MCAssembler &Asm) {
1017  ((ELFObjectWriterImpl*) Impl)->ExecutePostLayoutBinding(Asm);
1018}
1019
1020void ELFObjectWriter::RecordRelocation(const MCAssembler &Asm,
1021                                       const MCAsmLayout &Layout,
1022                                       const MCFragment *Fragment,
1023                                       const MCFixup &Fixup, MCValue Target,
1024                                       uint64_t &FixedValue) {
1025  ((ELFObjectWriterImpl*) Impl)->RecordRelocation(Asm, Layout, Fragment, Fixup,
1026                                                  Target, FixedValue);
1027}
1028
1029void ELFObjectWriter::WriteObject(const MCAssembler &Asm,
1030                                  const MCAsmLayout &Layout) {
1031  ((ELFObjectWriterImpl*) Impl)->WriteObject(Asm, Layout);
1032}
1033