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