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(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 | |
91 | void 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 | |
101 | void 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 | |
111 | void 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 | |
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(MinAlignment: 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(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 | |
167 | void 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). |
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>(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 | |
313 | void 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 | |
344 | void MCELFStreamer::emitELFSize(MCSymbol *Symbol, const MCExpr *Value) { |
345 | cast<MCSymbolELF>(Val: Symbol)->setSize(Value); |
346 | } |
347 | |
348 | void 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 | |
355 | void 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 | |
364 | void 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 | |
372 | void 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 | |
381 | void 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 | |
387 | void MCELFStreamer::emitIdent(StringRef IdentString) { |
388 | MCSection * = 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 | |
401 | void 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 | |
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 | 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 | |
512 | void 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 | |
531 | void 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. |
543 | static 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 | |
549 | void 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 | |
643 | void 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 | |
653 | void 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 | |
672 | void 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 | |
705 | void 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 | |
723 | void MCELFStreamer::emitThumbFunc(MCSymbol *Func) { |
724 | llvm_unreachable("Generic ELF doesn't support this directive" ); |
725 | } |
726 | |
727 | void MCELFStreamer::emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) { |
728 | llvm_unreachable("ELF doesn't support this directive" ); |
729 | } |
730 | |
731 | void 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 | |
737 | void MCELFStreamer::emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, |
738 | uint64_t Size, Align ByteAlignment) { |
739 | llvm_unreachable("ELF doesn't support this directive" ); |
740 | } |
741 | |
742 | void 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 | |
759 | void 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 | |
776 | void 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 | |
795 | MCELFStreamer::AttributeItem * |
796 | MCELFStreamer::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 | |
803 | size_t |
804 | MCELFStreamer::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 | |
829 | void 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 = 4 + Vendor.size() + 1; |
853 | |
854 | // Tag + Tag Size |
855 | const size_t = 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 | |
892 | MCStreamer *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 | |