[MachineOutliner] Adding aggressive tail call outlining options.

[plotfi]

Summary

This diff introduces an option -aggressive-tail-call-outlining to run the MachineOutliner twice: Once in a special only-tail-calls mode, and then again in its regular mode. There is also an option -aggressive-tail-call-outlining-only to be used for debugging that tells the outliner to bail after outlining just the tail calls.

In the only-tail-calls mode, the limitations on W30 are ignored, resulting in a different suffix tree with longer matches, which are then processed for tail calls only. This has a slight improvement over the newer CFI outlining strategy alone (by one or two instructions).

[paquette]

I'm a little concerned about putting this in the generic outlining algorithm, because not every target's outliner necessarily supports tail calls.

For example, the x86 outliner doesn't support tail calls right now. I would expect that in that case we should get a warning or some debug output. I can imagine someone enabling this and then being surprised when it does nothing.

I'm not opposed to this otherwise. In general, I'd like to keep potentially target-specific things outside of the generic outlining algorithm, even if those things are pretty widespread.

Also, do you think that you could build CTMark for AArch64 at -Oz with + without this change? It would be nice to see what kind of code size savings this gives us.

llvm/lib/CodeGen/MachineOutliner.cpp

115–117

More succinct:

"Only outline tail calls. Meant for testing purposes. (default = off)"

661

Why is "Tail Call Only" capitalized?

I think this could be more descriptive anyway.

E.g.

"If true, only outline tail calls. If false, outline all types of frames."

1131–1132

Why not do this as a comment on the outlined function name?

1512

It's weird to me that you can have

AggressiveTailCallOutlining == false
AggressiveTailCallOutliningOnly == true

Intuitively, I would assume that AggressiveTailCallOutliningOnly implies AggressiveTailCallOutlining.

llvm/lib/Target/AArch64/AArch64InstrInfo.cpp

6259

Earlier, you called this "Only Tail Calls mode". This should be consistent across the board to make grepping the source easier.

[plotfi]

Abandoning. I think the stuff @AndrewLitteken added a few months ago is more than sufficient.

llvm/include/llvm/CodeGen/TargetInstrInfo.h

public:
   virtual MachineBasicBlock::iterator
   insertOutlinedCall(Module &M, MachineBasicBlock &MBB,
                      MachineBasicBlock::iterator &It, MachineFunction &MF,
                      const outliner::Candidate &C) const {
     llvm_unreachable(
         "Target didn't implement TargetInstrInfo::insertOutlinedCall!");
   }
 
+  virtual outliner::OutlinedFunction getOutliningCandidateInfo(
+      std::vector<outliner::Candidate> &RepeatedSequenceLocs,
+      bool OnlyTailCalls) const {
+    return getOutliningCandidateInfo(RepeatedSequenceLocs);
+  }
+
+  virtual outliner::InstrType getOutliningType(MachineBasicBlock::iterator &MIT,
+                                               unsigned Flags,
+                                               bool OnlyTailCalls) const {
+    return getOutliningType(MIT, Flags);
+  }
+
   /// Return true if the function can safely be outlined from.
   /// A function \p MF is considered safe for outlining if an outlined function
   /// produced from instructions in F will produce a program which produces the
   /// same output for any set of given inputs.
   virtual bool isFunctionSafeToOutlineFrom(MachineFunction &MF,
                                            bool OutlineFromLinkOnceODRs) const {
     llvm_unreachable("Target didn't implement "
                      "TargetInstrInfo::isFunctionSafeToOutlineFrom!");

llvm/lib/CodeGen/MachineOutliner.cpp

 /// Number of times to re-run the outliner. This is not the total number of runs
 /// as the outliner will run at least one time. The default value is set to 0,
 /// meaning the outliner will run one time and rerun zero times after that.
 static cl::opt<unsigned> OutlinerReruns(
     "machine-outliner-reruns", cl::init(0), cl::Hidden,
     cl::desc(
         "Number of times to rerun the outliner after the initial outline"));
 
+static cl::opt<bool> AggressiveTailCallOutlining(
+    "aggressive-tail-call-outlining", cl::init(false), cl::Hidden,
+    cl::desc("Perform an extra run of the machine outliner for tail calls "
+             "(default = off)"));
+
+static cl::opt<bool> AggressiveTailCallOutliningOnly(
+    "aggressive-tail-call-outlining-only", cl::init(false), cl::Hidden,
+    cl::desc("Like -aggressive-tail-call-outlining, but stop outlining after "
+             "outlining the tail calls (ie bail immediately): Meant for "
+             "testing purposes. (default = off)"));
+
 namespace {
 
 /// Represents an undefined index in the suffix tree.
 const unsigned EmptyIdx = -1;
 
 /// A node in a suffix tree which represents a substring or suffix.
 ///
 /// Each node has either no children or at least two children, with the root
struct InstructionMapper {
   std::vector<MachineBasicBlock::iterator> InstrList;
 
   // Set if we added an illegal number in the previous step.
   // Since each illegal number is unique, we only need one of them between
   // each range of legal numbers. This lets us make sure we don't add more
   // than one illegal number per range.
   bool AddedIllegalLastTime = false;
 
+  /// Used to toggle Tail Call Only mode.
+  bool OnlyTailCalls;
+
   /// Maps \p *It to a legal integer.
   ///
   /// Updates \p CanOutlineWithPrevInstr, \p HaveLegalRange, \p InstrListForMBB,
   /// \p UnsignedVecForMBB, \p InstructionIntegerMap, and \p LegalInstrNumber.
   ///
   /// \returns The integer that \p *It was mapped to.
   unsigned mapToLegalUnsigned(
       MachineBasicBlock::iterator &It, bool &CanOutlineWithPrevInstr,
void convertToUnsignedVec(MachineBasicBlock &MBB,
 
     // FIXME: Should this all just be handled in the target, rather than using
     // repeated calls to getOutliningType?
     std::vector<unsigned> UnsignedVecForMBB;
     std::vector<MachineBasicBlock::iterator> InstrListForMBB;
 
     for (MachineBasicBlock::iterator Et = MBB.end(); It != Et; ++It) {
       // Keep track of where this instruction is in the module.
-      switch (TII.getOutliningType(It, Flags)) {
+      switch (TII.getOutliningType(It, Flags, OnlyTailCalls)) {
       case InstrType::Illegal:
         mapToIllegalUnsigned(It, CanOutlineWithPrevInstr, UnsignedVecForMBB,
                              InstrListForMBB);
         break;
 
       case InstrType::Legal:
         mapToLegalUnsigned(It, CanOutlineWithPrevInstr, HaveLegalRange,
                            NumLegalInBlock, UnsignedVecForMBB, InstrListForMBB);
struct MachineOutliner : public ModulePass {
   unsigned OutlineRepeatedNum = 0;
 
   /// Set to true if the outliner should run on all functions in the module
   /// considered safe for outlining.
   /// Set to true by default for compatibility with llc's -run-pass option.
   /// Set when the pass is constructed in TargetPassConfig.
   bool RunOnAllFunctions = true;
 
+  /// Used to toggle Tail Call Only mode.
+  bool OnlyTailCalls;
+
   StringRef getPassName() const override { return "Machine Outliner"; }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<MachineModuleInfoWrapperPass>();
     AU.addPreserved<MachineModuleInfoWrapperPass>();
     AU.setPreservesAll();
     ModulePass::getAnalysisUsage(AU);
   }
if (CandidatesForRepeatedSeq.size() < 2)
       continue;
 
     // Arbitrarily choose a TII from the first candidate.
     // FIXME: Should getOutliningCandidateInfo move to TargetMachine?
     const TargetInstrInfo *TII =
         CandidatesForRepeatedSeq[0].getMF()->getSubtarget().getInstrInfo();
 
     OutlinedFunction OF =
-        TII->getOutliningCandidateInfo(CandidatesForRepeatedSeq);
+        TII->getOutliningCandidateInfo(CandidatesForRepeatedSeq, OnlyTailCalls);
 
     // If we deleted too many candidates, then there's nothing worth outlining.
     // FIXME: This should take target-specified instruction sizes into account.
     if (OF.Candidates.size() < 2)
       continue;
 
     // Is it better to outline this candidate than not?
     if (OF.getBenefit() < 1) {
       emitNotOutliningCheaperRemark(StringLen, CandidatesForRepeatedSeq, OF);
       continue;
     }
 
     FunctionList.push_back(OF);
   }
 }
 
 MachineFunction *MachineOutliner::createOutlinedFunction(
     Module &M, OutlinedFunction &OF, InstructionMapper &Mapper, unsigned Name) {
 
   // Create the function name. This should be unique.
   // FIXME: We should have a better naming scheme. This should be stable,
   // regardless of changes to the outliner's cost model/traversal order.
   std::string FunctionName = "OUTLINED_FUNCTION_";
+  if (OnlyTailCalls)
+    FunctionName += "AGGRESSIVE_TAIL_CALL_";
   if (OutlineRepeatedNum > 0)
     FunctionName += std::to_string(OutlineRepeatedNum + 1) + "_";
   FunctionName += std::to_string(Name);
 
   // Create the function using an IR-level function.
   LLVMContext &C = M.getContext();
   Function *F = Function::Create(FunctionType::get(Type::getVoidTy(C), false),
                                  Function::ExternalLinkage, FunctionName, M);

 }
 
 bool MachineOutliner::runOnModule(Module &M) {
   // Check if there's anything in the module. If it's empty, then there's
   // nothing to outline.
   if (M.empty())
     return false;
 
+  bool Changed = false;
+  if (AggressiveTailCallOutlining || AggressiveTailCallOutliningOnly) {
+    // Number to append to the current tail-call-only outlined function.
+    unsigned OutlinedTailCallFunctionNum = 0;
+    OnlyTailCalls = true;
+    Changed = doOutline(M, OutlinedTailCallFunctionNum);
+    if (AggressiveTailCallOutliningOnly)
+      return Changed;
+  }
+  OnlyTailCalls = false;
+
   // Number to append to the current outlined function.
   unsigned OutlinedFunctionNum = 0;
 
   OutlineRepeatedNum = 0;
   if (!doOutline(M, OutlinedFunctionNum))
-    return false;
+    return Changed;
 
   for (unsigned I = 0; I < OutlinerReruns; ++I) {
     OutlinedFunctionNum = 0;
     OutlineRepeatedNum++;
     if (!doOutline(M, OutlinedFunctionNum)) {
       LLVM_DEBUG({
         dbgs() << "Did not outline on iteration " << I + 2 << " out of "
                << OutlinerReruns + 1 << "\n";
else
       dbgs() << "target-default functions";
     dbgs() << "\n";
   });
 
   // If the user specifies that they want to outline from linkonceodrs, set
   // it here.
   OutlineFromLinkOnceODRs = EnableLinkOnceODROutlining;
   InstructionMapper Mapper;
+  Mapper.OnlyTailCalls = OnlyTailCalls;
 
   // Prepare instruction mappings for the suffix tree.
   populateMapper(Mapper, M, MMI);
   std::vector<OutlinedFunction> FunctionList;
 
   // Find all of the outlining candidates.
   findCandidates(Mapper, FunctionList);
 

llvm/lib/Target/AArch64/AArch64InstrInfo.h

public:
   ArrayRef<std::pair<unsigned, const char *>>
   getSerializableBitmaskMachineOperandTargetFlags() const override;
   ArrayRef<std::pair<MachineMemOperand::Flags, const char *>>
   getSerializableMachineMemOperandTargetFlags() const override;
 
   bool isFunctionSafeToOutlineFrom(MachineFunction &MF,
                                    bool OutlineFromLinkOnceODRs) const override;
   outliner::OutlinedFunction getOutliningCandidateInfo(
+      std::vector<outliner::Candidate> &RepeatedSequenceLocs,
+      bool OnlyTailCalls) const override;
+  outliner::InstrType getOutliningType(MachineBasicBlock::iterator &MIT,
+                                       unsigned Flags,
+                                       bool OnlyTailCalls) const override;
+  outliner::OutlinedFunction getOutliningCandidateInfo(
       std::vector<outliner::Candidate> &RepeatedSequenceLocs) const override;
-  outliner::InstrType
-  getOutliningType(MachineBasicBlock::iterator &MIT, unsigned Flags) const override;
+  outliner::InstrType getOutliningType(MachineBasicBlock::iterator &MIT,
+                                       unsigned Flags) const override;
   bool isMBBSafeToOutlineFrom(MachineBasicBlock &MBB,
                               unsigned &Flags) const override;
   void buildOutlinedFrame(MachineBasicBlock &MBB, MachineFunction &MF,
                           const outliner::OutlinedFunction &OF) const override;
   MachineBasicBlock::iterator
   insertOutlinedCall(Module &M, MachineBasicBlock &MBB,
                      MachineBasicBlock::iterator &It, MachineFunction &MF,
                      const outliner::Candidate &C) const override;

llvm/lib/Target/AArch64/AArch64InstrInfo.cpp

const AArch64Subtarget &SubtargetA =
       a.getMF()->getSubtarget<AArch64Subtarget>();
   const AArch64Subtarget &SubtargetB =
       b.getMF()->getSubtarget<AArch64Subtarget>();
   return SubtargetA.hasV8_3aOps() == SubtargetB.hasV8_3aOps();
 }
 
 outliner::OutlinedFunction AArch64InstrInfo::getOutliningCandidateInfo(
     std::vector<outliner::Candidate> &RepeatedSequenceLocs) const {
+  return getOutliningCandidateInfo(RepeatedSequenceLocs,
+                                   false /* OnlyTailCalls */);
+}
+
+outliner::OutlinedFunction AArch64InstrInfo::getOutliningCandidateInfo(
+    std::vector<outliner::Candidate> &RepeatedSequenceLocs,
+    bool OnlyTailCalls) const {
   outliner::Candidate &FirstCand = RepeatedSequenceLocs[0];
   unsigned SequenceSize =
       std::accumulate(FirstCand.front(), std::next(FirstCand.back()), 0,
                       [this](unsigned Sum, const MachineInstr &MI) {
                         return Sum + getInstSizeInBytes(MI);
                       });
   unsigned NumBytesToCreateFrame = 0;
 
if (ModStackToSaveLR) {
         return outliner::OutlinedFunction();
       }
 
       // Save + restore LR.
       NumBytesToCreateFrame += 8;
     }
   }
 
+  // If we are aggresively outlining all tail calls prior to the first outline
+  // pass, return here prior to the CFICount check.
+  if (FrameID != MachineOutlinerTailCall && OnlyTailCalls) {
+    RepeatedSequenceLocs.clear();
+    return outliner::OutlinedFunction();
+  }
+
   // If we have CFI instructions, we can only outline if the outlined section
   // can be a tail call
   if (FrameID != MachineOutlinerTailCall && CFICount > 0)
     return outliner::OutlinedFunction();
 
   return outliner::OutlinedFunction(RepeatedSequenceLocs, SequenceSize,
                                     NumBytesToCreateFrame, FrameID);
 }
if (!CanSaveLR && !LRU.available(AArch64::LR))
     Flags |= MachineOutlinerMBBFlags::LRUnavailableSomewhere;
 
   return true;
 }
 
 outliner::InstrType
 AArch64InstrInfo::getOutliningType(MachineBasicBlock::iterator &MIT,
                                    unsigned Flags) const {
+    return getOutliningType(MIT, Flags, false /* OnlyTailCalls */ );
+}
+
+outliner::InstrType
+AArch64InstrInfo::getOutliningType(MachineBasicBlock::iterator &MIT,
+                                   unsigned Flags, bool OnlyTailCalls) const {
   MachineInstr &MI = *MIT;
   MachineBasicBlock *MBB = MI.getParent();
   MachineFunction *MF = MBB->getParent();
   AArch64FunctionInfo *FuncInfo = MF->getInfo<AArch64FunctionInfo>();
 
   // Don't outline anything used for return address signing. The outlined
   // function will get signed later if needed
   switch (MI.getOpcode()) {
AArch64InstrInfo::getOutliningType(MachineBasicBlock::iterator &MIT,
   }
 
   // Make sure none of the operands are un-outlinable.
   for (const MachineOperand &MOP : MI.operands()) {
     if (MOP.isCPI() || MOP.isJTI() || MOP.isCFIIndex() || MOP.isFI() ||
         MOP.isTargetIndex())
       return outliner::InstrType::Illegal;
 
+    // If we are in OnlyTailCalls mode, ignore the presence of W30 register.
+    // This improves outlining of tail calls by one or two instructions over the
+    // CFI outlining alone.
+    if (OnlyTailCalls)
+      continue;
+
     // If it uses LR or W30 explicitly, then don't touch it.
     if (MOP.isReg() && !MOP.isImplicit() &&
         (MOP.getReg() == AArch64::LR || MOP.getReg() == AArch64::W30))
       return outliner::InstrType::Illegal;
   }
 
   // Special cases for instructions that can always be outlined, but will fail
   // the later tests. e.g, ADRPs, which are PC-relative use LR, but can always
if (MI.isCall()) {
     // stack. Therefore, we can outline it.
     return outliner::InstrType::Legal;
   }
 
   // Don't outline positions.
   if (MI.isPosition())
     return outliner::InstrType::Illegal;
 
+  if (OnlyTailCalls)
+    return outliner::InstrType::Legal;
+
   // Don't touch the link register or W30.
   if (MI.readsRegister(AArch64::W30, &getRegisterInfo()) ||
       MI.modifiesRegister(AArch64::W30, &getRegisterInfo()))
     return outliner::InstrType::Illegal;
 
   // Don't outline BTI instructions, because that will prevent the outlining
   // site from being indirectly callable.
   if (MI.getOpcode() == AArch64::HINT) {

llvm/test/CodeGen/AArch64/machine-outliner-aggressive-tail.mir

+#RUN: llc -mtriple aarch64--- -verify-machineinstrs -run-pass=machine-outliner \
+#RUN:   -aggressive-tail-call-outlining -o - %s | FileCheck %s
+
+#RUN: llc -mtriple aarch64--- -verify-machineinstrs -run-pass=machine-outliner \
+#RUN:   -aggressive-tail-call-outlining-only -o - %s | FileCheck %s
+
+#CHECK: name:  OUTLINED_FUNCTION_AGGRESSIVE_TAIL_CALL_0
+#CHECK: LDPXi $sp, 4
+#CHECK-NEXT: LDPXi $sp, 2
+#CHECK-NEXT: LDRXpost $sp, 48
+#CHECK-NEXT: RET
+
+--- |
+  define void @a(i32 %a, i32 %b, i32 %c, i32 %d) { unreachable }
+  define void @b(i32 %a, i32 %b, i32 %c, i32 %d) { unreachable }
+  define void @c(i32 %a, i32 %b, i32 %c, i32 %d) { unreachable }
+  declare void @z(i32, i32, i32, i32)
+...
+---
+name:            a
+tracksRegLiveness: true
+machineFunctionInfo:
+  hasRedZone:      false
+body:             |
+  bb.0:
+    liveins: $w0, $w1, $w2, $w3, $x22, $x20, $x21, $lr, $x19
+    early-clobber $sp = frame-setup STRXpre killed $x22, $sp, -48 :: (store 8)
+    frame-setup STPXi killed $x21, killed $x20, $sp, 2 :: (store 8), (store 8)
+    frame-setup STPXi killed $x19, killed $lr, $sp, 4 :: (store 8), (store 8)
+    frame-setup CFI_INSTRUCTION def_cfa_offset 48
+    frame-setup CFI_INSTRUCTION offset $w30, -8
+    frame-setup CFI_INSTRUCTION offset $w19, -16
+    frame-setup CFI_INSTRUCTION offset $w20, -24
+    frame-setup CFI_INSTRUCTION offset $w21, -32
+    frame-setup CFI_INSTRUCTION offset $w22, -48
+    $w19 = ORRWrs $wzr, $w3, 0
+    $w20 = ORRWrs $wzr, $w2, 0
+    $w21 = ORRWrs $wzr, $w1, 0
+    $w22 = ORRWrs $wzr, $w0, 0
+    BL @z, csr_aarch64_aapcs
+    $w0 = ORRWri $wzr, 0
+    $w1 = ORRWri $wzr, 1984
+    $w2 = ORRWri $wzr, 1
+    $w3 = ORRWri $wzr, 1920
+    BL @z, csr_aarch64_aapcs
+    $w0 = ORRWrs $wzr, killed $w22, 0
+    $w1 = ORRWrs $wzr, killed $w21, 0
+    $w2 = ORRWrs $wzr, killed $w20, 0
+    $w3 = ORRWrs $wzr, killed $w19, 0
+    BL @z, csr_aarch64_aapcs
+    $x19, $lr = frame-destroy LDPXi $sp, 4 :: (load 8), (load 8)
+    $x21, $x20 = frame-destroy LDPXi $sp, 2 :: (load 8), (load 8)
+    early-clobber $sp, $x22 = frame-destroy LDRXpost $sp, 48 :: (load 8)
+    RET undef $lr
+
+...
+---
+name:            b
+tracksRegLiveness: true
+machineFunctionInfo:
+  hasRedZone:      false
+body:             |
+  bb.0:
+    liveins: $w0, $w1, $w2, $w3, $x22, $x20, $x21, $lr, $x19
+    early-clobber $sp = frame-setup STRXpre killed $x22, $sp, -48 :: (store 8)
+    frame-setup STPXi killed $x21, killed $x20, $sp, 2 :: (store 8), (store 8)
+    frame-setup STPXi killed $x19, killed $lr, $sp, 4 :: (store 8), (store 8)
+    frame-setup CFI_INSTRUCTION def_cfa_offset 48
+    frame-setup CFI_INSTRUCTION offset $w30, -8
+    frame-setup CFI_INSTRUCTION offset $w19, -16
+    frame-setup CFI_INSTRUCTION offset $w20, -24
+    frame-setup CFI_INSTRUCTION offset $w21, -32
+    frame-setup CFI_INSTRUCTION offset $w22, -48
+    $w19 = ORRWrs $wzr, $w3, 0
+    $w20 = ORRWrs $wzr, $w2, 0
+    $w21 = ORRWrs $wzr, $w1, 0
+    $w22 = ORRWrs $wzr, $w0, 0
+    BL @z, csr_aarch64_aapcs
+    $w0 = ORRWri $wzr, 1920
+    $w1 = ORRWri $wzr, 1
+    $w2 = ORRWri $wzr, 1984
+    $w3 = ORRWri $wzr, 0
+    BL @z, csr_aarch64_aapcs
+    $w0 = ORRWrs $wzr, killed $w22, 0
+    $w1 = ORRWrs $wzr, killed $w21, 0
+    $w2 = ORRWrs $wzr, killed $w20, 0
+    $w3 = ORRWrs $wzr, killed $w19, 0
+    BL @z, csr_aarch64_aapcs
+    $x19, $lr = frame-destroy LDPXi $sp, 4 :: (load 8), (load 8)
+    $x21, $x20 = frame-destroy LDPXi $sp, 2 :: (load 8), (load 8)
+    early-clobber $sp, $x22 = frame-destroy LDRXpost $sp, 48 :: (load 8)
+    RET undef $lr
+
+...
+
+...
+---
+name:            c
+tracksRegLiveness: true
+machineFunctionInfo:
+  hasRedZone:      false
+body:             |
+  bb.0:
+    liveins: $w0, $w1, $w2, $w3, $x22, $x20, $x21, $lr, $x19
+    early-clobber $sp = frame-setup STRXpre killed $x22, $sp, -48 :: (store 8)
+    frame-setup STPXi killed $x21, killed $x20, $sp, 2 :: (store 8), (store 8)
+    frame-setup STPXi killed $x19, killed $lr, $sp, 4 :: (store 8), (store 8)
+    frame-setup CFI_INSTRUCTION def_cfa_offset 48
+    frame-setup CFI_INSTRUCTION offset $w30, -8
+    frame-setup CFI_INSTRUCTION offset $w19, -16
+    frame-setup CFI_INSTRUCTION offset $w20, -24
+    frame-setup CFI_INSTRUCTION offset $w21, -32
+    frame-setup CFI_INSTRUCTION offset $w22, -48
+    $w19 = ORRWrs $wzr, $w3, 0
+    $w20 = ORRWrs $wzr, $w2, 0
+    $w21 = ORRWrs $wzr, $w1, 0
+    $w22 = ORRWrs $wzr, $w0, 0
+    BL @z, csr_aarch64_aapcs
+    $w0 = ORRWri $wzr, 1920
+    $w1 = ORRWri $wzr, 1
+    $w2 = ORRWri $wzr, 1984
+    $w3 = ORRWri $wzr, 0
+    BL @z, csr_aarch64_aapcs
+    $w0 = ORRWrs $wzr, killed $w22, 0
+    $w1 = ORRWrs $wzr, killed $w21, 0
+    $w2 = ORRWrs $wzr, killed $w20, 0
+    $w3 = ORRWrs $wzr, killed $w19, 0
+    BL @z, csr_aarch64_aapcs
+    $x19, $lr = frame-destroy LDPXi $sp, 4 :: (load 8), (load 8)
+    $x21, $x20 = frame-destroy LDPXi $sp, 2 :: (load 8), (load 8)
+    early-clobber $sp, $x22 = frame-destroy LDRXpost $sp, 48 :: (load 8)
+    RET undef $lr
+
+...