62 "Invalid personality index");
81 void emitSetFP(
unsigned FpReg,
unsigned SpReg, int64_t
Offset = 0)
override;
85 bool isVector)
override;
120ARMTargetAsmStreamer::ARMTargetAsmStreamer(
MCStreamer &S,
125 IsVerboseAsm(VerboseAsm) {}
127void ARMTargetAsmStreamer::emitFnStart() {
OS <<
"\t.fnstart\n"; }
128void ARMTargetAsmStreamer::emitFnEnd() {
OS <<
"\t.fnend\n"; }
129void ARMTargetAsmStreamer::emitCantUnwind() {
OS <<
"\t.cantunwind\n"; }
131void ARMTargetAsmStreamer::emitPersonality(
const MCSymbol *Personality) {
132 OS <<
"\t.personality " << Personality->
getName() <<
'\n';
135void ARMTargetAsmStreamer::emitPersonalityIndex(
unsigned Index) {
136 OS <<
"\t.personalityindex " <<
Index <<
'\n';
139void ARMTargetAsmStreamer::emitHandlerData() {
OS <<
"\t.handlerdata\n"; }
141void ARMTargetAsmStreamer::emitSetFP(
unsigned FpReg,
unsigned SpReg,
144 InstPrinter.printRegName(
OS, FpReg);
146 InstPrinter.printRegName(
OS, SpReg);
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");
157 InstPrinter.printRegName(
OS, Reg);
163void ARMTargetAsmStreamer::emitPad(int64_t
Offset) {
164 OS <<
"\t.pad\t#" <<
Offset <<
'\n';
169 assert(RegList.
size() &&
"RegList should not be empty");
175 InstPrinter.printRegName(
OS, RegList[0]);
177 for (
unsigned i = 1, e = RegList.
size(); i != e; ++i) {
179 InstPrinter.printRegName(
OS, RegList[i]);
185void ARMTargetAsmStreamer::switchVendor(
StringRef Vendor) {}
187void ARMTargetAsmStreamer::emitAttribute(
unsigned Attribute,
unsigned Value) {
198void ARMTargetAsmStreamer::emitTextAttribute(
unsigned Attribute,
205 OS <<
"\t.eabi_attribute\t" <<
Attribute <<
", \"";
222void ARMTargetAsmStreamer::emitIntTextAttribute(
unsigned Attribute,
228 OS <<
"\t.eabi_attribute\t" <<
Attribute <<
", " << IntValue;
229 if (!StringValue.
empty())
230 OS <<
", \"" << StringValue <<
"\"";
244void ARMTargetAsmStreamer::emitArchExtension(
uint64_t ArchExt) {
248void ARMTargetAsmStreamer::emitObjectArch(
ARM::ArchKind Arch) {
256void ARMTargetAsmStreamer::finishAttributeSection() {}
258void ARMTargetAsmStreamer::annotateTLSDescriptorSequence(
264 const MCAsmInfo *MAI = Streamer.getContext().getAsmInfo();
266 OS <<
"\t.thumb_set\t";
273void ARMTargetAsmStreamer::emitInst(
uint32_t Inst,
char Suffix) {
280void ARMTargetAsmStreamer::emitUnwindRaw(int64_t
Offset,
283 for (uint8_t
Opcode : Opcodes)
288void ARMTargetAsmStreamer::emitARMWinCFIAllocStack(
unsigned Size,
bool Wide) {
290 OS <<
"\t.seh_stackalloc_w\t" <<
Size <<
"\n";
292 OS <<
"\t.seh_stackalloc\t" <<
Size <<
"\n";
303void ARMTargetAsmStreamer::emitARMWinCFISaveRegMask(
unsigned Mask,
bool Wide) {
305 OS <<
"\t.seh_save_regs_w\t";
307 OS <<
"\t.seh_save_regs\t";
311 for (
int I = 0;
I <= 12;
I++) {
312 if (Mask & (1 <<
I)) {
324 if (Mask & (1 << 14))
329void ARMTargetAsmStreamer::emitARMWinCFISaveSP(
unsigned Reg) {
330 OS <<
"\t.seh_save_sp\tr" <<
Reg <<
"\n";
333void ARMTargetAsmStreamer::emitARMWinCFISaveFRegs(
unsigned First,
336 OS <<
"\t.seh_save_fregs\t{d" <<
First <<
"-d" <<
Last <<
"}\n";
338 OS <<
"\t.seh_save_fregs\t{d" <<
First <<
"}\n";
341void ARMTargetAsmStreamer::emitARMWinCFISaveLR(
unsigned Offset) {
342 OS <<
"\t.seh_save_lr\t" <<
Offset <<
"\n";
345void ARMTargetAsmStreamer::emitARMWinCFIPrologEnd(
bool Fragment) {
347 OS <<
"\t.seh_endprologue_fragment\n";
349 OS <<
"\t.seh_endprologue\n";
352void ARMTargetAsmStreamer::emitARMWinCFINop(
bool Wide) {
354 OS <<
"\t.seh_nop_w\n";
356 OS <<
"\t.seh_nop\n";
359void ARMTargetAsmStreamer::emitARMWinCFIEpilogStart(
unsigned Condition) {
361 OS <<
"\t.seh_startepilogue\n";
363 OS <<
"\t.seh_startepilogue_cond\t"
367void ARMTargetAsmStreamer::emitARMWinCFIEpilogEnd() {
368 OS <<
"\t.seh_endepilogue\n";
371void ARMTargetAsmStreamer::emitARMWinCFICustom(
unsigned Opcode) {
373 for (
I = 3;
I > 0;
I--)
374 if (
Opcode & (0xffu << (8 *
I)))
377 OS <<
"\t.seh_custom\t";
379 OS << LS << ((
Opcode >> (8 *
I)) & 0xff);
392 void emitArchDefaultAttributes();
393 void emitFPUDefaultAttributes();
403 void emitSetFP(
unsigned FpReg,
unsigned SpReg, int64_t
Offset = 0)
override;
407 bool isVector)
override;
427 void reset()
override;
448 friend class ARMTargetELFStreamer;
450 ARMELFStreamer(
MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
451 std::unique_ptr<MCObjectWriter> OW,
452 std::unique_ptr<MCCodeEmitter>
Emitter,
bool IsThumb,
456 IsThumb(IsThumb), IsAndroid(IsAndroid) {
460 ~ARMELFStreamer()
override =
default;
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);
477 SMLoc Loc)
override {
478 emitDataMappingSymbol();
485 auto LastMappingSymbol = LastMappingSymbols.find(Section);
486 if (LastMappingSymbol != LastMappingSymbols.end()) {
487 LastEMSInfo = std::move(LastMappingSymbol->second);
490 LastEMSInfo.reset(
new ElfMappingSymbolInfo(
SMLoc(),
nullptr, 0));
499 EmitThumbMappingSymbol();
501 EmitARMMappingSymbol();
506 void emitInst(
uint32_t Inst,
char Suffix) {
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);
525 Size = (Suffix ==
'n' ? 2 : 4);
528 EmitThumbMappingSymbol();
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);
550 emitDataMappingSymbol();
554 void FlushPendingMappingSymbol() {
555 if (!LastEMSInfo->hasInfo())
557 ElfMappingSymbolInfo *EMS = LastEMSInfo.get();
558 EmitMappingSymbol(
"$d", EMS->Loc, EMS->F, EMS->Offset);
574 emitDataMappingSymbol();
611 unsigned Type = cast<MCSymbolELF>(Symbol)->getType();
620 enum ElfMappingSymbol {
627 struct ElfMappingSymbolInfo {
629 : Loc(Loc),
F(
F),
Offset(
O), State(EMS_None) {}
634 bool hasInfo() {
return F !=
nullptr; }
638 ElfMappingSymbol State;
641 void emitDataMappingSymbol() {
642 if (LastEMSInfo->State == EMS_Data)
644 else if (LastEMSInfo->State == EMS_None) {
647 ElfMappingSymbolInfo *EMS = LastEMSInfo.get();
653 EMS->Offset =
DF->getContents().size();
654 LastEMSInfo->State = EMS_Data;
657 EmitMappingSymbol(
"$d");
658 LastEMSInfo->State = EMS_Data;
661 void EmitThumbMappingSymbol() {
662 if (LastEMSInfo->State == EMS_Thumb)
664 FlushPendingMappingSymbol();
665 EmitMappingSymbol(
"$t");
666 LastEMSInfo->State = EMS_Thumb;
669 void EmitARMMappingSymbol() {
670 if (LastEMSInfo->State == EMS_ARM)
672 FlushPendingMappingSymbol();
673 EmitMappingSymbol(
"$a");
674 LastEMSInfo->State = EMS_ARM;
679 Name +
"." +
Twine(MappingSymbolCounter++)));
689 Name +
"." +
Twine(MappingSymbolCounter++)));
704 void reset()
override;
707 void FlushPendingOffset();
708 void FlushUnwindOpcodes(
bool NoHandlerData);
710 void SwitchToEHSection(
StringRef Prefix,
unsigned Type,
unsigned Flags,
712 void SwitchToExTabSection(
const MCSymbol &FnStart);
713 void SwitchToExIdxSection(
const MCSymbol &FnStart);
719 int64_t MappingSymbolCounter = 0;
724 std::unique_ptr<ElfMappingSymbolInfo> LastEMSInfo;
730 unsigned PersonalityIndex;
734 int64_t PendingOffset;
743ARMELFStreamer &ARMTargetELFStreamer::getStreamer() {
744 return static_cast<ARMELFStreamer &
>(Streamer);
747void ARMTargetELFStreamer::emitFnStart() { getStreamer().emitFnStart(); }
748void ARMTargetELFStreamer::emitFnEnd() { getStreamer().emitFnEnd(); }
749void ARMTargetELFStreamer::emitCantUnwind() { getStreamer().emitCantUnwind(); }
751void ARMTargetELFStreamer::emitPersonality(
const MCSymbol *Personality) {
752 getStreamer().emitPersonality(Personality);
755void ARMTargetELFStreamer::emitPersonalityIndex(
unsigned Index) {
756 getStreamer().emitPersonalityIndex(
Index);
759void ARMTargetELFStreamer::emitHandlerData() {
760 getStreamer().emitHandlerData();
763void ARMTargetELFStreamer::emitSetFP(
unsigned FpReg,
unsigned SpReg,
765 getStreamer().emitSetFP(FpReg, SpReg,
Offset);
768void ARMTargetELFStreamer::emitMovSP(
unsigned Reg, int64_t
Offset) {
769 getStreamer().emitMovSP(Reg,
Offset);
772void ARMTargetELFStreamer::emitPad(int64_t
Offset) {
773 getStreamer().emitPad(
Offset);
778 getStreamer().emitRegSave(RegList, isVector);
781void ARMTargetELFStreamer::emitUnwindRaw(int64_t
Offset,
783 getStreamer().emitUnwindRaw(
Offset, Opcodes);
786void ARMTargetELFStreamer::switchVendor(
StringRef Vendor) {
787 assert(!Vendor.
empty() &&
"Vendor cannot be empty.");
789 if (CurrentVendor == Vendor)
792 if (!CurrentVendor.empty())
793 finishAttributeSection();
795 assert(getStreamer().Contents.empty() &&
796 ".ARM.attributes should be flushed before changing vendor");
797 CurrentVendor = Vendor;
801void ARMTargetELFStreamer::emitAttribute(
unsigned Attribute,
unsigned Value) {
806void ARMTargetELFStreamer::emitTextAttribute(
unsigned Attribute,
812void ARMTargetELFStreamer::emitIntTextAttribute(
unsigned Attribute,
815 getStreamer().setAttributeItems(
Attribute, IntValue, StringValue,
827void ARMTargetELFStreamer::emitArchDefaultAttributes() {
828 using namespace ARMBuildAttrs;
829 ARMELFStreamer &S = getStreamer();
833 if (EmittedArch == ARM::ArchKind::INVALID)
839 case ARM::ArchKind::ARMV4:
840 S.setAttributeItem(ARM_ISA_use, Allowed,
false);
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);
852 case ARM::ArchKind::ARMV6T2:
853 S.setAttributeItem(ARM_ISA_use, Allowed,
false);
854 S.setAttributeItem(THUMB_ISA_use, AllowThumb32,
false);
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);
864 case ARM::ArchKind::ARMV6M:
865 S.setAttributeItem(THUMB_ISA_use, Allowed,
false);
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);
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);
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);
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 S.setAttributeItem(CPU_arch_profile, ApplicationProfile,
false);
902 S.setAttributeItem(ARM_ISA_use, Allowed,
false);
903 S.setAttributeItem(THUMB_ISA_use, AllowThumb32,
false);
904 S.setAttributeItem(MPextension_use, Allowed,
false);
905 S.setAttributeItem(Virtualization_use, AllowTZVirtualization,
false);
908 case ARM::ArchKind::ARMV8MBaseline:
909 case ARM::ArchKind::ARMV8MMainline:
910 S.setAttributeItem(THUMB_ISA_use, AllowThumbDerived,
false);
911 S.setAttributeItem(CPU_arch_profile, MicroControllerProfile,
false);
914 case ARM::ArchKind::IWMMXT:
915 S.setAttributeItem(ARM_ISA_use, Allowed,
false);
916 S.setAttributeItem(THUMB_ISA_use, Allowed,
false);
917 S.setAttributeItem(WMMX_arch, AllowWMMXv1,
false);
920 case ARM::ArchKind::IWMMXT2:
921 S.setAttributeItem(ARM_ISA_use, Allowed,
false);
922 S.setAttributeItem(THUMB_ISA_use, Allowed,
false);
923 S.setAttributeItem(WMMX_arch, AllowWMMXv2,
false);
934void ARMTargetELFStreamer::emitFPUDefaultAttributes() {
935 ARMELFStreamer &S = getStreamer();
949 case ARM::FK_VFPV3_FP16:
956 case ARM::FK_VFPV3_D16:
961 case ARM::FK_VFPV3_D16_FP16:
968 case ARM::FK_VFPV3XD:
972 case ARM::FK_VFPV3XD_FP16:
986 case ARM::FK_FPV4_SP_D16:
987 case ARM::FK_VFPV4_D16:
992 case ARM::FK_FP_ARMV8:
999 case ARM::FK_FPV5_SP_D16:
1000 case ARM::FK_FPV5_D16:
1013 case ARM::FK_NEON_FP16:
1023 case ARM::FK_NEON_VFPV4:
1031 case ARM::FK_NEON_FP_ARMV8:
1032 case ARM::FK_CRYPTO_NEON_FP_ARMV8:
1039 case ARM::FK_SOFTVFP:
1049void ARMTargetELFStreamer::finishAttributeSection() {
1050 ARMELFStreamer &S = getStreamer();
1052 if (FPU != ARM::FK_INVALID)
1053 emitFPUDefaultAttributes();
1055 if (Arch != ARM::ArchKind::INVALID)
1056 emitArchDefaultAttributes();
1058 if (S.Contents.empty())
1079 S.emitAttributesSection(CurrentVendor,
".ARM.attributes",
1082 FPU = ARM::FK_INVALID;
1085void ARMTargetELFStreamer::emitLabel(
MCSymbol *Symbol) {
1086 ARMELFStreamer &Streamer = getStreamer();
1087 if (!Streamer.IsThumb)
1090 Streamer.getAssembler().registerSymbol(*Symbol);
1091 unsigned Type = cast<MCSymbolELF>(Symbol)->getType();
1093 Streamer.emitThumbFunc(Symbol);
1096void ARMTargetELFStreamer::annotateTLSDescriptorSequence(
1104 if (!
Sym.isDefined()) {
1105 getStreamer().emitAssignment(Symbol,
Value);
1110 getStreamer().emitThumbFunc(Symbol);
1111 getStreamer().emitAssignment(Symbol,
Value);
1114void ARMTargetELFStreamer::emitInst(
uint32_t Inst,
char Suffix) {
1115 getStreamer().emitInst(Inst, Suffix);
1118void ARMTargetELFStreamer::reset() { AttributeSection =
nullptr; }
1120void ARMELFStreamer::finishImpl() {
1128void ARMELFStreamer::reset() {
1132 MappingSymbolCounter = 0;
1134 LastMappingSymbols.clear();
1135 LastEMSInfo.reset();
1142inline void ARMELFStreamer::SwitchToEHSection(
StringRef Prefix,
1153 if (FnSecName !=
".text") {
1154 EHSecName += FnSecName;
1162 EHSecName,
Type, Flags, 0, Group,
true,
1166 assert(EHSection &&
"Failed to get the required EH section");
1169 switchSection(EHSection);
1170 emitValueToAlignment(
Align(4), 0, 1, 0);
1173inline void ARMELFStreamer::SwitchToExTabSection(
const MCSymbol &FnStart) {
1178inline void ARMELFStreamer::SwitchToExIdxSection(
const MCSymbol &FnStart) {
1190void ARMELFStreamer::EHReset() {
1193 Personality =
nullptr;
1203 UnwindOpAsm.Reset();
1206void ARMELFStreamer::emitFnStart() {
1207 assert(FnStart ==
nullptr);
1208 FnStart = getContext().createTempSymbol();
1212void ARMELFStreamer::emitFnEnd() {
1213 assert(FnStart &&
".fnstart must precedes .fnend");
1216 if (!ExTab && !CantUnwind)
1217 FlushUnwindOpcodes(
true);
1220 SwitchToExIdxSection(*FnStart);
1235 emitValue(FnStartRef, 4);
1245 emitValue(ExTabEntryRef, 4);
1251 "Compact model must use __aeabi_unwind_cpp_pr0 as personality");
1253 "Unwind opcode size for __aeabi_unwind_cpp_pr0 must be equal to 4");
1258 emitIntValue(Intval, Opcodes.
size());
1268void ARMELFStreamer::emitCantUnwind() { CantUnwind =
true; }
1272 const MCSymbol *PersonalitySym = getContext().getOrCreateSymbol(
Name);
1277 visitUsedExpr(*PersonalityRef);
1284void ARMELFStreamer::FlushPendingOffset() {
1285 if (PendingOffset != 0) {
1286 UnwindOpAsm.EmitSPOffset(-PendingOffset);
1291void ARMELFStreamer::FlushUnwindOpcodes(
bool NoHandlerData) {
1295 int64_t LastRegSaveSPOffset = SPOffset - PendingOffset;
1296 UnwindOpAsm.EmitSPOffset(LastRegSaveSPOffset - FPOffset);
1297 UnwindOpAsm.EmitSetSP(
MRI->getEncodingValue(FPReg));
1299 FlushPendingOffset();
1303 UnwindOpAsm.Finalize(PersonalityIndex, Opcodes);
1312 SwitchToExTabSection(*FnStart);
1316 ExTab = getContext().createTempSymbol();
1326 emitValue(PersonalityRef, 4);
1331 "Unwind opcode size for __aeabi_cpp_unwind_pr0 must be multiple of 4");
1332 for (
unsigned I = 0;
I != Opcodes.
size();
I += 4) {
1334 Opcodes[
I + 1] << 8 |
1335 Opcodes[
I + 2] << 16 |
1336 Opcodes[
I + 3] << 24;
1347 if (NoHandlerData && !Personality)
1351void ARMELFStreamer::emitHandlerData() { FlushUnwindOpcodes(
false); }
1353void ARMELFStreamer::emitPersonality(
const MCSymbol *Per) {
1355 UnwindOpAsm.setPersonality(Per);
1358void ARMELFStreamer::emitPersonalityIndex(
unsigned Index) {
1360 PersonalityIndex =
Index;
1363void ARMELFStreamer::emitSetFP(
unsigned NewFPReg,
unsigned NewSPReg,
1365 assert((NewSPReg == ARM::SP || NewSPReg == FPReg) &&
1366 "the operand of .setfp directive should be either $sp or $fp");
1371 if (NewSPReg == ARM::SP)
1372 FPOffset = SPOffset +
Offset;
1377void ARMELFStreamer::emitMovSP(
unsigned Reg, int64_t
Offset) {
1378 assert((Reg != ARM::SP && Reg != ARM::PC) &&
1379 "the operand of .movsp cannot be either sp or pc");
1380 assert(FPReg == ARM::SP &&
"current FP must be SP");
1382 FlushPendingOffset();
1385 FPOffset = SPOffset +
Offset;
1388 UnwindOpAsm.EmitSetSP(
MRI->getEncodingValue(FPReg));
1391void ARMELFStreamer::emitPad(int64_t
Offset) {
1400static std::pair<unsigned, unsigned>
1407 unsigned Reg = RegList[
Idx - 1];
1408 if (Reg == ARM::RA_AUTH_CODE)
1410 Reg =
MRI.getEncodingValue(Reg);
1411 assert(Reg < (IsVector ? 32U : 16U) &&
"Register out of range");
1412 unsigned Bit = (1u << Reg);
1413 if ((Mask & Bit) == 0) {
1421 return {
Idx, Count};
1427 unsigned Idx, Count;
1444 SPOffset -= Count * (IsVector ? 8 : 4);
1447 FlushPendingOffset();
1449 UnwindOpAsm.EmitVFPRegSave(Mask);
1451 UnwindOpAsm.EmitRegSave(Mask);
1452 }
else if (
Idx > 0 && RegList[
Idx - 1] == ARM::RA_AUTH_CODE) {
1455 FlushPendingOffset();
1456 UnwindOpAsm.EmitRegSave(0);
1461void ARMELFStreamer::emitUnwindRaw(int64_t
Offset,
1463 FlushPendingOffset();
1464 SPOffset = SPOffset -
Offset;
1465 UnwindOpAsm.EmitRaw(Opcodes);
1473 bool isVerboseAsm) {
1474 return new ARMTargetAsmStreamer(S,
OS, *InstPrint, isVerboseAsm);
1482 return new ARMTargetELFStreamer(S);
1486 std::unique_ptr<MCAsmBackend> TAB,
1487 std::unique_ptr<MCObjectWriter> OW,
1488 std::unique_ptr<MCCodeEmitter>
Emitter,
1489 bool RelaxAll,
bool IsThumb,
1492 new ARMELFStreamer(
Context, std::move(TAB), std::move(OW),
1493 std::move(
Emitter), IsThumb, IsAndroid);
1500 S->getAssembler().setRelaxAll(
true);
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.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallString class.
This file defines the SmallVector class.
static constexpr uint32_t Opcode
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 emitFnStart()
virtual void emitPersonality(const MCSymbol *Personality)
virtual void emitObjectArch(ARM::ArchKind Arch)
virtual void emitHandlerData()
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 emitCantUnwind()
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...
bool isLittleEndian() const
True if the target is little endian.
void setIsThumbFunc(const MCSymbol *Func)
Flag a function symbol as the target of a .thumb_func directive.
Context object for machine code objects.
const MCAsmInfo * getAsmInfo() const
void reportError(SMLoc L, const Twine &Msg)
Fragment for data and encoded instructions.
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
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()
SmallVectorImpl< MCFixup > & getFixups()
Base class for the full range of assembler expressions which are needed for parsing.
static MCFixupKind getKindForSize(unsigned Size, bool IsPCRel)
Return the generic fixup kind for a value with the given size.
static MCFixup create(uint32_t Offset, const MCExpr *Value, MCFixupKind Kind, SMLoc Loc=SMLoc())
This is an instance of a target assembly language printer that converts an MCInst to valid target ass...
Instances of this class represent a single low-level machine instruction.
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.
unsigned getUniqueID() const
const MCSymbolELF * getGroup() const
Instances of this class represent a uniqued identifier for a section in the current translation unit.
StringRef getName() const
MCSymbol * getBeginSymbol()
Streaming machine code generation interface.
MCContext & getContext() const
MCSectionSubPair getCurrentSection() const
Return the current section that the streamer is emitting code to.
Generic base class for all target subtargets.
Represent a reference to a symbol from inside an expression.
const MCSymbol & getSymbol() const
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
StringRef getName() const
getName - Get the symbol name.
MCSection & getSection() const
Get the section associated with a defined, non-absolute symbol.
Target specific streamer interface.
MCStreamer & getStreamer()
virtual void emitLabel(MCSymbol *Symbol)
Represents a location in source code.
SectionKind - This is a simple POD value that classifies the properties of a section.
static SectionKind getData()
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
constexpr bool empty() const
empty - Check if the string is empty.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
static Twine utohexstr(const uint64_t &Val)
The instances of the Type class are immutable: once they are created, they are never changed.
LLVM Value Representation.
void print(raw_ostream &O, bool IsForDebug=false) const
Implement operator<< on Value.
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.
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.
StringRef attrTypeAsString(unsigned attr, TagNameMap tagNameMap, bool hasTagPrefix=true)
Reg
All possible values of the reg field in the ModR/M byte.
This is an optimization pass for GlobalISel generic memory operations.
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)
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
MCFixupKind
Extensible enumeration to represent the type of a fixup.
@ FK_Data_4
A four-byte fixup.
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
@ MCAF_SyntaxUnified
.syntax (ARM/ELF)
@ MCAF_Code64
.code64 (X86)
@ MCAF_Code16
.code16 (X86) / .code 16 (ARM)
@ MCAF_Code32
.code32 (X86) / .code 32 (ARM)
@ MCAF_SubsectionsViaSymbols
.subsections_via_symbols (MachO)
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
static const char * ARMCondCodeToString(ARMCC::CondCodes CC)
MCTargetStreamer * createARMTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint, bool isVerboseAsm)
MCTargetStreamer * createARMNullTargetStreamer(MCStreamer &S)
@ MCSA_ELF_TypeFunction
.type _foo, STT_FUNC # aka @function
Implement std::hash so that hash_code can be used in STL containers.
This struct is a compact representation of a valid (non-zero power of two) alignment.
ELF object attributes section emission support.