LLVM 19.0.0git
ARMELFStreamer.cpp
Go to the documentation of this file.
1//===- lib/MC/ARMELFStreamer.cpp - ELF Object Output for ARM --------------===//
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 ARM ELF .o object files. Different
10// from generic ELF streamer in emitting mapping symbols ($a, $t and $d) to
11// delimit regions of data and code.
12//
13//===----------------------------------------------------------------------===//
14
15#include "ARMMCTargetDesc.h"
16#include "ARMUnwindOpAsm.h"
17#include "Utils/ARMBaseInfo.h"
18#include "llvm/ADT/DenseMap.h"
22#include "llvm/ADT/StringRef.h"
23#include "llvm/ADT/Twine.h"
26#include "llvm/MC/MCAsmInfo.h"
27#include "llvm/MC/MCAssembler.h"
29#include "llvm/MC/MCContext.h"
31#include "llvm/MC/MCExpr.h"
32#include "llvm/MC/MCFixup.h"
33#include "llvm/MC/MCFragment.h"
34#include "llvm/MC/MCInst.h"
38#include "llvm/MC/MCSection.h"
40#include "llvm/MC/MCStreamer.h"
42#include "llvm/MC/MCSymbol.h"
43#include "llvm/MC/MCSymbolELF.h"
44#include "llvm/MC/SectionKind.h"
51#include <algorithm>
52#include <cassert>
53#include <climits>
54#include <cstddef>
55#include <cstdint>
56#include <string>
57
58using namespace llvm;
59
60static std::string GetAEABIUnwindPersonalityName(unsigned Index) {
62 "Invalid personality index");
63 return (Twine("__aeabi_unwind_cpp_pr") + Twine(Index)).str();
64}
65
66namespace {
67
68class ARMELFStreamer;
69
70class ARMTargetAsmStreamer : public ARMTargetStreamer {
72 MCInstPrinter &InstPrinter;
73 bool IsVerboseAsm;
74
75 void emitFnStart() override;
76 void emitFnEnd() override;
77 void emitCantUnwind() override;
78 void emitPersonality(const MCSymbol *Personality) override;
79 void emitPersonalityIndex(unsigned Index) override;
80 void emitHandlerData() override;
81 void emitSetFP(unsigned FpReg, unsigned SpReg, int64_t Offset = 0) override;
82 void emitMovSP(unsigned Reg, int64_t Offset = 0) override;
83 void emitPad(int64_t Offset) override;
84 void emitRegSave(const SmallVectorImpl<unsigned> &RegList,
85 bool isVector) override;
86 void emitUnwindRaw(int64_t Offset,
87 const SmallVectorImpl<uint8_t> &Opcodes) override;
88
89 void switchVendor(StringRef Vendor) override;
90 void emitAttribute(unsigned Attribute, unsigned Value) override;
91 void emitTextAttribute(unsigned Attribute, StringRef String) override;
92 void emitIntTextAttribute(unsigned Attribute, unsigned IntValue,
93 StringRef StringValue) override;
94 void emitArch(ARM::ArchKind Arch) override;
95 void emitArchExtension(uint64_t ArchExt) override;
96 void emitObjectArch(ARM::ArchKind Arch) override;
97 void emitFPU(ARM::FPUKind FPU) override;
98 void emitInst(uint32_t Inst, char Suffix = '\0') override;
99 void finishAttributeSection() override;
100
101 void annotateTLSDescriptorSequence(const MCSymbolRefExpr *SRE) override;
102 void emitThumbSet(MCSymbol *Symbol, const MCExpr *Value) override;
103
104 void emitARMWinCFIAllocStack(unsigned Size, bool Wide) override;
105 void emitARMWinCFISaveRegMask(unsigned Mask, bool Wide) override;
106 void emitARMWinCFISaveSP(unsigned Reg) override;
107 void emitARMWinCFISaveFRegs(unsigned First, unsigned Last) override;
108 void emitARMWinCFISaveLR(unsigned Offset) override;
109 void emitARMWinCFIPrologEnd(bool Fragment) override;
110 void emitARMWinCFINop(bool Wide) override;
111 void emitARMWinCFIEpilogStart(unsigned Condition) override;
112 void emitARMWinCFIEpilogEnd() override;
113 void emitARMWinCFICustom(unsigned Opcode) override;
114
115public:
116 ARMTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS,
117 MCInstPrinter &InstPrinter, bool VerboseAsm);
118};
119
120ARMTargetAsmStreamer::ARMTargetAsmStreamer(MCStreamer &S,
122 MCInstPrinter &InstPrinter,
123 bool VerboseAsm)
124 : ARMTargetStreamer(S), OS(OS), InstPrinter(InstPrinter),
125 IsVerboseAsm(VerboseAsm) {}
126
127void ARMTargetAsmStreamer::emitFnStart() { OS << "\t.fnstart\n"; }
128void ARMTargetAsmStreamer::emitFnEnd() { OS << "\t.fnend\n"; }
129void ARMTargetAsmStreamer::emitCantUnwind() { OS << "\t.cantunwind\n"; }
130
131void ARMTargetAsmStreamer::emitPersonality(const MCSymbol *Personality) {
132 OS << "\t.personality " << Personality->getName() << '\n';
133}
134
135void ARMTargetAsmStreamer::emitPersonalityIndex(unsigned Index) {
136 OS << "\t.personalityindex " << Index << '\n';
137}
138
139void ARMTargetAsmStreamer::emitHandlerData() { OS << "\t.handlerdata\n"; }
140
141void ARMTargetAsmStreamer::emitSetFP(unsigned FpReg, unsigned SpReg,
142 int64_t Offset) {
143 OS << "\t.setfp\t";
144 InstPrinter.printRegName(OS, FpReg);
145 OS << ", ";
146 InstPrinter.printRegName(OS, SpReg);
147 if (Offset)
148 OS << ", #" << Offset;
149 OS << '\n';
150}
151
152void ARMTargetAsmStreamer::emitMovSP(unsigned Reg, int64_t Offset) {
153 assert((Reg != ARM::SP && Reg != ARM::PC) &&
154 "the operand of .movsp cannot be either sp or pc");
155
156 OS << "\t.movsp\t";
157 InstPrinter.printRegName(OS, Reg);
158 if (Offset)
159 OS << ", #" << Offset;
160 OS << '\n';
161}
162
163void ARMTargetAsmStreamer::emitPad(int64_t Offset) {
164 OS << "\t.pad\t#" << Offset << '\n';
165}
166
167void ARMTargetAsmStreamer::emitRegSave(const SmallVectorImpl<unsigned> &RegList,
168 bool isVector) {
169 assert(RegList.size() && "RegList should not be empty");
170 if (isVector)
171 OS << "\t.vsave\t{";
172 else
173 OS << "\t.save\t{";
174
175 InstPrinter.printRegName(OS, RegList[0]);
176
177 for (unsigned i = 1, e = RegList.size(); i != e; ++i) {
178 OS << ", ";
179 InstPrinter.printRegName(OS, RegList[i]);
180 }
181
182 OS << "}\n";
183}
184
185void ARMTargetAsmStreamer::switchVendor(StringRef Vendor) {}
186
187void ARMTargetAsmStreamer::emitAttribute(unsigned Attribute, unsigned Value) {
188 OS << "\t.eabi_attribute\t" << Attribute << ", " << Twine(Value);
189 if (IsVerboseAsm) {
192 if (!Name.empty())
193 OS << "\t@ " << Name;
194 }
195 OS << "\n";
196}
197
198void ARMTargetAsmStreamer::emitTextAttribute(unsigned Attribute,
200 switch (Attribute) {
202 OS << "\t.cpu\t" << String.lower();
203 break;
204 default:
205 OS << "\t.eabi_attribute\t" << Attribute << ", \"";
208 else
209 OS << String;
210 OS << "\"";
211 if (IsVerboseAsm) {
214 if (!Name.empty())
215 OS << "\t@ " << Name;
216 }
217 break;
218 }
219 OS << "\n";
220}
221
222void ARMTargetAsmStreamer::emitIntTextAttribute(unsigned Attribute,
223 unsigned IntValue,
224 StringRef StringValue) {
225 switch (Attribute) {
226 default: llvm_unreachable("unsupported multi-value attribute in asm mode");
228 OS << "\t.eabi_attribute\t" << Attribute << ", " << IntValue;
229 if (!StringValue.empty())
230 OS << ", \"" << StringValue << "\"";
231 if (IsVerboseAsm)
232 OS << "\t@ "
235 break;
236 }
237 OS << "\n";
238}
239
240void ARMTargetAsmStreamer::emitArch(ARM::ArchKind Arch) {
241 OS << "\t.arch\t" << ARM::getArchName(Arch) << "\n";
242}
243
244void ARMTargetAsmStreamer::emitArchExtension(uint64_t ArchExt) {
245 OS << "\t.arch_extension\t" << ARM::getArchExtName(ArchExt) << "\n";
246}
247
248void ARMTargetAsmStreamer::emitObjectArch(ARM::ArchKind Arch) {
249 OS << "\t.object_arch\t" << ARM::getArchName(Arch) << '\n';
250}
251
252void ARMTargetAsmStreamer::emitFPU(ARM::FPUKind FPU) {
253 OS << "\t.fpu\t" << ARM::getFPUName(FPU) << "\n";
254}
255
256void ARMTargetAsmStreamer::finishAttributeSection() {}
257
258void ARMTargetAsmStreamer::annotateTLSDescriptorSequence(
259 const MCSymbolRefExpr *S) {
260 OS << "\t.tlsdescseq\t" << S->getSymbol().getName() << "\n";
261}
262
263void ARMTargetAsmStreamer::emitThumbSet(MCSymbol *Symbol, const MCExpr *Value) {
264 const MCAsmInfo *MAI = Streamer.getContext().getAsmInfo();
265
266 OS << "\t.thumb_set\t";
267 Symbol->print(OS, MAI);
268 OS << ", ";
269 Value->print(OS, MAI);
270 OS << '\n';
271}
272
273void ARMTargetAsmStreamer::emitInst(uint32_t Inst, char Suffix) {
274 OS << "\t.inst";
275 if (Suffix)
276 OS << "." << Suffix;
277 OS << "\t0x" << Twine::utohexstr(Inst) << "\n";
278}
279
280void ARMTargetAsmStreamer::emitUnwindRaw(int64_t Offset,
281 const SmallVectorImpl<uint8_t> &Opcodes) {
282 OS << "\t.unwind_raw " << Offset;
283 for (uint8_t Opcode : Opcodes)
284 OS << ", 0x" << Twine::utohexstr(Opcode);
285 OS << '\n';
286}
287
288void ARMTargetAsmStreamer::emitARMWinCFIAllocStack(unsigned Size, bool Wide) {
289 if (Wide)
290 OS << "\t.seh_stackalloc_w\t" << Size << "\n";
291 else
292 OS << "\t.seh_stackalloc\t" << Size << "\n";
293}
294
295static void printRegs(formatted_raw_ostream &OS, ListSeparator &LS, int First,
296 int Last) {
297 if (First != Last)
298 OS << LS << "r" << First << "-r" << Last;
299 else
300 OS << LS << "r" << First;
301}
302
303void ARMTargetAsmStreamer::emitARMWinCFISaveRegMask(unsigned Mask, bool Wide) {
304 if (Wide)
305 OS << "\t.seh_save_regs_w\t";
306 else
307 OS << "\t.seh_save_regs\t";
308 ListSeparator LS;
309 int First = -1;
310 OS << "{";
311 for (int I = 0; I <= 12; I++) {
312 if (Mask & (1 << I)) {
313 if (First < 0)
314 First = I;
315 } else {
316 if (First >= 0) {
317 printRegs(OS, LS, First, I - 1);
318 First = -1;
319 }
320 }
321 }
322 if (First >= 0)
323 printRegs(OS, LS, First, 12);
324 if (Mask & (1 << 14))
325 OS << LS << "lr";
326 OS << "}\n";
327}
328
329void ARMTargetAsmStreamer::emitARMWinCFISaveSP(unsigned Reg) {
330 OS << "\t.seh_save_sp\tr" << Reg << "\n";
331}
332
333void ARMTargetAsmStreamer::emitARMWinCFISaveFRegs(unsigned First,
334 unsigned Last) {
335 if (First != Last)
336 OS << "\t.seh_save_fregs\t{d" << First << "-d" << Last << "}\n";
337 else
338 OS << "\t.seh_save_fregs\t{d" << First << "}\n";
339}
340
341void ARMTargetAsmStreamer::emitARMWinCFISaveLR(unsigned Offset) {
342 OS << "\t.seh_save_lr\t" << Offset << "\n";
343}
344
345void ARMTargetAsmStreamer::emitARMWinCFIPrologEnd(bool Fragment) {
346 if (Fragment)
347 OS << "\t.seh_endprologue_fragment\n";
348 else
349 OS << "\t.seh_endprologue\n";
350}
351
352void ARMTargetAsmStreamer::emitARMWinCFINop(bool Wide) {
353 if (Wide)
354 OS << "\t.seh_nop_w\n";
355 else
356 OS << "\t.seh_nop\n";
357}
358
359void ARMTargetAsmStreamer::emitARMWinCFIEpilogStart(unsigned Condition) {
360 if (Condition == ARMCC::AL)
361 OS << "\t.seh_startepilogue\n";
362 else
363 OS << "\t.seh_startepilogue_cond\t"
364 << ARMCondCodeToString(static_cast<ARMCC::CondCodes>(Condition)) << "\n";
365}
366
367void ARMTargetAsmStreamer::emitARMWinCFIEpilogEnd() {
368 OS << "\t.seh_endepilogue\n";
369}
370
371void ARMTargetAsmStreamer::emitARMWinCFICustom(unsigned Opcode) {
372 int I;
373 for (I = 3; I > 0; I--)
374 if (Opcode & (0xffu << (8 * I)))
375 break;
376 ListSeparator LS;
377 OS << "\t.seh_custom\t";
378 for (; I >= 0; I--)
379 OS << LS << ((Opcode >> (8 * I)) & 0xff);
380 OS << "\n";
381}
382
383class ARMTargetELFStreamer : public ARMTargetStreamer {
384private:
385 StringRef CurrentVendor;
386 ARM::FPUKind FPU = ARM::FK_INVALID;
387 ARM::ArchKind Arch = ARM::ArchKind::INVALID;
388 ARM::ArchKind EmittedArch = ARM::ArchKind::INVALID;
389
390 MCSection *AttributeSection = nullptr;
391
392 void emitArchDefaultAttributes();
393 void emitFPUDefaultAttributes();
394
395 ARMELFStreamer &getStreamer();
396
397 void emitFnStart() override;
398 void emitFnEnd() override;
399 void emitCantUnwind() override;
400 void emitPersonality(const MCSymbol *Personality) override;
401 void emitPersonalityIndex(unsigned Index) override;
402 void emitHandlerData() override;
403 void emitSetFP(unsigned FpReg, unsigned SpReg, int64_t Offset = 0) override;
404 void emitMovSP(unsigned Reg, int64_t Offset = 0) override;
405 void emitPad(int64_t Offset) override;
406 void emitRegSave(const SmallVectorImpl<unsigned> &RegList,
407 bool isVector) override;
408 void emitUnwindRaw(int64_t Offset,
409 const SmallVectorImpl<uint8_t> &Opcodes) override;
410
411 void switchVendor(StringRef Vendor) override;
412 void emitAttribute(unsigned Attribute, unsigned Value) override;
413 void emitTextAttribute(unsigned Attribute, StringRef String) override;
414 void emitIntTextAttribute(unsigned Attribute, unsigned IntValue,
415 StringRef StringValue) override;
416 void emitArch(ARM::ArchKind Arch) override;
417 void emitObjectArch(ARM::ArchKind Arch) override;
418 void emitFPU(ARM::FPUKind FPU) override;
419 void emitInst(uint32_t Inst, char Suffix = '\0') override;
420 void finishAttributeSection() override;
421 void emitLabel(MCSymbol *Symbol) override;
422
423 void annotateTLSDescriptorSequence(const MCSymbolRefExpr *SRE) override;
424 void emitThumbSet(MCSymbol *Symbol, const MCExpr *Value) override;
425
426 // Reset state between object emissions
427 void reset() override;
428
429public:
430 ARMTargetELFStreamer(MCStreamer &S)
431 : ARMTargetStreamer(S), CurrentVendor("aeabi") {}
432};
433
434/// Extend the generic ELFStreamer class so that it can emit mapping symbols at
435/// the appropriate points in the object files. These symbols are defined in the
436/// ARM ELF ABI: infocenter.arm.com/help/topic/com.arm.../IHI0044D_aaelf.pdf.
437///
438/// In brief: $a, $t or $d should be emitted at the start of each contiguous
439/// region of ARM code, Thumb code or data in a section. In practice, this
440/// emission does not rely on explicit assembler directives but on inherent
441/// properties of the directives doing the emission (e.g. ".byte" is data, "add
442/// r0, r0, r0" an instruction).
443///
444/// As a result this system is orthogonal to the DataRegion infrastructure used
445/// by MachO. Beware!
446class ARMELFStreamer : public MCELFStreamer {
447public:
448 friend class ARMTargetELFStreamer;
449
450 ARMELFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
451 std::unique_ptr<MCObjectWriter> OW,
452 std::unique_ptr<MCCodeEmitter> Emitter, bool IsThumb,
453 bool IsAndroid)
454 : MCELFStreamer(Context, std::move(TAB), std::move(OW),
455 std::move(Emitter)),
456 IsThumb(IsThumb), IsAndroid(IsAndroid) {
457 EHReset();
458 }
459
460 ~ARMELFStreamer() override = default;
461
462 void finishImpl() override;
463
464 // ARM exception handling directives
465 void emitFnStart();
466 void emitFnEnd();
467 void emitCantUnwind();
468 void emitPersonality(const MCSymbol *Per);
469 void emitPersonalityIndex(unsigned index);
470 void emitHandlerData();
471 void emitSetFP(unsigned NewFpReg, unsigned NewSpReg, int64_t Offset = 0);
472 void emitMovSP(unsigned Reg, int64_t Offset = 0);
473 void emitPad(int64_t Offset);
474 void emitRegSave(const SmallVectorImpl<unsigned> &RegList, bool isVector);
475 void emitUnwindRaw(int64_t Offset, const SmallVectorImpl<uint8_t> &Opcodes);
476 void emitFill(const MCExpr &NumBytes, uint64_t FillValue,
477 SMLoc Loc) override {
478 emitDataMappingSymbol();
479 MCObjectStreamer::emitFill(NumBytes, FillValue, Loc);
480 }
481
482 void changeSection(MCSection *Section, const MCExpr *Subsection) override {
483 LastMappingSymbols[getCurrentSection().first] = std::move(LastEMSInfo);
484 MCELFStreamer::changeSection(Section, Subsection);
485 auto LastMappingSymbol = LastMappingSymbols.find(Section);
486 if (LastMappingSymbol != LastMappingSymbols.end()) {
487 LastEMSInfo = std::move(LastMappingSymbol->second);
488 return;
489 }
490 LastEMSInfo.reset(new ElfMappingSymbolInfo(SMLoc(), nullptr, 0));
491 }
492
493 /// This function is the one used to emit instruction data into the ELF
494 /// streamer. We override it to add the appropriate mapping symbol if
495 /// necessary.
496 void emitInstruction(const MCInst &Inst,
497 const MCSubtargetInfo &STI) override {
498 if (IsThumb)
499 EmitThumbMappingSymbol();
500 else
501 EmitARMMappingSymbol();
502
504 }
505
506 void emitInst(uint32_t Inst, char Suffix) {
507 unsigned Size;
508 char Buffer[4];
509 const bool LittleEndian = getContext().getAsmInfo()->isLittleEndian();
510
511 switch (Suffix) {
512 case '\0':
513 Size = 4;
514
515 assert(!IsThumb);
516 EmitARMMappingSymbol();
517 for (unsigned II = 0, IE = Size; II != IE; II++) {
518 const unsigned I = LittleEndian ? (Size - II - 1) : II;
519 Buffer[Size - II - 1] = uint8_t(Inst >> I * CHAR_BIT);
520 }
521
522 break;
523 case 'n':
524 case 'w':
525 Size = (Suffix == 'n' ? 2 : 4);
526
527 assert(IsThumb);
528 EmitThumbMappingSymbol();
529 // Thumb wide instructions are emitted as a pair of 16-bit words of the
530 // appropriate endianness.
531 for (unsigned II = 0, IE = Size; II != IE; II = II + 2) {
532 const unsigned I0 = LittleEndian ? II + 0 : II + 1;
533 const unsigned I1 = LittleEndian ? II + 1 : II + 0;
534 Buffer[Size - II - 2] = uint8_t(Inst >> I0 * CHAR_BIT);
535 Buffer[Size - II - 1] = uint8_t(Inst >> I1 * CHAR_BIT);
536 }
537
538 break;
539 default:
540 llvm_unreachable("Invalid Suffix");
541 }
542
544 }
545
546 /// This is one of the functions used to emit data into an ELF section, so the
547 /// ARM streamer overrides it to add the appropriate mapping symbol ($d) if
548 /// necessary.
549 void emitBytes(StringRef Data) override {
550 emitDataMappingSymbol();
552 }
553
554 void FlushPendingMappingSymbol() {
555 if (!LastEMSInfo->hasInfo())
556 return;
557 ElfMappingSymbolInfo *EMS = LastEMSInfo.get();
558 EmitMappingSymbol("$d", EMS->Loc, EMS->F, EMS->Offset);
559 EMS->resetInfo();
560 }
561
562 /// This is one of the functions used to emit data into an ELF section, so the
563 /// ARM streamer overrides it to add the appropriate mapping symbol ($d) if
564 /// necessary.
565 void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override {
566 if (const MCSymbolRefExpr *SRE = dyn_cast_or_null<MCSymbolRefExpr>(Value)) {
567 if (SRE->getKind() == MCSymbolRefExpr::VK_ARM_SBREL && !(Size == 4)) {
568 getContext().reportError(Loc, "relocated expression must be 32-bit");
569 return;
570 }
572 }
573
574 emitDataMappingSymbol();
576 }
577
578 void emitAssemblerFlag(MCAssemblerFlag Flag) override {
580
581 switch (Flag) {
583 return; // no-op here.
584 case MCAF_Code16:
585 IsThumb = true;
586 return; // Change to Thumb mode
587 case MCAF_Code32:
588 IsThumb = false;
589 return; // Change to ARM mode
590 case MCAF_Code64:
591 return;
593 return;
594 }
595 }
596
597 /// If a label is defined before the .type directive sets the label's type
598 /// then the label can't be recorded as thumb function when the label is
599 /// defined. We override emitSymbolAttribute() which is called as part of the
600 /// parsing of .type so that if the symbol has already been defined we can
601 /// record the label as Thumb. FIXME: there is a corner case where the state
602 /// is changed in between the label definition and the .type directive, this
603 /// is not expected to occur in practice and handling it would require the
604 /// backend to track IsThumb for every label.
605 bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override {
607
608 if (!IsThumb)
609 return Val;
610
611 unsigned Type = cast<MCSymbolELF>(Symbol)->getType();
612 if ((Type == ELF::STT_FUNC || Type == ELF::STT_GNU_IFUNC) &&
613 Symbol->isDefined())
615
616 return Val;
617 };
618
619private:
620 enum ElfMappingSymbol {
621 EMS_None,
622 EMS_ARM,
623 EMS_Thumb,
624 EMS_Data
625 };
626
627 struct ElfMappingSymbolInfo {
628 explicit ElfMappingSymbolInfo(SMLoc Loc, MCFragment *F, uint64_t O)
629 : Loc(Loc), F(F), Offset(O), State(EMS_None) {}
630 void resetInfo() {
631 F = nullptr;
632 Offset = 0;
633 }
634 bool hasInfo() { return F != nullptr; }
635 SMLoc Loc;
636 MCFragment *F;
638 ElfMappingSymbol State;
639 };
640
641 void emitDataMappingSymbol() {
642 if (LastEMSInfo->State == EMS_Data)
643 return;
644 else if (LastEMSInfo->State == EMS_None) {
645 // This is a tentative symbol, it won't really be emitted until it's
646 // actually needed.
647 ElfMappingSymbolInfo *EMS = LastEMSInfo.get();
648 auto *DF = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
649 if (!DF)
650 return;
651 EMS->Loc = SMLoc();
652 EMS->F = getCurrentFragment();
653 EMS->Offset = DF->getContents().size();
654 LastEMSInfo->State = EMS_Data;
655 return;
656 }
657 EmitMappingSymbol("$d");
658 LastEMSInfo->State = EMS_Data;
659 }
660
661 void EmitThumbMappingSymbol() {
662 if (LastEMSInfo->State == EMS_Thumb)
663 return;
664 FlushPendingMappingSymbol();
665 EmitMappingSymbol("$t");
666 LastEMSInfo->State = EMS_Thumb;
667 }
668
669 void EmitARMMappingSymbol() {
670 if (LastEMSInfo->State == EMS_ARM)
671 return;
672 FlushPendingMappingSymbol();
673 EmitMappingSymbol("$a");
674 LastEMSInfo->State = EMS_ARM;
675 }
676
677 void EmitMappingSymbol(StringRef Name) {
678 auto *Symbol = cast<MCSymbolELF>(getContext().getOrCreateSymbol(
679 Name + "." + Twine(MappingSymbolCounter++)));
680 emitLabel(Symbol);
681
682 Symbol->setType(ELF::STT_NOTYPE);
683 Symbol->setBinding(ELF::STB_LOCAL);
684 }
685
686 void EmitMappingSymbol(StringRef Name, SMLoc Loc, MCFragment *F,
688 auto *Symbol = cast<MCSymbolELF>(getContext().getOrCreateSymbol(
689 Name + "." + Twine(MappingSymbolCounter++)));
690 emitLabelAtPos(Symbol, Loc, F, Offset);
691 Symbol->setType(ELF::STT_NOTYPE);
692 Symbol->setBinding(ELF::STB_LOCAL);
693 }
694
695 void emitThumbFunc(MCSymbol *Func) override {
698 }
699
700 // Helper functions for ARM exception handling directives
701 void EHReset();
702
703 // Reset state between object emissions
704 void reset() override;
705
706 void EmitPersonalityFixup(StringRef Name);
707 void FlushPendingOffset();
708 void FlushUnwindOpcodes(bool NoHandlerData);
709
710 void SwitchToEHSection(StringRef Prefix, unsigned Type, unsigned Flags,
711 SectionKind Kind, const MCSymbol &Fn);
712 void SwitchToExTabSection(const MCSymbol &FnStart);
713 void SwitchToExIdxSection(const MCSymbol &FnStart);
714
715 void EmitFixup(const MCExpr *Expr, MCFixupKind Kind);
716
717 bool IsThumb;
718 bool IsAndroid;
719 int64_t MappingSymbolCounter = 0;
720
722 LastMappingSymbols;
723
724 std::unique_ptr<ElfMappingSymbolInfo> LastEMSInfo;
725
726 // ARM Exception Handling Frame Information
727 MCSymbol *ExTab;
728 MCSymbol *FnStart;
729 const MCSymbol *Personality;
730 unsigned PersonalityIndex;
731 unsigned FPReg; // Frame pointer register
732 int64_t FPOffset; // Offset: (final frame pointer) - (initial $sp)
733 int64_t SPOffset; // Offset: (final $sp) - (initial $sp)
734 int64_t PendingOffset; // Offset: (final $sp) - (emitted $sp)
735 bool UsedFP;
736 bool CantUnwind;
738 UnwindOpcodeAssembler UnwindOpAsm;
739};
740
741} // end anonymous namespace
742
743ARMELFStreamer &ARMTargetELFStreamer::getStreamer() {
744 return static_cast<ARMELFStreamer &>(Streamer);
745}
746
747void ARMTargetELFStreamer::emitFnStart() { getStreamer().emitFnStart(); }
748void ARMTargetELFStreamer::emitFnEnd() { getStreamer().emitFnEnd(); }
749void ARMTargetELFStreamer::emitCantUnwind() { getStreamer().emitCantUnwind(); }
750
751void ARMTargetELFStreamer::emitPersonality(const MCSymbol *Personality) {
752 getStreamer().emitPersonality(Personality);
753}
754
755void ARMTargetELFStreamer::emitPersonalityIndex(unsigned Index) {
756 getStreamer().emitPersonalityIndex(Index);
757}
758
759void ARMTargetELFStreamer::emitHandlerData() {
760 getStreamer().emitHandlerData();
761}
762
763void ARMTargetELFStreamer::emitSetFP(unsigned FpReg, unsigned SpReg,
764 int64_t Offset) {
765 getStreamer().emitSetFP(FpReg, SpReg, Offset);
766}
767
768void ARMTargetELFStreamer::emitMovSP(unsigned Reg, int64_t Offset) {
769 getStreamer().emitMovSP(Reg, Offset);
770}
771
772void ARMTargetELFStreamer::emitPad(int64_t Offset) {
773 getStreamer().emitPad(Offset);
774}
775
776void ARMTargetELFStreamer::emitRegSave(const SmallVectorImpl<unsigned> &RegList,
777 bool isVector) {
778 getStreamer().emitRegSave(RegList, isVector);
779}
780
781void ARMTargetELFStreamer::emitUnwindRaw(int64_t Offset,
782 const SmallVectorImpl<uint8_t> &Opcodes) {
783 getStreamer().emitUnwindRaw(Offset, Opcodes);
784}
785
786void ARMTargetELFStreamer::switchVendor(StringRef Vendor) {
787 assert(!Vendor.empty() && "Vendor cannot be empty.");
788
789 if (CurrentVendor == Vendor)
790 return;
791
792 if (!CurrentVendor.empty())
793 finishAttributeSection();
794
795 assert(getStreamer().Contents.empty() &&
796 ".ARM.attributes should be flushed before changing vendor");
797 CurrentVendor = Vendor;
798
799}
800
801void ARMTargetELFStreamer::emitAttribute(unsigned Attribute, unsigned Value) {
802 getStreamer().setAttributeItem(Attribute, Value,
803 /* OverwriteExisting= */ true);
804}
805
806void ARMTargetELFStreamer::emitTextAttribute(unsigned Attribute,
808 getStreamer().setAttributeItem(Attribute, Value,
809 /* OverwriteExisting= */ true);
810}
811
812void ARMTargetELFStreamer::emitIntTextAttribute(unsigned Attribute,
813 unsigned IntValue,
814 StringRef StringValue) {
815 getStreamer().setAttributeItems(Attribute, IntValue, StringValue,
816 /* OverwriteExisting= */ true);
817}
818
819void ARMTargetELFStreamer::emitArch(ARM::ArchKind Value) {
820 Arch = Value;
821}
822
823void ARMTargetELFStreamer::emitObjectArch(ARM::ArchKind Value) {
824 EmittedArch = Value;
825}
826
827void ARMTargetELFStreamer::emitArchDefaultAttributes() {
828 using namespace ARMBuildAttrs;
829 ARMELFStreamer &S = getStreamer();
830
831 S.setAttributeItem(CPU_name, ARM::getCPUAttr(Arch), false);
832
833 if (EmittedArch == ARM::ArchKind::INVALID)
834 S.setAttributeItem(CPU_arch, ARM::getArchAttr(Arch), false);
835 else
836 S.setAttributeItem(CPU_arch, ARM::getArchAttr(EmittedArch), false);
837
838 switch (Arch) {
839 case ARM::ArchKind::ARMV4:
840 S.setAttributeItem(ARM_ISA_use, Allowed, false);
841 break;
842
843 case ARM::ArchKind::ARMV4T:
844 case ARM::ArchKind::ARMV5T:
845 case ARM::ArchKind::XSCALE:
846 case ARM::ArchKind::ARMV5TE:
847 case ARM::ArchKind::ARMV6:
848 S.setAttributeItem(ARM_ISA_use, Allowed, false);
849 S.setAttributeItem(THUMB_ISA_use, Allowed, false);
850 break;
851
852 case ARM::ArchKind::ARMV6T2:
853 S.setAttributeItem(ARM_ISA_use, Allowed, false);
854 S.setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
855 break;
856
857 case ARM::ArchKind::ARMV6K:
858 case ARM::ArchKind::ARMV6KZ:
859 S.setAttributeItem(ARM_ISA_use, Allowed, false);
860 S.setAttributeItem(THUMB_ISA_use, Allowed, false);
861 S.setAttributeItem(Virtualization_use, AllowTZ, false);
862 break;
863
864 case ARM::ArchKind::ARMV6M:
865 S.setAttributeItem(THUMB_ISA_use, Allowed, false);
866 break;
867
868 case ARM::ArchKind::ARMV7A:
869 S.setAttributeItem(CPU_arch_profile, ApplicationProfile, false);
870 S.setAttributeItem(ARM_ISA_use, Allowed, false);
871 S.setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
872 break;
873
874 case ARM::ArchKind::ARMV7R:
875 S.setAttributeItem(CPU_arch_profile, RealTimeProfile, false);
876 S.setAttributeItem(ARM_ISA_use, Allowed, false);
877 S.setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
878 break;
879
880 case ARM::ArchKind::ARMV7EM:
881 case ARM::ArchKind::ARMV7M:
882 S.setAttributeItem(CPU_arch_profile, MicroControllerProfile, false);
883 S.setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
884 break;
885
886 case ARM::ArchKind::ARMV8A:
887 case ARM::ArchKind::ARMV8_1A:
888 case ARM::ArchKind::ARMV8_2A:
889 case ARM::ArchKind::ARMV8_3A:
890 case ARM::ArchKind::ARMV8_4A:
891 case ARM::ArchKind::ARMV8_5A:
892 case ARM::ArchKind::ARMV8_6A:
893 case ARM::ArchKind::ARMV8_7A:
894 case ARM::ArchKind::ARMV8_8A:
895 case ARM::ArchKind::ARMV8_9A:
896 case ARM::ArchKind::ARMV9A:
897 case ARM::ArchKind::ARMV9_1A:
898 case ARM::ArchKind::ARMV9_2A:
899 case ARM::ArchKind::ARMV9_3A:
900 case ARM::ArchKind::ARMV9_4A:
901 case ARM::ArchKind::ARMV9_5A:
902 S.setAttributeItem(CPU_arch_profile, ApplicationProfile, false);
903 S.setAttributeItem(ARM_ISA_use, Allowed, false);
904 S.setAttributeItem(THUMB_ISA_use, AllowThumb32, false);
905 S.setAttributeItem(MPextension_use, Allowed, false);
906 S.setAttributeItem(Virtualization_use, AllowTZVirtualization, false);
907 break;
908
909 case ARM::ArchKind::ARMV8MBaseline:
910 case ARM::ArchKind::ARMV8MMainline:
911 S.setAttributeItem(THUMB_ISA_use, AllowThumbDerived, false);
912 S.setAttributeItem(CPU_arch_profile, MicroControllerProfile, false);
913 break;
914
915 case ARM::ArchKind::IWMMXT:
916 S.setAttributeItem(ARM_ISA_use, Allowed, false);
917 S.setAttributeItem(THUMB_ISA_use, Allowed, false);
918 S.setAttributeItem(WMMX_arch, AllowWMMXv1, false);
919 break;
920
921 case ARM::ArchKind::IWMMXT2:
922 S.setAttributeItem(ARM_ISA_use, Allowed, false);
923 S.setAttributeItem(THUMB_ISA_use, Allowed, false);
924 S.setAttributeItem(WMMX_arch, AllowWMMXv2, false);
925 break;
926
927 default:
928 report_fatal_error("Unknown Arch: " + Twine(ARM::getArchName(Arch)));
929 break;
930 }
931}
932
933void ARMTargetELFStreamer::emitFPU(ARM::FPUKind Value) { FPU = Value; }
934
935void ARMTargetELFStreamer::emitFPUDefaultAttributes() {
936 ARMELFStreamer &S = getStreamer();
937
938 switch (FPU) {
939 case ARM::FK_VFP:
940 case ARM::FK_VFPV2:
942 /* OverwriteExisting= */ false);
943 break;
944
945 case ARM::FK_VFPV3:
947 /* OverwriteExisting= */ false);
948 break;
949
950 case ARM::FK_VFPV3_FP16:
952 /* OverwriteExisting= */ false);
954 /* OverwriteExisting= */ false);
955 break;
956
957 case ARM::FK_VFPV3_D16:
959 /* OverwriteExisting= */ false);
960 break;
961
962 case ARM::FK_VFPV3_D16_FP16:
964 /* OverwriteExisting= */ false);
966 /* OverwriteExisting= */ false);
967 break;
968
969 case ARM::FK_VFPV3XD:
971 /* OverwriteExisting= */ false);
972 break;
973 case ARM::FK_VFPV3XD_FP16:
975 /* OverwriteExisting= */ false);
977 /* OverwriteExisting= */ false);
978 break;
979
980 case ARM::FK_VFPV4:
982 /* OverwriteExisting= */ false);
983 break;
984
985 // ABI_HardFP_use is handled in ARMAsmPrinter, so _SP_D16 is treated the same
986 // as _D16 here.
987 case ARM::FK_FPV4_SP_D16:
988 case ARM::FK_VFPV4_D16:
990 /* OverwriteExisting= */ false);
991 break;
992
993 case ARM::FK_FP_ARMV8:
995 /* OverwriteExisting= */ false);
996 break;
997
998 // FPV5_D16 is identical to FP_ARMV8 except for the number of D registers, so
999 // uses the FP_ARMV8_D16 build attribute.
1000 case ARM::FK_FPV5_SP_D16:
1001 case ARM::FK_FPV5_D16:
1003 /* OverwriteExisting= */ false);
1004 break;
1005
1006 case ARM::FK_NEON:
1008 /* OverwriteExisting= */ false);
1009 S.setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
1011 /* OverwriteExisting= */ false);
1012 break;
1013
1014 case ARM::FK_NEON_FP16:
1016 /* OverwriteExisting= */ false);
1017 S.setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
1019 /* OverwriteExisting= */ false);
1021 /* OverwriteExisting= */ false);
1022 break;
1023
1024 case ARM::FK_NEON_VFPV4:
1026 /* OverwriteExisting= */ false);
1027 S.setAttributeItem(ARMBuildAttrs::Advanced_SIMD_arch,
1029 /* OverwriteExisting= */ false);
1030 break;
1031
1032 case ARM::FK_NEON_FP_ARMV8:
1033 case ARM::FK_CRYPTO_NEON_FP_ARMV8:
1035 /* OverwriteExisting= */ false);
1036 // 'Advanced_SIMD_arch' must be emitted not here, but within
1037 // ARMAsmPrinter::emitAttributes(), depending on hasV8Ops() and hasV8_1a()
1038 break;
1039
1040 case ARM::FK_SOFTVFP:
1041 case ARM::FK_NONE:
1042 break;
1043
1044 default:
1045 report_fatal_error("Unknown FPU: " + Twine(FPU));
1046 break;
1047 }
1048}
1049
1050void ARMTargetELFStreamer::finishAttributeSection() {
1051 ARMELFStreamer &S = getStreamer();
1052
1053 if (FPU != ARM::FK_INVALID)
1054 emitFPUDefaultAttributes();
1055
1056 if (Arch != ARM::ArchKind::INVALID)
1057 emitArchDefaultAttributes();
1058
1059 if (S.Contents.empty())
1060 return;
1061
1062 auto LessTag = [](const MCELFStreamer::AttributeItem &LHS,
1063 const MCELFStreamer::AttributeItem &RHS) -> bool {
1064 // The conformance tag must be emitted first when serialised into an
1065 // object file. Specifically, the addenda to the ARM ABI states that
1066 // (2.3.7.4):
1067 //
1068 // "To simplify recognition by consumers in the common case of claiming
1069 // conformity for the whole file, this tag should be emitted first in a
1070 // file-scope sub-subsection of the first public subsection of the
1071 // attributes section."
1072 //
1073 // So it is special-cased in this comparison predicate when the
1074 // attributes are sorted in finishAttributeSection().
1075 return (RHS.Tag != ARMBuildAttrs::conformance) &&
1076 ((LHS.Tag == ARMBuildAttrs::conformance) || (LHS.Tag < RHS.Tag));
1077 };
1078 llvm::sort(S.Contents, LessTag);
1079
1080 S.emitAttributesSection(CurrentVendor, ".ARM.attributes",
1081 ELF::SHT_ARM_ATTRIBUTES, AttributeSection);
1082
1083 FPU = ARM::FK_INVALID;
1084}
1085
1086void ARMTargetELFStreamer::emitLabel(MCSymbol *Symbol) {
1087 ARMELFStreamer &Streamer = getStreamer();
1088 if (!Streamer.IsThumb)
1089 return;
1090
1091 Streamer.getAssembler().registerSymbol(*Symbol);
1092 unsigned Type = cast<MCSymbolELF>(Symbol)->getType();
1094 Streamer.emitThumbFunc(Symbol);
1095}
1096
1097void ARMTargetELFStreamer::annotateTLSDescriptorSequence(
1098 const MCSymbolRefExpr *S) {
1099 getStreamer().EmitFixup(S, FK_Data_4);
1100}
1101
1102void ARMTargetELFStreamer::emitThumbSet(MCSymbol *Symbol, const MCExpr *Value) {
1103 if (const MCSymbolRefExpr *SRE = dyn_cast<MCSymbolRefExpr>(Value)) {
1104 const MCSymbol &Sym = SRE->getSymbol();
1105 if (!Sym.isDefined()) {
1106 getStreamer().emitAssignment(Symbol, Value);
1107 return;
1108 }
1109 }
1110
1111 getStreamer().emitThumbFunc(Symbol);
1112 getStreamer().emitAssignment(Symbol, Value);
1113}
1114
1115void ARMTargetELFStreamer::emitInst(uint32_t Inst, char Suffix) {
1116 getStreamer().emitInst(Inst, Suffix);
1117}
1118
1119void ARMTargetELFStreamer::reset() { AttributeSection = nullptr; }
1120
1121void ARMELFStreamer::finishImpl() {
1122 MCTargetStreamer &TS = *getTargetStreamer();
1123 ARMTargetStreamer &ATS = static_cast<ARMTargetStreamer &>(TS);
1125
1127}
1128
1129void ARMELFStreamer::reset() {
1130 MCTargetStreamer &TS = *getTargetStreamer();
1131 ARMTargetStreamer &ATS = static_cast<ARMTargetStreamer &>(TS);
1132 ATS.reset();
1133 MappingSymbolCounter = 0;
1135 LastMappingSymbols.clear();
1136 LastEMSInfo.reset();
1137 // MCELFStreamer clear's the assembler's e_flags. However, for
1138 // arm we manually set the ABI version on streamer creation, so
1139 // do the same here
1140 getAssembler().setELFHeaderEFlags(ELF::EF_ARM_EABI_VER5);
1141}
1142
1143inline void ARMELFStreamer::SwitchToEHSection(StringRef Prefix,
1144 unsigned Type,
1145 unsigned Flags,
1146 SectionKind Kind,
1147 const MCSymbol &Fn) {
1148 const MCSectionELF &FnSection =
1149 static_cast<const MCSectionELF &>(Fn.getSection());
1150
1151 // Create the name for new section
1152 StringRef FnSecName(FnSection.getName());
1153 SmallString<128> EHSecName(Prefix);
1154 if (FnSecName != ".text") {
1155 EHSecName += FnSecName;
1156 }
1157
1158 // Get .ARM.extab or .ARM.exidx section
1159 const MCSymbolELF *Group = FnSection.getGroup();
1160 if (Group)
1162 MCSectionELF *EHSection = getContext().getELFSection(
1163 EHSecName, Type, Flags, 0, Group, /*IsComdat=*/true,
1164 FnSection.getUniqueID(),
1165 static_cast<const MCSymbolELF *>(FnSection.getBeginSymbol()));
1166
1167 assert(EHSection && "Failed to get the required EH section");
1168
1169 // Switch to .ARM.extab or .ARM.exidx section
1170 switchSection(EHSection);
1171 emitValueToAlignment(Align(4), 0, 1, 0);
1172}
1173
1174inline void ARMELFStreamer::SwitchToExTabSection(const MCSymbol &FnStart) {
1175 SwitchToEHSection(".ARM.extab", ELF::SHT_PROGBITS, ELF::SHF_ALLOC,
1176 SectionKind::getData(), FnStart);
1177}
1178
1179inline void ARMELFStreamer::SwitchToExIdxSection(const MCSymbol &FnStart) {
1180 SwitchToEHSection(".ARM.exidx", ELF::SHT_ARM_EXIDX,
1182 SectionKind::getData(), FnStart);
1183}
1184
1185void ARMELFStreamer::EmitFixup(const MCExpr *Expr, MCFixupKind Kind) {
1186 MCDataFragment *Frag = getOrCreateDataFragment();
1187 Frag->getFixups().push_back(MCFixup::create(Frag->getContents().size(), Expr,
1188 Kind));
1189}
1190
1191void ARMELFStreamer::EHReset() {
1192 ExTab = nullptr;
1193 FnStart = nullptr;
1194 Personality = nullptr;
1195 PersonalityIndex = ARM::EHABI::NUM_PERSONALITY_INDEX;
1196 FPReg = ARM::SP;
1197 FPOffset = 0;
1198 SPOffset = 0;
1199 PendingOffset = 0;
1200 UsedFP = false;
1201 CantUnwind = false;
1202
1203 Opcodes.clear();
1204 UnwindOpAsm.Reset();
1205}
1206
1207void ARMELFStreamer::emitFnStart() {
1208 assert(FnStart == nullptr);
1209 FnStart = getContext().createTempSymbol();
1210 emitLabel(FnStart);
1211}
1212
1213void ARMELFStreamer::emitFnEnd() {
1214 assert(FnStart && ".fnstart must precedes .fnend");
1215
1216 // Emit unwind opcodes if there is no .handlerdata directive
1217 if (!ExTab && !CantUnwind)
1218 FlushUnwindOpcodes(true);
1219
1220 // Emit the exception index table entry
1221 SwitchToExIdxSection(*FnStart);
1222
1223 // The EHABI requires a dependency preserving R_ARM_NONE relocation to the
1224 // personality routine to protect it from an arbitrary platform's static
1225 // linker garbage collection. We disable this for Android where the unwinder
1226 // is either dynamically linked or directly references the personality
1227 // routine.
1228 if (PersonalityIndex < ARM::EHABI::NUM_PERSONALITY_INDEX && !IsAndroid)
1229 EmitPersonalityFixup(GetAEABIUnwindPersonalityName(PersonalityIndex));
1230
1231 const MCSymbolRefExpr *FnStartRef =
1234 getContext());
1235
1236 emitValue(FnStartRef, 4);
1237
1238 if (CantUnwind) {
1240 } else if (ExTab) {
1241 // Emit a reference to the unwind opcodes in the ".ARM.extab" section.
1242 const MCSymbolRefExpr *ExTabEntryRef =
1245 getContext());
1246 emitValue(ExTabEntryRef, 4);
1247 } else {
1248 // For the __aeabi_unwind_cpp_pr0, we have to emit the unwind opcodes in
1249 // the second word of exception index table entry. The size of the unwind
1250 // opcodes should always be 4 bytes.
1251 assert(PersonalityIndex == ARM::EHABI::AEABI_UNWIND_CPP_PR0 &&
1252 "Compact model must use __aeabi_unwind_cpp_pr0 as personality");
1253 assert(Opcodes.size() == 4u &&
1254 "Unwind opcode size for __aeabi_unwind_cpp_pr0 must be equal to 4");
1255 uint64_t Intval = Opcodes[0] |
1256 Opcodes[1] << 8 |
1257 Opcodes[2] << 16 |
1258 Opcodes[3] << 24;
1259 emitIntValue(Intval, Opcodes.size());
1260 }
1261
1262 // Switch to the section containing FnStart
1263 switchSection(&FnStart->getSection());
1264
1265 // Clean exception handling frame information
1266 EHReset();
1267}
1268
1269void ARMELFStreamer::emitCantUnwind() { CantUnwind = true; }
1270
1271// Add the R_ARM_NONE fixup at the same position
1272void ARMELFStreamer::EmitPersonalityFixup(StringRef Name) {
1273 const MCSymbol *PersonalitySym = getContext().getOrCreateSymbol(Name);
1274
1275 const MCSymbolRefExpr *PersonalityRef = MCSymbolRefExpr::create(
1276 PersonalitySym, MCSymbolRefExpr::VK_ARM_NONE, getContext());
1277
1278 visitUsedExpr(*PersonalityRef);
1279 MCDataFragment *DF = getOrCreateDataFragment();
1280 DF->getFixups().push_back(MCFixup::create(DF->getContents().size(),
1281 PersonalityRef,
1282 MCFixup::getKindForSize(4, false)));
1283}
1284
1285void ARMELFStreamer::FlushPendingOffset() {
1286 if (PendingOffset != 0) {
1287 UnwindOpAsm.EmitSPOffset(-PendingOffset);
1288 PendingOffset = 0;
1289 }
1290}
1291
1292void ARMELFStreamer::FlushUnwindOpcodes(bool NoHandlerData) {
1293 // Emit the unwind opcode to restore $sp.
1294 if (UsedFP) {
1295 const MCRegisterInfo *MRI = getContext().getRegisterInfo();
1296 int64_t LastRegSaveSPOffset = SPOffset - PendingOffset;
1297 UnwindOpAsm.EmitSPOffset(LastRegSaveSPOffset - FPOffset);
1298 UnwindOpAsm.EmitSetSP(MRI->getEncodingValue(FPReg));
1299 } else {
1300 FlushPendingOffset();
1301 }
1302
1303 // Finalize the unwind opcode sequence
1304 UnwindOpAsm.Finalize(PersonalityIndex, Opcodes);
1305
1306 // For compact model 0, we have to emit the unwind opcodes in the .ARM.exidx
1307 // section. Thus, we don't have to create an entry in the .ARM.extab
1308 // section.
1309 if (NoHandlerData && PersonalityIndex == ARM::EHABI::AEABI_UNWIND_CPP_PR0)
1310 return;
1311
1312 // Switch to .ARM.extab section.
1313 SwitchToExTabSection(*FnStart);
1314
1315 // Create .ARM.extab label for offset in .ARM.exidx
1316 assert(!ExTab);
1317 ExTab = getContext().createTempSymbol();
1318 emitLabel(ExTab);
1319
1320 // Emit personality
1321 if (Personality) {
1322 const MCSymbolRefExpr *PersonalityRef =
1323 MCSymbolRefExpr::create(Personality,
1325 getContext());
1326
1327 emitValue(PersonalityRef, 4);
1328 }
1329
1330 // Emit unwind opcodes
1331 assert((Opcodes.size() % 4) == 0 &&
1332 "Unwind opcode size for __aeabi_cpp_unwind_pr0 must be multiple of 4");
1333 for (unsigned I = 0; I != Opcodes.size(); I += 4) {
1334 uint64_t Intval = Opcodes[I] |
1335 Opcodes[I + 1] << 8 |
1336 Opcodes[I + 2] << 16 |
1337 Opcodes[I + 3] << 24;
1338 emitInt32(Intval);
1339 }
1340
1341 // According to ARM EHABI section 9.2, if the __aeabi_unwind_cpp_pr1() or
1342 // __aeabi_unwind_cpp_pr2() is used, then the handler data must be emitted
1343 // after the unwind opcodes. The handler data consists of several 32-bit
1344 // words, and should be terminated by zero.
1345 //
1346 // In case that the .handlerdata directive is not specified by the
1347 // programmer, we should emit zero to terminate the handler data.
1348 if (NoHandlerData && !Personality)
1349 emitInt32(0);
1350}
1351
1352void ARMELFStreamer::emitHandlerData() { FlushUnwindOpcodes(false); }
1353
1354void ARMELFStreamer::emitPersonality(const MCSymbol *Per) {
1355 Personality = Per;
1356 UnwindOpAsm.setPersonality(Per);
1357}
1358
1359void ARMELFStreamer::emitPersonalityIndex(unsigned Index) {
1360 assert(Index < ARM::EHABI::NUM_PERSONALITY_INDEX && "invalid index");
1361 PersonalityIndex = Index;
1362}
1363
1364void ARMELFStreamer::emitSetFP(unsigned NewFPReg, unsigned NewSPReg,
1365 int64_t Offset) {
1366 assert((NewSPReg == ARM::SP || NewSPReg == FPReg) &&
1367 "the operand of .setfp directive should be either $sp or $fp");
1368
1369 UsedFP = true;
1370 FPReg = NewFPReg;
1371
1372 if (NewSPReg == ARM::SP)
1373 FPOffset = SPOffset + Offset;
1374 else
1375 FPOffset += Offset;
1376}
1377
1378void ARMELFStreamer::emitMovSP(unsigned Reg, int64_t Offset) {
1379 assert((Reg != ARM::SP && Reg != ARM::PC) &&
1380 "the operand of .movsp cannot be either sp or pc");
1381 assert(FPReg == ARM::SP && "current FP must be SP");
1382
1383 FlushPendingOffset();
1384
1385 FPReg = Reg;
1386 FPOffset = SPOffset + Offset;
1387
1388 const MCRegisterInfo *MRI = getContext().getRegisterInfo();
1389 UnwindOpAsm.EmitSetSP(MRI->getEncodingValue(FPReg));
1390}
1391
1392void ARMELFStreamer::emitPad(int64_t Offset) {
1393 // Track the change of the $sp offset
1394 SPOffset -= Offset;
1395
1396 // To squash multiple .pad directives, we should delay the unwind opcode
1397 // until the .save, .vsave, .handlerdata, or .fnend directives.
1398 PendingOffset -= Offset;
1399}
1400
1401static std::pair<unsigned, unsigned>
1403 const SmallVectorImpl<unsigned> &RegList, bool IsVector,
1404 uint32_t &Mask_) {
1405 uint32_t Mask = 0;
1406 unsigned Count = 0;
1407 while (Idx > 0) {
1408 unsigned Reg = RegList[Idx - 1];
1409 if (Reg == ARM::RA_AUTH_CODE)
1410 break;
1411 Reg = MRI.getEncodingValue(Reg);
1412 assert(Reg < (IsVector ? 32U : 16U) && "Register out of range");
1413 unsigned Bit = (1u << Reg);
1414 if ((Mask & Bit) == 0) {
1415 Mask |= Bit;
1416 ++Count;
1417 }
1418 --Idx;
1419 }
1420
1421 Mask_ = Mask;
1422 return {Idx, Count};
1423}
1424
1425void ARMELFStreamer::emitRegSave(const SmallVectorImpl<unsigned> &RegList,
1426 bool IsVector) {
1427 uint32_t Mask;
1428 unsigned Idx, Count;
1429 const MCRegisterInfo &MRI = *getContext().getRegisterInfo();
1430
1431 // Collect the registers in the register list. Issue unwinding instructions in
1432 // three parts: ordinary hardware registers, return address authentication
1433 // code pseudo register, the rest of the registers. The RA PAC is kept in an
1434 // architectural register (usually r12), but we treat it as a special case in
1435 // order to distinguish between that register containing RA PAC or a general
1436 // value.
1437 Idx = RegList.size();
1438 while (Idx > 0) {
1439 std::tie(Idx, Count) = collectHWRegs(MRI, Idx, RegList, IsVector, Mask);
1440 if (Count) {
1441 // Track the change the $sp offset: For the .save directive, the
1442 // corresponding push instruction will decrease the $sp by (4 * Count).
1443 // For the .vsave directive, the corresponding vpush instruction will
1444 // decrease $sp by (8 * Count).
1445 SPOffset -= Count * (IsVector ? 8 : 4);
1446
1447 // Emit the opcode
1448 FlushPendingOffset();
1449 if (IsVector)
1450 UnwindOpAsm.EmitVFPRegSave(Mask);
1451 else
1452 UnwindOpAsm.EmitRegSave(Mask);
1453 } else if (Idx > 0 && RegList[Idx - 1] == ARM::RA_AUTH_CODE) {
1454 --Idx;
1455 SPOffset -= 4;
1456 FlushPendingOffset();
1457 UnwindOpAsm.EmitRegSave(0);
1458 }
1459 }
1460}
1461
1462void ARMELFStreamer::emitUnwindRaw(int64_t Offset,
1463 const SmallVectorImpl<uint8_t> &Opcodes) {
1464 FlushPendingOffset();
1465 SPOffset = SPOffset - Offset;
1466 UnwindOpAsm.EmitRaw(Opcodes);
1467}
1468
1469namespace llvm {
1470
1473 MCInstPrinter *InstPrint,
1474 bool isVerboseAsm) {
1475 return new ARMTargetAsmStreamer(S, OS, *InstPrint, isVerboseAsm);
1476}
1477
1479 return new ARMTargetStreamer(S);
1480}
1481
1483 return new ARMTargetELFStreamer(S);
1484}
1485
1487 std::unique_ptr<MCAsmBackend> TAB,
1488 std::unique_ptr<MCObjectWriter> OW,
1489 std::unique_ptr<MCCodeEmitter> Emitter,
1490 bool RelaxAll, bool IsThumb,
1491 bool IsAndroid) {
1492 ARMELFStreamer *S =
1493 new ARMELFStreamer(Context, std::move(TAB), std::move(OW),
1494 std::move(Emitter), IsThumb, IsAndroid);
1495 // FIXME: This should eventually end up somewhere else where more
1496 // intelligent flag decisions can be made. For now we are just maintaining
1497 // the status quo for ARM and setting EF_ARM_EABI_VER5 as the default.
1498 S->getAssembler().setELFHeaderEFlags(ELF::EF_ARM_EABI_VER5);
1499
1500 if (RelaxAll)
1501 S->getAssembler().setRelaxAll(true);
1502 return S;
1503}
1504
1505} // end namespace llvm
unsigned const MachineRegisterInfo * MRI
static std::string GetAEABIUnwindPersonalityName(unsigned Index)
static std::pair< unsigned, unsigned > collectHWRegs(const MCRegisterInfo &MRI, unsigned Idx, const SmallVectorImpl< unsigned > &RegList, bool IsVector, uint32_t &Mask_)
dxil DXContainer Global Emitter
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
static RegisterPass< DebugifyFunctionPass > DF("debugify-function", "Attach debug info to a function")
This file defines the DenseMap class.
std::string Name
uint64_t Size
Symbol * Sym
Definition: ELF_riscv.cpp:479
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
unsigned Reg
LLVMContext & Context
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
This file defines the SmallString class.
This file defines the SmallVector class.
This file contains some functions that are useful when dealing with strings.
Value * RHS
Value * LHS
virtual void emitUnwindRaw(int64_t StackOffset, const SmallVectorImpl< uint8_t > &Opcodes)
virtual void reset()
Reset any state between object emissions, i.e.
virtual void annotateTLSDescriptorSequence(const MCSymbolRefExpr *SRE)
virtual void finishAttributeSection()
virtual void emitARMWinCFISaveSP(unsigned Reg)
virtual void emitPersonalityIndex(unsigned Index)
virtual void emitInst(uint32_t Inst, char Suffix='\0')
virtual void emitARMWinCFISaveLR(unsigned Offset)
virtual void emitArchExtension(uint64_t ArchExt)
virtual void emitRegSave(const SmallVectorImpl< unsigned > &RegList, bool isVector)
virtual void emitTextAttribute(unsigned Attribute, StringRef String)
virtual void emitARMWinCFIAllocStack(unsigned Size, bool Wide)
virtual void emitMovSP(unsigned Reg, int64_t Offset=0)
virtual void emitARMWinCFICustom(unsigned Opcode)
virtual void emitARMWinCFISaveRegMask(unsigned Mask, bool Wide)
virtual void emitARMWinCFIEpilogEnd()
virtual void emitARMWinCFIPrologEnd(bool Fragment)
virtual void switchVendor(StringRef Vendor)
virtual void emitPersonality(const MCSymbol *Personality)
virtual void emitObjectArch(ARM::ArchKind Arch)
virtual void emitIntTextAttribute(unsigned Attribute, unsigned IntValue, StringRef StringValue="")
virtual void emitThumbSet(MCSymbol *Symbol, const MCExpr *Value)
virtual void emitFPU(ARM::FPUKind FPU)
virtual void emitARMWinCFISaveFRegs(unsigned First, unsigned Last)
virtual void emitARMWinCFIEpilogStart(unsigned Condition)
virtual void emitPad(int64_t Offset)
virtual void emitAttribute(unsigned Attribute, unsigned Value)
virtual void emitARMWinCFINop(bool Wide)
virtual void emitSetFP(unsigned FpReg, unsigned SpReg, int64_t Offset=0)
virtual void emitArch(ARM::ArchKind Arch)
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition: MCAsmInfo.h:56
bool isLittleEndian() const
True if the target is little endian.
Definition: MCAsmInfo.h:555
void setIsThumbFunc(const MCSymbol *Func)
Flag a function symbol as the target of a .thumb_func directive.
Definition: MCAssembler.h:278
Context object for machine code objects.
Definition: MCContext.h:76
const MCAsmInfo * getAsmInfo() const
Definition: MCContext.h:446
void reportError(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:1064
Fragment for data and encoded instructions.
Definition: MCFragment.h:242
void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc=SMLoc()) override
Emit the expression Value into the output as a native integer of the given Size bytes.
void emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc, MCFragment *F, uint64_t Offset) override
void emitAssemblerFlag(MCAssemblerFlag Flag) override
Note in the output the specified Flag.
void emitThumbFunc(MCSymbol *Func) override
Note in the output that the specified Func is a Thumb mode function (ARM target only).
void reset() override
state management
Definition: MCELFStreamer.h:40
void changeSection(MCSection *Section, const MCExpr *Subsection) override
Update streamer for a new active section.
void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc()) override
Emit a label for Symbol into the current section.
bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override
Add the given Attribute to Symbol.
void finishImpl() override
Streamer specific finalization.
SmallVectorImpl< char > & getContents()
Definition: MCFragment.h:197
SmallVectorImpl< MCFixup > & getFixups()
Definition: MCFragment.h:223
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
static MCFixupKind getKindForSize(unsigned Size, bool IsPCRel)
Return the generic fixup kind for a value with the given size.
Definition: MCFixup.h:109
static MCFixup create(uint32_t Offset, const MCExpr *Value, MCFixupKind Kind, SMLoc Loc=SMLoc())
Definition: MCFixup.h:87
This is an instance of a target assembly language printer that converts an MCInst to valid target ass...
Definition: MCInstPrinter.h:45
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
void emitFill(const MCExpr &NumBytes, uint64_t FillValue, SMLoc Loc=SMLoc()) override
Emit Size bytes worth of the value specified by FillValue.
MCDataFragment * getOrCreateDataFragment(const MCSubtargetInfo *STI=nullptr)
Get a data fragment to write into, creating a new one if the current fragment is not a data fragment.
MCAssembler & getAssembler()
void emitBytes(StringRef Data) override
Emit the bytes in Data into the output.
void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override
Emit the given Instruction into the current section.
MCFragment * getCurrentFragment() const
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
This represents a section on linux, lots of unix variants and some bare metal systems.
Definition: MCSectionELF.h:26
unsigned getUniqueID() const
Definition: MCSectionELF.h:87
const MCSymbolELF * getGroup() const
Definition: MCSectionELF.h:76
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:39
StringRef getName() const
Definition: MCSection.h:124
MCSymbol * getBeginSymbol()
Definition: MCSection.h:129
Streaming machine code generation interface.
Definition: MCStreamer.h:212
MCContext & getContext() const
Definition: MCStreamer.h:297
MCSectionSubPair getCurrentSection() const
Return the current section that the streamer is emitting code to.
Definition: MCStreamer.h:388
Generic base class for all target subtargets.
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:192
const MCSymbol & getSymbol() const
Definition: MCExpr.h:410
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:397
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:205
MCSection & getSection() const
Get the section associated with a defined, non-absolute symbol.
Definition: MCSymbol.h:269
Target specific streamer interface.
Definition: MCStreamer.h:93
MCStreamer & getStreamer()
Definition: MCStreamer.h:101
virtual void emitLabel(MCSymbol *Symbol)
Definition: MCStreamer.cpp:53
Represents a location in source code.
Definition: SMLoc.h:23
SectionKind - This is a simple POD value that classifies the properties of a section.
Definition: SectionKind.h:22
static SectionKind getData()
Definition: SectionKind.h:213
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
size_t size() const
Definition: SmallVector.h:91
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
static Twine utohexstr(const uint64_t &Val)
Definition: Twine.h:416
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
LLVM Value Representation.
Definition: Value.h:74
void print(raw_ostream &O, bool IsForDebug=false) const
Implement operator<< on Value.
Definition: AsmWriter.cpp:4976
formatted_raw_ostream - A raw_ostream that wraps another one and keeps track of line and column posit...
raw_ostream & write_escaped(StringRef Str, bool UseHexEscapes=false)
Output Str, turning '\', '\t', ' ', '"', and anything that doesn't satisfy llvm::isPrint into an esca...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
const TagNameMap & getARMAttributeTags()
@ EXIDX_CANTUNWIND
Special entry for the function never unwind.
Definition: ARMEHABI.h:35
StringRef getArchExtName(uint64_t ArchExtKind)
StringRef getCPUAttr(ArchKind AK)
StringRef getArchName(ArchKind AK)
unsigned getArchAttr(ArchKind AK)
StringRef getFPUName(FPUKind FPUKind)
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:121
StringRef attrTypeAsString(unsigned attr, TagNameMap tagNameMap, bool hasTagPrefix=true)
@ SHF_ALLOC
Definition: ELF.h:1157
@ SHF_LINK_ORDER
Definition: ELF.h:1172
@ SHF_GROUP
Definition: ELF.h:1179
@ EF_ARM_EABI_VER5
Definition: ELF.h:447
@ SHT_PROGBITS
Definition: ELF.h:1063
@ SHT_ARM_ATTRIBUTES
Definition: ELF.h:1119
@ SHT_ARM_EXIDX
Definition: ELF.h:1115
@ STB_LOCAL
Definition: ELF.h:1310
@ STT_FUNC
Definition: ELF.h:1324
@ STT_NOTYPE
Definition: ELF.h:1322
@ STT_GNU_IFUNC
Definition: ELF.h:1329
Reg
All possible values of the reg field in the ModR/M byte.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
MCTargetStreamer * createARMObjectTargetELFStreamer(MCStreamer &S)
MCELFStreamer * createARMELFStreamer(MCContext &Context, std::unique_ptr< MCAsmBackend > TAB, std::unique_ptr< MCObjectWriter > OW, std::unique_ptr< MCCodeEmitter > Emitter, bool RelaxAll, bool IsThumb, bool IsAndroid)
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1656
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:156
MCFixupKind
Extensible enumeration to represent the type of a fixup.
Definition: MCFixup.h:21
@ FK_Data_4
A four-byte fixup.
Definition: MCFixup.h:25
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
MCAssemblerFlag
Definition: MCDirectives.h:53
@ MCAF_SyntaxUnified
.syntax (ARM/ELF)
Definition: MCDirectives.h:54
@ MCAF_Code64
.code64 (X86)
Definition: MCDirectives.h:58
@ MCAF_Code16
.code16 (X86) / .code 16 (ARM)
Definition: MCDirectives.h:56
@ MCAF_Code32
.code32 (X86) / .code 32 (ARM)
Definition: MCDirectives.h:57
@ MCAF_SubsectionsViaSymbols
.subsections_via_symbols (MachO)
Definition: MCDirectives.h:55
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1858
static const char * ARMCondCodeToString(ARMCC::CondCodes CC)
Definition: ARMBaseInfo.h:146
MCTargetStreamer * createARMTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint, bool isVerboseAsm)
MCTargetStreamer * createARMNullTargetStreamer(MCStreamer &S)
MCSymbolAttr
Definition: MCDirectives.h:18
@ MCSA_ELF_TypeFunction
.type _foo, STT_FUNC # aka @function
Definition: MCDirectives.h:23
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
ELF object attributes section emission support.
Definition: MCELFStreamer.h:91