81#define DEBUG_TYPE "AArch64AsmPrinter"
86 "Number of zero-cycle FPR zeroing instructions expanded from "
87 "canonical pseudo instructions");
95 bool ShouldEmitWeakSwiftAsyncExtendedFramePointerFlags =
false;
96 bool PtrauthInitFini =
false;
97 bool PtrauthInitFiniAddressDisc =
false;
99 unsigned InstsEmitted;
100 bool ExplicitWinCFIRangeOpen =
false;
101 bool EmittedExplicitWinCFIRange =
false;
103 bool EnableImportCallOptimization =
false;
105 SectionToImportedFunctionCalls;
106 unsigned PAuthIFuncNextUniqueID = 1;
113 MCInstLowering(OutContext, *this), FM(*this) {}
115 StringRef getPassName()
const override {
return "AArch64 Assembly Printer"; }
117 bool hasExplicitWinCFIRanges()
const override {
118 return AArch64FI->hasExplicitWinCFIRanges();
123 bool lowerOperand(
const MachineOperand &MO, MCOperand &MCOp)
const {
124 return MCInstLowering.lowerOperand(MO, MCOp);
127 const MCExpr *lowerConstantPtrAuth(
const ConstantPtrAuth &CPA)
override;
129 const MCExpr *lowerBlockAddressConstant(
const BlockAddress &BA)
override;
131 void emitStartOfAsmFile(
Module &M)
override;
132 void emitJumpTableImpl(
const MachineJumpTableInfo &MJTI,
133 ArrayRef<unsigned> JumpTableIndices)
override;
136 getCodeViewJumpTableInfo(
int JTI,
const MachineInstr *BranchInstr,
137 const MCSymbol *BranchLabel)
const override;
139 void emitFunctionEntryLabel()
override;
141 void emitXXStructor(
const DataLayout &
DL,
const Constant *CV)
override;
143 void LowerJumpTableDest(MCStreamer &OutStreamer,
const MachineInstr &
MI);
145 void LowerHardenedBRJumpTable(
const MachineInstr &
MI);
147 void LowerMOPS(MCStreamer &OutStreamer,
const MachineInstr &
MI);
149 void LowerSTACKMAP(MCStreamer &OutStreamer, StackMaps &SM,
150 const MachineInstr &
MI);
151 void LowerPATCHPOINT(MCStreamer &OutStreamer, StackMaps &SM,
152 const MachineInstr &
MI);
153 void LowerSTATEPOINT(MCStreamer &OutStreamer, StackMaps &SM,
154 const MachineInstr &
MI);
155 void LowerFAULTING_OP(
const MachineInstr &
MI);
157 void LowerPATCHABLE_FUNCTION_ENTER(
const MachineInstr &
MI);
158 void LowerPATCHABLE_FUNCTION_EXIT(
const MachineInstr &
MI);
159 void LowerPATCHABLE_TAIL_CALL(
const MachineInstr &
MI);
160 void LowerPATCHABLE_EVENT_CALL(
const MachineInstr &
MI,
bool Typed);
162 typedef std::tuple<unsigned, bool, uint32_t, bool, uint64_t>
163 HwasanMemaccessTuple;
164 std::map<HwasanMemaccessTuple, MCSymbol *> HwasanMemaccessSymbols;
165 void LowerKCFI_CHECK(
const MachineInstr &
MI);
166 void LowerHWASAN_CHECK_MEMACCESS(
const MachineInstr &
MI);
167 void emitHwasanMemaccessSymbols(
Module &M);
169 void emitSled(
const MachineInstr &
MI, SledKind Kind);
177 if (STI->isX16X17Safer())
178 return Reg == AArch64::X16 ||
Reg == AArch64::X17;
184 void emitPtrauthBranch(
const MachineInstr *
MI);
186 void emitPtrauthCheckAuthenticatedValue(
Register TestedReg,
190 const MCSymbol *OnFailure =
nullptr);
193 void emitPtrauthTailCallHardening(
const MachineInstr *TC);
195 struct PtrAuthSchema {
197 const MachineOperand &AddrDiscOp);
204 bool AddrDiscIsKilled;
207 bool addrDiscIsKilledAndNoneOf(std::initializer_list<Register> Regs) {
225 PtrAuthSchema AuthSchema,
226 std::optional<PtrAuthSchema> SignSchema,
227 std::optional<int64_t> Addend,
Value *DS);
232 bool emitDeactivationSymbolRelocation(
Value *DS);
235 void emitPtrauthSign(
const MachineInstr *
MI);
259 bool MayClobberAddrDisc =
false);
262 void LowerLOADauthptrstatic(
const MachineInstr &
MI);
266 void LowerMOVaddrPAC(
const MachineInstr &
MI);
271 void LowerLOADgotAUTH(
const MachineInstr &
MI);
273 void emitAddImm(MCRegister Val, int64_t Addend, MCRegister Tmp);
274 void emitAddress(MCRegister
Reg,
const MCExpr *Expr, MCRegister Tmp,
275 bool DSOLocal,
const MCSubtargetInfo &STI);
277 const MCExpr *emitPAuthRelocationAsIRelative(
279 bool HasAddressDiversity,
bool IsDSOLocal,
const MCExpr *DSExpr);
283 bool lowerPseudoInstExpansion(
const MachineInstr *
MI, MCInst &Inst);
286 void emitAttributes(
unsigned Flags,
uint64_t PAuthABIPlatform,
287 uint64_t PAuthABIVersion, AArch64TargetStreamer *TS);
290 void emitCBPseudoExpansion(
const MachineInstr *
MI);
293 void emitAtomicHintPseudoExpansion(
const MachineInstr *
MI);
294 void emitAtomicHintPseudoExpansionRO(
const MachineInstr *
MI);
295 void emitAtomicHintPseudoExpansionImm(
const MachineInstr *
MI);
298 void emitAtomicFetchHintPseudoExpansion(
const MachineInstr *
MI);
300 void EmitToStreamer(MCStreamer &S,
const MCInst &Inst);
301 void EmitToStreamer(
const MCInst &Inst) {
302 EmitToStreamer(*OutStreamer, Inst);
307 void emitFunctionHeaderComment()
override;
309 void getAnalysisUsage(AnalysisUsage &AU)
const override {
315 if (
auto *PSIW = getAnalysisIfAvailable<ProfileSummaryInfoWrapperPass>())
316 PSI = &PSIW->getPSI();
318 getAnalysisIfAvailable<StaticDataProfileInfoWrapperPass>())
319 SDPI = &SDPIW->getStaticDataProfileInfo();
321 AArch64FI = MF.
getInfo<AArch64FunctionInfo>();
325 ExplicitWinCFIRangeOpen =
false;
326 EmittedExplicitWinCFIRange =
false;
328 SetupMachineFunction(MF);
330 if (STI->isTargetCOFF()) {
337 OutStreamer->beginCOFFSymbolDef(CurrentFnSym);
338 OutStreamer->emitCOFFSymbolStorageClass(Scl);
339 OutStreamer->emitCOFFSymbolType(
Type);
340 OutStreamer->endCOFFSymbolDef();
354 const Constant *BaseCV =
nullptr,
358 void emitInstructionImpl(
const MachineInstr *
MI);
359 void printOperand(
const MachineInstr *
MI,
unsigned OpNum, raw_ostream &O);
361 bool printAsmRegInClass(
const MachineOperand &MO,
365 bool PrintAsmOperand(
const MachineInstr *
MI,
unsigned OpNum,
366 const char *ExtraCode, raw_ostream &O)
override;
367 bool PrintAsmMemoryOperand(
const MachineInstr *
MI,
unsigned OpNum,
368 const char *ExtraCode, raw_ostream &O)
override;
370 void PrintDebugValueComment(
const MachineInstr *
MI, raw_ostream &OS);
372 void emitFunctionBodyEnd()
override;
373 void emitBasicBlockEnd(
const MachineBasicBlock &
MBB)
override;
374 void emitGlobalAlias(
const Module &M,
const GlobalAlias &GA)
override;
376 MCSymbol *GetCPISymbol(
unsigned CPID)
const override;
377 void emitEndOfAsmFile(
Module &M)
override;
379 AArch64FunctionInfo *AArch64FI =
nullptr;
394 void emitFMov0(
const MachineInstr &
MI);
395 void emitFMov0AsFMov(
const MachineInstr &
MI,
Register DestReg);
397 using MInstToMCSymbol = std::map<const MachineInstr *, MCSymbol *>;
399 MInstToMCSymbol LOHInstToLabel;
401 bool shouldEmitWeakSwiftAsyncExtendedFramePointerFlags()
const override {
402 return ShouldEmitWeakSwiftAsyncExtendedFramePointerFlags;
405 const MCSubtargetInfo *getIFuncMCSubtargetInfo()
const override {
409 void emitMachOIFuncStubBody(
Module &M,
const GlobalIFunc &GI,
410 MCSymbol *LazyPointer)
override;
411 void emitMachOIFuncStubHelperBody(
Module &M,
const GlobalIFunc &GI,
412 MCSymbol *LazyPointer)
override;
417 void recordIfImportCall(
const MachineInstr *BranchInst);
424 Metadata *Flag = M.getModuleFlag(Name);
429 assert((
Value == 0 ||
Value == 1) &&
"Boolean flag is expected, if present");
433void AArch64AsmPrinter::emitStartOfAsmFile(
Module &M) {
434 const Triple &
TT =
M.getTargetTriple();
436 if (
TT.isOSBinFormatCOFF()) {
437 emitCOFFFeatureSymbol(M);
438 emitCOFFReplaceableFunctionData(M);
440 if (
M.getModuleFlag(
"import-call-optimization"))
441 EnableImportCallOptimization =
true;
446 M,
"ptrauth-init-fini-address-discrimination");
448 if (!
TT.isOSBinFormatELF())
453 static_cast<AArch64TargetStreamer *
>(OutStreamer->getTargetStreamer());
456 unsigned BAFlags = 0;
457 unsigned GNUFlags = 0;
459 M.getModuleFlag(
"branch-target-enforcement"))) {
460 if (!BTE->isZero()) {
461 BAFlags |= AArch64BuildAttributes::FeatureAndBitsFlag::Feature_BTI_Flag;
467 M.getModuleFlag(
"guarded-control-stack"))) {
468 if (!GCS->isZero()) {
469 BAFlags |= AArch64BuildAttributes::FeatureAndBitsFlag::Feature_GCS_Flag;
475 M.getModuleFlag(
"sign-return-address"))) {
476 if (!
Sign->isZero()) {
477 BAFlags |= AArch64BuildAttributes::FeatureAndBitsFlag::Feature_PAC_Flag;
484 M.getModuleFlag(
"aarch64-elf-pauthabi-platform"))) {
485 PAuthABIPlatform = PAP->getZExtValue();
490 M.getModuleFlag(
"aarch64-elf-pauthabi-version"))) {
491 PAuthABIVersion = PAV->getZExtValue();
499 PAuthABIVersion == 0) {
505 emitAttributes(BAFlags, PAuthABIPlatform, PAuthABIVersion, TS);
507 TS->emitNoteSection(GNUFlags, PAuthABIPlatform, PAuthABIVersion);
510void AArch64AsmPrinter::emitFunctionHeaderComment() {
511 const AArch64FunctionInfo *FI = MF->
getInfo<AArch64FunctionInfo>();
513 if (OutlinerString != std::nullopt)
514 OutStreamer->getCommentOS() <<
' ' << OutlinerString;
517void AArch64AsmPrinter::LowerPATCHABLE_FUNCTION_ENTER(
const MachineInstr &
MI)
520 if (
F.hasFnAttribute(
"patchable-function-entry")) {
522 if (
F.getFnAttribute(
"patchable-function-entry")
524 .getAsInteger(10, Num))
530 emitSled(
MI, SledKind::FUNCTION_ENTER);
533void AArch64AsmPrinter::LowerPATCHABLE_FUNCTION_EXIT(
const MachineInstr &
MI) {
534 emitSled(
MI, SledKind::FUNCTION_EXIT);
537void AArch64AsmPrinter::LowerPATCHABLE_TAIL_CALL(
const MachineInstr &
MI) {
538 emitSled(
MI, SledKind::TAIL_CALL);
541void AArch64AsmPrinter::emitSled(
const MachineInstr &
MI, SledKind Kind) {
542 static const int8_t NoopsInSledCount = 7;
563 OutStreamer->emitCodeAlignment(
Align(4), getSubtargetInfo());
564 auto CurSled = OutContext.createTempSymbol(
"xray_sled_",
true);
565 OutStreamer->emitLabel(CurSled);
566 auto Target = OutContext.createTempSymbol();
571 EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::B).addImm(8));
573 for (int8_t
I = 0;
I < NoopsInSledCount;
I++)
574 EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::NOP));
576 OutStreamer->emitLabel(Target);
577 recordSled(CurSled,
MI, Kind, 2);
580void AArch64AsmPrinter::emitAttributes(
unsigned Flags,
583 AArch64TargetStreamer *TS) {
585 PAuthABIPlatform = (
uint64_t(-1) == PAuthABIPlatform) ? 0 : PAuthABIPlatform;
586 PAuthABIVersion = (
uint64_t(-1) == PAuthABIVersion) ? 0 : PAuthABIVersion;
588 if (PAuthABIPlatform || PAuthABIVersion) {
592 AArch64BuildAttributes::SubsectionOptional::REQUIRED,
593 AArch64BuildAttributes::SubsectionType::ULEB128);
597 PAuthABIPlatform,
"");
611 if (BTIValue || PACValue || GCSValue) {
615 AArch64BuildAttributes::SubsectionOptional::OPTIONAL,
616 AArch64BuildAttributes::SubsectionType::ULEB128);
644void AArch64AsmPrinter::LowerPATCHABLE_EVENT_CALL(
const MachineInstr &
MI,
646 auto &
O = *OutStreamer;
647 MCSymbol *CurSled = OutContext.createTempSymbol(
"xray_sled_",
true);
648 O.emitLabel(CurSled);
649 bool MachO = MMI->getModule()->getTargetTriple().isOSBinFormatMachO();
651 OutContext.getOrCreateSymbol(
652 Twine(MachO ?
"_" :
"") +
653 (Typed ?
"__xray_TypedEvent" :
"__xray_CustomEvent")),
656 O.AddComment(
"Begin XRay typed event");
657 EmitToStreamer(O, MCInstBuilder(AArch64::B).addImm(9));
658 EmitToStreamer(O, MCInstBuilder(AArch64::STPXpre)
664 EmitToStreamer(O, MCInstBuilder(AArch64::STRXui)
668 emitMovXReg(AArch64::X0,
MI.getOperand(0).getReg());
669 emitMovXReg(AArch64::X1,
MI.getOperand(1).getReg());
670 emitMovXReg(AArch64::X2,
MI.getOperand(2).getReg());
671 EmitToStreamer(O, MCInstBuilder(AArch64::BL).addExpr(Sym));
672 EmitToStreamer(O, MCInstBuilder(AArch64::LDRXui)
676 O.AddComment(
"End XRay typed event");
677 EmitToStreamer(O, MCInstBuilder(AArch64::LDPXpost)
684 recordSled(CurSled,
MI, SledKind::TYPED_EVENT, 2);
686 O.AddComment(
"Begin XRay custom event");
687 EmitToStreamer(O, MCInstBuilder(AArch64::B).addImm(6));
688 EmitToStreamer(O, MCInstBuilder(AArch64::STPXpre)
694 emitMovXReg(AArch64::X0,
MI.getOperand(0).getReg());
695 emitMovXReg(AArch64::X1,
MI.getOperand(1).getReg());
696 EmitToStreamer(O, MCInstBuilder(AArch64::BL).addExpr(Sym));
697 O.AddComment(
"End XRay custom event");
698 EmitToStreamer(O, MCInstBuilder(AArch64::LDPXpost)
705 recordSled(CurSled,
MI, SledKind::CUSTOM_EVENT, 2);
709void AArch64AsmPrinter::LowerKCFI_CHECK(
const MachineInstr &
MI) {
711 assert(std::next(
MI.getIterator())->isCall() &&
712 "KCFI_CHECK not followed by a call instruction");
713 assert(std::next(
MI.getIterator())->getOperand(0).getReg() == AddrReg &&
714 "KCFI_CHECK call target doesn't match call operand");
718 unsigned ScratchRegs[] = {AArch64::W16, AArch64::W17};
719 if (AddrReg == AArch64::XZR) {
723 emitMovXReg(AddrReg, AArch64::XZR);
729 for (
auto &
Reg : ScratchRegs) {
735 assert(ScratchRegs[0] != AddrReg && ScratchRegs[1] != AddrReg &&
736 "Invalid scratch registers for KCFI_CHECK");
741 MI.getMF()->getFunction().getFnAttributeAsParsedInteger(
742 "patchable-function-prefix");
745 EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::LDURWi)
746 .addReg(ScratchRegs[0])
748 .addImm(-(PrefixNops * 4 + 4)));
752 const int64_t
Type =
MI.getOperand(1).getImm();
753 emitMOVK(ScratchRegs[1],
Type & 0xFFFF, 0);
754 emitMOVK(ScratchRegs[1], (
Type >> 16) & 0xFFFF, 16);
757 EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::SUBSWrs)
758 .addReg(AArch64::WZR)
759 .addReg(ScratchRegs[0])
760 .addReg(ScratchRegs[1])
764 EmitToStreamer(*OutStreamer,
765 MCInstBuilder(AArch64::Bcc)
774 unsigned TypeIndex = ScratchRegs[1] - AArch64::W0;
778 AddrIndex = AddrReg - AArch64::X0;
788 assert(AddrIndex < 31 && TypeIndex < 31);
790 unsigned ESR = 0x8000 | ((TypeIndex & 31) << 5) | (AddrIndex & 31);
791 EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::BRK).addImm(ESR));
792 OutStreamer->emitLabel(
Pass);
795void AArch64AsmPrinter::LowerHWASAN_CHECK_MEMACCESS(
const MachineInstr &
MI) {
803 if (
Reg == AArch64::XZR)
807 ((
MI.getOpcode() == AArch64::HWASAN_CHECK_MEMACCESS_SHORTGRANULES) ||
809 AArch64::HWASAN_CHECK_MEMACCESS_SHORTGRANULES_FIXEDSHADOW));
810 uint32_t AccessInfo =
MI.getOperand(1).getImm();
812 ((
MI.getOpcode() == AArch64::HWASAN_CHECK_MEMACCESS_FIXEDSHADOW) ||
814 AArch64::HWASAN_CHECK_MEMACCESS_SHORTGRANULES_FIXEDSHADOW));
815 uint64_t FixedShadowOffset = IsFixedShadow ?
MI.getOperand(2).getImm() : 0;
817 MCSymbol *&Sym = HwasanMemaccessSymbols[HwasanMemaccessTuple(
818 Reg, IsShort, AccessInfo, IsFixedShadow, FixedShadowOffset)];
821 if (!TM.getTargetTriple().isOSBinFormatELF())
824 std::string SymName =
"__hwasan_check_x" +
utostr(
Reg - AArch64::X0) +
"_" +
827 SymName +=
"_fixed_" +
utostr(FixedShadowOffset);
829 SymName +=
"_short_v2";
830 Sym = OutContext.getOrCreateSymbol(SymName);
833 EmitToStreamer(*OutStreamer,
834 MCInstBuilder(AArch64::BL)
838void AArch64AsmPrinter::emitHwasanMemaccessSymbols(
Module &M) {
839 if (HwasanMemaccessSymbols.empty())
842 const Triple &
TT =
M.getTargetTriple();
846 auto STI = std::make_unique<AArch64Subtarget>(
847 TT, TM.getTargetCPU(), TM.getTargetCPU(), TM.getTargetFeatureString(), TM,
849 this->STI = STI.get();
852 OutContext.getOrCreateSymbol(
"__hwasan_tag_mismatch");
854 OutContext.getOrCreateSymbol(
"__hwasan_tag_mismatch_v2");
856 const MCSymbolRefExpr *HwasanTagMismatchV1Ref =
858 const MCSymbolRefExpr *HwasanTagMismatchV2Ref =
861 for (
auto &
P : HwasanMemaccessSymbols) {
862 unsigned Reg = std::get<0>(
P.first);
863 bool IsShort = std::get<1>(
P.first);
864 uint32_t AccessInfo = std::get<2>(
P.first);
865 bool IsFixedShadow = std::get<3>(
P.first);
866 uint64_t FixedShadowOffset = std::get<4>(
P.first);
867 const MCSymbolRefExpr *HwasanTagMismatchRef =
868 IsShort ? HwasanTagMismatchV2Ref : HwasanTagMismatchV1Ref;
871 bool HasMatchAllTag =
873 uint8_t MatchAllTag =
880 OutStreamer->switchSection(OutContext.getELFSection(
886 OutStreamer->emitSymbolAttribute(Sym,
MCSA_Weak);
887 OutStreamer->emitSymbolAttribute(Sym,
MCSA_Hidden);
888 OutStreamer->emitLabel(Sym);
890 EmitToStreamer(MCInstBuilder(AArch64::SBFMXri)
891 .addReg(AArch64::X16)
901 emitMOVZ(AArch64::X17, FixedShadowOffset >> 32, 32);
902 EmitToStreamer(MCInstBuilder(AArch64::LDRBBroX)
903 .addReg(AArch64::W16)
904 .addReg(AArch64::X17)
905 .addReg(AArch64::X16)
909 EmitToStreamer(MCInstBuilder(AArch64::LDRBBroX)
910 .addReg(AArch64::W16)
911 .addReg(IsShort ? AArch64::X20 : AArch64::X9)
912 .addReg(AArch64::X16)
917 EmitToStreamer(MCInstBuilder(AArch64::SUBSXrs)
918 .addReg(AArch64::XZR)
919 .addReg(AArch64::X16)
922 MCSymbol *HandleMismatchOrPartialSym = OutContext.createTempSymbol();
923 EmitToStreamer(MCInstBuilder(AArch64::Bcc)
926 HandleMismatchOrPartialSym, OutContext)));
927 MCSymbol *ReturnSym = OutContext.createTempSymbol();
928 OutStreamer->emitLabel(ReturnSym);
929 EmitToStreamer(MCInstBuilder(AArch64::RET).addReg(AArch64::LR));
930 OutStreamer->emitLabel(HandleMismatchOrPartialSym);
932 if (HasMatchAllTag) {
933 EmitToStreamer(MCInstBuilder(AArch64::UBFMXri)
934 .addReg(AArch64::X17)
938 EmitToStreamer(MCInstBuilder(AArch64::SUBSXri)
939 .addReg(AArch64::XZR)
940 .addReg(AArch64::X17)
944 MCInstBuilder(AArch64::Bcc)
950 EmitToStreamer(MCInstBuilder(AArch64::SUBSWri)
951 .addReg(AArch64::WZR)
952 .addReg(AArch64::W16)
955 MCSymbol *HandleMismatchSym = OutContext.createTempSymbol();
957 MCInstBuilder(AArch64::Bcc)
961 EmitToStreamer(MCInstBuilder(AArch64::ANDXri)
962 .addReg(AArch64::X17)
966 EmitToStreamer(MCInstBuilder(AArch64::ADDXri)
967 .addReg(AArch64::X17)
968 .addReg(AArch64::X17)
971 EmitToStreamer(MCInstBuilder(AArch64::SUBSWrs)
972 .addReg(AArch64::WZR)
973 .addReg(AArch64::W16)
974 .addReg(AArch64::W17)
977 MCInstBuilder(AArch64::Bcc)
981 EmitToStreamer(MCInstBuilder(AArch64::ORRXri)
982 .addReg(AArch64::X16)
985 EmitToStreamer(MCInstBuilder(AArch64::LDRBBui)
986 .addReg(AArch64::W16)
987 .addReg(AArch64::X16)
990 MCInstBuilder(AArch64::SUBSXrs)
991 .addReg(AArch64::XZR)
992 .addReg(AArch64::X16)
996 MCInstBuilder(AArch64::Bcc)
1000 OutStreamer->emitLabel(HandleMismatchSym);
1003 EmitToStreamer(MCInstBuilder(AArch64::STPXpre)
1004 .addReg(AArch64::SP)
1005 .addReg(AArch64::X0)
1006 .addReg(AArch64::X1)
1007 .addReg(AArch64::SP)
1009 EmitToStreamer(MCInstBuilder(AArch64::STPXi)
1010 .addReg(AArch64::FP)
1011 .addReg(AArch64::LR)
1012 .addReg(AArch64::SP)
1015 if (
Reg != AArch64::X0)
1016 emitMovXReg(AArch64::X0,
Reg);
1019 if (CompileKernel) {
1023 EmitToStreamer(MCInstBuilder(AArch64::B).addExpr(HwasanTagMismatchRef));
1028 EmitToStreamer(MCInstBuilder(AArch64::ADRP)
1029 .addReg(AArch64::X16)
1033 EmitToStreamer(MCInstBuilder(AArch64::LDRXui)
1034 .addReg(AArch64::X16)
1035 .addReg(AArch64::X16)
1039 EmitToStreamer(MCInstBuilder(AArch64::BR).addReg(AArch64::X16));
1042 this->STI =
nullptr;
1047 const MCExpr *StubAuthPtrRef) {
1050 OutStreamer.
emitValue(StubAuthPtrRef, 8);
1053void AArch64AsmPrinter::emitEndOfAsmFile(
Module &M) {
1054 emitHwasanMemaccessSymbols(M);
1056 const Triple &
TT =
M.getTargetTriple();
1057 if (
TT.isOSBinFormatMachO()) {
1059 MachineModuleInfoMachO &MMIMacho =
1060 MMI->getObjFileInfo<MachineModuleInfoMachO>();
1064 if (!Stubs.empty()) {
1066 OutStreamer->switchSection(
1069 emitAlignment(
Align(8));
1071 for (
const auto &Stub : Stubs)
1074 OutStreamer->addBlankLine();
1082 OutStreamer->emitSubsectionsViaSymbols();
1085 if (
TT.isOSBinFormatELF()) {
1087 MachineModuleInfoELF &MMIELF = MMI->getObjFileInfo<MachineModuleInfoELF>();
1091 if (!Stubs.empty()) {
1092 const TargetLoweringObjectFile &TLOF = getObjFileLowering();
1094 emitAlignment(
Align(8));
1096 for (
const auto &Stub : Stubs)
1099 OutStreamer->addBlankLine();
1110 M.getModuleFlag(
"ptrauth-elf-got"));
1111 if (PtrAuthELFGOTFlag && PtrAuthELFGOTFlag->getZExtValue() == 1)
1112 for (
const GlobalValue &GV :
M.global_values())
1114 !GV.getName().starts_with(
"llvm."))
1115 OutStreamer->emitSymbolAttribute(getSymbol(&GV),
1124 if (EnableImportCallOptimization &&
TT.isOSBinFormatCOFF()) {
1125 OutStreamer->switchSection(getObjFileLowering().getImportCallSection());
1128 constexpr char ImpCallMagic[12] =
"Imp_Call_V1";
1129 OutStreamer->emitBytes(StringRef{ImpCallMagic,
sizeof(ImpCallMagic)});
1140 for (
auto &[Section, CallsToImportedFuncs] :
1141 SectionToImportedFunctionCalls) {
1143 sizeof(uint32_t) * (2 + 3 * CallsToImportedFuncs.size());
1144 OutStreamer->emitInt32(SectionSize);
1145 OutStreamer->emitCOFFSecNumber(
Section->getBeginSymbol());
1146 for (
auto &[CallsiteSymbol, CalledSymbol] : CallsToImportedFuncs) {
1148 OutStreamer->emitInt32(0x13);
1149 OutStreamer->emitCOFFSecOffset(CallsiteSymbol);
1150 OutStreamer->emitCOFFSymbolIndex(CalledSymbol);
1156void AArch64AsmPrinter::emitLOHs() {
1160 for (
const MachineInstr *
MI :
D.getArgs()) {
1161 MInstToMCSymbol::iterator LabelIt = LOHInstToLabel.find(
MI);
1162 assert(LabelIt != LOHInstToLabel.end() &&
1163 "Label hasn't been inserted for LOH related instruction");
1166 OutStreamer->emitLOHDirective(
D.getKind(), MCArgs);
1177void AArch64AsmPrinter::emitBasicBlockEnd(
const MachineBasicBlock &
MBB) {
1180 if (
Next == MF->
end() ||
Next->isEHFuncletEntry()) {
1182 if (
MI.isMetaInstruction() || AArch64InstrInfo::isSEHInstruction(
MI))
1184 if (
MI.isCall() && !
MI.isReturn())
1185 EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::BRK).addImm(1));
1194void AArch64AsmPrinter::emitFunctionBodyEnd() {
1196 assert(!ExplicitWinCFIRangeOpen &&
1197 "Explicit Windows CFI range is still open at function end");
1199 "Explicit Windows CFI ranges should only be used for flagged "
1200 "functions. If a function is flagged then it must have explicit "
1201 "Windows CFI ranges.");
1208MCSymbol *AArch64AsmPrinter::GetCPISymbol(
unsigned CPID)
const {
1212 if (!getDataLayout().getLinkerPrivateGlobalPrefix().
empty())
1213 return OutContext.getOrCreateSymbol(
1214 Twine(getDataLayout().getLinkerPrivateGlobalPrefix()) +
"CPI" +
1215 Twine(getFunctionNumber()) +
"_" + Twine(CPID));
1220void AArch64AsmPrinter::printOperand(
const MachineInstr *
MI,
unsigned OpNum,
1222 const MachineOperand &MO =
MI->getOperand(OpNum);
1238 PrintSymbolOperand(MO, O);
1249bool AArch64AsmPrinter::printAsmMRegister(
const MachineOperand &MO,
char Mode,
1273bool AArch64AsmPrinter::printAsmRegInClass(
const MachineOperand &MO,
1275 unsigned AltName, raw_ostream &O) {
1276 assert(MO.
isReg() &&
"Should only get here with a register!");
1277 const TargetRegisterInfo *RI = STI->getRegisterInfo();
1286bool AArch64AsmPrinter::PrintAsmOperand(
const MachineInstr *
MI,
unsigned OpNum,
1287 const char *ExtraCode, raw_ostream &O) {
1288 const MachineOperand &MO =
MI->getOperand(OpNum);
1295 if (ExtraCode && ExtraCode[0]) {
1296 if (ExtraCode[1] != 0)
1299 switch (ExtraCode[0]) {
1307 unsigned Reg = ExtraCode[0] ==
'w' ? AArch64::WZR : AArch64::XZR;
1321 switch (ExtraCode[0]) {
1323 RC = &AArch64::FPR8RegClass;
1326 RC = &AArch64::FPR16RegClass;
1329 RC = &AArch64::FPR32RegClass;
1332 RC = &AArch64::FPR64RegClass;
1335 RC = &AArch64::FPR128RegClass;
1338 RC = &AArch64::ZPRRegClass;
1343 return printAsmRegInClass(MO, RC, AArch64::NoRegAltName, O);
1364 unsigned AltName = AArch64::NoRegAltName;
1367 RegClass = &AArch64::ZPRRegClass;
1369 RegClass = &AArch64::PPRRegClass;
1371 RegClass = &AArch64::PNRRegClass;
1373 RegClass = &AArch64::FPR128RegClass;
1374 AltName = AArch64::vreg;
1378 return printAsmRegInClass(MO, RegClass, AltName, O);
1385bool AArch64AsmPrinter::PrintAsmMemoryOperand(
const MachineInstr *
MI,
1387 const char *ExtraCode,
1389 if (ExtraCode && ExtraCode[0] && ExtraCode[0] !=
'a')
1392 const MachineOperand &MO =
MI->getOperand(OpNum);
1393 assert(MO.
isReg() &&
"unexpected inline asm memory operand");
1398void AArch64AsmPrinter::PrintDebugValueComment(
const MachineInstr *
MI,
1400 unsigned NOps =
MI->getNumOperands();
1402 OS <<
'\t' << MAI.getCommentString() <<
"DEBUG_VALUE: ";
1404 OS <<
MI->getDebugVariable()->getName();
1407 assert(
MI->isIndirectDebugValue());
1419void AArch64AsmPrinter::emitJumpTableImpl(
const MachineJumpTableInfo &MJTI,
1420 ArrayRef<unsigned> JumpTableIndices) {
1422 if (JumpTableIndices.
empty())
1424 const TargetLoweringObjectFile &TLOF = getObjFileLowering();
1428 MCSection *ReadOnlySec =
nullptr;
1429 if (TM.Options.EnableStaticDataPartitioning) {
1435 OutStreamer->switchSection(ReadOnlySec);
1437 auto AFI = MF->
getInfo<AArch64FunctionInfo>();
1438 for (
unsigned JTI : JumpTableIndices) {
1439 const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;
1442 if (JTBBs.empty())
continue;
1444 unsigned Size = AFI->getJumpTableEntrySize(JTI);
1446 OutStreamer->emitLabel(GetJTISymbol(JTI));
1451 for (
auto *JTBB : JTBBs) {
1452 const MCExpr *
Value =
1471AArch64AsmPrinter::getCodeViewJumpTableInfo(
int JTI,
1472 const MachineInstr *BranchInstr,
1473 const MCSymbol *BranchLabel)
const {
1474 const auto AFI = MF->
getInfo<AArch64FunctionInfo>();
1477 switch (AFI->getJumpTableEntrySize(JTI)) {
1479 EntrySize = codeview::JumpTableEntrySize::UInt8ShiftLeft;
1482 EntrySize = codeview::JumpTableEntrySize::UInt16ShiftLeft;
1485 EntrySize = codeview::JumpTableEntrySize::Int32;
1490 return std::make_tuple(
Base, 0, BranchLabel, EntrySize);
1493void AArch64AsmPrinter::emitFunctionEntryLabel() {
1494 const Triple &
TT = TM.getTargetTriple();
1495 if (
TT.isOSBinFormatELF() &&
1498 CallingConv::AArch64_SVE_VectorCall ||
1499 MF->
getInfo<AArch64FunctionInfo>()->isSVECC())) {
1501 static_cast<AArch64TargetStreamer *
>(OutStreamer->getTargetStreamer());
1512 OutStreamer->emitAssignment(
1516 auto getSymbolFromMetadata = [&](StringRef
Name) {
1520 Sym = MMI->getContext().getOrCreateSymbol(NameStr);
1527 for (MDNode *Node : UnmangledNames) {
1529 MCSymbol *UnmangledSym = MMI->getContext().getOrCreateSymbol(NameStr);
1530 if (std::optional<std::string> MangledName =
1533 MMI->getContext().getOrCreateSymbol(*MangledName);
1534 emitFunctionAlias(UnmangledSym, ECMangledSym);
1537 if (MCSymbol *ECMangledSym =
1538 getSymbolFromMetadata(
"arm64ec_ecmangled_name"))
1539 emitFunctionAlias(ECMangledSym, CurrentFnSym);
1543void AArch64AsmPrinter::emitXXStructor(
const DataLayout &
DL,
1544 const Constant *CV) {
1547 "ctors/dtors are to be signed by asm printer");
1549 if (PtrauthInitFini) {
1555 ConstantInt *IntDisc = ConstantInt::get(
1559 if (PtrauthInitFiniAddressDisc) {
1573void AArch64AsmPrinter::emitGlobalAlias(
const Module &M,
1574 const GlobalAlias &GA) {
1580 if (MDNode *Node =
F->getMetadata(
"arm64ec_exp_name")) {
1582 MCSymbol *ExpSym = MMI->getContext().getOrCreateSymbol(ExpStr);
1585 OutStreamer->beginCOFFSymbolDef(ExpSym);
1589 OutStreamer->endCOFFSymbolDef();
1591 OutStreamer->beginCOFFSymbolDef(Sym);
1595 OutStreamer->endCOFFSymbolDef();
1596 OutStreamer->emitSymbolAttribute(Sym,
MCSA_Weak);
1597 OutStreamer->emitAssignment(
1614void AArch64AsmPrinter::LowerJumpTableDest(llvm::MCStreamer &OutStreamer,
1615 const llvm::MachineInstr &
MI) {
1616 Register DestReg =
MI.getOperand(0).getReg();
1617 Register ScratchReg =
MI.getOperand(1).getReg();
1619 STI->getRegisterInfo()->getSubReg(ScratchReg, AArch64::sub_32);
1620 Register TableReg =
MI.getOperand(2).getReg();
1621 Register EntryReg =
MI.getOperand(3).getReg();
1622 int JTIdx =
MI.getOperand(4).getIndex();
1628 MF->
getInfo<AArch64FunctionInfo>()->getJumpTableEntryPCRelSymbol(JTIdx);
1639 EmitToStreamer(OutStreamer, MCInstBuilder(AArch64::ADR)
1641 .addExpr(LabelExpr));
1646 case 1: LdrOpcode = AArch64::LDRBBroX;
break;
1647 case 2: LdrOpcode = AArch64::LDRHHroX;
break;
1648 case 4: LdrOpcode = AArch64::LDRSWroX;
break;
1653 EmitToStreamer(OutStreamer, MCInstBuilder(LdrOpcode)
1654 .addReg(
Size == 4 ? ScratchReg : ScratchRegW)
1658 .addImm(
Size == 1 ? 0 : 1));
1662 EmitToStreamer(OutStreamer, MCInstBuilder(AArch64::ADDXrs)
1666 .addImm(
Size == 4 ? 0 : 2));
1669void AArch64AsmPrinter::LowerHardenedBRJumpTable(
const MachineInstr &
MI) {
1671 assert(MJTI &&
"Can't lower jump-table dispatch without JTI");
1673 const std::vector<MachineJumpTableEntry> &JTs = MJTI->
getJumpTables();
1674 assert(!JTs.empty() &&
"Invalid JT index for jump-table dispatch");
1690 MachineOperand JTOp =
MI.getOperand(0);
1694 "unsupported compressed jump table");
1696 const uint64_t NumTableEntries = JTs[JTI].MBBs.size();
1700 uint64_t MaxTableEntry = NumTableEntries - 1;
1702 EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::SUBSXri)
1703 .addReg(AArch64::XZR)
1704 .addReg(AArch64::X16)
1705 .addImm(MaxTableEntry)
1708 emitMOVZ(AArch64::X17,
static_cast<uint16_t
>(MaxTableEntry), 0);
1713 if ((MaxTableEntry >>
Offset) == 0)
1715 emitMOVK(AArch64::X17,
static_cast<uint16_t
>(MaxTableEntry >>
Offset),
1718 EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::SUBSXrs)
1719 .addReg(AArch64::XZR)
1720 .addReg(AArch64::X16)
1721 .addReg(AArch64::X17)
1727 EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::CSELXr)
1728 .addReg(AArch64::X16)
1729 .addReg(AArch64::X16)
1730 .addReg(AArch64::XZR)
1734 MachineOperand JTMOHi(JTOp), JTMOLo(JTOp);
1735 MCOperand JTMCHi, JTMCLo;
1745 MCInstBuilder(AArch64::ADRP).addReg(AArch64::X17).
addOperand(JTMCHi));
1747 EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::ADDXri)
1748 .addReg(AArch64::X17)
1749 .addReg(AArch64::X17)
1753 EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::LDRSWroX)
1754 .addReg(AArch64::X16)
1755 .addReg(AArch64::X17)
1756 .addReg(AArch64::X16)
1767 MCInstBuilder(AArch64::ADR).addReg(AArch64::X17).addExpr(AdrLabelE));
1769 EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::ADDXrs)
1770 .addReg(AArch64::X16)
1771 .addReg(AArch64::X17)
1772 .addReg(AArch64::X16)
1775 EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::BR).addReg(AArch64::X16));
1778void AArch64AsmPrinter::LowerMOPS(llvm::MCStreamer &OutStreamer,
1779 const llvm::MachineInstr &
MI) {
1780 unsigned Opcode =
MI.getOpcode();
1782 assert(STI->hasMTE() || Opcode != AArch64::MOPSMemorySetTaggingPseudo);
1784 const auto Ops = [Opcode]() -> std::array<unsigned, 3> {
1785 if (Opcode == AArch64::MOPSMemoryCopyPseudo)
1786 return {AArch64::CPYFP, AArch64::CPYFM, AArch64::CPYFE};
1787 if (Opcode == AArch64::MOPSMemoryMovePseudo)
1788 return {AArch64::CPYP, AArch64::CPYM, AArch64::CPYE};
1789 if (Opcode == AArch64::MOPSMemorySetPseudo)
1790 return {AArch64::SETP, AArch64::SETM, AArch64::SETE};
1791 if (Opcode == AArch64::MOPSMemorySetTaggingPseudo)
1792 return {AArch64::SETGP, AArch64::SETGM, AArch64::MOPSSETGE};
1795 const bool IsSet = Opcode == AArch64::MOPSMemorySetPseudo ||
1796 Opcode == AArch64::MOPSMemorySetTaggingPseudo;
1798 for (
auto Op :
Ops) {
1800 auto MCIB = MCInstBuilder(
Op);
1802 MCIB.addReg(
MI.getOperand(i++).getReg());
1803 MCIB.addReg(
MI.getOperand(i++).getReg());
1805 MCIB.addReg(
MI.getOperand(i++).getReg());
1807 MCIB.addReg(
MI.getOperand(i++).getReg());
1808 MCIB.addReg(
MI.getOperand(i++).getReg());
1809 MCIB.addReg(
MI.getOperand(i++).getReg());
1811 EmitToStreamer(OutStreamer, MCIB);
1815void AArch64AsmPrinter::LowerSTACKMAP(MCStreamer &OutStreamer, StackMaps &SM,
1816 const MachineInstr &
MI) {
1817 unsigned NumNOPBytes = StackMapOpers(&
MI).getNumPatchBytes();
1820 MCSymbol *MILabel = Ctx.createTempSymbol();
1824 assert(NumNOPBytes % 4 == 0 &&
"Invalid number of NOP bytes requested!");
1830 while (NumNOPBytes > 0) {
1831 if (MII !=
MBB.
end() && MII->isDebugInstr()) {
1835 if (MII ==
MBB.
end() || MII->isCall() ||
1836 MII->getOpcode() == TargetOpcode::PATCHPOINT ||
1837 MII->getOpcode() == TargetOpcode::STACKMAP)
1844 for (
unsigned i = 0; i < NumNOPBytes; i += 4)
1845 EmitToStreamer(OutStreamer, MCInstBuilder(AArch64::NOP));
1850void AArch64AsmPrinter::LowerPATCHPOINT(MCStreamer &OutStreamer, StackMaps &SM,
1851 const MachineInstr &
MI) {
1853 MCSymbol *MILabel = Ctx.createTempSymbol();
1857 PatchPointOpers Opers(&
MI);
1859 int64_t CallTarget = Opers.getCallTarget().getImm();
1860 unsigned EncodedBytes = 0;
1862 assert((CallTarget & 0xFFFFFFFFFFFF) == CallTarget &&
1863 "High 16 bits of call target should be zero.");
1864 Register ScratchReg =
MI.getOperand(Opers.getNextScratchIdx()).getReg();
1867 emitMOVZ(ScratchReg, (CallTarget >> 32) & 0xFFFF, 32);
1868 emitMOVK(ScratchReg, (CallTarget >> 16) & 0xFFFF, 16);
1869 emitMOVK(ScratchReg, CallTarget & 0xFFFF, 0);
1870 EmitToStreamer(OutStreamer, MCInstBuilder(AArch64::BLR).addReg(ScratchReg));
1873 unsigned NumBytes = Opers.getNumPatchBytes();
1874 assert(NumBytes >= EncodedBytes &&
1875 "Patchpoint can't request size less than the length of a call.");
1876 assert((NumBytes - EncodedBytes) % 4 == 0 &&
1877 "Invalid number of NOP bytes requested!");
1878 for (
unsigned i = EncodedBytes; i < NumBytes; i += 4)
1879 EmitToStreamer(OutStreamer, MCInstBuilder(AArch64::NOP));
1882void AArch64AsmPrinter::LowerSTATEPOINT(MCStreamer &OutStreamer, StackMaps &SM,
1883 const MachineInstr &
MI) {
1884 StatepointOpers SOpers(&
MI);
1885 if (
unsigned PatchBytes = SOpers.getNumPatchBytes()) {
1886 assert(PatchBytes % 4 == 0 &&
"Invalid number of NOP bytes requested!");
1887 for (
unsigned i = 0; i < PatchBytes; i += 4)
1888 EmitToStreamer(OutStreamer, MCInstBuilder(AArch64::NOP));
1891 const MachineOperand &CallTarget = SOpers.getCallTarget();
1892 MCOperand CallTargetMCOp;
1893 unsigned CallOpcode;
1894 switch (CallTarget.
getType()) {
1897 MCInstLowering.
lowerOperand(CallTarget, CallTargetMCOp);
1898 CallOpcode = AArch64::BL;
1902 CallOpcode = AArch64::BL;
1906 CallOpcode = AArch64::BLR;
1913 EmitToStreamer(OutStreamer,
1914 MCInstBuilder(CallOpcode).
addOperand(CallTargetMCOp));
1918 MCSymbol *MILabel = Ctx.createTempSymbol();
1923void AArch64AsmPrinter::LowerFAULTING_OP(
const MachineInstr &FaultingMI) {
1932 unsigned OperandsBeginIdx = 4;
1935 MCSymbol *FaultingLabel = Ctx.createTempSymbol();
1942 MI.setOpcode(Opcode);
1947 for (
const MachineOperand &MO :
1950 lowerOperand(MO, Dest);
1951 MI.addOperand(Dest);
1959 EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::ORRXrs)
1961 .addReg(AArch64::XZR)
1967 bool Is64Bit = AArch64::GPR64RegClass.contains(Dest);
1968 EmitToStreamer(*OutStreamer,
1969 MCInstBuilder(Is64Bit ? AArch64::MOVZXi : AArch64::MOVZWi)
1976 bool Is64Bit = AArch64::GPR64RegClass.contains(Dest);
1977 EmitToStreamer(*OutStreamer,
1978 MCInstBuilder(Is64Bit ? AArch64::MOVKXi : AArch64::MOVKWi)
1987 bool IsZeroDisc = Disc == AArch64::XZR;
1999 EmitToStreamer(AUTInst);
2004 bool IsZeroDisc = Disc == AArch64::XZR;
2016 EmitToStreamer(PACInst);
2021 bool IsZeroDisc = Disc == AArch64::XZR;
2031 EmitToStreamer(Inst);
2034void AArch64AsmPrinter::emitFMov0(
const MachineInstr &
MI) {
2035 Register DestReg =
MI.getOperand(0).getReg();
2036 if (!STI->hasZeroCycleZeroingFPWorkaround() && STI->isNeonAvailable()) {
2037 if (STI->hasZeroCycleZeroingFPR64()) {
2039 const AArch64RegisterInfo *
TRI = STI->getRegisterInfo();
2040 if (AArch64::FPR16RegClass.
contains(DestReg))
2041 DestReg =
TRI->getMatchingSuperReg(DestReg, AArch64::hsub,
2042 &AArch64::FPR64RegClass);
2043 else if (AArch64::FPR32RegClass.
contains(DestReg))
2044 DestReg =
TRI->getMatchingSuperReg(DestReg, AArch64::ssub,
2045 &AArch64::FPR64RegClass);
2053 EmitToStreamer(*OutStreamer, MOVI);
2054 ++NumZCZeroingInstrsFPR;
2055 }
else if (STI->hasZeroCycleZeroingFPR128()) {
2057 const AArch64RegisterInfo *
TRI = STI->getRegisterInfo();
2058 if (AArch64::FPR16RegClass.
contains(DestReg)) {
2059 DestReg =
TRI->getMatchingSuperReg(DestReg, AArch64::hsub,
2060 &AArch64::FPR128RegClass);
2061 }
else if (AArch64::FPR32RegClass.
contains(DestReg)) {
2062 DestReg =
TRI->getMatchingSuperReg(DestReg, AArch64::ssub,
2063 &AArch64::FPR128RegClass);
2066 DestReg =
TRI->getMatchingSuperReg(DestReg, AArch64::dsub,
2067 &AArch64::FPR128RegClass);
2074 EmitToStreamer(*OutStreamer, MOVI);
2075 ++NumZCZeroingInstrsFPR;
2077 emitFMov0AsFMov(
MI, DestReg);
2080 emitFMov0AsFMov(
MI, DestReg);
2084void AArch64AsmPrinter::emitFMov0AsFMov(
const MachineInstr &
MI,
2087 switch (
MI.getOpcode()) {
2090 case AArch64::FMOVH0:
2091 FMov.
setOpcode(STI->hasFullFP16() ? AArch64::FMOVWHr : AArch64::FMOVWSr);
2092 if (!STI->hasFullFP16())
2093 DestReg = (AArch64::S0 + (DestReg - AArch64::H0));
2097 case AArch64::FMOVS0:
2102 case AArch64::FMOVD0:
2108 EmitToStreamer(*OutStreamer, FMov);
2114 bool MayClobberAddrDisc) {
2115 assert(isPtrauthRegSafe(ScratchReg) &&
2116 "Safe scratch register must be provided by the caller");
2121 AddrDisc = AArch64::XZR;
2129 if (AddrDisc == AArch64::XZR) {
2130 emitMOVZ(ScratchReg, Disc, 0);
2137 if (MayClobberAddrDisc && isPtrauthRegSafe(AddrDisc)) {
2138 ScratchReg = AddrDisc;
2140 emitMovXReg(ScratchReg, AddrDisc);
2141 assert(ScratchReg != AddrDisc &&
2142 "Forbidden to clobber AddrDisc, but have to");
2145 emitMOVK(ScratchReg, Disc, 48);
2159void AArch64AsmPrinter::emitPtrauthCheckAuthenticatedValue(
2191 if (Method == AuthCheckMethod::None)
2193 if (Method == AuthCheckMethod::DummyLoad) {
2194 EmitToStreamer(MCInstBuilder(AArch64::LDRWui)
2198 assert(!OnFailure &&
"DummyLoad always traps on error");
2202 MCSymbol *SuccessSym = createTempSymbol(
"auth_success_");
2203 if (Method == AuthCheckMethod::XPAC || Method == AuthCheckMethod::XPACHint) {
2205 emitMovXReg(ScratchReg, TestedReg);
2207 if (Method == AuthCheckMethod::XPAC) {
2211 MCInstBuilder(XPACOpc).addReg(ScratchReg).addReg(ScratchReg));
2216 assert(TestedReg == AArch64::LR &&
2217 "XPACHint mode is only compatible with checking the LR register");
2219 "XPACHint mode is only compatible with I-keys");
2220 EmitToStreamer(MCInstBuilder(AArch64::XPACLRI));
2224 EmitToStreamer(MCInstBuilder(AArch64::SUBSXrs)
2225 .addReg(AArch64::XZR)
2232 MCInstBuilder(AArch64::Bcc)
2235 }
else if (Method == AuthCheckMethod::HighBitsNoTBI) {
2237 EmitToStreamer(MCInstBuilder(AArch64::EORXrs)
2244 MCInstBuilder(AArch64::TBZX)
2255 EmitToStreamer(MCInstBuilder(AArch64::BRK).addImm(0xc470 |
Key));
2269 case AuthCheckMethod::XPACHint:
2272 case AuthCheckMethod::XPAC:
2274 emitMovXReg(TestedReg, ScratchReg);
2281 MCInstBuilder(XPACOpc).addReg(TestedReg).addReg(TestedReg));
2286 EmitToStreamer(MCInstBuilder(AArch64::B).addExpr(OnFailureExpr));
2298void AArch64AsmPrinter::emitPtrauthTailCallHardening(
const MachineInstr *TC) {
2302 auto LRCheckMethod = STI->getAuthenticatedLRCheckMethod(*MF);
2303 if (LRCheckMethod == AArch64PAuth::AuthCheckMethod::None)
2306 const AArch64RegisterInfo *
TRI = STI->getRegisterInfo();
2310 "Neither x16 nor x17 is available as a scratch register");
2313 emitPtrauthCheckAuthenticatedValue(AArch64::LR, ScratchReg,
Key,
2317bool AArch64AsmPrinter::emitDeactivationSymbolRelocation(
Value *DS) {
2323 EmitToStreamer(MCInstBuilder(AArch64::NOP));
2326 MCSymbol *Dot = OutContext.createTempSymbol();
2331 OutContext.getOrCreateSymbol(
DS->getName()), OutContext);
2337AArch64AsmPrinter::PtrAuthSchema AArch64AsmPrinter::PtrAuthSchema::CreateImmReg(
2339 PtrAuthSchema Schema;
2341 Schema.IntDisc = IntDisc;
2342 Schema.AddrDisc = AddrDiscOp.
getReg();
2343 Schema.AddrDiscIsKilled = AddrDiscOp.
isKill();
2348AArch64AsmPrinter::PtrAuthSchema AArch64AsmPrinter::PtrAuthSchema::CreateRegReg(
2350 assert(PCDisc.
isValid() &&
"Use CreateImmReg for non-PC schemas");
2351 PtrAuthSchema Schema;
2354 Schema.AddrDisc = AddrDisc;
2355 Schema.AddrDiscIsKilled =
false;
2356 Schema.PCDisc = PCDisc;
2360void AArch64AsmPrinter::emitPtrauthApplyIndirectAddend(
Register Pointer,
2365 EmitToStreamer(MCInstBuilder(AArch64::LDRSWpre)
2375 for (
int BitPos = 0; BitPos != 24 && (Addend >> BitPos); BitPos += 12) {
2377 MCInstBuilder(AArch64::ADDXri)
2380 .addImm((Addend >> BitPos) & 0xfff)
2386 emitMOVZ(Scratch, Addend & 0xffff, 0);
2393 EmitToStreamer(MCInstBuilder(AArch64::ADDXrs)
2400 EmitToStreamer(MCInstBuilder(AArch64::LDRSWui)
2406 EmitToStreamer(MCInstBuilder(AArch64::ADDXrs)
2417 if (std::optional<PtrauthCheckMode>
Mode =
2424 return PtrauthCheckMode::Unchecked;
2427 return ShouldTrap ? PtrauthCheckMode::Trap : PtrauthCheckMode::Poison;
2458void AArch64AsmPrinter::emitPtrauthAuthResign(
2460 std::optional<PtrAuthSchema> SignSchema, std::optional<int64_t> Addend,
2463 const bool IsAuthWithPC = AuthSchema.PCDisc.isValid();
2464 assert(!SignSchema || !SignSchema->PCDisc.isValid());
2466 Register SignAddrDiscOrNone = SignSchema ? SignSchema->AddrDisc :
Register();
2472 assert(Pointer == AArch64::X17 && Scratch == AArch64::X16 &&
2473 "AUTPCPAC must use x17/x16 as Pointer/Scratch");
2475 assert(AuthSchema.AddrDisc == AArch64::X16 &&
2476 "AUTPCPAC requires address discriminator in X16");
2478 assert(AuthSchema.PCDisc == AArch64::X15 &&
2479 "AUTPCPAC requires PC discriminator in X15");
2481 assert(AuthSchema.IntDisc == 0 &&
"AUTPCPAC does not support IntDisc");
2485 "AUTPCPAC only supports AUT-ing with IA/IB");
2487 if (!emitDeactivationSymbolRelocation(DS)) {
2489 ? AArch64::AUTIB171615
2490 : AArch64::AUTIA171615;
2491 EmitToStreamer(MCInstBuilder(AutOpc));
2501 Register AUTDiscReg = emitPtrauthDiscriminator(
2502 AuthSchema.IntDisc, AuthSchema.AddrDisc, Scratch,
2503 AuthSchema.addrDiscIsKilledAndNoneOf({Pointer, SignAddrDiscOrNone}));
2504 if (!emitDeactivationSymbolRelocation(DS))
2505 emitAUT(AuthSchema.Key, Pointer, AUTDiscReg);
2510 auto EmitCheck = [&](
MCSymbol *OnFailure =
nullptr) {
2511 emitPtrauthCheckAuthenticatedValue(Pointer, Scratch, AuthSchema.Key,
2512 AArch64PAuth::AuthCheckMethod::XPAC,
2516 auto EmitResignOnSuccess = [&]() {
2517 if (Addend.has_value())
2518 emitPtrauthApplyIndirectAddend(Pointer, Scratch, *Addend);
2520 assert(Pointer != SignSchema->AddrDisc &&
"Pointer is early-clobbered");
2522 emitPtrauthDiscriminator(SignSchema->IntDisc, SignSchema->AddrDisc,
2523 Scratch, SignSchema->AddrDiscIsKilled);
2524 emitPAC(SignSchema->Key, Pointer, PACDiscReg);
2530 if (CheckMode == PtrauthCheckMode::Trap)
2536 switch (CheckMode) {
2537 case PtrauthCheckMode::Unchecked:
2538 EmitResignOnSuccess();
2540 case PtrauthCheckMode::Trap:
2542 EmitResignOnSuccess();
2544 case PtrauthCheckMode::Poison:
2545 MCSymbol *OnFailure = createTempSymbol(
"resign_end_");
2546 EmitCheck(OnFailure);
2547 EmitResignOnSuccess();
2553void AArch64AsmPrinter::emitPtrauthSign(
const MachineInstr *
MI) {
2557 Register AddrDisc =
MI->getOperand(4).getReg();
2558 bool AddrDiscKilled =
MI->getOperand(4).isKill();
2562 Register ScratchReg = Val == AArch64::X16 ? AArch64::X17 : AArch64::X16;
2563 assert(ScratchReg != AddrDisc &&
2564 "Neither X16 nor X17 is available as a scratch register");
2567 Register DiscReg = emitPtrauthDiscriminator(
2568 Disc, AddrDisc, ScratchReg, AddrDiscKilled);
2570 if (emitDeactivationSymbolRelocation(
MI->getDeactivationSymbol()))
2573 emitPAC(
Key, Val, DiscReg);
2576void AArch64AsmPrinter::emitPtrauthBranch(
const MachineInstr *
MI) {
2577 bool IsCall =
MI->getOpcode() == AArch64::BLRA;
2578 unsigned BrTarget =
MI->getOperand(0).getReg();
2583 unsigned AddrDisc =
MI->getOperand(3).getReg();
2589 if (BrTarget == AddrDisc)
2606 bool AddrDiscIsImplicitDef =
2607 IsCall && (AddrDisc == AArch64::X16 || AddrDisc == AArch64::X17);
2608 Register DiscReg = emitPtrauthDiscriminator(Disc, AddrDisc, AArch64::X17,
2609 AddrDiscIsImplicitDef);
2610 emitBLRA(IsCall,
Key, BrTarget, DiscReg);
2613void AArch64AsmPrinter::emitAddImm(MCRegister
Reg, int64_t Addend,
2617 const bool IsNeg = Addend < 0;
2619 for (
int BitPos = 0; BitPos != 24 && (AbsOffset >> BitPos);
2622 MCInstBuilder(IsNeg ? AArch64::SUBXri : AArch64::ADDXri)
2625 .addImm((AbsOffset >> BitPos) & 0xfff)
2630 EmitToStreamer(MCInstBuilder(IsNeg ? AArch64::MOVNXi : AArch64::MOVZXi)
2632 .addImm((IsNeg ? ~UAddend : UAddend) & 0xffff)
2634 auto NeedMovk = [IsNeg, UAddend](
int BitPos) ->
bool {
2635 assert(BitPos == 16 || BitPos == 32 || BitPos == 48);
2636 uint64_t Shifted = UAddend >> BitPos;
2638 return Shifted != 0;
2639 for (
int I = 0;
I != 64 - BitPos;
I += 16)
2640 if (((Shifted >>
I) & 0xffff) != 0xffff)
2644 for (
int BitPos = 16; BitPos != 64 && NeedMovk(BitPos); BitPos += 16)
2645 emitMOVK(Tmp, (UAddend >> BitPos) & 0xffff, BitPos);
2647 EmitToStreamer(MCInstBuilder(AArch64::ADDXrs)
2656void AArch64AsmPrinter::emitAddress(MCRegister
Reg,
const MCExpr *Expr,
2657 MCRegister Tmp,
bool DSOLocal,
2658 const MCSubtargetInfo &STI) {
2664 MCInstBuilder(AArch64::ADRP)
2668 EmitToStreamer(MCInstBuilder(AArch64::ADDXri)
2678 MCInstBuilder(AArch64::ADRP)
2683 MCInstBuilder(AArch64::LDRXui)
2694 if (!TT.isOSBinFormatELF())
2698 return TT.isOSGlibc() || TT.isAndroid() || TT.isOSFreeBSD() ||
2699 TT.isOSDragonFly() || TT.isOSNetBSD();
2753const MCExpr *AArch64AsmPrinter::emitPAuthRelocationAsIRelative(
2755 bool HasAddressDiversity,
bool IsDSOLocal,
const MCExpr *DSExpr) {
2756 const Triple &
TT = TM.getTargetTriple();
2768 auto STI = std::make_unique<AArch64Subtarget>(
2769 TT, TM.getTargetCPU(), TM.getTargetCPU(), TM.getTargetFeatureString(), TM,
2778 const MCSymbolELF *Group =
2793 .addReg(AArch64::X0)
2798 emitAddress(AArch64::X0, Target, AArch64::X16, IsDSOLocal, *STI);
2800 if (HasAddressDiversity) {
2805 emitAddress(AArch64::X1, PlacePlusDisc, AArch64::X16,
true,
2809 OutContext.reportError(SMLoc(),
"AArch64 PAC Discriminator '" +
2811 "' out of range [0, 0xFFFF]");
2813 emitMOVZ(AArch64::X1, Disc, 0);
2820 auto *PrePACInstExpr =
2832 const MCSymbolRefExpr *EmuPACRef =
2834 OutStreamer->
emitInstruction(MCInstBuilder(AArch64::B).addExpr(EmuPACRef),
2841 MCInstBuilder(AArch64::RET).addReg(AArch64::LR), *STI);
2850AArch64AsmPrinter::lowerConstantPtrAuth(
const ConstantPtrAuth &CPA) {
2851 MCContext &Ctx = OutContext;
2856 getDataLayout(),
Offset,
true);
2876 const MCExpr *DSExpr =
nullptr;
2888 "' out of range [0, " +
2896 if (
auto *IFuncSym = emitPAuthRelocationAsIRelative(
2898 BaseGVB && BaseGVB->isDSOLocal(), DSExpr))
2903 "' out of range [0, 0xFFFF]");
2909 "expressions on this target");
2916void AArch64AsmPrinter::LowerLOADauthptrstatic(
const MachineInstr &
MI) {
2917 unsigned DstReg =
MI.getOperand(0).getReg();
2918 const MachineOperand &GAOp =
MI.getOperand(1);
2919 const uint64_t KeyC =
MI.getOperand(2).getImm();
2921 "key is out of range [0, AArch64PACKey::LAST]");
2923 const uint64_t Disc =
MI.getOperand(3).getImm();
2925 "constant discriminator is out of range [0, 0xffff]");
2934 if (TM.getTargetTriple().isOSBinFormatELF()) {
2936 static_cast<const AArch64_ELFTargetObjectFile &
>(getObjFileLowering());
2939 "non-zero offset for $auth_ptr$ stub slots is not supported");
2941 AuthPtrStubSym = TLOF.getAuthPtrSlotSymbol(TM, MMI, GASym,
Key, Disc);
2943 assert(TM.getTargetTriple().isOSBinFormatMachO() &&
2944 "LOADauthptrstatic is implemented only for MachO/ELF");
2946 const auto &TLOF =
static_cast<const AArch64_MachoTargetObjectFile &
>(
2947 getObjFileLowering());
2950 "non-zero offset for $auth_ptr$ stub slots is not supported");
2952 AuthPtrStubSym = TLOF.getAuthPtrSlotSymbol(TM, MMI, GASym,
Key, Disc);
2955 MachineOperand StubMOHi =
2959 MCOperand StubMCHi, StubMCLo;
2966 MCInstBuilder(AArch64::ADRP).addReg(DstReg).
addOperand(StubMCHi));
2968 EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::LDRXui)
2974void AArch64AsmPrinter::LowerMOVaddrPAC(
const MachineInstr &
MI) {
2975 const bool IsGOTLoad =
MI.getOpcode() == AArch64::LOADgotPAC;
2976 const bool IsELFSignedGOT =
MI.getParent()
2978 ->getInfo<AArch64FunctionInfo>()
2979 ->hasELFSignedGOT();
2980 MachineOperand GAOp =
MI.getOperand(0);
2981 const uint64_t KeyC =
MI.getOperand(1).getImm();
2983 "key is out of range [0, AArch64PACKey::LAST]");
2985 const unsigned AddrDisc =
MI.getOperand(2).getReg();
2986 const uint64_t Disc =
MI.getOperand(3).getImm();
3033 MachineOperand GAMOHi(GAOp), GAMOLo(GAOp);
3034 MCOperand GAMCHi, GAMCLo;
3047 MCInstBuilder(AArch64::ADRP)
3048 .addReg(IsGOTLoad && IsELFSignedGOT ? AArch64::X17 : AArch64::X16)
3052 if (IsELFSignedGOT) {
3053 EmitToStreamer(MCInstBuilder(AArch64::ADDXri)
3054 .addReg(AArch64::X17)
3055 .addReg(AArch64::X17)
3059 EmitToStreamer(MCInstBuilder(AArch64::LDRXui)
3060 .addReg(AArch64::X16)
3061 .addReg(AArch64::X17)
3069 emitAUT(AuthKey, AArch64::X16, AArch64::X17);
3071 if (!STI->hasFPAC())
3072 emitPtrauthCheckAuthenticatedValue(AArch64::X16, AArch64::X17, AuthKey,
3073 AArch64PAuth::AuthCheckMethod::XPAC);
3075 EmitToStreamer(MCInstBuilder(AArch64::LDRXui)
3076 .addReg(AArch64::X16)
3077 .addReg(AArch64::X16)
3081 EmitToStreamer(MCInstBuilder(AArch64::ADDXri)
3082 .addReg(AArch64::X16)
3083 .addReg(AArch64::X16)
3088 emitAddImm(AArch64::X16,
Offset, AArch64::X17);
3089 Register DiscReg = emitPtrauthDiscriminator(Disc, AddrDisc, AArch64::X17);
3091 emitPAC(
Key, AArch64::X16, DiscReg);
3094void AArch64AsmPrinter::LowerLOADgotAUTH(
const MachineInstr &
MI) {
3096 Register AuthResultReg = STI->hasFPAC() ? DstReg : AArch64::X16;
3097 const MachineOperand &GAMO =
MI.getOperand(1);
3104 MCInstBuilder(AArch64::ADR).addReg(AArch64::X17).
addOperand(GAMC));
3105 EmitToStreamer(MCInstBuilder(AArch64::LDRXui)
3106 .addReg(AuthResultReg)
3107 .addReg(AArch64::X17)
3110 MachineOperand GAHiOp(GAMO);
3111 MachineOperand GALoOp(GAMO);
3115 MCOperand GAMCHi, GAMCLo;
3120 MCInstBuilder(AArch64::ADRP).addReg(AArch64::X17).
addOperand(GAMCHi));
3122 EmitToStreamer(MCInstBuilder(AArch64::ADDXri)
3123 .addReg(AArch64::X17)
3124 .addReg(AArch64::X17)
3128 EmitToStreamer(MCInstBuilder(AArch64::LDRXui)
3129 .addReg(AuthResultReg)
3130 .addReg(AArch64::X17)
3137 UndefWeakSym = createTempSymbol(
"undef_weak");
3139 MCInstBuilder(AArch64::CBZX)
3140 .addReg(AuthResultReg)
3148 emitAUT(AuthKey, AuthResultReg, AArch64::X17);
3153 if (!STI->hasFPAC()) {
3154 emitPtrauthCheckAuthenticatedValue(AuthResultReg, AArch64::X17, AuthKey,
3155 AArch64PAuth::AuthCheckMethod::XPAC);
3157 emitMovXReg(DstReg, AuthResultReg);
3162AArch64AsmPrinter::lowerBlockAddressConstant(
const BlockAddress &BA) {
3166 if (std::optional<uint16_t> BADisc =
3167 STI->getPtrAuthBlockAddressDiscriminatorIfEnabled(Fn))
3174void AArch64AsmPrinter::emitCBPseudoExpansion(
const MachineInstr *
MI) {
3178 switch (
MI->getOpcode()) {
3181 case AArch64::CBBAssertExt:
3185 case AArch64::CBHAssertExt:
3189 case AArch64::CBWPrr:
3192 case AArch64::CBXPrr:
3195 case AArch64::CBWPri:
3199 case AArch64::CBXPri:
3207 bool NeedsRegSwap =
false;
3208 bool NeedsImmDec =
false;
3209 bool NeedsImmInc =
false;
3211#define GET_CB_OPC(IsImm, Width, ImmCond, RegCond) \
3213 ? (Width == 32 ? AArch64::CB##ImmCond##Wri : AArch64::CB##ImmCond##Xri) \
3215 ? AArch64::CBB##RegCond##Wrr \
3216 : (Width == 16 ? AArch64::CBH##RegCond##Wrr \
3217 : (Width == 32 ? AArch64::CB##RegCond##Wrr \
3218 : AArch64::CB##RegCond##Xrr))))
3234 NeedsImmDec = IsImm;
3238 NeedsRegSwap = !IsImm;
3245 NeedsRegSwap = !IsImm;
3246 NeedsImmInc = IsImm;
3250 NeedsImmDec = IsImm;
3254 NeedsRegSwap = !IsImm;
3261 NeedsRegSwap = !IsImm;
3262 NeedsImmInc = IsImm;
3270 MCOperand Lhs, Rhs, Trgt;
3271 lowerOperand(
MI->getOperand(1), Lhs);
3272 lowerOperand(
MI->getOperand(2), Rhs);
3273 lowerOperand(
MI->getOperand(3), Trgt);
3277 assert(Lhs.
isReg() &&
"Expected register operand for CB");
3278 assert(Rhs.
isReg() &&
"Expected register operand for CB");
3281 }
else if (NeedsImmDec) {
3285 }
else if (NeedsImmInc) {
3295 "CB immediate operand out-of-bounds");
3298 EmitToStreamer(*OutStreamer, Inst);
3301void AArch64AsmPrinter::emitAtomicHintPseudoExpansion(
const MachineInstr *
MI) {
3304 unsigned Relaxed =
MI->getOperand(2).getImm();
3305 assert(
Relaxed < 2 &&
"Atomic hint relaxed immediate out-of-bounds");
3306 switch (
MI->getOpcode()) {
3307 case AArch64::ATOMIC_STORE_HINT_B:
3308 StOpc =
Relaxed ? AArch64::STRBBui : AArch64::STLRB;
3310 case AArch64::ATOMIC_STORE_HINT_H:
3311 StOpc =
Relaxed ? AArch64::STRHHui : AArch64::STLRH;
3313 case AArch64::ATOMIC_STORE_HINT_W:
3314 StOpc =
Relaxed ? AArch64::STRWui : AArch64::STLRW;
3316 case AArch64::ATOMIC_STORE_HINT_X:
3317 StOpc =
Relaxed ? AArch64::STRXui : AArch64::STLRX;
3324 MCInstBuilder(AArch64::HINT).addImm(
MI->getOperand(3).getImm()));
3327 Store.setOpcode(StOpc);
3330 Store.setFlags(
MI->getFlags());
3333 EmitToStreamer(*OutStreamer,
Store);
3336void AArch64AsmPrinter::emitAtomicHintPseudoExpansionRO(
3337 const MachineInstr *
MI) {
3339 assert(
MI->getOperand(5).getImm() == 1 &&
3340 "Atomic store addressing mode only supports relaxed stores");
3342 switch (
MI->getOpcode()) {
3343 case AArch64::ATOMIC_STORE_HINT_BroW:
3344 StOpc = AArch64::STRBBroW;
3346 case AArch64::ATOMIC_STORE_HINT_HroW:
3347 StOpc = AArch64::STRHHroW;
3349 case AArch64::ATOMIC_STORE_HINT_WroW:
3350 StOpc = AArch64::STRWroW;
3352 case AArch64::ATOMIC_STORE_HINT_XroW:
3353 StOpc = AArch64::STRXroW;
3355 case AArch64::ATOMIC_STORE_HINT_SroW:
3356 StOpc = AArch64::STRSroW;
3358 case AArch64::ATOMIC_STORE_HINT_DroW:
3359 StOpc = AArch64::STRDroW;
3361 case AArch64::ATOMIC_STORE_HINT_BroX:
3362 StOpc = AArch64::STRBBroX;
3364 case AArch64::ATOMIC_STORE_HINT_HroX:
3365 StOpc = AArch64::STRHHroX;
3367 case AArch64::ATOMIC_STORE_HINT_WroX:
3368 StOpc = AArch64::STRWroX;
3370 case AArch64::ATOMIC_STORE_HINT_XroX:
3371 StOpc = AArch64::STRXroX;
3373 case AArch64::ATOMIC_STORE_HINT_SroX:
3374 StOpc = AArch64::STRSroX;
3376 case AArch64::ATOMIC_STORE_HINT_DroX:
3377 StOpc = AArch64::STRDroX;
3384 MCInstBuilder(AArch64::HINT).addImm(
MI->getOperand(6).getImm()));
3387 Store.setOpcode(StOpc);
3393 Store.setFlags(
MI->getFlags());
3394 EmitToStreamer(*OutStreamer,
Store);
3397void AArch64AsmPrinter::emitAtomicHintPseudoExpansionImm(
3398 const MachineInstr *
MI) {
3400 assert(
MI->getOperand(3).getImm() == 1 &&
3401 "Atomic store addressing mode only supports relaxed stores");
3403 switch (
MI->getOpcode()) {
3404 case AArch64::ATOMIC_STORE_HINT_Bui:
3405 StOpc = AArch64::STRBBui;
3407 case AArch64::ATOMIC_STORE_HINT_Hui:
3408 StOpc = AArch64::STRHHui;
3410 case AArch64::ATOMIC_STORE_HINT_Wui:
3411 StOpc = AArch64::STRWui;
3413 case AArch64::ATOMIC_STORE_HINT_Xui:
3414 StOpc = AArch64::STRXui;
3416 case AArch64::ATOMIC_STORE_HINT_Sui:
3417 StOpc = AArch64::STRSui;
3419 case AArch64::ATOMIC_STORE_HINT_Dui:
3420 StOpc = AArch64::STRDui;
3422 case AArch64::ATOMIC_STORE_HINT_Bi:
3423 StOpc = AArch64::STURBBi;
3425 case AArch64::ATOMIC_STORE_HINT_Hi:
3426 StOpc = AArch64::STURHHi;
3428 case AArch64::ATOMIC_STORE_HINT_Wi:
3429 StOpc = AArch64::STURWi;
3431 case AArch64::ATOMIC_STORE_HINT_Xi:
3432 StOpc = AArch64::STURXi;
3434 case AArch64::ATOMIC_STORE_HINT_Si:
3435 StOpc = AArch64::STURSi;
3437 case AArch64::ATOMIC_STORE_HINT_Di:
3438 StOpc = AArch64::STURDi;
3445 MCInstBuilder(AArch64::HINT).addImm(
MI->getOperand(4).getImm()));
3448 Store.setOpcode(StOpc);
3452 Store.setFlags(
MI->getFlags());
3453 EmitToStreamer(*OutStreamer,
Store);
3456void AArch64AsmPrinter::emitAtomicFetchHintPseudoExpansion(
3457 const MachineInstr *
MI) {
3459 MCInstBuilder(AArch64::HINT).addImm(
MI->getOperand(4).getImm()));
3467 EmitToStreamer(*OutStreamer, Fetch);
3472#include "AArch64GenMCPseudoLowering.inc"
3474void AArch64AsmPrinter::EmitToStreamer(MCStreamer &S,
const MCInst &Inst) {
3481void AArch64AsmPrinter::emitInstruction(
const MachineInstr *
MI) {
3482 emitInstructionImpl(
MI);
3483 if (!
MI->isBundledWithSucc())
3486 const MachineInstr *EndProc =
MI->getNextNode();
3487 assert(
MI->isTerminator() &&
"Unexpected late AArch64 bundle head");
3490 "Unexpected late AArch64 bundle member");
3491 emitInstructionImpl(EndProc);
3494void AArch64AsmPrinter::emitInstructionImpl(
const MachineInstr *
MI) {
3495 AArch64_MC::verifyInstructionPredicates(
MI->getOpcode(), STI->
getFeatureBits());
3500 assert(STI->getInstrInfo()->getInstSizeInBytes(*
MI) >= InstsEmitted * 4);
3505 if (MCInst OutInst; lowerPseudoInstExpansion(
MI, OutInst)) {
3506 EmitToStreamer(*OutStreamer, OutInst);
3510 if (
MI->getOpcode() == AArch64::ADRP) {
3511 for (
auto &Opd :
MI->operands()) {
3512 if (Opd.isSymbol() && StringRef(Opd.getSymbolName()) ==
3513 "swift_async_extendedFramePointerFlags") {
3514 ShouldEmitWeakSwiftAsyncExtendedFramePointerFlags =
true;
3521 MCSymbol *LOHLabel = createTempSymbol(
"loh");
3523 LOHInstToLabel[
MI] = LOHLabel;
3527 AArch64TargetStreamer *TS =
3530 switch (
MI->getOpcode()) {
3533 "Unhandled tail call instruction");
3535 case AArch64::READ_REGISTER_GPR64:
3539 EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::ORRXrs)
3540 .addReg(
MI->getOperand(0).getReg())
3541 .addReg(AArch64::XZR)
3542 .addReg(
MI->getOperand(1).getImm())
3545 case AArch64::READ_REGISTER_FPR64:
3547 EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::FMOVDr)
3548 .addReg(
MI->getOperand(0).getReg())
3549 .addReg(
MI->getOperand(1).getImm()));
3551 case AArch64::HINT: {
3556 if (CurrentPatchableFunctionEntrySym &&
3557 CurrentPatchableFunctionEntrySym == CurrentFnBegin &&
3559 int64_t
Imm =
MI->getOperand(0).getImm();
3560 if (
Imm == 32 ||
Imm == 34 ||
Imm == 36 ||
Imm == 38) {
3562 MCInstLowering.
Lower(
MI, Inst);
3563 EmitToStreamer(*OutStreamer, Inst);
3564 CurrentPatchableFunctionEntrySym = createTempSymbol(
"patch");
3565 OutStreamer->
emitLabel(CurrentPatchableFunctionEntrySym);
3571 case AArch64::MOVMCSym: {
3572 Register DestReg =
MI->getOperand(0).getReg();
3573 const MachineOperand &MO_Sym =
MI->getOperand(1);
3574 MachineOperand Hi_MOSym(MO_Sym), Lo_MOSym(MO_Sym);
3575 MCOperand Hi_MCSym, Lo_MCSym;
3588 EmitToStreamer(*OutStreamer, MovZ);
3596 EmitToStreamer(*OutStreamer, MovK);
3599 case AArch64::MOVIv2d_ns:
3607 if (STI->hasZeroCycleZeroingFPWorkaround() &&
3608 MI->getOperand(1).getImm() == 0) {
3610 TmpInst.
setOpcode(AArch64::MOVIv16b_ns);
3613 EmitToStreamer(*OutStreamer, TmpInst);
3618 case AArch64::DBG_VALUE:
3619 case AArch64::DBG_VALUE_LIST:
3621 SmallString<128> TmpStr;
3622 raw_svector_ostream OS(TmpStr);
3623 PrintDebugValueComment(
MI, OS);
3628 case AArch64::EMITBKEY:
3629 case AArch64::EMITNONHINTED: {
3631 if (ExceptionHandlingType != ExceptionHandling::DwarfCFI &&
3632 ExceptionHandlingType != ExceptionHandling::ARM)
3635 if (getFunctionCFISectionType(*MF) == CFISection::None)
3638 if (
MI->getOpcode() == AArch64::EMITBKEY)
3646 case AArch64::EMITMTETAGGED: {
3648 if (ExceptionHandlingType != ExceptionHandling::DwarfCFI &&
3649 ExceptionHandlingType != ExceptionHandling::ARM)
3652 if (getFunctionCFISectionType(*MF) != CFISection::None)
3657 case AArch64::AUTx16x17: {
3659 const Register Scratch = AArch64::X17;
3661 auto AuthSchema = PtrAuthSchema::CreateImmReg(
3663 MI->getOperand(1).getImm(),
MI->getOperand(2));
3665 emitPtrauthAuthResign(Pointer, Scratch, AuthSchema, std::nullopt,
3666 std::nullopt,
MI->getDeactivationSymbol());
3670 case AArch64::AUTxMxN: {
3672 const Register Scratch =
MI->getOperand(1).getReg();
3674 auto AuthSchema = PtrAuthSchema::CreateImmReg(
3676 MI->getOperand(4).getImm(),
MI->getOperand(5));
3678 emitPtrauthAuthResign(Pointer, Scratch, AuthSchema, std::nullopt,
3679 std::nullopt,
MI->getDeactivationSymbol());
3683 case AArch64::AUTPAC: {
3685 const Register Scratch = AArch64::X17;
3687 auto AuthSchema = PtrAuthSchema::CreateImmReg(
3689 MI->getOperand(1).getImm(),
MI->getOperand(2));
3691 auto SignSchema = PtrAuthSchema::CreateImmReg(
3693 MI->getOperand(4).getImm(),
MI->getOperand(5));
3695 emitPtrauthAuthResign(Pointer, Scratch, AuthSchema, SignSchema,
3696 std::nullopt,
MI->getDeactivationSymbol());
3700 case AArch64::AUTPCPAC: {
3701 auto AuthSchema = PtrAuthSchema::CreateRegReg(
3705 auto SignSchema = PtrAuthSchema::CreateImmReg(
3707 MI->getOperand(2).getImm(),
MI->getOperand(3));
3709 emitPtrauthAuthResign(AArch64::X17, AArch64::X16,
3710 AuthSchema, SignSchema, std::nullopt,
3711 MI->getDeactivationSymbol());
3715 case AArch64::AUTRELLOADPAC: {
3717 const Register Scratch = AArch64::X17;
3719 auto AuthSchema = PtrAuthSchema::CreateImmReg(
3721 MI->getOperand(1).getImm(),
MI->getOperand(2));
3723 auto SignSchema = PtrAuthSchema::CreateImmReg(
3725 MI->getOperand(4).getImm(),
MI->getOperand(5));
3727 emitPtrauthAuthResign(Pointer, Scratch, AuthSchema, SignSchema,
3728 MI->getOperand(6).getImm(),
3729 MI->getDeactivationSymbol());
3735 emitPtrauthSign(
MI);
3738 case AArch64::LOADauthptrstatic:
3739 LowerLOADauthptrstatic(*
MI);
3742 case AArch64::LOADgotPAC:
3743 case AArch64::MOVaddrPAC:
3744 LowerMOVaddrPAC(*
MI);
3747 case AArch64::LOADgotAUTH:
3748 LowerLOADgotAUTH(*
MI);
3753 emitPtrauthBranch(
MI);
3759 case AArch64::AUTH_TCRETURN:
3760 case AArch64::AUTH_TCRETURN_BTI: {
3763 const uint64_t Disc =
MI->getOperand(3).getImm();
3765 Register AddrDisc =
MI->getOperand(4).getReg();
3767 Register ScratchReg =
Callee == AArch64::X16 ? AArch64::X17 : AArch64::X16;
3769 emitPtrauthTailCallHardening(
MI);
3772 if (Callee == AddrDisc)
3779 bool AddrDiscIsImplicitDef =
3780 AddrDisc == AArch64::X16 || AddrDisc == AArch64::X17;
3781 Register DiscReg = emitPtrauthDiscriminator(Disc, AddrDisc, ScratchReg,
3782 AddrDiscIsImplicitDef);
3783 emitBLRA(
false,
Key, Callee, DiscReg);
3787 case AArch64::TCRETURNri:
3788 case AArch64::TCRETURNrix16x17:
3789 case AArch64::TCRETURNrix17:
3790 case AArch64::TCRETURNrinotx16:
3791 case AArch64::TCRETURNriALL: {
3792 emitPtrauthTailCallHardening(
MI);
3794 recordIfImportCall(
MI);
3798 EmitToStreamer(*OutStreamer, TmpInst);
3801 case AArch64::TCRETURNdi: {
3802 emitPtrauthTailCallHardening(
MI);
3806 recordIfImportCall(
MI);
3810 EmitToStreamer(*OutStreamer, TmpInst);
3813 case AArch64::SpeculationBarrierISBDSBEndBB: {
3818 EmitToStreamer(*OutStreamer, TmpInstDSB);
3822 EmitToStreamer(*OutStreamer, TmpInstISB);
3825 case AArch64::SpeculationBarrierSBEndBB: {
3829 EmitToStreamer(*OutStreamer, TmpInstSB);
3832 case AArch64::TLSDESC_AUTH_CALLSEQ: {
3840 const MachineOperand &MO_Sym =
MI->getOperand(0);
3841 MachineOperand MO_TLSDESC_LO12(MO_Sym), MO_TLSDESC(MO_Sym);
3842 MCOperand Sym, SymTLSDescLo12, SymTLSDesc;
3846 MCInstLowering.
lowerOperand(MO_TLSDESC_LO12, SymTLSDescLo12);
3853 EmitToStreamer(*OutStreamer, Adrp);
3861 EmitToStreamer(*OutStreamer, Ldr);
3864 Add.setOpcode(AArch64::ADDXri);
3867 Add.addOperand(SymTLSDescLo12);
3869 EmitToStreamer(*OutStreamer,
Add);
3873 MCInst TLSAuthDescCall;
3874 TLSAuthDescCall.
setOpcode(AArch64::TLSAUTHDESCCALL);
3876 EmitToStreamer(*OutStreamer, TLSAuthDescCall);
3885 EmitToStreamer(*OutStreamer, Blraa);
3889 case AArch64::TLSDESC_CALLSEQ: {
3897 const MachineOperand &MO_Sym =
MI->getOperand(0);
3898 MachineOperand MO_TLSDESC_LO12(MO_Sym), MO_TLSDESC(MO_Sym);
3899 MCOperand Sym, SymTLSDescLo12, SymTLSDesc;
3903 MCInstLowering.
lowerOperand(MO_TLSDESC_LO12, SymTLSDescLo12);
3910 EmitToStreamer(*OutStreamer, Adrp);
3913 if (STI->isTargetILP32()) {
3923 EmitToStreamer(*OutStreamer, Ldr);
3926 if (STI->isTargetILP32()) {
3927 Add.setOpcode(AArch64::ADDWri);
3931 Add.setOpcode(AArch64::ADDXri);
3935 Add.addOperand(SymTLSDescLo12);
3937 EmitToStreamer(*OutStreamer,
Add);
3942 TLSDescCall.
setOpcode(AArch64::TLSDESCCALL);
3944 EmitToStreamer(*OutStreamer, TLSDescCall);
3952 EmitToStreamer(*OutStreamer, Blr);
3957 case AArch64::JumpTableDest32:
3958 case AArch64::JumpTableDest16:
3959 case AArch64::JumpTableDest8:
3960 LowerJumpTableDest(*OutStreamer, *
MI);
3963 case AArch64::BR_JumpTable:
3964 LowerHardenedBRJumpTable(*
MI);
3967 case AArch64::FMOVH0:
3968 case AArch64::FMOVS0:
3969 case AArch64::FMOVD0:
3973 case AArch64::MOPSMemoryCopyPseudo:
3974 case AArch64::MOPSMemoryMovePseudo:
3975 case AArch64::MOPSMemorySetPseudo:
3976 case AArch64::MOPSMemorySetTaggingPseudo:
3977 LowerMOPS(*OutStreamer, *
MI);
3980 case TargetOpcode::STACKMAP:
3981 return LowerSTACKMAP(*OutStreamer, SM, *
MI);
3983 case TargetOpcode::PATCHPOINT:
3984 return LowerPATCHPOINT(*OutStreamer, SM, *
MI);
3986 case TargetOpcode::STATEPOINT:
3987 return LowerSTATEPOINT(*OutStreamer, SM, *
MI);
3989 case TargetOpcode::FAULTING_OP:
3990 return LowerFAULTING_OP(*
MI);
3992 case TargetOpcode::PATCHABLE_FUNCTION_ENTER:
3993 LowerPATCHABLE_FUNCTION_ENTER(*
MI);
3996 case TargetOpcode::PATCHABLE_FUNCTION_EXIT:
3997 LowerPATCHABLE_FUNCTION_EXIT(*
MI);
4000 case TargetOpcode::PATCHABLE_TAIL_CALL:
4001 LowerPATCHABLE_TAIL_CALL(*
MI);
4003 case TargetOpcode::PATCHABLE_EVENT_CALL:
4004 return LowerPATCHABLE_EVENT_CALL(*
MI,
false);
4005 case TargetOpcode::PATCHABLE_TYPED_EVENT_CALL:
4006 return LowerPATCHABLE_EVENT_CALL(*
MI,
true);
4008 case AArch64::KCFI_CHECK:
4009 LowerKCFI_CHECK(*
MI);
4012 case AArch64::HWASAN_CHECK_MEMACCESS:
4013 case AArch64::HWASAN_CHECK_MEMACCESS_SHORTGRANULES:
4014 case AArch64::HWASAN_CHECK_MEMACCESS_FIXEDSHADOW:
4015 case AArch64::HWASAN_CHECK_MEMACCESS_SHORTGRANULES_FIXEDSHADOW:
4016 LowerHWASAN_CHECK_MEMACCESS(*
MI);
4019 case AArch64::SEH_StartProc:
4021 assert(!ExplicitWinCFIRangeOpen &&
"Starting an explicit Windows CFI range "
4022 "before ending the previous one");
4023 ExplicitWinCFIRangeOpen =
true;
4024 EmittedExplicitWinCFIRange =
true;
4029 case AArch64::SEH_EndProc:
4031 assert(ExplicitWinCFIRangeOpen &&
4032 "Ending an explicit Windows CFI range without a matching start");
4033 ExplicitWinCFIRangeOpen =
false;
4039 case AArch64::SEH_EndC:
4043 case AArch64::SEH_StackAlloc:
4047 case AArch64::SEH_SaveFPLR:
4051 case AArch64::SEH_SaveFPLR_X:
4052 assert(
MI->getOperand(0).getImm() < 0 &&
4053 "Pre increment SEH opcode must have a negative offset");
4057 case AArch64::SEH_SaveReg:
4059 MI->getOperand(1).getImm());
4062 case AArch64::SEH_SaveReg_X:
4063 assert(
MI->getOperand(1).getImm() < 0 &&
4064 "Pre increment SEH opcode must have a negative offset");
4066 -
MI->getOperand(1).getImm());
4069 case AArch64::SEH_SaveRegP:
4070 if (
MI->getOperand(1).getImm() == 30 &&
MI->getOperand(0).getImm() >= 19 &&
4071 MI->getOperand(0).getImm() <= 28) {
4072 assert((
MI->getOperand(0).getImm() - 19) % 2 == 0 &&
4073 "Register paired with LR must be odd");
4075 MI->getOperand(2).getImm());
4078 assert((
MI->getOperand(1).getImm() -
MI->getOperand(0).getImm() == 1) &&
4079 "Non-consecutive registers not allowed for save_regp");
4081 MI->getOperand(2).getImm());
4084 case AArch64::SEH_SaveRegP_X:
4085 assert((
MI->getOperand(1).getImm() -
MI->getOperand(0).getImm() == 1) &&
4086 "Non-consecutive registers not allowed for save_regp_x");
4087 assert(
MI->getOperand(2).getImm() < 0 &&
4088 "Pre increment SEH opcode must have a negative offset");
4090 -
MI->getOperand(2).getImm());
4093 case AArch64::SEH_SaveFReg:
4095 MI->getOperand(1).getImm());
4098 case AArch64::SEH_SaveFReg_X:
4099 assert(
MI->getOperand(1).getImm() < 0 &&
4100 "Pre increment SEH opcode must have a negative offset");
4102 -
MI->getOperand(1).getImm());
4105 case AArch64::SEH_SaveFRegP:
4106 assert((
MI->getOperand(1).getImm() -
MI->getOperand(0).getImm() == 1) &&
4107 "Non-consecutive registers not allowed for save_regp");
4109 MI->getOperand(2).getImm());
4112 case AArch64::SEH_SaveFRegP_X:
4113 assert((
MI->getOperand(1).getImm() -
MI->getOperand(0).getImm() == 1) &&
4114 "Non-consecutive registers not allowed for save_regp_x");
4115 assert(
MI->getOperand(2).getImm() < 0 &&
4116 "Pre increment SEH opcode must have a negative offset");
4118 -
MI->getOperand(2).getImm());
4121 case AArch64::SEH_SetFP:
4125 case AArch64::SEH_AddFP:
4129 case AArch64::SEH_Nop:
4133 case AArch64::SEH_PrologEnd:
4137 case AArch64::SEH_EpilogStart:
4141 case AArch64::SEH_EpilogEnd:
4145 case AArch64::SEH_PACSignLR:
4149 case AArch64::SEH_SaveAnyRegI:
4151 "SaveAnyRegI SEH opcode offset must fit into 6 bits");
4153 MI->getOperand(1).getImm());
4156 case AArch64::SEH_SaveAnyRegIP:
4157 assert(
MI->getOperand(1).getImm() -
MI->getOperand(0).getImm() == 1 &&
4158 "Non-consecutive registers not allowed for save_any_reg");
4160 "SaveAnyRegIP SEH opcode offset must fit into 6 bits");
4162 MI->getOperand(2).getImm());
4165 case AArch64::SEH_SaveAnyRegQ:
4167 "SaveAnyRegQ SEH opcode offset must fit into 6 bits");
4169 MI->getOperand(1).getImm());
4172 case AArch64::SEH_SaveAnyRegQX:
4174 "SaveAnyRegQX SEH opcode offset must fit into 6 bits");
4176 -
MI->getOperand(1).getImm());
4179 case AArch64::SEH_SaveAnyRegQP:
4180 assert(
MI->getOperand(1).getImm() -
MI->getOperand(0).getImm() == 1 &&
4181 "Non-consecutive registers not allowed for save_any_reg");
4183 "SaveAnyRegQP SEH opcode offset must fit into 6 bits");
4185 MI->getOperand(2).getImm());
4188 case AArch64::SEH_SaveAnyRegQPX:
4189 assert(
MI->getOperand(1).getImm() -
MI->getOperand(0).getImm() == 1 &&
4190 "Non-consecutive registers not allowed for save_any_reg");
4192 "SaveAnyRegQPX SEH opcode offset must fit into 6 bits");
4194 -
MI->getOperand(2).getImm());
4197 case AArch64::SEH_AllocZ:
4198 assert(
MI->getOperand(0).getImm() >= 0 &&
4199 "AllocZ SEH opcode offset must be non-negative");
4200 assert(
MI->getOperand(0).getImm() <= 255 &&
4201 "AllocZ SEH opcode offset must fit into 8 bits");
4205 case AArch64::SEH_SaveZReg:
4206 assert(
MI->getOperand(1).getImm() >= 0 &&
4207 "SaveZReg SEH opcode offset must be non-negative");
4208 assert(
MI->getOperand(1).getImm() <= 255 &&
4209 "SaveZReg SEH opcode offset must fit into 8 bits");
4211 MI->getOperand(1).getImm());
4214 case AArch64::SEH_SavePReg:
4215 assert(
MI->getOperand(1).getImm() >= 0 &&
4216 "SavePReg SEH opcode offset must be non-negative");
4217 assert(
MI->getOperand(1).getImm() <= 255 &&
4218 "SavePReg SEH opcode offset must fit into 8 bits");
4220 MI->getOperand(1).getImm());
4225 recordIfImportCall(
MI);
4227 MCInstLowering.
Lower(
MI, TmpInst);
4228 EmitToStreamer(*OutStreamer, TmpInst);
4231 case AArch64::CBWPri:
4232 case AArch64::CBXPri:
4233 case AArch64::CBBAssertExt:
4234 case AArch64::CBHAssertExt:
4235 case AArch64::CBWPrr:
4236 case AArch64::CBXPrr:
4237 emitCBPseudoExpansion(
MI);
4239 case AArch64::ATOMIC_STORE_HINT_B:
4240 case AArch64::ATOMIC_STORE_HINT_H:
4241 case AArch64::ATOMIC_STORE_HINT_W:
4242 case AArch64::ATOMIC_STORE_HINT_X:
4243 emitAtomicHintPseudoExpansion(
MI);
4245 case AArch64::ATOMIC_FETCH_HINT_W:
4246 case AArch64::ATOMIC_FETCH_HINT_X:
4247 emitAtomicFetchHintPseudoExpansion(
MI);
4249 case AArch64::ATOMIC_STORE_HINT_BroW:
4250 case AArch64::ATOMIC_STORE_HINT_HroW:
4251 case AArch64::ATOMIC_STORE_HINT_WroW:
4252 case AArch64::ATOMIC_STORE_HINT_XroW:
4253 case AArch64::ATOMIC_STORE_HINT_SroW:
4254 case AArch64::ATOMIC_STORE_HINT_DroW:
4255 case AArch64::ATOMIC_STORE_HINT_BroX:
4256 case AArch64::ATOMIC_STORE_HINT_HroX:
4257 case AArch64::ATOMIC_STORE_HINT_WroX:
4258 case AArch64::ATOMIC_STORE_HINT_XroX:
4259 case AArch64::ATOMIC_STORE_HINT_SroX:
4260 case AArch64::ATOMIC_STORE_HINT_DroX:
4261 emitAtomicHintPseudoExpansionRO(
MI);
4263 case AArch64::ATOMIC_STORE_HINT_Bui:
4264 case AArch64::ATOMIC_STORE_HINT_Hui:
4265 case AArch64::ATOMIC_STORE_HINT_Wui:
4266 case AArch64::ATOMIC_STORE_HINT_Xui:
4267 case AArch64::ATOMIC_STORE_HINT_Sui:
4268 case AArch64::ATOMIC_STORE_HINT_Dui:
4269 case AArch64::ATOMIC_STORE_HINT_Bi:
4270 case AArch64::ATOMIC_STORE_HINT_Hi:
4271 case AArch64::ATOMIC_STORE_HINT_Wi:
4272 case AArch64::ATOMIC_STORE_HINT_Xi:
4273 case AArch64::ATOMIC_STORE_HINT_Si:
4274 case AArch64::ATOMIC_STORE_HINT_Di:
4275 emitAtomicHintPseudoExpansionImm(
MI);
4279 if (emitDeactivationSymbolRelocation(
MI->getDeactivationSymbol()))
4284 MCInstLowering.
Lower(
MI, TmpInst);
4285 EmitToStreamer(*OutStreamer, TmpInst);
4288void AArch64AsmPrinter::recordIfImportCall(
4289 const llvm::MachineInstr *BranchInst) {
4290 if (!EnableImportCallOptimization)
4294 if (GV && GV->hasDLLImportStorageClass()) {
4295 auto *CallSiteSymbol = MMI->getContext().createNamedTempSymbol(
"impcall");
4300 .push_back({CallSiteSymbol, CalledSymbol});
4304void AArch64AsmPrinter::emitMachOIFuncStubBody(
Module &M,
const GlobalIFunc &GI,
4305 MCSymbol *LazyPointer) {
4322 EmitToStreamer(Adrp);
4330 MCOperand SymPageOff;
4337 EmitToStreamer(Ldr);
4340 EmitToStreamer(MCInstBuilder(AArch64::LDRXui)
4341 .addReg(AArch64::X16)
4342 .addReg(AArch64::X16)
4345 EmitToStreamer(MCInstBuilder(TM.getTargetTriple().isArm64e() ? AArch64::BRAAZ
4347 .addReg(AArch64::X16));
4350void AArch64AsmPrinter::emitMachOIFuncStubHelperBody(
Module &M,
4351 const GlobalIFunc &GI,
4352 MCSymbol *LazyPointer) {
4384 EmitToStreamer(MCInstBuilder(AArch64::STPXpre)
4385 .addReg(AArch64::SP)
4386 .addReg(AArch64::FP)
4387 .addReg(AArch64::LR)
4388 .addReg(AArch64::SP)
4391 EmitToStreamer(MCInstBuilder(AArch64::ADDXri)
4392 .addReg(AArch64::FP)
4393 .addReg(AArch64::SP)
4397 for (
int I = 0;
I != 4; ++
I)
4398 EmitToStreamer(MCInstBuilder(AArch64::STPXpre)
4399 .addReg(AArch64::SP)
4400 .addReg(AArch64::X1 + 2 *
I)
4401 .addReg(AArch64::X0 + 2 *
I)
4402 .addReg(AArch64::SP)
4405 for (
int I = 0;
I != 4; ++
I)
4406 EmitToStreamer(MCInstBuilder(AArch64::STPDpre)
4407 .addReg(AArch64::SP)
4408 .addReg(AArch64::D1 + 2 *
I)
4409 .addReg(AArch64::D0 + 2 *
I)
4410 .addReg(AArch64::SP)
4414 MCInstBuilder(AArch64::BL)
4427 EmitToStreamer(Adrp);
4435 MCOperand SymPageOff;
4442 EmitToStreamer(Ldr);
4445 EmitToStreamer(MCInstBuilder(AArch64::STRXui)
4446 .addReg(AArch64::X0)
4447 .addReg(AArch64::X16)
4450 EmitToStreamer(MCInstBuilder(AArch64::ADDXri)
4451 .addReg(AArch64::X16)
4452 .addReg(AArch64::X0)
4456 for (
int I = 3;
I != -1; --
I)
4457 EmitToStreamer(MCInstBuilder(AArch64::LDPDpost)
4458 .addReg(AArch64::SP)
4459 .addReg(AArch64::D1 + 2 *
I)
4460 .addReg(AArch64::D0 + 2 *
I)
4461 .addReg(AArch64::SP)
4464 for (
int I = 3;
I != -1; --
I)
4465 EmitToStreamer(MCInstBuilder(AArch64::LDPXpost)
4466 .addReg(AArch64::SP)
4467 .addReg(AArch64::X1 + 2 *
I)
4468 .addReg(AArch64::X0 + 2 *
I)
4469 .addReg(AArch64::SP)
4472 EmitToStreamer(MCInstBuilder(AArch64::LDPXpost)
4473 .addReg(AArch64::SP)
4474 .addReg(AArch64::FP)
4475 .addReg(AArch64::LR)
4476 .addReg(AArch64::SP)
4479 EmitToStreamer(MCInstBuilder(TM.getTargetTriple().isArm64e() ? AArch64::BRAAZ
4481 .addReg(AArch64::X16));
4484const MCExpr *AArch64AsmPrinter::lowerConstant(
const Constant *CV,
4485 const Constant *BaseCV,
4495char AArch64AsmPrinter::ID = 0;
4498 "AArch64 Assembly Printer",
false,
false)
4502LLVMInitializeAArch64AsmPrinter() {
4512 AArch64AsmPrinter &
AsmPrinter =
static_cast<AArch64AsmPrinter &
>(
4522 AArch64AsmPrinter &
AsmPrinter =
static_cast<AArch64AsmPrinter &
>(
4533 AArch64AsmPrinter &
AsmPrinter =
static_cast<AArch64AsmPrinter &
>(
#define GET_CB_OPC(IsImm, Width, ImmCond, RegCond)
static void emitAuthenticatedPointer(MCStreamer &OutStreamer, MCSymbol *StubLabel, const MCExpr *StubAuthPtrRef)
static bool getOptionalBooleanModuleFlag(Module &M, StringRef Name)
static bool targetSupportsIRelativeRelocation(const Triple &TT)
static PtrauthCheckMode getCheckMode(const MachineFunction *MF)
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
static MCDisassembler::DecodeStatus addOperand(MCInst &Inst, const MCOperand &Opnd)
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static const Function * getParent(const Value *V)
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define LLVM_EXTERNAL_VISIBILITY
Module.h This file contains the declarations for the Module class.
This header defines various interfaces for pass management in LLVM.
const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]
print mir2vec MIR2Vec Vocabulary Printer Pass
Machine Check Debug Module
Register const TargetRegisterInfo * TRI
Promote Memory to Register
ModuleAnalysisManager MAM
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
static SDValue lowerConstant(SDValue Op, SelectionDAG &DAG, const RISCVSubtarget &Subtarget)
static cl::opt< RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode > Mode("regalloc-enable-advisor", cl::Hidden, cl::init(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default), cl::desc("Enable regalloc advisor mode"), cl::values(clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default, "default", "Default"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Release, "release", "precompiled"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Development, "development", "for training")))
static bool contains(SmallPtrSetImpl< ConstantExpr * > &Cache, ConstantExpr *Expr, Constant *C)
This file provides utility classes that use RAII to save and restore values.
This file defines the scope_exit class, which executes user-defined cleanup logic at scope exit.
static bool printOperand(raw_ostream &OS, const SelectionDAG *G, const SDValue Value)
This file defines the SmallString class.
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
std::unique_ptr< MCStreamer > && Streamer
static TableGen::Emitter::Opt Y("gen-skeleton-entry", EmitSkeleton, "Generate example skeleton entry")
static bool printAsmMRegister(const X86AsmPrinter &P, const MachineInstr &MI, const MachineOperand &MO, char Mode, raw_ostream &O)
PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM)
PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM)
PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &MFAM)
static const AArch64AuthMCExpr * create(const MCExpr *Expr, uint16_t Discriminator, AArch64PACKey::ID Key, bool HasAddressDiversity, MCContext &Ctx, SMLoc Loc=SMLoc())
const SetOfInstructions & getLOHRelated() const
bool hasExplicitWinCFIRanges() const
unsigned getJumpTableEntrySize(int Idx) const
MCSymbol * getJumpTableEntryPCRelSymbol(int Idx) const
static bool shouldSignReturnAddress(SignReturnAddress Condition, bool IsLRSpilled)
std::optional< std::string > getOutliningStyle() const
const MILOHContainer & getLOHContainer() const
void setJumpTableEntryInfo(int Idx, unsigned Size, MCSymbol *PCRelSym)
bool shouldSignWithBKey() const
static const char * getRegisterName(MCRegister Reg, unsigned AltIdx=AArch64::NoRegAltName)
static bool isTailCallReturnInst(const MachineInstr &MI)
Returns true if MI is one of the TCRETURN* instructions.
AArch64MCInstLower - This class is used to lower an MachineInstr into an MCInst.
MCSymbol * GetGlobalValueSymbol(const GlobalValue *GV, unsigned TargetFlags) const
void Lower(const MachineInstr *MI, MCInst &OutMI) const
bool lowerOperand(const MachineOperand &MO, MCOperand &MCOp) const
const AArch64Options & getCLOpts() const
virtual void emitARM64WinCFISaveRegP(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveAnyRegQX(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveRegPX(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveAnyRegQ(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveAnyRegQP(unsigned Reg, int Offset)
virtual void emitAttributesSubsection(StringRef VendorName, AArch64BuildAttributes::SubsectionOptional IsOptional, AArch64BuildAttributes::SubsectionType ParameterType)
Build attributes implementation.
virtual void emitARM64WinCFISavePReg(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveFReg(unsigned Reg, int Offset)
virtual void emitARM64WinCFIPACSignLR()
virtual void emitARM64WinCFISaveAnyRegI(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveFRegPX(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveRegX(unsigned Reg, int Offset)
virtual void emitARM64WinCFIAllocStack(unsigned Size)
virtual void emitARM64WinCFISaveFPLRX(int Offset)
virtual void emitARM64WinCFIAllocZ(int Offset)
virtual void emitAttribute(StringRef VendorName, unsigned Tag, uint64_t Value, std::string String)
virtual void emitDirectiveVariantPCS(MCSymbol *Symbol)
Callback used to implement the .variant_pcs directive.
virtual void emitARM64WinCFIAddFP(unsigned Size)
virtual void emitARM64WinCFISaveFPLR(int Offset)
virtual void emitARM64WinCFISaveFRegP(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveAnyRegQPX(unsigned Reg, int Offset)
virtual void emitARM64WinCFISaveFRegX(unsigned Reg, int Offset)
virtual void emitARM64WinCFISetFP()
virtual void emitARM64WinCFIEpilogEnd()
virtual void emitARM64WinCFISaveZReg(unsigned Reg, int Offset)
virtual void emitARM64WinCFIPrologEnd()
virtual void emitARM64WinCFIEndC()
virtual void emitARM64WinCFISaveReg(unsigned Reg, int Offset)
virtual void emitARM64WinCFINop()
virtual void emitARM64WinCFISaveLRPair(unsigned Reg, int Offset)
virtual void emitARM64WinCFIEpilogStart()
virtual void emitARM64WinCFISaveAnyRegIP(unsigned Reg, int Offset)
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
void setPreservesAll()
Set by analyses that do not transform their input at all.
const T & front() const
Get the first element.
bool empty() const
Check if the array is empty.
This class is intended to be used as a driving class for all asm writers.
virtual void emitGlobalAlias(const Module &M, const GlobalAlias &GA)
virtual void emitBasicBlockEnd(const MachineBasicBlock &MBB)
Targets can override this to emit stuff at the end of a basic block.
virtual MCSymbol * GetCPISymbol(unsigned CPID) const
Return the symbol for the specified constant pool entry.
virtual const MCExpr * lowerConstant(const Constant *CV, const Constant *BaseCV=nullptr, uint64_t Offset=0)
Lower the specified LLVM Constant to an MCExpr.
bool doInitialization(Module &M) override
Set up the AsmPrinter when we are working on a new module.
void getAnalysisUsage(AnalysisUsage &AU) const override
Record analysis usage.
bool doFinalization(Module &M) override
Shut down the asmprinter.
bool runOnMachineFunction(MachineFunction &MF) override
Emit the specified function out to the OutStreamer.
virtual void emitXXStructor(const DataLayout &DL, const Constant *CV)
Targets can override this to change how global constants that are part of a C++ static/global constru...
virtual void emitFunctionEntryLabel()
EmitFunctionEntryLabel - Emit the label that is the entrypoint for the function.
virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &OS)
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant.
virtual const MCExpr * lowerBlockAddressConstant(const BlockAddress &BA)
Lower the specified BlockAddress to an MCExpr.
Function * getFunction() const
static LLVM_ABI Constant * getIntToPtr(Constant *C, Type *Ty, bool OnlyIfReduced=false)
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
static LLVM_ABI ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
@ AddrDiscriminator_CtorsDtors
Constant * getPointer() const
The pointer that is signed in this ptrauth signed pointer.
static LLVM_ABI ConstantPtrAuth * get(Constant *Ptr, ConstantInt *Key, ConstantInt *Disc, Constant *AddrDisc, Constant *DeactivationSymbol)
Return a pointer signed with the specified parameters.
ConstantInt * getKey() const
The Key ID, an i32 constant.
Constant * getDeactivationSymbol() const
bool hasAddressDiscriminator() const
Whether there is any non-null address discriminator.
ConstantInt * getDiscriminator() const
The integer discriminator, an i64 constant, or 0.
LLVM_ABI void recordFaultingOp(FaultKind FaultTy, const MCSymbol *FaultingLabel, const MCSymbol *HandlerLabel)
LLVM_ABI void serializeToFaultMapSection()
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
const Constant * getAliasee() const
const Constant * getResolver() const
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this GlobalObject.
bool hasLocalLinkage() const
bool hasExternalWeakLinkage() const
Type * getValueType() const
static LLVM_ABI IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
LLVM_ABI void emitError(const Instruction *I, const Twine &ErrorStr)
emitError - Emit an error message to the currently installed error handler with optional location inf...
static const MCBinaryExpr * createLShr(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx, SMLoc Loc=SMLoc())
static const MCBinaryExpr * createSub(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
static LLVM_ABI const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
LLVM_ABI MCSymbol * createTempSymbol()
Create a temporary symbol with a unique name.
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
LLVM_ABI MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
LLVM_ABI MCSymbol * createLinkerPrivateSymbol(const Twine &Name)
Base class for the full range of assembler expressions which are needed for parsing.
LLVM_ABI bool evaluateAsRelocatable(MCValue &Res, const MCAssembler *Asm) const
Try to evaluate the expression to a relocatable value, i.e.
void setFlags(unsigned F)
void addOperand(const MCOperand Op)
void setOpcode(unsigned Op)
MCSection * getDataSection() const
static MCOperand createExpr(const MCExpr *Val)
static MCOperand createReg(MCRegister Reg)
static MCOperand createImm(int64_t Val)
MCRegister getRegister(unsigned i) const
getRegister - Return the specified register in the class.
uint16_t getEncodingValue(MCRegister Reg) const
Returns the encoding for Reg.
static constexpr unsigned NonUniqueID
static const MCSpecifierExpr * create(const MCExpr *Expr, Spec S, MCContext &Ctx, SMLoc Loc=SMLoc())
Streaming machine code generation interface.
virtual void emitCFIBKeyFrame()
virtual bool popSection()
Restore the current and previous section from the section stack.
virtual void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI)
Emit the given Instruction into the current section.
virtual void emitRelocDirective(const MCExpr &Offset, StringRef Name, const MCExpr *Expr, SMLoc Loc={})
Record a relocation described by the .reloc directive.
virtual bool hasRawTextSupport() const
Return true if this asm streamer supports emitting unformatted text to the .s file with EmitRawText.
MCContext & getContext() const
virtual void AddComment(const Twine &T, bool EOL=true)
Add a textual comment.
virtual void emitCFIMTETaggedFrame()
virtual void emitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc=SMLoc())
void emitValue(const MCExpr *Value, unsigned Size, SMLoc Loc=SMLoc())
virtual void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc())
Emit a label for Symbol into the current section.
MCTargetStreamer * getTargetStreamer()
virtual void emitWinCFIEndProc(SMLoc Loc=SMLoc())
virtual void emitWinCFIFuncletOrFuncEnd(SMLoc Loc=SMLoc())
This is used on platforms, such as Windows on ARM64, that require function or funclet sizes to be emi...
void pushSection()
Save the current and previous section on the section stack.
virtual void switchSection(MCSection *Section, uint32_t Subsec=0)
Set the current section where code is being emitted to Section.
MCSection * getCurrentSectionOnly() const
void emitRawText(const Twine &String)
If this file is backed by a assembly streamer, this dumps the specified string in the output ....
virtual void emitCFINonHintPAuthFrame()
const FeatureBitset & getFeatureBits() const
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx, SMLoc Loc=SMLoc())
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
LLVM_ABI void print(raw_ostream &OS, const MCAsmInfo *MAI) const
print - Print the value to the stream OS.
StringRef getName() const
getName - Get the symbol name.
const MCSymbol * getAddSym() const
int64_t getConstant() const
MachineInstrBundleIterator< const MachineInstr > const_iterator
LLVM_ABI MCSymbol * getSymbol() const
Return the MCSymbol for this basic block.
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
CalledGlobalInfo tryGetCalledGlobal(const MachineInstr *MI) const
Tries to get the global and target flags for a call site, if the instruction is a call to a global.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
MCContext & getContext() const
Function & getFunction()
Return the LLVM function that this machine code represents.
bool usesWindowsUnwindInfo() const
True if this function describes its unwind information with Windows SEH unwind opcodes (....
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
const MachineBasicBlock & front() const
const MachineJumpTableInfo * getJumpTableInfo() const
getJumpTableInfo - Return the jump table info object for the current function.
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
bool readsRegister(Register Reg, const TargetRegisterInfo *TRI) const
Return true if the MachineInstr reads the specified register.
LLVM_ABI const MachineFunction * getMF() const
Return the function that contains the basic block that this instruction belongs to.
bool isBundledWithSucc() const
Return true if this instruction is part of a bundle, and it is not the last instruction in the bundle...
const MachineOperand & getOperand(unsigned i) const
const std::vector< MachineJumpTableEntry > & getJumpTables() const
ExprStubListTy getAuthGVStubList()
ExprStubListTy getAuthGVStubList()
unsigned getSubReg() const
static MachineOperand CreateMCSymbol(MCSymbol *Sym, unsigned TargetFlags=0)
const GlobalValue * getGlobal() const
static MachineOperand CreateES(const char *SymName, unsigned TargetFlags=0)
bool isReg() const
isReg - Tests if this is a MO_Register operand.
MachineBasicBlock * getMBB() const
bool isImm() const
isImm - Tests if this is a MO_Immediate operand.
const BlockAddress * getBlockAddress() const
void setOffset(int64_t Offset)
bool isGlobal() const
isGlobal - Tests if this is a MO_GlobalAddress operand.
MachineOperandType getType() const
getType - Returns the MachineOperandType for this operand.
Register getReg() const
getReg - Returns the register number.
@ MO_Immediate
Immediate operand.
@ MO_GlobalAddress
Address of a global value.
@ MO_BlockAddress
Address of a basic block.
@ MO_Register
Register operand.
@ MO_ExternalSymbol
Name of external global symbol.
int64_t getOffset() const
Return the offset from the symbol in this operand.
This class implements a map that also provides access to all stored values in a deterministic order.
A Module instance is used to store all the information related to an LLVM module.
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
constexpr bool isValid() const
constexpr bool isPhysical() const
Return true if the specified register number is in the physical register namespace.
static SectionKind getMetadata()
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
void push_back(const T &Elt)
LLVM_ABI void recordStatepoint(const MCSymbol &L, const MachineInstr &MI)
Generate a stackmap record for a statepoint instruction.
LLVM_ABI void recordPatchPoint(const MCSymbol &L, const MachineInstr &MI)
Generate a stackmap record for a patchpoint instruction.
LLVM_ABI void recordStackMap(const MCSymbol &L, const MachineInstr &MI)
Generate a stackmap record for a stackmap instruction.
Represent a constant reference to a string, i.e.
constexpr const char * data() const
Get a pointer to the start of the string (which may not be null terminated).
virtual MCSection * getSectionForJumpTable(const Function &F, const TargetMachine &TM) const
Primary interface to the complete machine description for the target machine.
bool regsOverlap(Register RegA, Register RegB) const
Returns true if the two registers are equal or alias each other.
Triple - Helper class for working with autoconf configuration names.
bool isFunctionTy() const
True if this is an instance of FunctionType.
LLVM Value Representation.
LLVMContext & getContext() const
All values hold a context through their type.
LLVM_ABI const Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds, bool AllowInvariantGroup=false, function_ref< bool(Value &Value, APInt &Offset)> ExternalAnalysis=nullptr, bool LookThroughIntToPtr=false) const
Accumulate the constant offset this value has compared to a base pointer.
LLVM_ABI StringRef getName() const
Return a constant reference to the value's name.
self_iterator getIterator()
Pass manager infrastructure for declaring and invalidating analyses.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
LLVM_ABI StringRef getVendorName(unsigned const Vendor)
@ MO_NC
MO_NC - Indicates whether the linker is expected to check the symbol reference for overflow.
@ MO_G1
MO_G1 - A symbol operand with this flag (granule 1) represents the bits 16-31 of a 64-bit address,...
@ MO_S
MO_S - Indicates that the bits of the symbol operand represented by MO_G0 etc are signed.
@ MO_PAGEOFF
MO_PAGEOFF - A symbol operand with this flag represents the offset of that symbol within a 4K page.
@ MO_GOT
MO_GOT - This flag indicates that a symbol operand represents the address of the GOT entry for the sy...
@ MO_G0
MO_G0 - A symbol operand with this flag (granule 0) represents the bits 0-15 of a 64-bit address,...
@ MO_PAGE
MO_PAGE - A symbol operand with this flag represents the pc-relative offset of the 4K page containing...
@ MO_TLS
MO_TLS - Indicates that the operand being accessed is some kind of thread-local symbol.
PtrauthCheckMode
Ways to check pointer authentication auth/resign failures.
constexpr AArch64PACKey::ID InitFiniKey
PAuth key to be used with function pointers in .init_array and .fini_array.
AuthCheckMethod
Variants of check performed on an authenticated pointer.
constexpr unsigned InitFiniPointerConstantDiscriminator
Constant discriminator to be used with function pointers in .init_array and .fini_array.
static unsigned getShiftValue(unsigned Imm)
getShiftValue - Extract the shift value.
static uint64_t encodeLogicalImmediate(uint64_t imm, unsigned regSize)
encodeLogicalImmediate - Return the encoded immediate value for a logical immediate instruction of th...
static unsigned getShifterImm(AArch64_AM::ShiftExtendType ST, unsigned Imm)
getShifterImm - Encode the shift type and amount: imm: 6-bit shift amount shifter: 000 ==> lsl 001 ==...
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
SymbolStorageClass
Storage class tells where and what the symbol represents.
@ IMAGE_SYM_CLASS_EXTERNAL
External symbol.
@ IMAGE_SYM_CLASS_STATIC
Static.
@ IMAGE_SYM_DTYPE_FUNCTION
A function that returns a base type.
@ SCT_COMPLEX_TYPE_SHIFT
Type is formed as (base + (derived << SCT_COMPLEX_TYPE_SHIFT))
@ GNU_PROPERTY_AARCH64_FEATURE_1_BTI
@ GNU_PROPERTY_AARCH64_FEATURE_1_PAC
@ GNU_PROPERTY_AARCH64_FEATURE_1_GCS
@ AARCH64_PAUTH_PLATFORM_LLVM_LINUX
@ S_REGULAR
S_REGULAR - Regular section.
void emitInstruction(MCObjectStreamer &, const MCInst &Inst, const MCSubtargetInfo &STI)
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract_or_null(Y &&MD)
Extract a Value from Metadata, allowing null.
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract(Y &&MD)
Extract a Value from Metadata.
NodeAddr< NodeBase * > Node
This is an optimization pass for GlobalISel generic memory operations.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
LLVM_ABI std::optional< std::string > getArm64ECMangledFunctionName(StringRef Name)
Returns the ARM64EC mangled function name unless the input is already mangled.
SaveAndRestore(T &) -> SaveAndRestore< T >
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
OuterAnalysisManagerProxy< ModuleAnalysisManager, MachineFunction > ModuleAnalysisManagerMachineFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
constexpr bool isInt(int64_t x)
Checks if an integer fits into the given bit width.
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
scope_exit(Callable) -> scope_exit< Callable >
@ Store
The extracted value is stored (ExtractElement only).
static unsigned getXPACOpcodeForKey(AArch64PACKey::ID K)
Return XPAC opcode to be used for a ptrauth strip using the given key.
Target & getTheAArch64beTarget()
std::string utostr(uint64_t X, bool isNeg=false)
AnalysisManager< MachineFunction > MachineFunctionAnalysisManager
static unsigned getBranchOpcodeForKey(bool IsCall, AArch64PACKey::ID K, bool Zero)
Return B(L)RA opcode to be used for an authenticated branch or call using the given key,...
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Value
Target & getTheAArch64leTarget()
auto dyn_cast_or_null(const Y &Val)
Target & getTheAArch64_32Target()
auto reverse(ContainerTy &&C)
MachineInstr * getImm(const MachineOperand &MO, const MachineRegisterInfo *MRI)
LLVM_ABI void setupModuleAsmPrinter(Module &M, ModuleAnalysisManager &MAM, AsmPrinter &AsmPrinter)
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
constexpr bool isUInt(uint64_t x)
Checks if an unsigned integer fits into the given bit width.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key
Target & getTheARM64_32Target()
static MCRegister getXRegFromWReg(MCRegister Reg)
Target & getTheARM64Target()
DWARFExpression::Operation Op
ArrayRef(const T &OneElt) -> ArrayRef< T >
static MCRegister getXRegFromXRegTuple(MCRegister RegTuple)
static unsigned getPACOpcodeForKey(AArch64PACKey::ID K, bool Zero)
Return PAC opcode to be used for a ptrauth sign using the given key, or its PAC*Z variant that doesn'...
static MCRegister getWRegFromXReg(MCRegister Reg)
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
LLVM_ABI void setupMachineFunctionAsmPrinter(MachineFunctionAnalysisManager &MFAM, MachineFunction &MF, AsmPrinter &AsmPrinter)
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Next
static unsigned getAUTOpcodeForKey(AArch64PACKey::ID K, bool Zero)
Return AUT opcode to be used for a ptrauth auth using the given key, or its AUT*Z variant that doesn'...
constexpr bool isShiftedUInt(uint64_t x)
Checks if a unsigned integer is an N bit number shifted left by S.
@ MCSA_WeakAntiDep
.weak_anti_dep (COFF)
@ MCSA_ELF_TypeFunction
.type _foo, STT_FUNC # aka @function
@ MCSA_Hidden
.hidden (ELF)
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
MCRegisterClass TargetRegisterClass
LLVM_ABI void reportFatalUsageError(Error Err)
Report a fatal error that does not indicate a bug in LLVM.
Implement std::hash so that hash_code can be used in STL containers.
RegisterAsmPrinter - Helper template for registering a target specific assembly printer,...