[Outliner] Add outliner for AArch64

[paquette]

Summary

This patch adds an outliner for AArch64. It adds the outliner target hooks to AArch64InstrInfo.cpp and AArch64InstrInfo.cpp. This allows for outlining using the -mno-red-zone and -enable-machine-outliner flags.

The main difference from the X86-64 outliner is the inclusion of post-outlining stack fixups. A function, getPostOutliningFixup is added to determine if an instruction that uses SP can be fixed up post-outlining. After each outlined function is created, fixupPostOutline is called on the MachineBasicBlock in that function, and recalculates stack offsets using getPostOutliningFixup.

For a simpler example of how this works, see https://reviews.llvm.org/D30797

[MatzeB]

This looks good! I only see one real problem right now, the rest is the usual coding style/nitpicking.

• ARM instructions only use a limited number of bits to encode immediate values. I don't see the stack fixup code checking whether the adjusted value still fits the instruction encodings.

lib/Target/AArch64/AArch64InstrInfo.cpp

4306

Typing MachineOperand & here isn't that much longer and friendlier to the reader.

4315–4389

This is an awful lot of instruction specifics here. This list is dangerous to become stale/out of date when people add instruction in the future. Better try to move this into AArch64InstrInfo where the chance is higher that people will see and update it. Or better try to share code with one of the existing functions there (AArch64InstrInfo::getMemOpBaseRegImmOfsWidth looks similar, do you need modifications to the API to reuse it?)

4403–4405

That's a bit of a pity. Shouldn't be too hard to determine the effected LOH entries and throw them away as part of an upcoming patch (I would consider outlining more important than having a linker optimization hint).

4414

Maybe make a slightly higher level statement: // Does the function end here?

4435–4436

Could you check whether you really need the getDesc() checks? I was hoping only the X86 target has these missing operand bugs... Same with the next if.

4463

Less auto please.

4464

The getNumExplicitOperands()-1 seems somewhat magical, is there an AArch64InstrInfo function for it? If not consider creating one.

4514–4537

Suggestion for followup patches: Use the LivePhysReg utility to discover unused registers in the outlined sequence so you can get away without a load/store in some cases.

lib/Target/AArch64/AArch64InstrInfo.h

337

The llvm:: prefix is probably unnecessary.

347

I should have noticed in the main outliner review already: When you use an instruction iterator to signal the insertion point, I'd recommend calling it InsertBefore or InsertAfter to make it obvious whether we insert before or after the given instruction...
(Feel free to fix this on the side without review)

[paquette]

Updated diff to address comments

Major changes

• Added getScale to AArch64InstrInfo.h. This returns the scale of an appropriate instruction.
• Added getMemOpBaseRegImmOfsOffsetOperand to hide the magical getNumExplicitOperands()-1 stuff.
• Added isEncodableLdStOffset, which determines if the updated offset would overflow.

I noticed that the scale of an instruction is calculated in lots of places throughout AArch64InstrInfo.cpp. It might be good to refactor these to use something like getScale in the future to prevent breakage, since it seems like in all these places roughly the same instructions are being used. (I tried shoehorning the scale calculation into getMemOpBaseRegImmOfsWidth, but it seemed a little kludgey.)

[MatzeB]

lib/Target/AArch64/AArch64InstrInfo.cpp

1410–1463

Seeing that this is another instance of information about every load/store instruction. How about emitting this information as well if we go for something like getMemOpInfo()?

lib/Target/AArch64/AArch64InstrInfo.h

223

We should only put short and performance critical functions into a header (and well templates force you sometimes).

It shouldn't be too hard to share code with getMemOpBaseRegImmOfsWidth() and for maintenance reasons we really should do so:

• Add a new function similar to this:

/// Returns true if opcode \p Opc is a memory operation and set \p Scale and \p Width
/// accordingly.
bool getMemOpInfo(unsigned Opcode, unsigned &Scale, unsigned &Width) {
   switch (Opc) {
      // Move stuff from getMemOpBaseRegImmOfsWidth() here
   }
}

bool AArch64InstrInfo::getMemOpBaseRegImmOfsWidth(...) {
   // ... keep the beginning as is ...
   unsigned Scale = 0;
   if (!getMemOpInfo(LdSt.getOpcode(), Width, Scale))
     return false;
   // ... keep end as is ...
}

// Every use of getScale() can now call getMemOpInfo() and just ignore the Width value

[paquette]

Updated the diff to address comments.

Changes

• Replaced getScale with getMemOpInfo.
• Replaced the switch statement in getMemOpBaseRegImmOfsWidth with a call to getMemOpInfo.

In the future, getMemOpInfo can probably be expanded so that the other functions that use large switch statements over all loads/stores use it (or something similar) instead.

[MatzeB]

LGTM, just check that return false branch (see below).

We should also have a test for the behavior on overflowing offset operands. However I see that this is really hard to test with .ll files so go ahead for now but please add a TODO and implement it later when we have fixed .mir parsing to work with passes that create new functions like the outliner.

lib/Target/AArch64/AArch64InstrInfo.cpp

1760

This had

default: return false;

before, was this case impossible to hit or do we need if (!getMemOpInfo()) return false?

[MatzeB]

Looks like this was committed in r298162

lib/Target/AArch64/AArch64InstrInfo.h

public:
   /// Returns true if there is a shiftable register and that the shift value
   /// is non-zero.
   bool hasShiftedReg(const MachineInstr &MI) const;
 
   /// Returns true if there is an extendable register and that the extending
   /// value is non-zero.
   bool hasExtendedReg(const MachineInstr &MI) const;
 
+  /// Return true if \p Offset is encodable for an instruction \p MI.
+  bool isEncodableLdStOffset(const MachineInstr &MI, int64_t Offset) const;
+
   /// \brief Does this instruction set its full destination register to zero?
   bool isGPRZero(const MachineInstr &MI) const;
 
   /// \brief Does this instruction rename a GPR without modifying bits?
   bool isGPRCopy(const MachineInstr &MI) const;
 
   /// \brief Does this instruction rename an FPR without modifying bits?
   bool isFPRCopy(const MachineInstr &MI) const;
public:
   bool getMemOpBaseRegImmOfs(MachineInstr &LdSt, unsigned &BaseReg,
                              int64_t &Offset,
                              const TargetRegisterInfo *TRI) const override;
 
   bool getMemOpBaseRegImmOfsWidth(MachineInstr &LdSt, unsigned &BaseReg,
                                   int64_t &Offset, unsigned &Width,
                                   const TargetRegisterInfo *TRI) const;
 
+  /// Return the immediate offset of the base register in a load/store \p LdSt.
+  MachineOperand &getMemOpBaseRegImmOfsOffsetOperand(MachineInstr &LdSt) const;
+
+  /// \brief Return the scale applied to the immediate offset for an instruction
+  /// with opcode \p Opc.
+  static int getScale(unsigned Opc) {
+    switch(Opc) {
+    default:
+      return -1;
+    case AArch64::LDRBBui:
+    case AArch64::LDRBui:
+    case AArch64::LDURBBi:
+    case AArch64::LDURBi:
+    case AArch64::LDURDi:
+    case AArch64::LDURHHi:
+    case AArch64::LDURHi:
+    case AArch64::LDURQi:
+    case AArch64::LDURSBWi:
+    case AArch64::LDURSBXi:
+    case AArch64::LDURSHWi:
+    case AArch64::LDURSHXi:
+    case AArch64::LDURSWi:
+    case AArch64::LDURSi:
+    case AArch64::LDURWi:
+    case AArch64::LDURXi:
+    case AArch64::STRBBui:
+    case AArch64::STRBui:
+    case AArch64::STURBBi:
+    case AArch64::STURBi:
+    case AArch64::STURDi:
+    case AArch64::STURHHi:
+    case AArch64::STURHi:
+    case AArch64::STURQi:
+    case AArch64::STURSi:
+    case AArch64::STURWi:
+    case AArch64::STURXi:
+    return 1;
+
+    case AArch64::LDRHHui:
+    case AArch64::LDRHui:
+    case AArch64::LDRSHWui:
+    case AArch64::LDRSHXui:
+    case AArch64::STRHHui:
+    case AArch64::STRHui:
+      return 2;
+
+    case AArch64::LDNPSi:
+    case AArch64::LDNPWi:
+    case AArch64::LDPSi:
+    case AArch64::LDPWi:
+    case AArch64::LDRSWui:
+    case AArch64::LDRSui:
+    case AArch64::LDRWui:
+    case AArch64::STNPSi:
+    case AArch64::STNPWi:
+    case AArch64::STPSi:
+    case AArch64::STPWi:
+    case AArch64::STRSui:
+    case AArch64::STRWui:
+      return 4;
+
+    case AArch64::LDNPDi:
+    case AArch64::LDNPXi:
+    case AArch64::LDPDi:
+    case AArch64::LDPXi:
+    case AArch64::LDRDui:
+    case AArch64::LDRXui:
+    case AArch64::PRFMui:
+    case AArch64::STNPDi:
+    case AArch64::STNPXi:
+    case AArch64::STPDi:
+    case AArch64::STPXi:
+    case AArch64::STRDui:
+    case AArch64::STRXui:
+      return 8;
+
+    case AArch64::LDNPQi:
+    case AArch64::LDPQi:
+    case AArch64::LDRQui:
+    case AArch64::STNPQi:
+    case AArch64::STPQi:
+    case AArch64::STRQui:
+      return 16;
+    }
+  }
+
   bool shouldClusterMemOps(MachineInstr &FirstLdSt, MachineInstr &SecondLdSt,
                            unsigned NumLoads) const override;
 
   MachineInstr *emitFrameIndexDebugValue(MachineFunction &MF, int FrameIx,
                                          uint64_t Offset, const MDNode *Var,
                                          const MDNode *Expr,
                                          const DebugLoc &DL) const;
   void copyPhysRegTuple(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
public:
 
   std::pair<unsigned, unsigned>
   decomposeMachineOperandsTargetFlags(unsigned TF) const override;
   ArrayRef<std::pair<unsigned, const char *>>
   getSerializableDirectMachineOperandTargetFlags() const override;
   ArrayRef<std::pair<unsigned, const char *>>
   getSerializableBitmaskMachineOperandTargetFlags() const override;
 
+  bool isFunctionSafeToOutlineFrom(MachineFunction &MF) const override;
+  unsigned getOutliningBenefit(size_t SequenceSize, size_t Occurrences,
+                               bool CanBeTailCall) const override;
+  AArch64GenInstrInfo::MachineOutlinerInstrType
+  getOutliningType(MachineInstr &MI) const override;
+  void insertOutlinerEpilogue(MachineBasicBlock &MBB,
+                              MachineFunction &MF,
+                              bool IsTailCall) const override;
+  void insertOutlinerPrologue(MachineBasicBlock &MBB,
+                              MachineFunction &MF,
+                              bool isTailCall) const override;
+  MachineBasicBlock::iterator
+  insertOutlinedCall(Module &M, MachineBasicBlock &MBB,
+                     MachineBasicBlock::iterator &It,
+                     MachineFunction &MF,
+                     bool IsTailCall) const override;
+
 private:
+
+  /// \brief Sets the offsets on outlined instructions in \p MBB which use SP
+  /// so that they will be valid post-outlining.
+  ///
+  /// \param MBB A \p MachineBasicBlock in an outlined function.
+  void fixupPostOutline(MachineBasicBlock &MBB) const;
+
   void instantiateCondBranch(MachineBasicBlock &MBB, const DebugLoc &DL,
                              MachineBasicBlock *TBB,
                              ArrayRef<MachineOperand> Cond) const;
   bool substituteCmpToZero(MachineInstr &CmpInstr, unsigned SrcReg,
                            const MachineRegisterInfo *MRI) const;
 };
 
 /// emitFrameOffset - Emit instructions as needed to set DestReg to SrcReg

lib/Target/AArch64/AArch64InstrInfo.cpp

 //===- AArch64InstrInfo.cpp - AArch64 Instruction Information -------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the AArch64 implementation of the TargetInstrInfo class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "AArch64InstrInfo.h"
+#include "AArch64MachineFunctionInfo.h"
 #include "AArch64Subtarget.h"
 #include "MCTargetDesc/AArch64AddressingModes.h"
 #include "Utils/AArch64BaseInfo.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
if (MI.getOperand(3).isImm()) {
       return (val != 0);
     }
     break;
   }
 
   return false;
 }
 
+bool AArch64InstrInfo::isEncodableLdStOffset(const MachineInstr &MI,
+                                             int64_t Offset) const {
+  assert(MI.mayLoadOrStore() && "Expected a load/store!");
+
+  // Get the scale for the opcode and recompute the offset using it.
+  int Scale = getScale(MI.getOpcode());
+
+  // Does the instruction even have a scale?
+  if (Scale == -1)
+    return false;
+
+  Offset /= Scale;
+
+  // Check if the offset is in the range.
+  switch(MI.getOpcode()) {
+    // Unsigned instructions.
+    default:
+      return (Offset >= 0 && Offset <= 4095);
+
+    // Signed instructions with 9 bit offsets.
+    case AArch64::LDURXi:
+    case AArch64::LDURWi:
+    case AArch64::LDURBi:
+    case AArch64::LDURHi:
+    case AArch64::LDURSi:
+    case AArch64::LDURDi:
+    case AArch64::LDURQi:
+    case AArch64::LDURHHi:
+    case AArch64::LDURBBi:
+    case AArch64::LDURSBXi:
+    case AArch64::LDURSBWi:
+    case AArch64::LDURSHXi:
+    case AArch64::LDURSHWi:
+    case AArch64::LDURSWi:
+    case AArch64::STURXi:
+    case AArch64::STURWi:
+    case AArch64::STURBi:
+    case AArch64::STURHi:
+    case AArch64::STURSi:
+    case AArch64::STURDi:
+    case AArch64::STURQi:
+    case AArch64::STURBBi:
+    case AArch64::STURHHi:
+      return (Offset >= -256 && Offset <= 255);
+
+    // Signed instructions with 7 bit offsets.
+    case AArch64::LDPXi:
+    case AArch64::LDPDi:
+    case AArch64::STPXi:
+    case AArch64::STPDi:
+    case AArch64::LDNPXi:
+    case AArch64::LDNPDi:
+    case AArch64::STNPXi:
+    case AArch64::STNPDi:
+    case AArch64::LDPQi:
+    case AArch64::STPQi:
+    case AArch64::LDNPQi:
+    case AArch64::STNPQi:
+    case AArch64::LDPWi:
+    case AArch64::LDPSi:
+    case AArch64::STPWi:
+    case AArch64::STPSi:
+    case AArch64::LDNPWi:
+    case AArch64::LDNPSi:
+    case AArch64::STNPWi:
+      return (Offset >= -64 && Offset <= 63);
+  }
+}
+
 // Return true if this instruction simply sets its single destination register
 // to zero. This is equivalent to a register rename of the zero-register.
 bool AArch64InstrInfo::isGPRZero(const MachineInstr &MI) const {
   switch (MI.getOpcode()) {
   default:
     break;
   case AArch64::MOVZWi:
   case AArch64::MOVZXi: // movz Rd, #0 (LSL #0)
if (!LdSt.getOperand(1).isReg() || !LdSt.getOperand(2).isReg() ||
       return false;
   } else
     return false;
 
   // Offset is calculated as the immediate operand multiplied by the scaling factor.
   // Unscaled instructions have scaling factor set to 1.
   unsigned Scale = 0;
   switch (LdSt.getOpcode()) {
   default:
     return false;
   case AArch64::LDURQi:
   case AArch64::STURQi:
     Width = 16;
     Scale = 1;
     break;
   case AArch64::LDURXi:
   case AArch64::LDURDi:
bool AArch64InstrInfo::getMemOpBaseRegImmOfsWidth(
   } else {
     assert(LdSt.getNumExplicitOperands() == 4 && "invalid number of operands");
     BaseReg = LdSt.getOperand(2).getReg();
     Offset = LdSt.getOperand(3).getImm() * Scale;
   }
   return true;
 }
 
+MachineOperand&
+AArch64InstrInfo::getMemOpBaseRegImmOfsOffsetOperand(MachineInstr &LdSt) const {
+  assert(LdSt.mayLoadOrStore() && "Expected a memory operation.");
+  MachineOperand &OfsOp = LdSt.getOperand(LdSt.getNumExplicitOperands()-1);
+  assert(OfsOp.isImm() && "Offset operand wasn't immediate.");
+  return OfsOp;
+}
+
 // Scale the unscaled offsets.  Returns false if the unscaled offset can't be
 // scaled.
 static bool scaleOffset(unsigned Opc, int64_t &Offset) {
   unsigned OffsetStride = 1;
   switch (Opc) {
   default:
     return false;
   case AArch64::LDURQi:
AArch64InstrInfo::getSerializableBitmaskMachineOperandTargetFlags() const {
   using namespace AArch64II;
 
   static const std::pair<unsigned, const char *> TargetFlags[] = {
       {MO_GOT, "aarch64-got"},
       {MO_NC, "aarch64-nc"},
       {MO_TLS, "aarch64-tls"}};
   return makeArrayRef(TargetFlags);
 }
+
+unsigned AArch64InstrInfo::getOutliningBenefit(size_t SequenceSize,
+                                               size_t Occurrences,
+                                               bool CanBeTailCall) const {
+  unsigned NotOutlinedSize = SequenceSize * Occurrences;
+  unsigned OutlinedSize;
+
+  // Is this candidate something we can outline as a tail call?
+  if (CanBeTailCall) {
+    // If yes, then we just outline the sequence and replace each of its
+    // occurrences with a branch instruction.
+    OutlinedSize = SequenceSize + Occurrences;
+  } else {
+    // If no, then we outline the sequence (SequenceSize), add a return (+1),
+    // and replace each occurrence with a save/restore to LR and a call
+    // (3 * Occurrences)
+    OutlinedSize = (SequenceSize + 1) + (3 * Occurrences);
+  }
+
+  // Return the number of instructions saved by outlining this sequence.
+  return NotOutlinedSize > OutlinedSize ? NotOutlinedSize - OutlinedSize : 0;
+}
+
+bool AArch64InstrInfo::isFunctionSafeToOutlineFrom(MachineFunction &MF) const {
+  return MF.getFunction()->hasFnAttribute(Attribute::NoRedZone);
+}
+
+AArch64GenInstrInfo::MachineOutlinerInstrType
+AArch64InstrInfo::getOutliningType(MachineInstr &MI) const {
+
+  MachineFunction *MF = MI.getParent()->getParent();
+  AArch64FunctionInfo *FuncInfo = MF->getInfo<AArch64FunctionInfo>();
+
+  // Don't outline LOHs.
+  if (FuncInfo->getLOHRelated().count(&MI))
+    return MachineOutlinerInstrType::Illegal;
+
+  // Don't allow debug values to impact outlining type.
+  if (MI.isDebugValue() || MI.isIndirectDebugValue())
+    return MachineOutlinerInstrType::Invisible;
+
+  // Is this a terminator for a basic block?
+  if (MI.isTerminator()) {
+
+    // Is this the end of a function?
+    if (MI.getParent()->succ_empty())
+        return MachineOutlinerInstrType::Legal;
+
+    // It's not, so don't outline it.
+    return MachineOutlinerInstrType::Illegal;
+  }
+
+  // Don't outline positions.
+  if (MI.isPosition())
+    return MachineOutlinerInstrType::Illegal;
+
+  // 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 MachineOutlinerInstrType::Illegal;
+
+  // Don't outline anything that uses the link register.
+  if (MI.modifiesRegister(AArch64::LR, &RI) ||
+      MI.readsRegister(AArch64::LR, &RI))
+      return MachineOutlinerInstrType::Illegal;
+
+  // Does this use the stack?
+  if (MI.modifiesRegister(AArch64::SP, &RI) ||
+      MI.readsRegister(AArch64::SP, &RI)) {
+
+    // Is it a memory operation?
+    if (MI.mayLoadOrStore()) {
+      unsigned Base; // Filled with the base regiser of MI.
+      int64_t Offset; // Filled with the offset of MI.
+      unsigned Dummy;
+
+      // Does it allow us to offset the base register and is the base SP?
+      if (!getMemOpBaseRegImmOfsWidth(MI, Base, Offset, Dummy, &RI) ||
+                                      Base != AArch64::SP)
+        return MachineOutlinerInstrType::Illegal;
+
+      // Would adding the fixup overflow the instruction?
+      if (!isEncodableLdStOffset(MI, Offset + 16))
+        return MachineOutlinerInstrType::Illegal;
+
+      // It's fixable, so we can outline it.
+      return MachineOutlinerInstrType::Legal;
+    }
+
+    // We can't fix it up, so don't outline it.
+    return MachineOutlinerInstrType::Illegal;
+  }
+
+  return MachineOutlinerInstrType::Legal;
+}
+
+void AArch64InstrInfo::fixupPostOutline(MachineBasicBlock &MBB) const {
+  for (MachineInstr &MI : MBB) {
+    unsigned Base, Width;
+    int64_t Offset;
+
+    // Is this a load or store with an immediate offset with SP as the base?
+    if (!MI.mayLoadOrStore() ||
+        !getMemOpBaseRegImmOfsWidth(MI, Base, Offset, Width, &RI) ||
+        Base != AArch64::SP)
+      continue;
+
+    // It is, so we have to fix it up.
+    MachineOperand &StackOffsetOperand = getMemOpBaseRegImmOfsOffsetOperand(MI);
+    assert(StackOffsetOperand.isImm() && "Stack offset wasn't immediate!");
+    unsigned Scale = getScale(MI.getOpcode());
+    assert(Scale != 0 && "Instruction doesn't have a scale!");
+
+    // We've pushed the return address to the stack, so add 16 to the offset.
+    // This is safe, since we already checked if it would overflow when we
+    // checked if this instruction was legal to outline.
+    int64_t NewImm = (Offset + 16)/Scale;
+    StackOffsetOperand.setImm(NewImm);
+  }
+}
+
+void AArch64InstrInfo::insertOutlinerEpilogue(MachineBasicBlock &MBB,
+                                              MachineFunction &MF,
+                                              bool IsTailCall) const {
+
+  // If this is a tail call outlined function, then there's already a return.
+  if (IsTailCall)
+    return;
+
+  // It's not a tail call, so we have to insert the return ourselves.
+  MachineInstr *ret = BuildMI(MF, DebugLoc(), get(AArch64::RET))
+                          .addReg(AArch64::LR, RegState::Undef);
+  MBB.insert(MBB.end(), ret);
+
+  // Walk over the basic block and fix up all the stack accesses.
+  fixupPostOutline(MBB);
+}
+
+void AArch64InstrInfo::insertOutlinerPrologue(MachineBasicBlock &MBB,
+                                              MachineFunction &MF,
+                                              bool IsTailCall) const {}
+
+MachineBasicBlock::iterator AArch64InstrInfo::insertOutlinedCall(
+    Module &M, MachineBasicBlock &MBB, MachineBasicBlock::iterator &It,
+    MachineFunction &MF, bool IsTailCall) const {
+
+  // Are we tail calling?
+  if (IsTailCall) {
+    // If yes, then we can just branch to the label.
+    It = MBB.insert(It,
+                    BuildMI(MF, DebugLoc(), get(AArch64::B))
+                        .addGlobalAddress(M.getNamedValue(MF.getName())));
+    return It;
+  }
+
+  // We're not tail calling, so we have to save LR before the call and restore
+  // it after.
+  MachineInstr *STRXpre = BuildMI(MF, DebugLoc(), get(AArch64::STRXpre))
+                              .addReg(AArch64::SP, RegState::Define)
+                              .addReg(AArch64::LR)
+                              .addReg(AArch64::SP)
+                              .addImm(-16);
+  It = MBB.insert(It, STRXpre);
+  It++;
+
+  // Insert the call.
+  It = MBB.insert(It,
+                  BuildMI(MF, DebugLoc(), get(AArch64::BL))
+                      .addGlobalAddress(M.getNamedValue(MF.getName())));
+
+  It++;
+
+  // Restore the link register.
+  MachineInstr *LDRXpost = BuildMI(MF, DebugLoc(), get(AArch64::LDRXpost))
+                               .addReg(AArch64::SP, RegState::Define)
+                               .addReg(AArch64::LR)
+                               .addReg(AArch64::SP)
+                               .addImm(16);
+  It = MBB.insert(It, LDRXpost);
+
+  return It;
+}
+

test/CodeGen/AArch64/machine-outliner.ll

+; RUN: llc -enable-machine-outliner -mtriple=aarch64-apple-darwin < %s | FileCheck %s
+
+define void @cat() #0 {
+; CHECK-LABEL: _cat:
+; CHECK: b l_OUTLINED_FUNCTION_0
+; CHECK-NOT: ret
+  %1 = alloca i32, align 4
+  %2 = alloca i32, align 4
+  %3 = alloca i32, align 4
+  %4 = alloca i32, align 4
+  store i32 0, i32* %1, align 4
+  store i32 1, i32* %2, align 4
+  store i32 2, i32* %3, align 4
+  store i32 3, i32* %4, align 4
+  ret void
+}
+
+define void @dog() #0 {
+; CHECK-LABEL: _dog:
+; CHECK: b l_OUTLINED_FUNCTION_0
+; CHECK-NOT: ret
+  %1 = alloca i32, align 4
+  %2 = alloca i32, align 4
+  %3 = alloca i32, align 4
+  %4 = alloca i32, align 4
+  store i32 0, i32* %1, align 4
+  store i32 1, i32* %2, align 4
+  store i32 2, i32* %3, align 4
+  store i32 3, i32* %4, align 4
+  ret void
+}
+
+; CHECK-LABEL: l_OUTLINED_FUNCTION_0:
+; CHECK:      orr w8, wzr, #0x1
+; CHECK-NEXT: stp w8, wzr, [sp, #8]
+; CHECK-NEXT: orr w8, wzr, #0x2
+; CHECK-NEXT: str w8, [sp, #4]
+; CHECK-NEXT: orr w8, wzr, #0x3
+; CHECK-NEXT: str w8, [sp], #16
+; CHECK-NEXT: ret
+
+
+attributes #0 = { noredzone nounwind ssp uwtable "no-frame-pointer-elim"="false" "target-cpu"="cyclone" }