MCELFStreamer.cpp revision 256281 
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                                  unsigned AddrSpace) {
301  if (getCurrentSectionData()->isBundleLocked())
302    report_fatal_error("Emitting values inside a locked bundle is forbidden");
303  fixSymbolsInTLSFixups(Value);
304  MCObjectStreamer::EmitValueImpl(Value, Size, AddrSpace);
305}
306
307void MCELFStreamer::EmitValueToAlignment(unsigned ByteAlignment,
308                                         int64_t Value,
309                                         unsigned ValueSize,
310                                         unsigned MaxBytesToEmit) {
311  if (getCurrentSectionData()->isBundleLocked())
312    report_fatal_error("Emitting values inside a locked bundle is forbidden");
313  MCObjectStreamer::EmitValueToAlignment(ByteAlignment, Value,
314                                         ValueSize, MaxBytesToEmit);
315}
316
317
318// Add a symbol for the file name of this module. This is the second
319// entry in the module's symbol table (the first being the null symbol).
320void MCELFStreamer::EmitFileDirective(StringRef Filename) {
321  MCSymbol *Symbol = getAssembler().getContext().GetOrCreateSymbol(Filename);
322  Symbol->setSection(*getCurrentSection().first);
323  Symbol->setAbsolute();
324
325  MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
326
327  SD.setFlags(ELF_STT_File | ELF_STB_Local | ELF_STV_Default);
328}
329
330void  MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) {
331  switch (expr->getKind()) {
332  case MCExpr::Target:
333    cast<MCTargetExpr>(expr)->fixELFSymbolsInTLSFixups(getAssembler());
334    break;
335  case MCExpr::Constant:
336    break;
337
338  case MCExpr::Binary: {
339    const MCBinaryExpr *be = cast<MCBinaryExpr>(expr);
340    fixSymbolsInTLSFixups(be->getLHS());
341    fixSymbolsInTLSFixups(be->getRHS());
342    break;
343  }
344
345  case MCExpr::SymbolRef: {
346    const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr);
347    switch (symRef.getKind()) {
348    default:
349      return;
350    case MCSymbolRefExpr::VK_GOTTPOFF:
351    case MCSymbolRefExpr::VK_INDNTPOFF:
352    case MCSymbolRefExpr::VK_NTPOFF:
353    case MCSymbolRefExpr::VK_GOTNTPOFF:
354    case MCSymbolRefExpr::VK_TLSGD:
355    case MCSymbolRefExpr::VK_TLSLD:
356    case MCSymbolRefExpr::VK_TLSLDM:
357    case MCSymbolRefExpr::VK_TPOFF:
358    case MCSymbolRefExpr::VK_DTPOFF:
359    case MCSymbolRefExpr::VK_ARM_TLSGD:
360    case MCSymbolRefExpr::VK_ARM_TPOFF:
361    case MCSymbolRefExpr::VK_ARM_GOTTPOFF:
362    case MCSymbolRefExpr::VK_Mips_TLSGD:
363    case MCSymbolRefExpr::VK_Mips_GOTTPREL:
364    case MCSymbolRefExpr::VK_Mips_TPREL_HI:
365    case MCSymbolRefExpr::VK_Mips_TPREL_LO:
366    case MCSymbolRefExpr::VK_PPC_TPREL16_HA:
367    case MCSymbolRefExpr::VK_PPC_TPREL16_LO:
368    case MCSymbolRefExpr::VK_PPC_DTPREL16_HA:
369    case MCSymbolRefExpr::VK_PPC_DTPREL16_LO:
370    case MCSymbolRefExpr::VK_PPC_GOT_TPREL16_HA:
371    case MCSymbolRefExpr::VK_PPC_GOT_TPREL16_LO:
372    case MCSymbolRefExpr::VK_PPC_TLS:
373    case MCSymbolRefExpr::VK_PPC_GOT_TLSGD16_HA:
374    case MCSymbolRefExpr::VK_PPC_GOT_TLSGD16_LO:
375    case MCSymbolRefExpr::VK_PPC_TLSGD:
376    case MCSymbolRefExpr::VK_PPC_GOT_TLSLD16_HA:
377    case MCSymbolRefExpr::VK_PPC_GOT_TLSLD16_LO:
378    case MCSymbolRefExpr::VK_PPC_TLSLD:
379      break;
380    }
381    MCSymbolData &SD = getAssembler().getOrCreateSymbolData(symRef.getSymbol());
382    MCELF::SetType(SD, ELF::STT_TLS);
383    break;
384  }
385
386  case MCExpr::Unary:
387    fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr());
388    break;
389  }
390}
391
392void MCELFStreamer::EmitInstToFragment(const MCInst &Inst) {
393  this->MCObjectStreamer::EmitInstToFragment(Inst);
394  MCRelaxableFragment &F = *cast<MCRelaxableFragment>(getCurrentFragment());
395
396  for (unsigned i = 0, e = F.getFixups().size(); i != e; ++i)
397    fixSymbolsInTLSFixups(F.getFixups()[i].getValue());
398}
399
400void MCELFStreamer::EmitInstToData(const MCInst &Inst) {
401  MCAssembler &Assembler = getAssembler();
402  SmallVector<MCFixup, 4> Fixups;
403  SmallString<256> Code;
404  raw_svector_ostream VecOS(Code);
405  Assembler.getEmitter().EncodeInstruction(Inst, VecOS, Fixups);
406  VecOS.flush();
407
408  for (unsigned i = 0, e = Fixups.size(); i != e; ++i)
409    fixSymbolsInTLSFixups(Fixups[i].getValue());
410
411  // There are several possibilities here:
412  //
413  // If bundling is disabled, append the encoded instruction to the current data
414  // fragment (or create a new such fragment if the current fragment is not a
415  // data fragment).
416  //
417  // If bundling is enabled:
418  // - If we're not in a bundle-locked group, emit the instruction into a
419  //   fragment of its own. If there are no fixups registered for the
420  //   instruction, emit a MCCompactEncodedInstFragment. Otherwise, emit a
421  //   MCDataFragment.
422  // - If we're in a bundle-locked group, append the instruction to the current
423  //   data fragment because we want all the instructions in a group to get into
424  //   the same fragment. Be careful not to do that for the first instruction in
425  //   the group, though.
426  MCDataFragment *DF;
427
428  if (Assembler.isBundlingEnabled()) {
429    MCSectionData *SD = getCurrentSectionData();
430    if (SD->isBundleLocked() && !SD->isBundleGroupBeforeFirstInst())
431      // If we are bundle-locked, we re-use the current fragment.
432      // The bundle-locking directive ensures this is a new data fragment.
433      DF = cast<MCDataFragment>(getCurrentFragment());
434    else if (!SD->isBundleLocked() && Fixups.size() == 0) {
435      // Optimize memory usage by emitting the instruction to a
436      // MCCompactEncodedInstFragment when not in a bundle-locked group and
437      // there are no fixups registered.
438      MCCompactEncodedInstFragment *CEIF = new MCCompactEncodedInstFragment();
439      insert(CEIF);
440      CEIF->getContents().append(Code.begin(), Code.end());
441      return;
442    } else {
443      DF = new MCDataFragment();
444      insert(DF);
445      if (SD->getBundleLockState() == MCSectionData::BundleLockedAlignToEnd) {
446        // If this is a new fragment created for a bundle-locked group, and the
447        // group was marked as "align_to_end", set a flag in the fragment.
448        DF->setAlignToBundleEnd(true);
449      }
450    }
451
452    // We're now emitting an instruction in a bundle group, so this flag has
453    // to be turned off.
454    SD->setBundleGroupBeforeFirstInst(false);
455  } else {
456    DF = getOrCreateDataFragment();
457  }
458
459  // Add the fixups and data.
460  for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
461    Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size());
462    DF->getFixups().push_back(Fixups[i]);
463  }
464  DF->setHasInstructions(true);
465  DF->getContents().append(Code.begin(), Code.end());
466}
467
468void MCELFStreamer::EmitBundleAlignMode(unsigned AlignPow2) {
469  assert(AlignPow2 <= 30 && "Invalid bundle alignment");
470  MCAssembler &Assembler = getAssembler();
471  if (Assembler.getBundleAlignSize() == 0 && AlignPow2 > 0)
472    Assembler.setBundleAlignSize(1 << AlignPow2);
473  else
474    report_fatal_error(".bundle_align_mode should be only set once per file");
475}
476
477void MCELFStreamer::EmitBundleLock(bool AlignToEnd) {
478  MCSectionData *SD = getCurrentSectionData();
479
480  // Sanity checks
481  //
482  if (!getAssembler().isBundlingEnabled())
483    report_fatal_error(".bundle_lock forbidden when bundling is disabled");
484  else if (SD->isBundleLocked())
485    report_fatal_error("Nesting of .bundle_lock is forbidden");
486
487  SD->setBundleLockState(AlignToEnd ? MCSectionData::BundleLockedAlignToEnd :
488                                      MCSectionData::BundleLocked);
489  SD->setBundleGroupBeforeFirstInst(true);
490}
491
492void MCELFStreamer::EmitBundleUnlock() {
493  MCSectionData *SD = getCurrentSectionData();
494
495  // Sanity checks
496  if (!getAssembler().isBundlingEnabled())
497    report_fatal_error(".bundle_unlock forbidden when bundling is disabled");
498  else if (!SD->isBundleLocked())
499    report_fatal_error(".bundle_unlock without matching lock");
500  else if (SD->isBundleGroupBeforeFirstInst())
501    report_fatal_error("Empty bundle-locked group is forbidden");
502
503  SD->setBundleLockState(MCSectionData::NotBundleLocked);
504}
505
506void MCELFStreamer::FinishImpl() {
507  EmitFrames(true);
508
509  for (std::vector<LocalCommon>::const_iterator i = LocalCommons.begin(),
510                                                e = LocalCommons.end();
511       i != e; ++i) {
512    MCSymbolData *SD = i->SD;
513    uint64_t Size = i->Size;
514    unsigned ByteAlignment = i->ByteAlignment;
515    const MCSymbol &Symbol = SD->getSymbol();
516    const MCSection &Section = Symbol.getSection();
517
518    MCSectionData &SectData = getAssembler().getOrCreateSectionData(Section);
519    new MCAlignFragment(ByteAlignment, 0, 1, ByteAlignment, &SectData);
520
521    MCFragment *F = new MCFillFragment(0, 0, Size, &SectData);
522    SD->setFragment(F);
523
524    // Update the maximum alignment of the section if necessary.
525    if (ByteAlignment > SectData.getAlignment())
526      SectData.setAlignment(ByteAlignment);
527  }
528
529  this->MCObjectStreamer::FinishImpl();
530}
531void MCELFStreamer::EmitTCEntry(const MCSymbol &S) {
532  // Creates a R_PPC64_TOC relocation
533  MCObjectStreamer::EmitSymbolValue(&S, 8);
534}
535
536MCStreamer *llvm::createELFStreamer(MCContext &Context, MCAsmBackend &MAB,
537                                    raw_ostream &OS, MCCodeEmitter *CE,
538                                    bool RelaxAll, bool NoExecStack) {
539  MCELFStreamer *S = new MCELFStreamer(Context, MAB, OS, CE);
540  if (RelaxAll)
541    S->getAssembler().setRelaxAll(true);
542  if (NoExecStack)
543    S->getAssembler().setNoExecStack(true);
544  return S;
545}
546
547void MCELFStreamer::EmitThumbFunc(MCSymbol *Func) {
548  llvm_unreachable("Generic ELF doesn't support this directive");
549}
550
551MCSymbolData &MCELFStreamer::getOrCreateSymbolData(MCSymbol *Symbol) {
552  return getAssembler().getOrCreateSymbolData(*Symbol);
553}
554
555void MCELFStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
556  llvm_unreachable("ELF doesn't support this directive");
557}
558
559void MCELFStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) {
560  llvm_unreachable("ELF doesn't support this directive");
561}
562
563void MCELFStreamer::EmitCOFFSymbolStorageClass(int StorageClass) {
564  llvm_unreachable("ELF doesn't support this directive");
565}
566
567void MCELFStreamer::EmitCOFFSymbolType(int Type) {
568  llvm_unreachable("ELF doesn't support this directive");
569}
570
571void MCELFStreamer::EndCOFFSymbolDef() {
572  llvm_unreachable("ELF doesn't support this directive");
573}
574
575void MCELFStreamer::EmitZerofill(const MCSection *Section, MCSymbol *Symbol,
576                                 uint64_t Size, unsigned ByteAlignment) {
577  llvm_unreachable("ELF doesn't support this directive");
578}
579
580void MCELFStreamer::EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol,
581                                   uint64_t Size, unsigned ByteAlignment) {
582  llvm_unreachable("ELF doesn't support this directive");
583}
584