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;
450 friend class ARMTargetELFStreamer;
452 ARMELFStreamer(
MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
453 std::unique_ptr<MCObjectWriter> OW,
454 std::unique_ptr<MCCodeEmitter>
Emitter,
bool IsThumb,
458 IsThumb(IsThumb), IsAndroid(IsAndroid) {
462 ~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);
499 EmitThumbMappingSymbol();
501 EmitARMMappingSymbol();
506 void emitInst(
uint32_t Inst,
char Suffix) {
516 EmitARMMappingSymbol();
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();
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->F, EMS->Offset);
574 emitDataMappingSymbol();
611 unsigned Type = cast<MCSymbolELF>(Symbol)->getType();
620 enum ElfMappingSymbol {
627 struct ElfMappingSymbolInfo {
632 bool hasInfo() {
return F !=
nullptr; }
635 ElfMappingSymbol State = EMS_None;
638 void emitDataMappingSymbol() {
639 if (LastEMSInfo->State == EMS_Data)
641 else if (LastEMSInfo->State == EMS_None) {
644 ElfMappingSymbolInfo *EMS = LastEMSInfo.get();
649 EMS->Offset =
DF->getContents().size();
650 LastEMSInfo->State = EMS_Data;
653 EmitMappingSymbol(
"$d");
654 LastEMSInfo->State = EMS_Data;
657 void EmitThumbMappingSymbol() {
658 if (LastEMSInfo->State == EMS_Thumb)
660 FlushPendingMappingSymbol();
661 EmitMappingSymbol(
"$t");
662 LastEMSInfo->State = EMS_Thumb;
665 void EmitARMMappingSymbol() {
666 if (LastEMSInfo->State == EMS_ARM)
668 FlushPendingMappingSymbol();
669 EmitMappingSymbol(
"$a");
670 LastEMSInfo->State = EMS_ARM;
675 Name +
"." +
Twine(MappingSymbolCounter++)));
684 Name +
"." +
Twine(MappingSymbolCounter++)));
699 void reset()
override;
702 void FlushPendingOffset();
703 void FlushUnwindOpcodes(
bool NoHandlerData);
705 void SwitchToEHSection(
StringRef Prefix,
unsigned Type,
unsigned Flags,
707 void SwitchToExTabSection(
const MCSymbol &FnStart);
708 void SwitchToExIdxSection(
const MCSymbol &FnStart);
714 int64_t MappingSymbolCounter = 0;
719 std::unique_ptr<ElfMappingSymbolInfo> LastEMSInfo;
725 unsigned PersonalityIndex;
729 int64_t PendingOffset;
738ARMELFStreamer &ARMTargetELFStreamer::getStreamer() {
739 return static_cast<ARMELFStreamer &
>(Streamer);
742void ARMTargetELFStreamer::emitFnStart() { getStreamer().emitFnStart(); }
743void ARMTargetELFStreamer::emitFnEnd() { getStreamer().emitFnEnd(); }
744void ARMTargetELFStreamer::emitCantUnwind() { getStreamer().emitCantUnwind(); }
746void ARMTargetELFStreamer::emitPersonality(
const MCSymbol *Personality) {
747 getStreamer().emitPersonality(Personality);
750void ARMTargetELFStreamer::emitPersonalityIndex(
unsigned Index) {
751 getStreamer().emitPersonalityIndex(
Index);
754void ARMTargetELFStreamer::emitHandlerData() {
755 getStreamer().emitHandlerData();
758void ARMTargetELFStreamer::emitSetFP(
unsigned FpReg,
unsigned SpReg,
760 getStreamer().emitSetFP(FpReg, SpReg,
Offset);
763void ARMTargetELFStreamer::emitMovSP(
unsigned Reg, int64_t
Offset) {
764 getStreamer().emitMovSP(Reg,
Offset);
767void ARMTargetELFStreamer::emitPad(int64_t
Offset) {
768 getStreamer().emitPad(
Offset);
773 getStreamer().emitRegSave(RegList, isVector);
776void ARMTargetELFStreamer::emitUnwindRaw(int64_t
Offset,
778 getStreamer().emitUnwindRaw(
Offset, Opcodes);
781void ARMTargetELFStreamer::switchVendor(
StringRef Vendor) {
782 assert(!Vendor.
empty() &&
"Vendor cannot be empty.");
784 if (CurrentVendor == Vendor)
787 if (!CurrentVendor.empty())
788 finishAttributeSection();
790 assert(getStreamer().Contents.empty() &&
791 ".ARM.attributes should be flushed before changing vendor");
792 CurrentVendor = Vendor;
796void ARMTargetELFStreamer::emitAttribute(
unsigned Attribute,
unsigned Value) {
801void ARMTargetELFStreamer::emitTextAttribute(
unsigned Attribute,
807void ARMTargetELFStreamer::emitIntTextAttribute(
unsigned Attribute,
810 getStreamer().setAttributeItems(
Attribute, IntValue, StringValue,
822void ARMTargetELFStreamer::emitArchDefaultAttributes() {
823 using namespace ARMBuildAttrs;
824 ARMELFStreamer &S = getStreamer();
828 if (EmittedArch == ARM::ArchKind::INVALID)
834 case ARM::ArchKind::ARMV4:
835 S.setAttributeItem(ARM_ISA_use, Allowed,
false);
838 case ARM::ArchKind::ARMV4T:
839 case ARM::ArchKind::ARMV5T:
840 case ARM::ArchKind::XSCALE:
841 case ARM::ArchKind::ARMV5TE:
842 case ARM::ArchKind::ARMV6:
843 S.setAttributeItem(ARM_ISA_use, Allowed,
false);
844 S.setAttributeItem(THUMB_ISA_use, Allowed,
false);
847 case ARM::ArchKind::ARMV6T2:
848 S.setAttributeItem(ARM_ISA_use, Allowed,
false);
849 S.setAttributeItem(THUMB_ISA_use, AllowThumb32,
false);
852 case ARM::ArchKind::ARMV6K:
853 case ARM::ArchKind::ARMV6KZ:
854 S.setAttributeItem(ARM_ISA_use, Allowed,
false);
855 S.setAttributeItem(THUMB_ISA_use, Allowed,
false);
856 S.setAttributeItem(Virtualization_use, AllowTZ,
false);
859 case ARM::ArchKind::ARMV6M:
860 S.setAttributeItem(THUMB_ISA_use, Allowed,
false);
863 case ARM::ArchKind::ARMV7A:
864 S.setAttributeItem(CPU_arch_profile, ApplicationProfile,
false);
865 S.setAttributeItem(ARM_ISA_use, Allowed,
false);
866 S.setAttributeItem(THUMB_ISA_use, AllowThumb32,
false);
869 case ARM::ArchKind::ARMV7R:
870 S.setAttributeItem(CPU_arch_profile, RealTimeProfile,
false);
871 S.setAttributeItem(ARM_ISA_use, Allowed,
false);
872 S.setAttributeItem(THUMB_ISA_use, AllowThumb32,
false);
875 case ARM::ArchKind::ARMV7EM:
876 case ARM::ArchKind::ARMV7M:
877 S.setAttributeItem(CPU_arch_profile, MicroControllerProfile,
false);
878 S.setAttributeItem(THUMB_ISA_use, AllowThumb32,
false);
881 case ARM::ArchKind::ARMV8A:
882 case ARM::ArchKind::ARMV8_1A:
883 case ARM::ArchKind::ARMV8_2A:
884 case ARM::ArchKind::ARMV8_3A:
885 case ARM::ArchKind::ARMV8_4A:
886 case ARM::ArchKind::ARMV8_5A:
887 case ARM::ArchKind::ARMV8_6A:
888 case ARM::ArchKind::ARMV8_7A:
889 case ARM::ArchKind::ARMV8_8A:
890 case ARM::ArchKind::ARMV8_9A:
891 case ARM::ArchKind::ARMV9A:
892 case ARM::ArchKind::ARMV9_1A:
893 case ARM::ArchKind::ARMV9_2A:
894 case ARM::ArchKind::ARMV9_3A:
895 case ARM::ArchKind::ARMV9_4A:
896 case ARM::ArchKind::ARMV9_5A:
897 S.setAttributeItem(CPU_arch_profile, ApplicationProfile,
false);
898 S.setAttributeItem(ARM_ISA_use, Allowed,
false);
899 S.setAttributeItem(THUMB_ISA_use, AllowThumb32,
false);
900 S.setAttributeItem(MPextension_use, Allowed,
false);
901 S.setAttributeItem(Virtualization_use, AllowTZVirtualization,
false);
904 case ARM::ArchKind::ARMV8MBaseline:
905 case ARM::ArchKind::ARMV8MMainline:
906 S.setAttributeItem(THUMB_ISA_use, AllowThumbDerived,
false);
907 S.setAttributeItem(CPU_arch_profile, MicroControllerProfile,
false);
910 case ARM::ArchKind::IWMMXT:
911 S.setAttributeItem(ARM_ISA_use, Allowed,
false);
912 S.setAttributeItem(THUMB_ISA_use, Allowed,
false);
913 S.setAttributeItem(WMMX_arch, AllowWMMXv1,
false);
916 case ARM::ArchKind::IWMMXT2:
917 S.setAttributeItem(ARM_ISA_use, Allowed,
false);
918 S.setAttributeItem(THUMB_ISA_use, Allowed,
false);
919 S.setAttributeItem(WMMX_arch, AllowWMMXv2,
false);
930void ARMTargetELFStreamer::emitFPUDefaultAttributes() {
931 ARMELFStreamer &S = getStreamer();
945 case ARM::FK_VFPV3_FP16:
952 case ARM::FK_VFPV3_D16:
957 case ARM::FK_VFPV3_D16_FP16:
964 case ARM::FK_VFPV3XD:
968 case ARM::FK_VFPV3XD_FP16:
982 case ARM::FK_FPV4_SP_D16:
983 case ARM::FK_VFPV4_D16:
988 case ARM::FK_FP_ARMV8:
995 case ARM::FK_FPV5_SP_D16:
996 case ARM::FK_FPV5_D16:
1009 case ARM::FK_NEON_FP16:
1019 case ARM::FK_NEON_VFPV4:
1027 case ARM::FK_NEON_FP_ARMV8:
1028 case ARM::FK_CRYPTO_NEON_FP_ARMV8:
1035 case ARM::FK_SOFTVFP:
1045void ARMTargetELFStreamer::finishAttributeSection() {
1046 ARMELFStreamer &S = getStreamer();
1048 if (FPU != ARM::FK_INVALID)
1049 emitFPUDefaultAttributes();
1051 if (Arch != ARM::ArchKind::INVALID)
1052 emitArchDefaultAttributes();
1054 if (S.Contents.empty())
1075 S.emitAttributesSection(CurrentVendor,
".ARM.attributes",
1078 FPU = ARM::FK_INVALID;
1081void ARMTargetELFStreamer::emitLabel(
MCSymbol *Symbol) {
1082 ARMELFStreamer &Streamer = getStreamer();
1083 if (!Streamer.IsThumb)
1086 Streamer.getAssembler().registerSymbol(*Symbol);
1087 unsigned Type = cast<MCSymbolELF>(Symbol)->getType();
1089 Streamer.emitThumbFunc(Symbol);
1092void ARMTargetELFStreamer::annotateTLSDescriptorSequence(
1100 if (!
Sym.isDefined()) {
1101 getStreamer().emitAssignment(Symbol,
Value);
1106 getStreamer().emitThumbFunc(Symbol);
1107 getStreamer().emitAssignment(Symbol,
Value);
1110void ARMTargetELFStreamer::emitInst(
uint32_t Inst,
char Suffix) {
1111 getStreamer().emitInst(Inst, Suffix);
1114void ARMTargetELFStreamer::reset() { AttributeSection =
nullptr; }
1116void ARMTargetELFStreamer::finish() {
1117 ARMTargetStreamer::finish();
1118 finishAttributeSection();
1121void ARMELFStreamer::reset() {
1125 MappingSymbolCounter = 0;
1127 LastMappingSymbols.clear();
1128 LastEMSInfo.reset();
1135inline void ARMELFStreamer::SwitchToEHSection(
StringRef Prefix,
1146 if (FnSecName !=
".text") {
1147 EHSecName += FnSecName;
1155 EHSecName,
Type, Flags, 0, Group,
true,
1159 assert(EHSection &&
"Failed to get the required EH section");
1162 switchSection(EHSection);
1163 emitValueToAlignment(
Align(4), 0, 1, 0);
1166inline void ARMELFStreamer::SwitchToExTabSection(
const MCSymbol &FnStart) {
1171inline void ARMELFStreamer::SwitchToExIdxSection(
const MCSymbol &FnStart) {
1183void ARMELFStreamer::EHReset() {
1186 Personality =
nullptr;
1196 UnwindOpAsm.Reset();
1199void ARMELFStreamer::emitFnStart() {
1200 assert(FnStart ==
nullptr);
1201 FnStart = getContext().createTempSymbol();
1205void ARMELFStreamer::emitFnEnd() {
1206 assert(FnStart &&
".fnstart must precedes .fnend");
1209 if (!ExTab && !CantUnwind)
1210 FlushUnwindOpcodes(
true);
1213 SwitchToExIdxSection(*FnStart);
1228 emitValue(FnStartRef, 4);
1238 emitValue(ExTabEntryRef, 4);
1244 "Compact model must use __aeabi_unwind_cpp_pr0 as personality");
1246 "Unwind opcode size for __aeabi_unwind_cpp_pr0 must be equal to 4");
1251 emitIntValue(Intval, Opcodes.
size());
1261void ARMELFStreamer::emitCantUnwind() { CantUnwind =
true; }
1265 const MCSymbol *PersonalitySym = getContext().getOrCreateSymbol(
Name);
1270 visitUsedExpr(*PersonalityRef);
1277void ARMELFStreamer::FlushPendingOffset() {
1278 if (PendingOffset != 0) {
1279 UnwindOpAsm.EmitSPOffset(-PendingOffset);
1284void ARMELFStreamer::FlushUnwindOpcodes(
bool NoHandlerData) {
1288 int64_t LastRegSaveSPOffset = SPOffset - PendingOffset;
1289 UnwindOpAsm.EmitSPOffset(LastRegSaveSPOffset - FPOffset);
1290 UnwindOpAsm.EmitSetSP(
MRI->getEncodingValue(FPReg));
1292 FlushPendingOffset();
1296 UnwindOpAsm.Finalize(PersonalityIndex, Opcodes);
1305 SwitchToExTabSection(*FnStart);
1309 ExTab = getContext().createTempSymbol();
1319 emitValue(PersonalityRef, 4);
1324 "Unwind opcode size for __aeabi_cpp_unwind_pr0 must be multiple of 4");
1325 for (
unsigned I = 0;
I != Opcodes.
size();
I += 4) {
1327 Opcodes[
I + 1] << 8 |
1328 Opcodes[
I + 2] << 16 |
1329 Opcodes[
I + 3] << 24;
1340 if (NoHandlerData && !Personality)
1344void ARMELFStreamer::emitHandlerData() { FlushUnwindOpcodes(
false); }
1346void ARMELFStreamer::emitPersonality(
const MCSymbol *Per) {
1348 UnwindOpAsm.setPersonality(Per);
1351void ARMELFStreamer::emitPersonalityIndex(
unsigned Index) {
1353 PersonalityIndex =
Index;
1356void ARMELFStreamer::emitSetFP(
unsigned NewFPReg,
unsigned NewSPReg,
1358 assert((NewSPReg == ARM::SP || NewSPReg == FPReg) &&
1359 "the operand of .setfp directive should be either $sp or $fp");
1364 if (NewSPReg == ARM::SP)
1365 FPOffset = SPOffset +
Offset;
1370void ARMELFStreamer::emitMovSP(
unsigned Reg, int64_t
Offset) {
1371 assert((Reg != ARM::SP && Reg != ARM::PC) &&
1372 "the operand of .movsp cannot be either sp or pc");
1373 assert(FPReg == ARM::SP &&
"current FP must be SP");
1375 FlushPendingOffset();
1378 FPOffset = SPOffset +
Offset;
1381 UnwindOpAsm.EmitSetSP(
MRI->getEncodingValue(FPReg));
1384void ARMELFStreamer::emitPad(int64_t
Offset) {
1393static std::pair<unsigned, unsigned>
1400 unsigned Reg = RegList[
Idx - 1];
1401 if (Reg == ARM::RA_AUTH_CODE)
1403 Reg =
MRI.getEncodingValue(Reg);
1404 assert(Reg < (IsVector ? 32U : 16U) &&
"Register out of range");
1405 unsigned Bit = (1u << Reg);
1406 if ((Mask & Bit) == 0) {
1414 return {
Idx, Count};
1420 unsigned Idx, Count;
1437 SPOffset -= Count * (IsVector ? 8 : 4);
1440 FlushPendingOffset();
1442 UnwindOpAsm.EmitVFPRegSave(Mask);
1444 UnwindOpAsm.EmitRegSave(Mask);
1445 }
else if (
Idx > 0 && RegList[
Idx - 1] == ARM::RA_AUTH_CODE) {
1448 FlushPendingOffset();
1449 UnwindOpAsm.EmitRegSave(0);
1454void ARMELFStreamer::emitUnwindRaw(int64_t
Offset,
1456 FlushPendingOffset();
1457 SPOffset = SPOffset -
Offset;
1458 UnwindOpAsm.EmitRaw(Opcodes);
1466 bool isVerboseAsm) {
1467 return new ARMTargetAsmStreamer(S,
OS, *InstPrint, isVerboseAsm);
1475 return new ARMTargetELFStreamer(S);
1479 std::unique_ptr<MCAsmBackend> TAB,
1480 std::unique_ptr<MCObjectWriter> OW,
1481 std::unique_ptr<MCCodeEmitter>
Emitter,
1482 bool IsThumb,
bool IsAndroid) {
1484 new ARMELFStreamer(Context, std::move(TAB), std::move(OW),
1485 std::move(
Emitter), IsThumb, IsAndroid);
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.
uint64_t IntrinsicInst * II
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallString class.
This file defines the SmallVector class.
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 changeSection(MCSection *Section, uint32_t Subsection=0) override
This is called by popSection and switchSection, if the current section changes.
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 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 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 emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc, MCDataFragment &F, uint64_t Offset) override
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.
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.
MCFragment * getCurrentFragment() const
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.
MCELFStreamer * createARMELFStreamer(MCContext &Context, std::unique_ptr< MCAsmBackend > TAB, std::unique_ptr< MCObjectWriter > OW, std::unique_ptr< MCCodeEmitter > Emitter, bool IsThumb, bool IsAndroid)
MCTargetStreamer * createARMObjectTargetELFStreamer(MCStreamer &S)
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.