xref: /freebsd/contrib/llvm-project/llvm/lib/MC/MCELFStreamer.cpp (revision 5ca8e32633c4ffbbcd6762e5888b6a4ba0708c6c) 
1 //===- lib/MC/MCELFStreamer.cpp - ELF Object Output -----------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file assembles .s files and emits ELF .o object files.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/MC/MCELFStreamer.h"
14 #include "llvm/ADT/SmallString.h"
15 #include "llvm/ADT/SmallVector.h"
16 #include "llvm/BinaryFormat/ELF.h"
17 #include "llvm/MC/MCAsmBackend.h"
18 #include "llvm/MC/MCAsmInfo.h"
19 #include "llvm/MC/MCAssembler.h"
20 #include "llvm/MC/MCCodeEmitter.h"
21 #include "llvm/MC/MCContext.h"
22 #include "llvm/MC/MCExpr.h"
23 #include "llvm/MC/MCFixup.h"
24 #include "llvm/MC/MCFragment.h"
25 #include "llvm/MC/MCObjectFileInfo.h"
26 #include "llvm/MC/MCObjectWriter.h"
27 #include "llvm/MC/MCSection.h"
28 #include "llvm/MC/MCSectionELF.h"
29 #include "llvm/MC/MCStreamer.h"
30 #include "llvm/MC/MCSymbol.h"
31 #include "llvm/MC/MCSymbolELF.h"
32 #include "llvm/MC/TargetRegistry.h"
33 #include "llvm/Support/Casting.h"
34 #include "llvm/Support/ErrorHandling.h"
35 #include "llvm/Support/LEB128.h"
36 #include "llvm/Support/raw_ostream.h"
37 #include <cassert>
38 #include <cstdint>
39 
40 using namespace llvm;
41 
42 MCELFStreamer::MCELFStreamer(MCContext &Context,
43                              std::unique_ptr<MCAsmBackend> TAB,
44                              std::unique_ptr<MCObjectWriter> OW,
45                              std::unique_ptr<MCCodeEmitter> Emitter)
46     : MCObjectStreamer(Context, std::move(TAB), std::move(OW),
47                        std::move(Emitter)) {}
48 
49 bool MCELFStreamer::isBundleLocked() const {
50   return getCurrentSectionOnly()->isBundleLocked();
51 }
52 
53 void MCELFStreamer::mergeFragment(MCDataFragment *DF,
54                                   MCDataFragment *EF) {
55   MCAssembler &Assembler = getAssembler();
56 
57   if (Assembler.isBundlingEnabled() && Assembler.getRelaxAll()) {
58     uint64_t FSize = EF->getContents().size();
59 
60     if (FSize > Assembler.getBundleAlignSize())
61       report_fatal_error("Fragment can't be larger than a bundle size");
62 
63     uint64_t RequiredBundlePadding = computeBundlePadding(
64         Assembler, EF, DF->getContents().size(), FSize);
65 
66     if (RequiredBundlePadding > UINT8_MAX)
67       report_fatal_error("Padding cannot exceed 255 bytes");
68 
69     if (RequiredBundlePadding > 0) {
70       SmallString<256> Code;
71       raw_svector_ostream VecOS(Code);
72       EF->setBundlePadding(static_cast<uint8_t>(RequiredBundlePadding));
73       Assembler.writeFragmentPadding(VecOS, *EF, FSize);
74 
75       DF->getContents().append(Code.begin(), Code.end());
76     }
77   }
78 
79   flushPendingLabels(DF, DF->getContents().size());
80 
81   for (unsigned i = 0, e = EF->getFixups().size(); i != e; ++i) {
82     EF->getFixups()[i].setOffset(EF->getFixups()[i].getOffset() +
83                                  DF->getContents().size());
84     DF->getFixups().push_back(EF->getFixups()[i]);
85   }
86   if (DF->getSubtargetInfo() == nullptr && EF->getSubtargetInfo())
87     DF->setHasInstructions(*EF->getSubtargetInfo());
88   DF->getContents().append(EF->getContents().begin(), EF->getContents().end());
89 }
90 
91 void MCELFStreamer::initSections(bool NoExecStack, const MCSubtargetInfo &STI) {
92   MCContext &Ctx = getContext();
93   switchSection(Ctx.getObjectFileInfo()->getTextSection());
94   emitCodeAlignment(Align(Ctx.getObjectFileInfo()->getTextSectionAlignment()),
95                     &STI);
96 
97   if (NoExecStack)
98     switchSection(Ctx.getAsmInfo()->getNonexecutableStackSection(Ctx));
99 }
100 
101 void MCELFStreamer::emitLabel(MCSymbol *S, SMLoc Loc) {
102   auto *Symbol = cast<MCSymbolELF>(S);
103   MCObjectStreamer::emitLabel(Symbol, Loc);
104 
105   const MCSectionELF &Section =
106       static_cast<const MCSectionELF &>(*getCurrentSectionOnly());
107   if (Section.getFlags() & ELF::SHF_TLS)
108     Symbol->setType(ELF::STT_TLS);
109 }
110 
111 void MCELFStreamer::emitLabelAtPos(MCSymbol *S, SMLoc Loc, MCFragment *F,
112                                    uint64_t Offset) {
113   auto *Symbol = cast<MCSymbolELF>(S);
114   MCObjectStreamer::emitLabelAtPos(Symbol, Loc, F, Offset);
115 
116   const MCSectionELF &Section =
117       static_cast<const MCSectionELF &>(*getCurrentSectionOnly());
118   if (Section.getFlags() & ELF::SHF_TLS)
119     Symbol->setType(ELF::STT_TLS);
120 }
121 
122 void MCELFStreamer::emitAssemblerFlag(MCAssemblerFlag Flag) {
123   // Let the target do whatever target specific stuff it needs to do.
124   getAssembler().getBackend().handleAssemblerFlag(Flag);
125   // Do any generic stuff we need to do.
126   switch (Flag) {
127   case MCAF_SyntaxUnified: return; // no-op here.
128   case MCAF_Code16: return; // Change parsing mode; no-op here.
129   case MCAF_Code32: return; // Change parsing mode; no-op here.
130   case MCAF_Code64: return; // Change parsing mode; no-op here.
131   case MCAF_SubsectionsViaSymbols:
132     getAssembler().setSubsectionsViaSymbols(true);
133     return;
134   }
135 
136   llvm_unreachable("invalid assembler flag!");
137 }
138 
139 // If bundle alignment is used and there are any instructions in the section, it
140 // needs to be aligned to at least the bundle size.
141 static void setSectionAlignmentForBundling(const MCAssembler &Assembler,
142                                            MCSection *Section) {
143   if (Section && Assembler.isBundlingEnabled() && Section->hasInstructions())
144     Section->ensureMinAlignment(Align(Assembler.getBundleAlignSize()));
145 }
146 
147 void MCELFStreamer::changeSection(MCSection *Section,
148                                   const MCExpr *Subsection) {
149   MCSection *CurSection = getCurrentSectionOnly();
150   if (CurSection && isBundleLocked())
151     report_fatal_error("Unterminated .bundle_lock when changing a section");
152 
153   MCAssembler &Asm = getAssembler();
154   // Ensure the previous section gets aligned if necessary.
155   setSectionAlignmentForBundling(Asm, CurSection);
156   auto *SectionELF = static_cast<const MCSectionELF *>(Section);
157   const MCSymbol *Grp = SectionELF->getGroup();
158   if (Grp)
159     Asm.registerSymbol(*Grp);
160   if (SectionELF->getFlags() & ELF::SHF_GNU_RETAIN)
161     Asm.getWriter().markGnuAbi();
162 
163   changeSectionImpl(Section, Subsection);
164   Asm.registerSymbol(*Section->getBeginSymbol());
165 }
166 
167 void MCELFStreamer::emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {
168   getAssembler().registerSymbol(*Symbol);
169   const MCExpr *Value = MCSymbolRefExpr::create(
170       Symbol, MCSymbolRefExpr::VK_WEAKREF, getContext());
171   Alias->setVariableValue(Value);
172 }
173 
174 // When GNU as encounters more than one .type declaration for an object it seems
175 // to use a mechanism similar to the one below to decide which type is actually
176 // used in the object file.  The greater of T1 and T2 is selected based on the
177 // following ordering:
178 //  STT_NOTYPE < STT_OBJECT < STT_FUNC < STT_GNU_IFUNC < STT_TLS < anything else
179 // If neither T1 < T2 nor T2 < T1 according to this ordering, use T2 (the user
180 // provided type).
181 static unsigned CombineSymbolTypes(unsigned T1, unsigned T2) {
182   for (unsigned Type : {ELF::STT_NOTYPE, ELF::STT_OBJECT, ELF::STT_FUNC,
183                         ELF::STT_GNU_IFUNC, ELF::STT_TLS}) {
184     if (T1 == Type)
185       return T2;
186     if (T2 == Type)
187       return T1;
188   }
189 
190   return T2;
191 }
192 
193 bool MCELFStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) {
194   auto *Symbol = cast<MCSymbolELF>(S);
195 
196   // Adding a symbol attribute always introduces the symbol, note that an
197   // important side effect of calling registerSymbol here is to register
198   // the symbol with the assembler.
199   getAssembler().registerSymbol(*Symbol);
200 
201   // The implementation of symbol attributes is designed to match 'as', but it
202   // leaves much to desired. It doesn't really make sense to arbitrarily add and
203   // remove flags, but 'as' allows this (in particular, see .desc).
204   //
205   // In the future it might be worth trying to make these operations more well
206   // defined.
207   switch (Attribute) {
208   case MCSA_Cold:
209   case MCSA_Extern:
210   case MCSA_LazyReference:
211   case MCSA_Reference:
212   case MCSA_SymbolResolver:
213   case MCSA_PrivateExtern:
214   case MCSA_WeakDefinition:
215   case MCSA_WeakDefAutoPrivate:
216   case MCSA_Invalid:
217   case MCSA_IndirectSymbol:
218   case MCSA_Exported:
219   case MCSA_WeakAntiDep:
220     return false;
221 
222   case MCSA_NoDeadStrip:
223     // Ignore for now.
224     break;
225 
226   case MCSA_ELF_TypeGnuUniqueObject:
227     Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT));
228     Symbol->setBinding(ELF::STB_GNU_UNIQUE);
229     getAssembler().getWriter().markGnuAbi();
230     break;
231 
232   case MCSA_Global:
233     // For `.weak x; .global x`, GNU as sets the binding to STB_WEAK while we
234     // traditionally set the binding to STB_GLOBAL. This is error-prone, so we
235     // error on such cases. Note, we also disallow changed binding from .local.
236     if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_GLOBAL)
237       getContext().reportError(getStartTokLoc(),
238                                Symbol->getName() +
239                                    " changed binding to STB_GLOBAL");
240     Symbol->setBinding(ELF::STB_GLOBAL);
241     break;
242 
243   case MCSA_WeakReference:
244   case MCSA_Weak:
245     // For `.global x; .weak x`, both MC and GNU as set the binding to STB_WEAK.
246     // We emit a warning for now but may switch to an error in the future.
247     if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_WEAK)
248       getContext().reportWarning(
249           getStartTokLoc(), Symbol->getName() + " changed binding to STB_WEAK");
250     Symbol->setBinding(ELF::STB_WEAK);
251     break;
252 
253   case MCSA_Local:
254     if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_LOCAL)
255       getContext().reportError(getStartTokLoc(),
256                                Symbol->getName() +
257                                    " changed binding to STB_LOCAL");
258     Symbol->setBinding(ELF::STB_LOCAL);
259     break;
260 
261   case MCSA_ELF_TypeFunction:
262     Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_FUNC));
263     break;
264 
265   case MCSA_ELF_TypeIndFunction:
266     Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_GNU_IFUNC));
267     getAssembler().getWriter().markGnuAbi();
268     break;
269 
270   case MCSA_ELF_TypeObject:
271     Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT));
272     break;
273 
274   case MCSA_ELF_TypeTLS:
275     Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_TLS));
276     break;
277 
278   case MCSA_ELF_TypeCommon:
279     // TODO: Emit these as a common symbol.
280     Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT));
281     break;
282 
283   case MCSA_ELF_TypeNoType:
284     Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_NOTYPE));
285     break;
286 
287   case MCSA_Protected:
288     Symbol->setVisibility(ELF::STV_PROTECTED);
289     break;
290 
291   case MCSA_Memtag:
292     Symbol->setMemtag(true);
293     break;
294 
295   case MCSA_Hidden:
296     Symbol->setVisibility(ELF::STV_HIDDEN);
297     break;
298 
299   case MCSA_Internal:
300     Symbol->setVisibility(ELF::STV_INTERNAL);
301     break;
302 
303   case MCSA_AltEntry:
304     llvm_unreachable("ELF doesn't support the .alt_entry attribute");
305 
306   case MCSA_LGlobal:
307     llvm_unreachable("ELF doesn't support the .lglobl attribute");
308   }
309 
310   return true;
311 }
312 
313 void MCELFStreamer::emitCommonSymbol(MCSymbol *S, uint64_t Size,
314                                      Align ByteAlignment) {
315   auto *Symbol = cast<MCSymbolELF>(S);
316   getAssembler().registerSymbol(*Symbol);
317 
318   if (!Symbol->isBindingSet())
319     Symbol->setBinding(ELF::STB_GLOBAL);
320 
321   Symbol->setType(ELF::STT_OBJECT);
322 
323   if (Symbol->getBinding() == ELF::STB_LOCAL) {
324     MCSection &Section = *getAssembler().getContext().getELFSection(
325         ".bss", ELF::SHT_NOBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
326     MCSectionSubPair P = getCurrentSection();
327     switchSection(&Section);
328 
329     emitValueToAlignment(ByteAlignment, 0, 1, 0);
330     emitLabel(Symbol);
331     emitZeros(Size);
332 
333     switchSection(P.first, P.second);
334   } else {
335     if (Symbol->declareCommon(Size, ByteAlignment))
336       report_fatal_error(Twine("Symbol: ") + Symbol->getName() +
337                          " redeclared as different type");
338   }
339 
340   cast<MCSymbolELF>(Symbol)
341       ->setSize(MCConstantExpr::create(Size, getContext()));
342 }
343 
344 void MCELFStreamer::emitELFSize(MCSymbol *Symbol, const MCExpr *Value) {
345   cast<MCSymbolELF>(Symbol)->setSize(Value);
346 }
347 
348 void MCELFStreamer::emitELFSymverDirective(const MCSymbol *OriginalSym,
349                                            StringRef Name,
350                                            bool KeepOriginalSym) {
351   getAssembler().Symvers.push_back(MCAssembler::Symver{
352       getStartTokLoc(), OriginalSym, Name, KeepOriginalSym});
353 }
354 
355 void MCELFStreamer::emitLocalCommonSymbol(MCSymbol *S, uint64_t Size,
356                                           Align ByteAlignment) {
357   auto *Symbol = cast<MCSymbolELF>(S);
358   // FIXME: Should this be caught and done earlier?
359   getAssembler().registerSymbol(*Symbol);
360   Symbol->setBinding(ELF::STB_LOCAL);
361   emitCommonSymbol(Symbol, Size, ByteAlignment);
362 }
363 
364 void MCELFStreamer::emitValueImpl(const MCExpr *Value, unsigned Size,
365                                   SMLoc Loc) {
366   if (isBundleLocked())
367     report_fatal_error("Emitting values inside a locked bundle is forbidden");
368   fixSymbolsInTLSFixups(Value);
369   MCObjectStreamer::emitValueImpl(Value, Size, Loc);
370 }
371 
372 void MCELFStreamer::emitValueToAlignment(Align Alignment, int64_t Value,
373                                          unsigned ValueSize,
374                                          unsigned MaxBytesToEmit) {
375   if (isBundleLocked())
376     report_fatal_error("Emitting values inside a locked bundle is forbidden");
377   MCObjectStreamer::emitValueToAlignment(Alignment, Value, ValueSize,
378                                          MaxBytesToEmit);
379 }
380 
381 void MCELFStreamer::emitCGProfileEntry(const MCSymbolRefExpr *From,
382                                        const MCSymbolRefExpr *To,
383                                        uint64_t Count) {
384   getAssembler().CGProfile.push_back({From, To, Count});
385 }
386 
387 void MCELFStreamer::emitIdent(StringRef IdentString) {
388   MCSection *Comment = getAssembler().getContext().getELFSection(
389       ".comment", ELF::SHT_PROGBITS, ELF::SHF_MERGE | ELF::SHF_STRINGS, 1);
390   pushSection();
391   switchSection(Comment);
392   if (!SeenIdent) {
393     emitInt8(0);
394     SeenIdent = true;
395   }
396   emitBytes(IdentString);
397   emitInt8(0);
398   popSection();
399 }
400 
401 void MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) {
402   switch (expr->getKind()) {
403   case MCExpr::Target:
404     cast<MCTargetExpr>(expr)->fixELFSymbolsInTLSFixups(getAssembler());
405     break;
406   case MCExpr::Constant:
407     break;
408 
409   case MCExpr::Binary: {
410     const MCBinaryExpr *be = cast<MCBinaryExpr>(expr);
411     fixSymbolsInTLSFixups(be->getLHS());
412     fixSymbolsInTLSFixups(be->getRHS());
413     break;
414   }
415 
416   case MCExpr::SymbolRef: {
417     const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr);
418     switch (symRef.getKind()) {
419     default:
420       return;
421     case MCSymbolRefExpr::VK_GOTTPOFF:
422     case MCSymbolRefExpr::VK_INDNTPOFF:
423     case MCSymbolRefExpr::VK_NTPOFF:
424     case MCSymbolRefExpr::VK_GOTNTPOFF:
425     case MCSymbolRefExpr::VK_TLSCALL:
426     case MCSymbolRefExpr::VK_TLSDESC:
427     case MCSymbolRefExpr::VK_TLSGD:
428     case MCSymbolRefExpr::VK_TLSLD:
429     case MCSymbolRefExpr::VK_TLSLDM:
430     case MCSymbolRefExpr::VK_TPOFF:
431     case MCSymbolRefExpr::VK_TPREL:
432     case MCSymbolRefExpr::VK_DTPOFF:
433     case MCSymbolRefExpr::VK_DTPREL:
434     case MCSymbolRefExpr::VK_PPC_DTPMOD:
435     case MCSymbolRefExpr::VK_PPC_TPREL_LO:
436     case MCSymbolRefExpr::VK_PPC_TPREL_HI:
437     case MCSymbolRefExpr::VK_PPC_TPREL_HA:
438     case MCSymbolRefExpr::VK_PPC_TPREL_HIGH:
439     case MCSymbolRefExpr::VK_PPC_TPREL_HIGHA:
440     case MCSymbolRefExpr::VK_PPC_TPREL_HIGHER:
441     case MCSymbolRefExpr::VK_PPC_TPREL_HIGHERA:
442     case MCSymbolRefExpr::VK_PPC_TPREL_HIGHEST:
443     case MCSymbolRefExpr::VK_PPC_TPREL_HIGHESTA:
444     case MCSymbolRefExpr::VK_PPC_DTPREL_LO:
445     case MCSymbolRefExpr::VK_PPC_DTPREL_HI:
446     case MCSymbolRefExpr::VK_PPC_DTPREL_HA:
447     case MCSymbolRefExpr::VK_PPC_DTPREL_HIGH:
448     case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHA:
449     case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHER:
450     case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHERA:
451     case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHEST:
452     case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHESTA:
453     case MCSymbolRefExpr::VK_PPC_GOT_TPREL:
454     case MCSymbolRefExpr::VK_PPC_GOT_TPREL_LO:
455     case MCSymbolRefExpr::VK_PPC_GOT_TPREL_HI:
456     case MCSymbolRefExpr::VK_PPC_GOT_TPREL_HA:
457     case MCSymbolRefExpr::VK_PPC_GOT_TPREL_PCREL:
458     case MCSymbolRefExpr::VK_PPC_GOT_DTPREL:
459     case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_LO:
460     case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_HI:
461     case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_HA:
462     case MCSymbolRefExpr::VK_PPC_TLS:
463     case MCSymbolRefExpr::VK_PPC_TLS_PCREL:
464     case MCSymbolRefExpr::VK_PPC_GOT_TLSGD:
465     case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO:
466     case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HI:
467     case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HA:
468     case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_PCREL:
469     case MCSymbolRefExpr::VK_PPC_TLSGD:
470     case MCSymbolRefExpr::VK_PPC_GOT_TLSLD:
471     case MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO:
472     case MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HI:
473     case MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HA:
474     case MCSymbolRefExpr::VK_PPC_TLSLD:
475       break;
476     }
477     getAssembler().registerSymbol(symRef.getSymbol());
478     cast<MCSymbolELF>(symRef.getSymbol()).setType(ELF::STT_TLS);
479     break;
480   }
481 
482   case MCExpr::Unary:
483     fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr());
484     break;
485   }
486 }
487 
488 void MCELFStreamer::finalizeCGProfileEntry(const MCSymbolRefExpr *&SRE,
489                                            uint64_t Offset) {
490   const MCSymbol *S = &SRE->getSymbol();
491   if (S->isTemporary()) {
492     if (!S->isInSection()) {
493       getContext().reportError(
494           SRE->getLoc(), Twine("Reference to undefined temporary symbol ") +
495                              "`" + S->getName() + "`");
496       return;
497     }
498     S = S->getSection().getBeginSymbol();
499     S->setUsedInReloc();
500     SRE = MCSymbolRefExpr::create(S, MCSymbolRefExpr::VK_None, getContext(),
501                                   SRE->getLoc());
502   }
503   const MCConstantExpr *MCOffset = MCConstantExpr::create(Offset, getContext());
504   MCObjectStreamer::visitUsedExpr(*SRE);
505   if (std::optional<std::pair<bool, std::string>> Err =
506           MCObjectStreamer::emitRelocDirective(
507               *MCOffset, "BFD_RELOC_NONE", SRE, SRE->getLoc(),
508               *getContext().getSubtargetInfo()))
509     report_fatal_error("Relocation for CG Profile could not be created: " +
510                        Twine(Err->second));
511 }
512 
513 void MCELFStreamer::finalizeCGProfile() {
514   MCAssembler &Asm = getAssembler();
515   if (Asm.CGProfile.empty())
516     return;
517   MCSection *CGProfile = getAssembler().getContext().getELFSection(
518       ".llvm.call-graph-profile", ELF::SHT_LLVM_CALL_GRAPH_PROFILE,
519       ELF::SHF_EXCLUDE, /*sizeof(Elf_CGProfile_Impl<>)=*/8);
520   pushSection();
521   switchSection(CGProfile);
522   uint64_t Offset = 0;
523   for (MCAssembler::CGProfileEntry &E : Asm.CGProfile) {
524     finalizeCGProfileEntry(E.From, Offset);
525     finalizeCGProfileEntry(E.To, Offset);
526     emitIntValue(E.Count, sizeof(uint64_t));
527     Offset += sizeof(uint64_t);
528   }
529   popSection();
530 }
531 
532 void MCELFStreamer::emitInstToFragment(const MCInst &Inst,
533                                        const MCSubtargetInfo &STI) {
534   this->MCObjectStreamer::emitInstToFragment(Inst, STI);
535   MCRelaxableFragment &F = *cast<MCRelaxableFragment>(getCurrentFragment());
536 
537   for (auto &Fixup : F.getFixups())
538     fixSymbolsInTLSFixups(Fixup.getValue());
539 }
540 
541 // A fragment can only have one Subtarget, and when bundling is enabled we
542 // sometimes need to use the same fragment. We give an error if there
543 // are conflicting Subtargets.
544 static void CheckBundleSubtargets(const MCSubtargetInfo *OldSTI,
545                                   const MCSubtargetInfo *NewSTI) {
546   if (OldSTI && NewSTI && OldSTI != NewSTI)
547     report_fatal_error("A Bundle can only have one Subtarget.");
548 }
549 
550 void MCELFStreamer::emitInstToData(const MCInst &Inst,
551                                    const MCSubtargetInfo &STI) {
552   MCAssembler &Assembler = getAssembler();
553   SmallVector<MCFixup, 4> Fixups;
554   SmallString<256> Code;
555   Assembler.getEmitter().encodeInstruction(Inst, Code, Fixups, STI);
556 
557   for (auto &Fixup : Fixups)
558     fixSymbolsInTLSFixups(Fixup.getValue());
559 
560   // There are several possibilities here:
561   //
562   // If bundling is disabled, append the encoded instruction to the current data
563   // fragment (or create a new such fragment if the current fragment is not a
564   // data fragment, or the Subtarget has changed).
565   //
566   // If bundling is enabled:
567   // - If we're not in a bundle-locked group, emit the instruction into a
568   //   fragment of its own. If there are no fixups registered for the
569   //   instruction, emit a MCCompactEncodedInstFragment. Otherwise, emit a
570   //   MCDataFragment.
571   // - If we're in a bundle-locked group, append the instruction to the current
572   //   data fragment because we want all the instructions in a group to get into
573   //   the same fragment. Be careful not to do that for the first instruction in
574   //   the group, though.
575   MCDataFragment *DF;
576 
577   if (Assembler.isBundlingEnabled()) {
578     MCSection &Sec = *getCurrentSectionOnly();
579     if (Assembler.getRelaxAll() && isBundleLocked()) {
580       // If the -mc-relax-all flag is used and we are bundle-locked, we re-use
581       // the current bundle group.
582       DF = BundleGroups.back();
583       CheckBundleSubtargets(DF->getSubtargetInfo(), &STI);
584     }
585     else if (Assembler.getRelaxAll() && !isBundleLocked())
586       // When not in a bundle-locked group and the -mc-relax-all flag is used,
587       // we create a new temporary fragment which will be later merged into
588       // the current fragment.
589       DF = new MCDataFragment();
590     else if (isBundleLocked() && !Sec.isBundleGroupBeforeFirstInst()) {
591       // If we are bundle-locked, we re-use the current fragment.
592       // The bundle-locking directive ensures this is a new data fragment.
593       DF = cast<MCDataFragment>(getCurrentFragment());
594       CheckBundleSubtargets(DF->getSubtargetInfo(), &STI);
595     }
596     else if (!isBundleLocked() && Fixups.size() == 0) {
597       // Optimize memory usage by emitting the instruction to a
598       // MCCompactEncodedInstFragment when not in a bundle-locked group and
599       // there are no fixups registered.
600       MCCompactEncodedInstFragment *CEIF = new MCCompactEncodedInstFragment();
601       insert(CEIF);
602       CEIF->getContents().append(Code.begin(), Code.end());
603       CEIF->setHasInstructions(STI);
604       return;
605     } else {
606       DF = new MCDataFragment();
607       insert(DF);
608     }
609     if (Sec.getBundleLockState() == MCSection::BundleLockedAlignToEnd) {
610       // If this fragment is for a group marked "align_to_end", set a flag
611       // in the fragment. This can happen after the fragment has already been
612       // created if there are nested bundle_align groups and an inner one
613       // is the one marked align_to_end.
614       DF->setAlignToBundleEnd(true);
615     }
616 
617     // We're now emitting an instruction in a bundle group, so this flag has
618     // to be turned off.
619     Sec.setBundleGroupBeforeFirstInst(false);
620   } else {
621     DF = getOrCreateDataFragment(&STI);
622   }
623 
624   // Add the fixups and data.
625   for (auto &Fixup : Fixups) {
626     Fixup.setOffset(Fixup.getOffset() + DF->getContents().size());
627     DF->getFixups().push_back(Fixup);
628   }
629 
630   DF->setHasInstructions(STI);
631   if (!Fixups.empty() && Fixups.back().getTargetKind() ==
632                              getAssembler().getBackend().RelaxFixupKind)
633     DF->setLinkerRelaxable();
634   DF->getContents().append(Code.begin(), Code.end());
635 
636   if (Assembler.isBundlingEnabled() && Assembler.getRelaxAll()) {
637     if (!isBundleLocked()) {
638       mergeFragment(getOrCreateDataFragment(&STI), DF);
639       delete DF;
640     }
641   }
642 }
643 
644 void MCELFStreamer::emitBundleAlignMode(Align Alignment) {
645   assert(Log2(Alignment) <= 30 && "Invalid bundle alignment");
646   MCAssembler &Assembler = getAssembler();
647   if (Alignment > 1 && (Assembler.getBundleAlignSize() == 0 ||
648                         Assembler.getBundleAlignSize() == Alignment.value()))
649     Assembler.setBundleAlignSize(Alignment.value());
650   else
651     report_fatal_error(".bundle_align_mode cannot be changed once set");
652 }
653 
654 void MCELFStreamer::emitBundleLock(bool AlignToEnd) {
655   MCSection &Sec = *getCurrentSectionOnly();
656 
657   if (!getAssembler().isBundlingEnabled())
658     report_fatal_error(".bundle_lock forbidden when bundling is disabled");
659 
660   if (!isBundleLocked())
661     Sec.setBundleGroupBeforeFirstInst(true);
662 
663   if (getAssembler().getRelaxAll() && !isBundleLocked()) {
664     // TODO: drop the lock state and set directly in the fragment
665     MCDataFragment *DF = new MCDataFragment();
666     BundleGroups.push_back(DF);
667   }
668 
669   Sec.setBundleLockState(AlignToEnd ? MCSection::BundleLockedAlignToEnd
670                                     : MCSection::BundleLocked);
671 }
672 
673 void MCELFStreamer::emitBundleUnlock() {
674   MCSection &Sec = *getCurrentSectionOnly();
675 
676   if (!getAssembler().isBundlingEnabled())
677     report_fatal_error(".bundle_unlock forbidden when bundling is disabled");
678   else if (!isBundleLocked())
679     report_fatal_error(".bundle_unlock without matching lock");
680   else if (Sec.isBundleGroupBeforeFirstInst())
681     report_fatal_error("Empty bundle-locked group is forbidden");
682 
683   // When the -mc-relax-all flag is used, we emit instructions to fragments
684   // stored on a stack. When the bundle unlock is emitted, we pop a fragment
685   // from the stack a merge it to the one below.
686   if (getAssembler().getRelaxAll()) {
687     assert(!BundleGroups.empty() && "There are no bundle groups");
688     MCDataFragment *DF = BundleGroups.back();
689 
690     // FIXME: Use BundleGroups to track the lock state instead.
691     Sec.setBundleLockState(MCSection::NotBundleLocked);
692 
693     // FIXME: Use more separate fragments for nested groups.
694     if (!isBundleLocked()) {
695       mergeFragment(getOrCreateDataFragment(DF->getSubtargetInfo()), DF);
696       BundleGroups.pop_back();
697       delete DF;
698     }
699 
700     if (Sec.getBundleLockState() != MCSection::BundleLockedAlignToEnd)
701       getOrCreateDataFragment()->setAlignToBundleEnd(false);
702   } else
703     Sec.setBundleLockState(MCSection::NotBundleLocked);
704 }
705 
706 void MCELFStreamer::finishImpl() {
707   // Emit the .gnu attributes section if any attributes have been added.
708   if (!GNUAttributes.empty()) {
709     MCSection *DummyAttributeSection = nullptr;
710     createAttributesSection("gnu", ".gnu.attributes", ELF::SHT_GNU_ATTRIBUTES,
711                             DummyAttributeSection, GNUAttributes);
712   }
713 
714   // Ensure the last section gets aligned if necessary.
715   MCSection *CurSection = getCurrentSectionOnly();
716   setSectionAlignmentForBundling(getAssembler(), CurSection);
717 
718   finalizeCGProfile();
719   emitFrames(nullptr);
720 
721   this->MCObjectStreamer::finishImpl();
722 }
723 
724 void MCELFStreamer::emitThumbFunc(MCSymbol *Func) {
725   llvm_unreachable("Generic ELF doesn't support this directive");
726 }
727 
728 void MCELFStreamer::emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
729   llvm_unreachable("ELF doesn't support this directive");
730 }
731 
732 void MCELFStreamer::emitZerofill(MCSection *Section, MCSymbol *Symbol,
733                                  uint64_t Size, Align ByteAlignment,
734                                  SMLoc Loc) {
735   llvm_unreachable("ELF doesn't support this directive");
736 }
737 
738 void MCELFStreamer::emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
739                                    uint64_t Size, Align ByteAlignment) {
740   llvm_unreachable("ELF doesn't support this directive");
741 }
742 
743 void MCELFStreamer::setAttributeItem(unsigned Attribute, unsigned Value,
744                                      bool OverwriteExisting) {
745   // Look for existing attribute item
746   if (AttributeItem *Item = getAttributeItem(Attribute)) {
747     if (!OverwriteExisting)
748       return;
749     Item->Type = AttributeItem::NumericAttribute;
750     Item->IntValue = Value;
751     return;
752   }
753 
754   // Create new attribute item
755   AttributeItem Item = {AttributeItem::NumericAttribute, Attribute, Value,
756                         std::string(StringRef(""))};
757   Contents.push_back(Item);
758 }
759 
760 void MCELFStreamer::setAttributeItem(unsigned Attribute, StringRef Value,
761                                      bool OverwriteExisting) {
762   // Look for existing attribute item
763   if (AttributeItem *Item = getAttributeItem(Attribute)) {
764     if (!OverwriteExisting)
765       return;
766     Item->Type = AttributeItem::TextAttribute;
767     Item->StringValue = std::string(Value);
768     return;
769   }
770 
771   // Create new attribute item
772   AttributeItem Item = {AttributeItem::TextAttribute, Attribute, 0,
773                         std::string(Value)};
774   Contents.push_back(Item);
775 }
776 
777 void MCELFStreamer::setAttributeItems(unsigned Attribute, unsigned IntValue,
778                                       StringRef StringValue,
779                                       bool OverwriteExisting) {
780   // Look for existing attribute item
781   if (AttributeItem *Item = getAttributeItem(Attribute)) {
782     if (!OverwriteExisting)
783       return;
784     Item->Type = AttributeItem::NumericAndTextAttributes;
785     Item->IntValue = IntValue;
786     Item->StringValue = std::string(StringValue);
787     return;
788   }
789 
790   // Create new attribute item
791   AttributeItem Item = {AttributeItem::NumericAndTextAttributes, Attribute,
792                         IntValue, std::string(StringValue)};
793   Contents.push_back(Item);
794 }
795 
796 MCELFStreamer::AttributeItem *
797 MCELFStreamer::getAttributeItem(unsigned Attribute) {
798   for (size_t I = 0; I < Contents.size(); ++I)
799     if (Contents[I].Tag == Attribute)
800       return &Contents[I];
801   return nullptr;
802 }
803 
804 size_t
805 MCELFStreamer::calculateContentSize(SmallVector<AttributeItem, 64> &AttrsVec) {
806   size_t Result = 0;
807   for (size_t I = 0; I < AttrsVec.size(); ++I) {
808     AttributeItem Item = AttrsVec[I];
809     switch (Item.Type) {
810     case AttributeItem::HiddenAttribute:
811       break;
812     case AttributeItem::NumericAttribute:
813       Result += getULEB128Size(Item.Tag);
814       Result += getULEB128Size(Item.IntValue);
815       break;
816     case AttributeItem::TextAttribute:
817       Result += getULEB128Size(Item.Tag);
818       Result += Item.StringValue.size() + 1; // string + '\0'
819       break;
820     case AttributeItem::NumericAndTextAttributes:
821       Result += getULEB128Size(Item.Tag);
822       Result += getULEB128Size(Item.IntValue);
823       Result += Item.StringValue.size() + 1; // string + '\0';
824       break;
825     }
826   }
827   return Result;
828 }
829 
830 void MCELFStreamer::createAttributesSection(
831     StringRef Vendor, const Twine &Section, unsigned Type,
832     MCSection *&AttributeSection, SmallVector<AttributeItem, 64> &AttrsVec) {
833   // <format-version>
834   // [ <section-length> "vendor-name"
835   // [ <file-tag> <size> <attribute>*
836   //   | <section-tag> <size> <section-number>* 0 <attribute>*
837   //   | <symbol-tag> <size> <symbol-number>* 0 <attribute>*
838   //   ]+
839   // ]*
840 
841   // Switch section to AttributeSection or get/create the section.
842   if (AttributeSection) {
843     switchSection(AttributeSection);
844   } else {
845     AttributeSection = getContext().getELFSection(Section, Type, 0);
846     switchSection(AttributeSection);
847 
848     // Format version
849     emitInt8(0x41);
850   }
851 
852   // Vendor size + Vendor name + '\0'
853   const size_t VendorHeaderSize = 4 + Vendor.size() + 1;
854 
855   // Tag + Tag Size
856   const size_t TagHeaderSize = 1 + 4;
857 
858   const size_t ContentsSize = calculateContentSize(AttrsVec);
859 
860   emitInt32(VendorHeaderSize + TagHeaderSize + ContentsSize);
861   emitBytes(Vendor);
862   emitInt8(0); // '\0'
863 
864   emitInt8(ARMBuildAttrs::File);
865   emitInt32(TagHeaderSize + ContentsSize);
866 
867   // Size should have been accounted for already, now
868   // emit each field as its type (ULEB or String)
869   for (size_t I = 0; I < AttrsVec.size(); ++I) {
870     AttributeItem Item = AttrsVec[I];
871     emitULEB128IntValue(Item.Tag);
872     switch (Item.Type) {
873     default:
874       llvm_unreachable("Invalid attribute type");
875     case AttributeItem::NumericAttribute:
876       emitULEB128IntValue(Item.IntValue);
877       break;
878     case AttributeItem::TextAttribute:
879       emitBytes(Item.StringValue);
880       emitInt8(0); // '\0'
881       break;
882     case AttributeItem::NumericAndTextAttributes:
883       emitULEB128IntValue(Item.IntValue);
884       emitBytes(Item.StringValue);
885       emitInt8(0); // '\0'
886       break;
887     }
888   }
889 
890   AttrsVec.clear();
891 }
892 
893 MCStreamer *llvm::createELFStreamer(MCContext &Context,
894                                     std::unique_ptr<MCAsmBackend> &&MAB,
895                                     std::unique_ptr<MCObjectWriter> &&OW,
896                                     std::unique_ptr<MCCodeEmitter> &&CE,
897                                     bool RelaxAll) {
898   MCELFStreamer *S =
899       new MCELFStreamer(Context, std::move(MAB), std::move(OW), std::move(CE));
900   if (RelaxAll)
901     S->getAssembler().setRelaxAll(true);
902   return S;
903 }
904