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
40using namespace llvm;
41
42MCELFStreamer::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
49bool MCELFStreamer::isBundleLocked() const {
50 return getCurrentSectionOnly()->isBundleLocked();
51}
52
53void 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(reason: "Fragment can't be larger than a bundle size");
62
63 uint64_t RequiredBundlePadding = computeBundlePadding(
64 Assembler, F: EF, FOffset: DF->getContents().size(), FSize);
65
66 if (RequiredBundlePadding > UINT8_MAX)
67 report_fatal_error(reason: "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(OS&: VecOS, F: *EF, FSize);
74
75 DF->getContents().append(in_start: Code.begin(), in_end: Code.end());
76 }
77 }
78
79 flushPendingLabels(F: DF, FOffset: 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(Elt: EF->getFixups()[i]);
85 }
86 if (DF->getSubtargetInfo() == nullptr && EF->getSubtargetInfo())
87 DF->setHasInstructions(*EF->getSubtargetInfo());
88 DF->getContents().append(in_start: EF->getContents().begin(), in_end: EF->getContents().end());
89}
90
91void MCELFStreamer::initSections(bool NoExecStack, const MCSubtargetInfo &STI) {
92 MCContext &Ctx = getContext();
93 switchSection(Section: Ctx.getObjectFileInfo()->getTextSection());
94 emitCodeAlignment(ByteAlignment: Align(Ctx.getObjectFileInfo()->getTextSectionAlignment()),
95 STI: &STI);
96
97 if (NoExecStack)
98 switchSection(Section: Ctx.getAsmInfo()->getNonexecutableStackSection(Ctx));
99}
100
101void MCELFStreamer::emitLabel(MCSymbol *S, SMLoc Loc) {
102 auto *Symbol = cast<MCSymbolELF>(Val: 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
111void MCELFStreamer::emitLabelAtPos(MCSymbol *S, SMLoc Loc, MCFragment *F,
112 uint64_t Offset) {
113 auto *Symbol = cast<MCSymbolELF>(Val: 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
122void 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.
141static void setSectionAlignmentForBundling(const MCAssembler &Assembler,
142 MCSection *Section) {
143 if (Section && Assembler.isBundlingEnabled() && Section->hasInstructions())
144 Section->ensureMinAlignment(MinAlignment: Align(Assembler.getBundleAlignSize()));
145}
146
147void MCELFStreamer::changeSection(MCSection *Section,
148 const MCExpr *Subsection) {
149 MCSection *CurSection = getCurrentSectionOnly();
150 if (CurSection && isBundleLocked())
151 report_fatal_error(reason: "Unterminated .bundle_lock when changing a section");
152
153 MCAssembler &Asm = getAssembler();
154 // Ensure the previous section gets aligned if necessary.
155 setSectionAlignmentForBundling(Assembler: Asm, Section: CurSection);
156 auto *SectionELF = static_cast<const MCSectionELF *>(Section);
157 const MCSymbol *Grp = SectionELF->getGroup();
158 if (Grp)
159 Asm.registerSymbol(Symbol: *Grp);
160 if (SectionELF->getFlags() & ELF::SHF_GNU_RETAIN)
161 Asm.getWriter().markGnuAbi();
162
163 changeSectionImpl(Section, Subsection);
164 Asm.registerSymbol(Symbol: *Section->getBeginSymbol());
165}
166
167void MCELFStreamer::emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {
168 getAssembler().registerSymbol(Symbol: *Symbol);
169 const MCExpr *Value = MCSymbolRefExpr::create(
170 Symbol, Kind: MCSymbolRefExpr::VK_WEAKREF, Ctx&: 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).
181static 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
193bool MCELFStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) {
194 auto *Symbol = cast<MCSymbolELF>(Val: 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: *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(T1: Symbol->getType(), T2: 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(L: getStartTokLoc(),
238 Msg: 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 L: getStartTokLoc(), Msg: 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(L: getStartTokLoc(),
256 Msg: 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(T1: Symbol->getType(), T2: ELF::STT_FUNC));
263 break;
264
265 case MCSA_ELF_TypeIndFunction:
266 Symbol->setType(CombineSymbolTypes(T1: Symbol->getType(), T2: ELF::STT_GNU_IFUNC));
267 getAssembler().getWriter().markGnuAbi();
268 break;
269
270 case MCSA_ELF_TypeObject:
271 Symbol->setType(CombineSymbolTypes(T1: Symbol->getType(), T2: ELF::STT_OBJECT));
272 break;
273
274 case MCSA_ELF_TypeTLS:
275 Symbol->setType(CombineSymbolTypes(T1: Symbol->getType(), T2: ELF::STT_TLS));
276 break;
277
278 case MCSA_ELF_TypeCommon:
279 // TODO: Emit these as a common symbol.
280 Symbol->setType(CombineSymbolTypes(T1: Symbol->getType(), T2: ELF::STT_OBJECT));
281 break;
282
283 case MCSA_ELF_TypeNoType:
284 Symbol->setType(CombineSymbolTypes(T1: Symbol->getType(), T2: 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
313void MCELFStreamer::emitCommonSymbol(MCSymbol *S, uint64_t Size,
314 Align ByteAlignment) {
315 auto *Symbol = cast<MCSymbolELF>(Val: S);
316 getAssembler().registerSymbol(Symbol: *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 Section: ".bss", Type: ELF::SHT_NOBITS, Flags: ELF::SHF_WRITE | ELF::SHF_ALLOC);
326 MCSectionSubPair P = getCurrentSection();
327 switchSection(Section: &Section);
328
329 emitValueToAlignment(ByteAlignment, 0, 1, 0);
330 emitLabel(S: Symbol);
331 emitZeros(NumBytes: Size);
332
333 switchSection(Section: P.first, Subsection: P.second);
334 } else {
335 if (Symbol->declareCommon(Size, Alignment: ByteAlignment))
336 report_fatal_error(reason: Twine("Symbol: ") + Symbol->getName() +
337 " redeclared as different type");
338 }
339
340 cast<MCSymbolELF>(Val: Symbol)
341 ->setSize(MCConstantExpr::create(Value: Size, Ctx&: getContext()));
342}
343
344void MCELFStreamer::emitELFSize(MCSymbol *Symbol, const MCExpr *Value) {
345 cast<MCSymbolELF>(Val: Symbol)->setSize(Value);
346}
347
348void MCELFStreamer::emitELFSymverDirective(const MCSymbol *OriginalSym,
349 StringRef Name,
350 bool KeepOriginalSym) {
351 getAssembler().Symvers.push_back(x: MCAssembler::Symver{
352 .Loc: getStartTokLoc(), .Sym: OriginalSym, .Name: Name, .KeepOriginalSym: KeepOriginalSym});
353}
354
355void MCELFStreamer::emitLocalCommonSymbol(MCSymbol *S, uint64_t Size,
356 Align ByteAlignment) {
357 auto *Symbol = cast<MCSymbolELF>(Val: S);
358 // FIXME: Should this be caught and done earlier?
359 getAssembler().registerSymbol(Symbol: *Symbol);
360 Symbol->setBinding(ELF::STB_LOCAL);
361 emitCommonSymbol(S: Symbol, Size, ByteAlignment);
362}
363
364void MCELFStreamer::emitValueImpl(const MCExpr *Value, unsigned Size,
365 SMLoc Loc) {
366 if (isBundleLocked())
367 report_fatal_error(reason: "Emitting values inside a locked bundle is forbidden");
368 fixSymbolsInTLSFixups(expr: Value);
369 MCObjectStreamer::emitValueImpl(Value, Size, Loc);
370}
371
372void MCELFStreamer::emitValueToAlignment(Align Alignment, int64_t Value,
373 unsigned ValueSize,
374 unsigned MaxBytesToEmit) {
375 if (isBundleLocked())
376 report_fatal_error(reason: "Emitting values inside a locked bundle is forbidden");
377 MCObjectStreamer::emitValueToAlignment(Alignment, Value, ValueSize,
378 MaxBytesToEmit);
379}
380
381void MCELFStreamer::emitCGProfileEntry(const MCSymbolRefExpr *From,
382 const MCSymbolRefExpr *To,
383 uint64_t Count) {
384 getAssembler().CGProfile.push_back(x: {.From: From, .To: To, .Count: Count});
385}
386
387void MCELFStreamer::emitIdent(StringRef IdentString) {
388 MCSection *Comment = getAssembler().getContext().getELFSection(
389 Section: ".comment", Type: ELF::SHT_PROGBITS, Flags: ELF::SHF_MERGE | ELF::SHF_STRINGS, EntrySize: 1);
390 pushSection();
391 switchSection(Section: Comment);
392 if (!SeenIdent) {
393 emitInt8(Value: 0);
394 SeenIdent = true;
395 }
396 emitBytes(Data: IdentString);
397 emitInt8(Value: 0);
398 popSection();
399}
400
401void MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) {
402 switch (expr->getKind()) {
403 case MCExpr::Target:
404 cast<MCTargetExpr>(Val: expr)->fixELFSymbolsInTLSFixups(getAssembler());
405 break;
406 case MCExpr::Constant:
407 break;
408
409 case MCExpr::Binary: {
410 const MCBinaryExpr *be = cast<MCBinaryExpr>(Val: expr);
411 fixSymbolsInTLSFixups(expr: be->getLHS());
412 fixSymbolsInTLSFixups(expr: be->getRHS());
413 break;
414 }
415
416 case MCExpr::SymbolRef: {
417 const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(Val: 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(Symbol: symRef.getSymbol());
478 cast<MCSymbolELF>(Val: symRef.getSymbol()).setType(ELF::STT_TLS);
479 break;
480 }
481
482 case MCExpr::Unary:
483 fixSymbolsInTLSFixups(expr: cast<MCUnaryExpr>(Val: expr)->getSubExpr());
484 break;
485 }
486}
487
488void 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 L: SRE->getLoc(), Msg: Twine("Reference to undefined temporary symbol ") +
495 "`" + S->getName() + "`");
496 return;
497 }
498 S = S->getSection().getBeginSymbol();
499 S->setUsedInReloc();
500 SRE = MCSymbolRefExpr::create(Symbol: S, Kind: MCSymbolRefExpr::VK_None, Ctx&: getContext(),
501 Loc: SRE->getLoc());
502 }
503 const MCConstantExpr *MCOffset = MCConstantExpr::create(Value: Offset, Ctx&: getContext());
504 if (std::optional<std::pair<bool, std::string>> Err =
505 MCObjectStreamer::emitRelocDirective(
506 Offset: *MCOffset, Name: "BFD_RELOC_NONE", Expr: SRE, Loc: SRE->getLoc(),
507 STI: *getContext().getSubtargetInfo()))
508 report_fatal_error(reason: "Relocation for CG Profile could not be created: " +
509 Twine(Err->second));
510}
511
512void MCELFStreamer::finalizeCGProfile() {
513 MCAssembler &Asm = getAssembler();
514 if (Asm.CGProfile.empty())
515 return;
516 MCSection *CGProfile = getAssembler().getContext().getELFSection(
517 Section: ".llvm.call-graph-profile", Type: ELF::SHT_LLVM_CALL_GRAPH_PROFILE,
518 Flags: ELF::SHF_EXCLUDE, /*sizeof(Elf_CGProfile_Impl<>)=*/EntrySize: 8);
519 pushSection();
520 switchSection(Section: CGProfile);
521 uint64_t Offset = 0;
522 for (MCAssembler::CGProfileEntry &E : Asm.CGProfile) {
523 finalizeCGProfileEntry(SRE&: E.From, Offset);
524 finalizeCGProfileEntry(SRE&: E.To, Offset);
525 emitIntValue(Value: E.Count, Size: sizeof(uint64_t));
526 Offset += sizeof(uint64_t);
527 }
528 popSection();
529}
530
531void MCELFStreamer::emitInstToFragment(const MCInst &Inst,
532 const MCSubtargetInfo &STI) {
533 this->MCObjectStreamer::emitInstToFragment(Inst, STI);
534 MCRelaxableFragment &F = *cast<MCRelaxableFragment>(Val: getCurrentFragment());
535
536 for (auto &Fixup : F.getFixups())
537 fixSymbolsInTLSFixups(expr: Fixup.getValue());
538}
539
540// A fragment can only have one Subtarget, and when bundling is enabled we
541// sometimes need to use the same fragment. We give an error if there
542// are conflicting Subtargets.
543static void CheckBundleSubtargets(const MCSubtargetInfo *OldSTI,
544 const MCSubtargetInfo *NewSTI) {
545 if (OldSTI && NewSTI && OldSTI != NewSTI)
546 report_fatal_error(reason: "A Bundle can only have one Subtarget.");
547}
548
549void MCELFStreamer::emitInstToData(const MCInst &Inst,
550 const MCSubtargetInfo &STI) {
551 MCAssembler &Assembler = getAssembler();
552 SmallVector<MCFixup, 4> Fixups;
553 SmallString<256> Code;
554 Assembler.getEmitter().encodeInstruction(Inst, CB&: Code, Fixups, STI);
555
556 for (auto &Fixup : Fixups)
557 fixSymbolsInTLSFixups(expr: Fixup.getValue());
558
559 // There are several possibilities here:
560 //
561 // If bundling is disabled, append the encoded instruction to the current data
562 // fragment (or create a new such fragment if the current fragment is not a
563 // data fragment, or the Subtarget has changed).
564 //
565 // If bundling is enabled:
566 // - If we're not in a bundle-locked group, emit the instruction into a
567 // fragment of its own. If there are no fixups registered for the
568 // instruction, emit a MCCompactEncodedInstFragment. Otherwise, emit a
569 // MCDataFragment.
570 // - If we're in a bundle-locked group, append the instruction to the current
571 // data fragment because we want all the instructions in a group to get into
572 // the same fragment. Be careful not to do that for the first instruction in
573 // the group, though.
574 MCDataFragment *DF;
575
576 if (Assembler.isBundlingEnabled()) {
577 MCSection &Sec = *getCurrentSectionOnly();
578 if (Assembler.getRelaxAll() && isBundleLocked()) {
579 // If the -mc-relax-all flag is used and we are bundle-locked, we re-use
580 // the current bundle group.
581 DF = BundleGroups.back();
582 CheckBundleSubtargets(OldSTI: DF->getSubtargetInfo(), NewSTI: &STI);
583 }
584 else if (Assembler.getRelaxAll() && !isBundleLocked())
585 // When not in a bundle-locked group and the -mc-relax-all flag is used,
586 // we create a new temporary fragment which will be later merged into
587 // the current fragment.
588 DF = new MCDataFragment();
589 else if (isBundleLocked() && !Sec.isBundleGroupBeforeFirstInst()) {
590 // If we are bundle-locked, we re-use the current fragment.
591 // The bundle-locking directive ensures this is a new data fragment.
592 DF = cast<MCDataFragment>(Val: getCurrentFragment());
593 CheckBundleSubtargets(OldSTI: DF->getSubtargetInfo(), NewSTI: &STI);
594 }
595 else if (!isBundleLocked() && Fixups.size() == 0) {
596 // Optimize memory usage by emitting the instruction to a
597 // MCCompactEncodedInstFragment when not in a bundle-locked group and
598 // there are no fixups registered.
599 MCCompactEncodedInstFragment *CEIF = new MCCompactEncodedInstFragment();
600 insert(F: CEIF);
601 CEIF->getContents().append(in_start: Code.begin(), in_end: Code.end());
602 CEIF->setHasInstructions(STI);
603 return;
604 } else {
605 DF = new MCDataFragment();
606 insert(F: DF);
607 }
608 if (Sec.getBundleLockState() == MCSection::BundleLockedAlignToEnd) {
609 // If this fragment is for a group marked "align_to_end", set a flag
610 // in the fragment. This can happen after the fragment has already been
611 // created if there are nested bundle_align groups and an inner one
612 // is the one marked align_to_end.
613 DF->setAlignToBundleEnd(true);
614 }
615
616 // We're now emitting an instruction in a bundle group, so this flag has
617 // to be turned off.
618 Sec.setBundleGroupBeforeFirstInst(false);
619 } else {
620 DF = getOrCreateDataFragment(STI: &STI);
621 }
622
623 // Add the fixups and data.
624 for (auto &Fixup : Fixups) {
625 Fixup.setOffset(Fixup.getOffset() + DF->getContents().size());
626 DF->getFixups().push_back(Elt: Fixup);
627 }
628
629 DF->setHasInstructions(STI);
630 if (!Fixups.empty() && Fixups.back().getTargetKind() ==
631 getAssembler().getBackend().RelaxFixupKind)
632 DF->setLinkerRelaxable();
633 DF->getContents().append(in_start: Code.begin(), in_end: Code.end());
634
635 if (Assembler.isBundlingEnabled() && Assembler.getRelaxAll()) {
636 if (!isBundleLocked()) {
637 mergeFragment(DF: getOrCreateDataFragment(STI: &STI), EF: DF);
638 delete DF;
639 }
640 }
641}
642
643void MCELFStreamer::emitBundleAlignMode(Align Alignment) {
644 assert(Log2(Alignment) <= 30 && "Invalid bundle alignment");
645 MCAssembler &Assembler = getAssembler();
646 if (Alignment > 1 && (Assembler.getBundleAlignSize() == 0 ||
647 Assembler.getBundleAlignSize() == Alignment.value()))
648 Assembler.setBundleAlignSize(Alignment.value());
649 else
650 report_fatal_error(reason: ".bundle_align_mode cannot be changed once set");
651}
652
653void MCELFStreamer::emitBundleLock(bool AlignToEnd) {
654 MCSection &Sec = *getCurrentSectionOnly();
655
656 if (!getAssembler().isBundlingEnabled())
657 report_fatal_error(reason: ".bundle_lock forbidden when bundling is disabled");
658
659 if (!isBundleLocked())
660 Sec.setBundleGroupBeforeFirstInst(true);
661
662 if (getAssembler().getRelaxAll() && !isBundleLocked()) {
663 // TODO: drop the lock state and set directly in the fragment
664 MCDataFragment *DF = new MCDataFragment();
665 BundleGroups.push_back(Elt: DF);
666 }
667
668 Sec.setBundleLockState(AlignToEnd ? MCSection::BundleLockedAlignToEnd
669 : MCSection::BundleLocked);
670}
671
672void MCELFStreamer::emitBundleUnlock() {
673 MCSection &Sec = *getCurrentSectionOnly();
674
675 if (!getAssembler().isBundlingEnabled())
676 report_fatal_error(reason: ".bundle_unlock forbidden when bundling is disabled");
677 else if (!isBundleLocked())
678 report_fatal_error(reason: ".bundle_unlock without matching lock");
679 else if (Sec.isBundleGroupBeforeFirstInst())
680 report_fatal_error(reason: "Empty bundle-locked group is forbidden");
681
682 // When the -mc-relax-all flag is used, we emit instructions to fragments
683 // stored on a stack. When the bundle unlock is emitted, we pop a fragment
684 // from the stack a merge it to the one below.
685 if (getAssembler().getRelaxAll()) {
686 assert(!BundleGroups.empty() && "There are no bundle groups");
687 MCDataFragment *DF = BundleGroups.back();
688
689 // FIXME: Use BundleGroups to track the lock state instead.
690 Sec.setBundleLockState(MCSection::NotBundleLocked);
691
692 // FIXME: Use more separate fragments for nested groups.
693 if (!isBundleLocked()) {
694 mergeFragment(DF: getOrCreateDataFragment(STI: DF->getSubtargetInfo()), EF: DF);
695 BundleGroups.pop_back();
696 delete DF;
697 }
698
699 if (Sec.getBundleLockState() != MCSection::BundleLockedAlignToEnd)
700 getOrCreateDataFragment()->setAlignToBundleEnd(false);
701 } else
702 Sec.setBundleLockState(MCSection::NotBundleLocked);
703}
704
705void MCELFStreamer::finishImpl() {
706 // Emit the .gnu attributes section if any attributes have been added.
707 if (!GNUAttributes.empty()) {
708 MCSection *DummyAttributeSection = nullptr;
709 createAttributesSection(Vendor: "gnu", Section: ".gnu.attributes", Type: ELF::SHT_GNU_ATTRIBUTES,
710 AttributeSection&: DummyAttributeSection, AttrsVec&: GNUAttributes);
711 }
712
713 // Ensure the last section gets aligned if necessary.
714 MCSection *CurSection = getCurrentSectionOnly();
715 setSectionAlignmentForBundling(Assembler: getAssembler(), Section: CurSection);
716
717 finalizeCGProfile();
718 emitFrames(MAB: nullptr);
719
720 this->MCObjectStreamer::finishImpl();
721}
722
723void MCELFStreamer::emitThumbFunc(MCSymbol *Func) {
724 llvm_unreachable("Generic ELF doesn't support this directive");
725}
726
727void MCELFStreamer::emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
728 llvm_unreachable("ELF doesn't support this directive");
729}
730
731void MCELFStreamer::emitZerofill(MCSection *Section, MCSymbol *Symbol,
732 uint64_t Size, Align ByteAlignment,
733 SMLoc Loc) {
734 llvm_unreachable("ELF doesn't support this directive");
735}
736
737void MCELFStreamer::emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
738 uint64_t Size, Align ByteAlignment) {
739 llvm_unreachable("ELF doesn't support this directive");
740}
741
742void MCELFStreamer::setAttributeItem(unsigned Attribute, unsigned Value,
743 bool OverwriteExisting) {
744 // Look for existing attribute item
745 if (AttributeItem *Item = getAttributeItem(Attribute)) {
746 if (!OverwriteExisting)
747 return;
748 Item->Type = AttributeItem::NumericAttribute;
749 Item->IntValue = Value;
750 return;
751 }
752
753 // Create new attribute item
754 AttributeItem Item = {.Type: AttributeItem::NumericAttribute, .Tag: Attribute, .IntValue: Value,
755 .StringValue: std::string(StringRef(""))};
756 Contents.push_back(Elt: Item);
757}
758
759void MCELFStreamer::setAttributeItem(unsigned Attribute, StringRef Value,
760 bool OverwriteExisting) {
761 // Look for existing attribute item
762 if (AttributeItem *Item = getAttributeItem(Attribute)) {
763 if (!OverwriteExisting)
764 return;
765 Item->Type = AttributeItem::TextAttribute;
766 Item->StringValue = std::string(Value);
767 return;
768 }
769
770 // Create new attribute item
771 AttributeItem Item = {.Type: AttributeItem::TextAttribute, .Tag: Attribute, .IntValue: 0,
772 .StringValue: std::string(Value)};
773 Contents.push_back(Elt: Item);
774}
775
776void MCELFStreamer::setAttributeItems(unsigned Attribute, unsigned IntValue,
777 StringRef StringValue,
778 bool OverwriteExisting) {
779 // Look for existing attribute item
780 if (AttributeItem *Item = getAttributeItem(Attribute)) {
781 if (!OverwriteExisting)
782 return;
783 Item->Type = AttributeItem::NumericAndTextAttributes;
784 Item->IntValue = IntValue;
785 Item->StringValue = std::string(StringValue);
786 return;
787 }
788
789 // Create new attribute item
790 AttributeItem Item = {.Type: AttributeItem::NumericAndTextAttributes, .Tag: Attribute,
791 .IntValue: IntValue, .StringValue: std::string(StringValue)};
792 Contents.push_back(Elt: Item);
793}
794
795MCELFStreamer::AttributeItem *
796MCELFStreamer::getAttributeItem(unsigned Attribute) {
797 for (size_t I = 0; I < Contents.size(); ++I)
798 if (Contents[I].Tag == Attribute)
799 return &Contents[I];
800 return nullptr;
801}
802
803size_t
804MCELFStreamer::calculateContentSize(SmallVector<AttributeItem, 64> &AttrsVec) {
805 size_t Result = 0;
806 for (size_t I = 0; I < AttrsVec.size(); ++I) {
807 AttributeItem Item = AttrsVec[I];
808 switch (Item.Type) {
809 case AttributeItem::HiddenAttribute:
810 break;
811 case AttributeItem::NumericAttribute:
812 Result += getULEB128Size(Value: Item.Tag);
813 Result += getULEB128Size(Value: Item.IntValue);
814 break;
815 case AttributeItem::TextAttribute:
816 Result += getULEB128Size(Value: Item.Tag);
817 Result += Item.StringValue.size() + 1; // string + '\0'
818 break;
819 case AttributeItem::NumericAndTextAttributes:
820 Result += getULEB128Size(Value: Item.Tag);
821 Result += getULEB128Size(Value: Item.IntValue);
822 Result += Item.StringValue.size() + 1; // string + '\0';
823 break;
824 }
825 }
826 return Result;
827}
828
829void MCELFStreamer::createAttributesSection(
830 StringRef Vendor, const Twine &Section, unsigned Type,
831 MCSection *&AttributeSection, SmallVector<AttributeItem, 64> &AttrsVec) {
832 // <format-version>
833 // [ <section-length> "vendor-name"
834 // [ <file-tag> <size> <attribute>*
835 // | <section-tag> <size> <section-number>* 0 <attribute>*
836 // | <symbol-tag> <size> <symbol-number>* 0 <attribute>*
837 // ]+
838 // ]*
839
840 // Switch section to AttributeSection or get/create the section.
841 if (AttributeSection) {
842 switchSection(Section: AttributeSection);
843 } else {
844 AttributeSection = getContext().getELFSection(Section, Type, Flags: 0);
845 switchSection(Section: AttributeSection);
846
847 // Format version
848 emitInt8(Value: 0x41);
849 }
850
851 // Vendor size + Vendor name + '\0'
852 const size_t VendorHeaderSize = 4 + Vendor.size() + 1;
853
854 // Tag + Tag Size
855 const size_t TagHeaderSize = 1 + 4;
856
857 const size_t ContentsSize = calculateContentSize(AttrsVec);
858
859 emitInt32(Value: VendorHeaderSize + TagHeaderSize + ContentsSize);
860 emitBytes(Data: Vendor);
861 emitInt8(Value: 0); // '\0'
862
863 emitInt8(Value: ARMBuildAttrs::File);
864 emitInt32(Value: TagHeaderSize + ContentsSize);
865
866 // Size should have been accounted for already, now
867 // emit each field as its type (ULEB or String)
868 for (size_t I = 0; I < AttrsVec.size(); ++I) {
869 AttributeItem Item = AttrsVec[I];
870 emitULEB128IntValue(Value: Item.Tag);
871 switch (Item.Type) {
872 default:
873 llvm_unreachable("Invalid attribute type");
874 case AttributeItem::NumericAttribute:
875 emitULEB128IntValue(Value: Item.IntValue);
876 break;
877 case AttributeItem::TextAttribute:
878 emitBytes(Data: Item.StringValue);
879 emitInt8(Value: 0); // '\0'
880 break;
881 case AttributeItem::NumericAndTextAttributes:
882 emitULEB128IntValue(Value: Item.IntValue);
883 emitBytes(Data: Item.StringValue);
884 emitInt8(Value: 0); // '\0'
885 break;
886 }
887 }
888
889 AttrsVec.clear();
890}
891
892MCStreamer *llvm::createELFStreamer(MCContext &Context,
893 std::unique_ptr<MCAsmBackend> &&MAB,
894 std::unique_ptr<MCObjectWriter> &&OW,
895 std::unique_ptr<MCCodeEmitter> &&CE,
896 bool RelaxAll) {
897 MCELFStreamer *S =
898 new MCELFStreamer(Context, std::move(MAB), std::move(OW), std::move(CE));
899 if (RelaxAll)
900 S->getAssembler().setRelaxAll(true);
901 return S;
902}
903

source code of llvm/lib/MC/MCELFStreamer.cpp