1//===- lib/MC/MCELFStreamer.cpp - ELF Object Output -----------------------===//
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 assembles .s files and emits ELF .o object files.
11//
12//===----------------------------------------------------------------------===//
13
14#include "llvm/MC/MCELFStreamer.h"
15#include "llvm/ADT/SmallPtrSet.h"
16#include "llvm/ADT/STLExtras.h"
17#include "llvm/MC/MCAssembler.h"
18#include "llvm/MC/MCCodeEmitter.h"
19#include "llvm/MC/MCContext.h"
20#include "llvm/MC/MCELF.h"
21#include "llvm/MC/MCELFSymbolFlags.h"
22#include "llvm/MC/MCExpr.h"
23#include "llvm/MC/MCInst.h"
24#include "llvm/MC/MCObjectStreamer.h"
25#include "llvm/MC/MCSection.h"
26#include "llvm/MC/MCSectionELF.h"
27#include "llvm/MC/MCSymbol.h"
28#include "llvm/MC/MCValue.h"
29#include "llvm/Support/Debug.h"
30#include "llvm/Support/ELF.h"
31#include "llvm/Support/ErrorHandling.h"
32#include "llvm/Support/raw_ostream.h"
33
34using namespace llvm;
35
36
37inline void MCELFStreamer::SetSection(StringRef Section, unsigned Type,
38                                      unsigned Flags, SectionKind Kind) {
39  SwitchSection(getContext().getELFSection(Section, Type, Flags, Kind));
40}
41
42inline void MCELFStreamer::SetSectionData() {
43  SetSection(".data",
44             ELF::SHT_PROGBITS,
45             ELF::SHF_WRITE | ELF::SHF_ALLOC,
46             SectionKind::getDataRel());
47  EmitCodeAlignment(4, 0);
48}
49
50inline void MCELFStreamer::SetSectionText() {
51  SetSection(".text",
52             ELF::SHT_PROGBITS,
53             ELF::SHF_EXECINSTR | ELF::SHF_ALLOC,
54             SectionKind::getText());
55  EmitCodeAlignment(4, 0);
56}
57
58inline void MCELFStreamer::SetSectionBss() {
59  SetSection(".bss",
60             ELF::SHT_NOBITS,
61             ELF::SHF_WRITE | ELF::SHF_ALLOC,
62             SectionKind::getBSS());
63  EmitCodeAlignment(4, 0);
64}
65
66MCELFStreamer::~MCELFStreamer() {
67}
68
69void MCELFStreamer::InitToTextSection() {
70  SetSectionText();
71}
72
73void MCELFStreamer::InitSections() {
74  // This emulates the same behavior of GNU as. This makes it easier
75  // to compare the output as the major sections are in the same order.
76  SetSectionText();
77  SetSectionData();
78  SetSectionBss();
79  SetSectionText();
80}
81
82void MCELFStreamer::EmitLabel(MCSymbol *Symbol) {
83  assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
84
85  MCObjectStreamer::EmitLabel(Symbol);
86
87  const MCSectionELF &Section =
88    static_cast<const MCSectionELF&>(Symbol->getSection());
89  MCSymbolData &SD = getAssembler().getSymbolData(*Symbol);
90  if (Section.getFlags() & ELF::SHF_TLS)
91    MCELF::SetType(SD, ELF::STT_TLS);
92}
93
94void MCELFStreamer::EmitDebugLabel(MCSymbol *Symbol) {
95  EmitLabel(Symbol);
96}
97
98void MCELFStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {
99  switch (Flag) {
100  case MCAF_SyntaxUnified: return; // no-op here.
101  case MCAF_Code16: return; // Change parsing mode; no-op here.
102  case MCAF_Code32: return; // Change parsing mode; no-op here.
103  case MCAF_Code64: return; // Change parsing mode; no-op here.
104  case MCAF_SubsectionsViaSymbols:
105    getAssembler().setSubsectionsViaSymbols(true);
106    return;
107  }
108
109  llvm_unreachable("invalid assembler flag!");
110}
111
112void MCELFStreamer::ChangeSection(const MCSection *Section,
113                                  const MCExpr *Subsection) {
114  MCSectionData *CurSection = getCurrentSectionData();
115  if (CurSection && CurSection->isBundleLocked())
116    report_fatal_error("Unterminated .bundle_lock when changing a section");
117  const MCSymbol *Grp = static_cast<const MCSectionELF *>(Section)->getGroup();
118  if (Grp)
119    getAssembler().getOrCreateSymbolData(*Grp);
120  this->MCObjectStreamer::ChangeSection(Section, Subsection);
121}
122
123void MCELFStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {
124  getAssembler().getOrCreateSymbolData(*Symbol);
125  MCSymbolData &AliasSD = getAssembler().getOrCreateSymbolData(*Alias);
126  AliasSD.setFlags(AliasSD.getFlags() | ELF_Other_Weakref);
127  const MCExpr *Value = MCSymbolRefExpr::Create(Symbol, getContext());
128  Alias->setVariableValue(Value);
129}
130
131// When GNU as encounters more than one .type declaration for an object it seems
132// to use a mechanism similar to the one below to decide which type is actually
133// used in the object file.  The greater of T1 and T2 is selected based on the
134// following ordering:
135//  STT_NOTYPE < STT_OBJECT < STT_FUNC < STT_GNU_IFUNC < STT_TLS < anything else
136// If neither T1 < T2 nor T2 < T1 according to this ordering, use T2 (the user
137// provided type).
138static unsigned CombineSymbolTypes(unsigned T1, unsigned T2) {
139  unsigned TypeOrdering[] = {ELF::STT_NOTYPE, ELF::STT_OBJECT, ELF::STT_FUNC,
140                             ELF::STT_GNU_IFUNC, ELF::STT_TLS};
141  for (unsigned i = 0; i != array_lengthof(TypeOrdering); ++i) {
142    if (T1 == TypeOrdering[i])
143      return T2;
144    if (T2 == TypeOrdering[i])
145      return T1;
146  }
147
148  return T2;
149}
150
151void MCELFStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
152                                          MCSymbolAttr Attribute) {
153  // Indirect symbols are handled differently, to match how 'as' handles
154  // them. This makes writing matching .o files easier.
155  if (Attribute == MCSA_IndirectSymbol) {
156    // Note that we intentionally cannot use the symbol data here; this is
157    // important for matching the string table that 'as' generates.
158    IndirectSymbolData ISD;
159    ISD.Symbol = Symbol;
160    ISD.SectionData = getCurrentSectionData();
161    getAssembler().getIndirectSymbols().push_back(ISD);
162    return;
163  }
164
165  // Adding a symbol attribute always introduces the symbol, note that an
166  // important side effect of calling getOrCreateSymbolData here is to register
167  // the symbol with the assembler.
168  MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
169
170  // The implementation of symbol attributes is designed to match 'as', but it
171  // leaves much to desired. It doesn't really make sense to arbitrarily add and
172  // remove flags, but 'as' allows this (in particular, see .desc).
173  //
174  // In the future it might be worth trying to make these operations more well
175  // defined.
176  switch (Attribute) {
177  case MCSA_LazyReference:
178  case MCSA_Reference:
179  case MCSA_SymbolResolver:
180  case MCSA_PrivateExtern:
181  case MCSA_WeakDefinition:
182  case MCSA_WeakDefAutoPrivate:
183  case MCSA_Invalid:
184  case MCSA_IndirectSymbol:
185    llvm_unreachable("Invalid symbol attribute for ELF!");
186
187  case MCSA_NoDeadStrip:
188  case MCSA_ELF_TypeGnuUniqueObject:
189    // Ignore for now.
190    break;
191
192  case MCSA_Global:
193    MCELF::SetBinding(SD, ELF::STB_GLOBAL);
194    SD.setExternal(true);
195    BindingExplicitlySet.insert(Symbol);
196    break;
197
198  case MCSA_WeakReference:
199  case MCSA_Weak:
200    MCELF::SetBinding(SD, ELF::STB_WEAK);
201    SD.setExternal(true);
202    BindingExplicitlySet.insert(Symbol);
203    break;
204
205  case MCSA_Local:
206    MCELF::SetBinding(SD, ELF::STB_LOCAL);
207    SD.setExternal(false);
208    BindingExplicitlySet.insert(Symbol);
209    break;
210
211  case MCSA_ELF_TypeFunction:
212    MCELF::SetType(SD, CombineSymbolTypes(MCELF::GetType(SD),
213                                          ELF::STT_FUNC));
214    break;
215
216  case MCSA_ELF_TypeIndFunction:
217    MCELF::SetType(SD, CombineSymbolTypes(MCELF::GetType(SD),
218                                          ELF::STT_GNU_IFUNC));
219    break;
220
221  case MCSA_ELF_TypeObject:
222    MCELF::SetType(SD, CombineSymbolTypes(MCELF::GetType(SD),
223                                          ELF::STT_OBJECT));
224    break;
225
226  case MCSA_ELF_TypeTLS:
227    MCELF::SetType(SD, CombineSymbolTypes(MCELF::GetType(SD),
228                                          ELF::STT_TLS));
229    break;
230
231  case MCSA_ELF_TypeCommon:
232    // TODO: Emit these as a common symbol.
233    MCELF::SetType(SD, CombineSymbolTypes(MCELF::GetType(SD),
234                                          ELF::STT_OBJECT));
235    break;
236
237  case MCSA_ELF_TypeNoType:
238    MCELF::SetType(SD, CombineSymbolTypes(MCELF::GetType(SD),
239                                          ELF::STT_NOTYPE));
240    break;
241
242  case MCSA_Protected:
243    MCELF::SetVisibility(SD, ELF::STV_PROTECTED);
244    break;
245
246  case MCSA_Hidden:
247    MCELF::SetVisibility(SD, ELF::STV_HIDDEN);
248    break;
249
250  case MCSA_Internal:
251    MCELF::SetVisibility(SD, ELF::STV_INTERNAL);
252    break;
253  }
254}
255
256void MCELFStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
257                                       unsigned ByteAlignment) {
258  MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
259
260  if (!BindingExplicitlySet.count(Symbol)) {
261    MCELF::SetBinding(SD, ELF::STB_GLOBAL);
262    SD.setExternal(true);
263  }
264
265  MCELF::SetType(SD, ELF::STT_OBJECT);
266
267  if (MCELF::GetBinding(SD) == ELF_STB_Local) {
268    const MCSection *Section = getAssembler().getContext().getELFSection(".bss",
269                                                         ELF::SHT_NOBITS,
270                                                         ELF::SHF_WRITE |
271                                                         ELF::SHF_ALLOC,
272                                                         SectionKind::getBSS());
273    Symbol->setSection(*Section);
274
275    struct LocalCommon L = {&SD, Size, ByteAlignment};
276    LocalCommons.push_back(L);
277  } else {
278    SD.setCommon(Size, ByteAlignment);
279  }
280
281  SD.setSize(MCConstantExpr::Create(Size, getContext()));
282}
283
284void MCELFStreamer::EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) {
285  MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
286  SD.setSize(Value);
287}
288
289void MCELFStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
290                                          unsigned ByteAlignment) {
291  // FIXME: Should this be caught and done earlier?
292  MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
293  MCELF::SetBinding(SD, ELF::STB_LOCAL);
294  SD.setExternal(false);
295  BindingExplicitlySet.insert(Symbol);
296  EmitCommonSymbol(Symbol, Size, ByteAlignment);
297}
298
299void MCELFStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size) {
300  if (getCurrentSectionData()->isBundleLocked())
301    report_fatal_error("Emitting values inside a locked bundle is forbidden");
302  fixSymbolsInTLSFixups(Value);
303  MCObjectStreamer::EmitValueImpl(Value, Size);
304}
305
306void MCELFStreamer::EmitValueToAlignment(unsigned ByteAlignment,
307                                         int64_t Value,
308                                         unsigned ValueSize,
309                                         unsigned MaxBytesToEmit) {
310  if (getCurrentSectionData()->isBundleLocked())
311    report_fatal_error("Emitting values inside a locked bundle is forbidden");
312  MCObjectStreamer::EmitValueToAlignment(ByteAlignment, Value,
313                                         ValueSize, MaxBytesToEmit);
314}
315
316
317// Add a symbol for the file name of this module. This is the second
318// entry in the module's symbol table (the first being the null symbol).
319void MCELFStreamer::EmitFileDirective(StringRef Filename) {
320  MCSymbol *Symbol = getAssembler().getContext().GetOrCreateSymbol(Filename);
321  Symbol->setSection(*getCurrentSection().first);
322  Symbol->setAbsolute();
323
324  MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
325
326  SD.setFlags(ELF_STT_File | ELF_STB_Local | ELF_STV_Default);
327}
328
329void  MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) {
330  switch (expr->getKind()) {
331  case MCExpr::Target:
332    cast<MCTargetExpr>(expr)->fixELFSymbolsInTLSFixups(getAssembler());
333    break;
334  case MCExpr::Constant:
335    break;
336
337  case MCExpr::Binary: {
338    const MCBinaryExpr *be = cast<MCBinaryExpr>(expr);
339    fixSymbolsInTLSFixups(be->getLHS());
340    fixSymbolsInTLSFixups(be->getRHS());
341    break;
342  }
343
344  case MCExpr::SymbolRef: {
345    const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr);
346    switch (symRef.getKind()) {
347    default:
348      return;
349    case MCSymbolRefExpr::VK_GOTTPOFF:
350    case MCSymbolRefExpr::VK_INDNTPOFF:
351    case MCSymbolRefExpr::VK_NTPOFF:
352    case MCSymbolRefExpr::VK_GOTNTPOFF:
353    case MCSymbolRefExpr::VK_TLSGD:
354    case MCSymbolRefExpr::VK_TLSLD:
355    case MCSymbolRefExpr::VK_TLSLDM:
356    case MCSymbolRefExpr::VK_TPOFF:
357    case MCSymbolRefExpr::VK_DTPOFF:
358    case MCSymbolRefExpr::VK_ARM_TLSGD:
359    case MCSymbolRefExpr::VK_ARM_TPOFF:
360    case MCSymbolRefExpr::VK_ARM_GOTTPOFF:
361    case MCSymbolRefExpr::VK_Mips_TLSGD:
362    case MCSymbolRefExpr::VK_Mips_GOTTPREL:
363    case MCSymbolRefExpr::VK_Mips_TPREL_HI:
364    case MCSymbolRefExpr::VK_Mips_TPREL_LO:
365    case MCSymbolRefExpr::VK_PPC_DTPMOD:
366    case MCSymbolRefExpr::VK_PPC_TPREL:
367    case MCSymbolRefExpr::VK_PPC_TPREL_LO:
368    case MCSymbolRefExpr::VK_PPC_TPREL_HI:
369    case MCSymbolRefExpr::VK_PPC_TPREL_HA:
370    case MCSymbolRefExpr::VK_PPC_TPREL_HIGHER:
371    case MCSymbolRefExpr::VK_PPC_TPREL_HIGHERA:
372    case MCSymbolRefExpr::VK_PPC_TPREL_HIGHEST:
373    case MCSymbolRefExpr::VK_PPC_TPREL_HIGHESTA:
374    case MCSymbolRefExpr::VK_PPC_DTPREL:
375    case MCSymbolRefExpr::VK_PPC_DTPREL_LO:
376    case MCSymbolRefExpr::VK_PPC_DTPREL_HI:
377    case MCSymbolRefExpr::VK_PPC_DTPREL_HA:
378    case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHER:
379    case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHERA:
380    case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHEST:
381    case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHESTA:
382    case MCSymbolRefExpr::VK_PPC_GOT_TPREL:
383    case MCSymbolRefExpr::VK_PPC_GOT_TPREL_LO:
384    case MCSymbolRefExpr::VK_PPC_GOT_TPREL_HI:
385    case MCSymbolRefExpr::VK_PPC_GOT_TPREL_HA:
386    case MCSymbolRefExpr::VK_PPC_GOT_DTPREL:
387    case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_LO:
388    case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_HI:
389    case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_HA:
390    case MCSymbolRefExpr::VK_PPC_TLS:
391    case MCSymbolRefExpr::VK_PPC_GOT_TLSGD:
392    case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO:
393    case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HI:
394    case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HA:
395    case MCSymbolRefExpr::VK_PPC_TLSGD:
396    case MCSymbolRefExpr::VK_PPC_GOT_TLSLD:
397    case MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO:
398    case MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HI:
399    case MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HA:
400    case MCSymbolRefExpr::VK_PPC_TLSLD:
401      break;
402    }
403    MCSymbolData &SD = getAssembler().getOrCreateSymbolData(symRef.getSymbol());
404    MCELF::SetType(SD, ELF::STT_TLS);
405    break;
406  }
407
408  case MCExpr::Unary:
409    fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr());
410    break;
411  }
412}
413
414void MCELFStreamer::EmitInstToFragment(const MCInst &Inst) {
415  this->MCObjectStreamer::EmitInstToFragment(Inst);
416  MCRelaxableFragment &F = *cast<MCRelaxableFragment>(getCurrentFragment());
417
418  for (unsigned i = 0, e = F.getFixups().size(); i != e; ++i)
419    fixSymbolsInTLSFixups(F.getFixups()[i].getValue());
420}
421
422void MCELFStreamer::EmitInstToData(const MCInst &Inst) {
423  MCAssembler &Assembler = getAssembler();
424  SmallVector<MCFixup, 4> Fixups;
425  SmallString<256> Code;
426  raw_svector_ostream VecOS(Code);
427  Assembler.getEmitter().EncodeInstruction(Inst, VecOS, Fixups);
428  VecOS.flush();
429
430  for (unsigned i = 0, e = Fixups.size(); i != e; ++i)
431    fixSymbolsInTLSFixups(Fixups[i].getValue());
432
433  // There are several possibilities here:
434  //
435  // If bundling is disabled, append the encoded instruction to the current data
436  // fragment (or create a new such fragment if the current fragment is not a
437  // data fragment).
438  //
439  // If bundling is enabled:
440  // - If we're not in a bundle-locked group, emit the instruction into a
441  //   fragment of its own. If there are no fixups registered for the
442  //   instruction, emit a MCCompactEncodedInstFragment. Otherwise, emit a
443  //   MCDataFragment.
444  // - If we're in a bundle-locked group, append the instruction to the current
445  //   data fragment because we want all the instructions in a group to get into
446  //   the same fragment. Be careful not to do that for the first instruction in
447  //   the group, though.
448  MCDataFragment *DF;
449
450  if (Assembler.isBundlingEnabled()) {
451    MCSectionData *SD = getCurrentSectionData();
452    if (SD->isBundleLocked() && !SD->isBundleGroupBeforeFirstInst())
453      // If we are bundle-locked, we re-use the current fragment.
454      // The bundle-locking directive ensures this is a new data fragment.
455      DF = cast<MCDataFragment>(getCurrentFragment());
456    else if (!SD->isBundleLocked() && Fixups.size() == 0) {
457      // Optimize memory usage by emitting the instruction to a
458      // MCCompactEncodedInstFragment when not in a bundle-locked group and
459      // there are no fixups registered.
460      MCCompactEncodedInstFragment *CEIF = new MCCompactEncodedInstFragment();
461      insert(CEIF);
462      CEIF->getContents().append(Code.begin(), Code.end());
463      return;
464    } else {
465      DF = new MCDataFragment();
466      insert(DF);
467      if (SD->getBundleLockState() == MCSectionData::BundleLockedAlignToEnd) {
468        // If this is a new fragment created for a bundle-locked group, and the
469        // group was marked as "align_to_end", set a flag in the fragment.
470        DF->setAlignToBundleEnd(true);
471      }
472    }
473
474    // We're now emitting an instruction in a bundle group, so this flag has
475    // to be turned off.
476    SD->setBundleGroupBeforeFirstInst(false);
477  } else {
478    DF = getOrCreateDataFragment();
479  }
480
481  // Add the fixups and data.
482  for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
483    Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size());
484    DF->getFixups().push_back(Fixups[i]);
485  }
486  DF->setHasInstructions(true);
487  DF->getContents().append(Code.begin(), Code.end());
488}
489
490void MCELFStreamer::EmitBundleAlignMode(unsigned AlignPow2) {
491  assert(AlignPow2 <= 30 && "Invalid bundle alignment");
492  MCAssembler &Assembler = getAssembler();
493  if (Assembler.getBundleAlignSize() == 0 && AlignPow2 > 0)
494    Assembler.setBundleAlignSize(1 << AlignPow2);
495  else
496    report_fatal_error(".bundle_align_mode should be only set once per file");
497}
498
499void MCELFStreamer::EmitBundleLock(bool AlignToEnd) {
500  MCSectionData *SD = getCurrentSectionData();
501
502  // Sanity checks
503  //
504  if (!getAssembler().isBundlingEnabled())
505    report_fatal_error(".bundle_lock forbidden when bundling is disabled");
506  else if (SD->isBundleLocked())
507    report_fatal_error("Nesting of .bundle_lock is forbidden");
508
509  SD->setBundleLockState(AlignToEnd ? MCSectionData::BundleLockedAlignToEnd :
510                                      MCSectionData::BundleLocked);
511  SD->setBundleGroupBeforeFirstInst(true);
512}
513
514void MCELFStreamer::EmitBundleUnlock() {
515  MCSectionData *SD = getCurrentSectionData();
516
517  // Sanity checks
518  if (!getAssembler().isBundlingEnabled())
519    report_fatal_error(".bundle_unlock forbidden when bundling is disabled");
520  else if (!SD->isBundleLocked())
521    report_fatal_error(".bundle_unlock without matching lock");
522  else if (SD->isBundleGroupBeforeFirstInst())
523    report_fatal_error("Empty bundle-locked group is forbidden");
524
525  SD->setBundleLockState(MCSectionData::NotBundleLocked);
526}
527
528void MCELFStreamer::FinishImpl() {
529  EmitFrames(true);
530
531  for (std::vector<LocalCommon>::const_iterator i = LocalCommons.begin(),
532                                                e = LocalCommons.end();
533       i != e; ++i) {
534    MCSymbolData *SD = i->SD;
535    uint64_t Size = i->Size;
536    unsigned ByteAlignment = i->ByteAlignment;
537    const MCSymbol &Symbol = SD->getSymbol();
538    const MCSection &Section = Symbol.getSection();
539
540    MCSectionData &SectData = getAssembler().getOrCreateSectionData(Section);
541    new MCAlignFragment(ByteAlignment, 0, 1, ByteAlignment, &SectData);
542
543    MCFragment *F = new MCFillFragment(0, 0, Size, &SectData);
544    SD->setFragment(F);
545
546    // Update the maximum alignment of the section if necessary.
547    if (ByteAlignment > SectData.getAlignment())
548      SectData.setAlignment(ByteAlignment);
549  }
550
551  this->MCObjectStreamer::FinishImpl();
552}
553void MCELFStreamer::EmitTCEntry(const MCSymbol &S) {
554  // Creates a R_PPC64_TOC relocation
555  MCObjectStreamer::EmitSymbolValue(&S, 8);
556}
557
558MCStreamer *llvm::createELFStreamer(MCContext &Context, MCAsmBackend &MAB,
559                                    raw_ostream &OS, MCCodeEmitter *CE,
560                                    bool RelaxAll, bool NoExecStack) {
561  MCELFStreamer *S = new MCELFStreamer(Context, MAB, OS, CE);
562  if (RelaxAll)
563    S->getAssembler().setRelaxAll(true);
564  if (NoExecStack)
565    S->getAssembler().setNoExecStack(true);
566  return S;
567}
568
569void MCELFStreamer::EmitThumbFunc(MCSymbol *Func) {
570  llvm_unreachable("Generic ELF doesn't support this directive");
571}
572
573MCSymbolData &MCELFStreamer::getOrCreateSymbolData(MCSymbol *Symbol) {
574  return getAssembler().getOrCreateSymbolData(*Symbol);
575}
576
577void MCELFStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
578  llvm_unreachable("ELF doesn't support this directive");
579}
580
581void MCELFStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) {
582  llvm_unreachable("ELF doesn't support this directive");
583}
584
585void MCELFStreamer::EmitCOFFSymbolStorageClass(int StorageClass) {
586  llvm_unreachable("ELF doesn't support this directive");
587}
588
589void MCELFStreamer::EmitCOFFSymbolType(int Type) {
590  llvm_unreachable("ELF doesn't support this directive");
591}
592
593void MCELFStreamer::EndCOFFSymbolDef() {
594  llvm_unreachable("ELF doesn't support this directive");
595}
596
597void MCELFStreamer::EmitZerofill(const MCSection *Section, MCSymbol *Symbol,
598                                 uint64_t Size, unsigned ByteAlignment) {
599  llvm_unreachable("ELF doesn't support this directive");
600}
601
602void MCELFStreamer::EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol,
603                                   uint64_t Size, unsigned ByteAlignment) {
604  llvm_unreachable("ELF doesn't support this directive");
605}
606