diff --git a/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp b/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp
index dd10050592190..3d740a0cb3dc7 100644
--- a/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp
+++ b/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp
@@ -169,18 +169,22 @@ class AArch64AsmPrinter : public AsmPrinter {
   void emitPtrauthTailCallHardening(const MachineInstr *TC);
 
   // Emit the sequence for AUT or AUTPAC.
-  void emitPtrauthAuthResign(const MachineInstr *MI);
+  void emitPtrauthAuthResign(Register AUTVal, AArch64PACKey::ID AUTKey,
+                             uint64_t AUTDisc,
+                             const MachineOperand *AUTAddrDisc,
+                             Register Scratch,
+                             std::optional<AArch64PACKey::ID> PACKey,
+                             uint64_t PACDisc, Register PACAddrDisc);
 
   // Emit the sequence to compute the discriminator.
   //
-  // ScratchReg should be x16/x17.
-  //
-  // The returned register is either unmodified AddrDisc or x16/x17.
+  // The returned register is either unmodified AddrDisc or ScratchReg.
   //
   // If the expanded pseudo is allowed to clobber AddrDisc register, setting
   // MayUseAddrAsScratch may save one MOV instruction, provided the address
   // is already in x16/x17 (i.e. return x16/x17 which is the *modified* AddrDisc
-  // register at the same time):
+  // register at the same time) or the OS doesn't make it safer to use x16/x17
+  // (see AArch64Subtarget::isX16X17Safer()):
   //
   //   mov   x17, x16
   //   movk  x17, #1234, lsl #48
@@ -1867,7 +1871,8 @@ Register AArch64AsmPrinter::emitPtrauthDiscriminator(uint16_t Disc,
                                                      Register AddrDisc,
                                                      Register ScratchReg,
                                                      bool MayUseAddrAsScratch) {
-  assert(ScratchReg == AArch64::X16 || ScratchReg == AArch64::X17);
+  assert(ScratchReg == AArch64::X16 || ScratchReg == AArch64::X17 ||
+         !STI->isX16X17Safer());
   // So far we've used NoRegister in pseudos.  Now we need real encodings.
   if (AddrDisc == AArch64::NoRegister)
     AddrDisc = AArch64::XZR;
@@ -1887,7 +1892,8 @@ Register AArch64AsmPrinter::emitPtrauthDiscriminator(uint16_t Disc,
 
   // Check if we can save one MOV instruction.
   assert(MayUseAddrAsScratch || ScratchReg != AddrDisc);
-  bool AddrDiscIsSafe = AddrDisc == AArch64::X16 || AddrDisc == AArch64::X17;
+  bool AddrDiscIsSafe = AddrDisc == AArch64::X16 || AddrDisc == AArch64::X17 ||
+                        !STI->isX16X17Safer();
   if (MayUseAddrAsScratch && AddrDiscIsSafe)
     ScratchReg = AddrDisc;
   else
@@ -2065,8 +2071,12 @@ void AArch64AsmPrinter::emitPtrauthTailCallHardening(const MachineInstr *TC) {
       /*ShouldTrap=*/true, /*OnFailure=*/nullptr);
 }
 
-void AArch64AsmPrinter::emitPtrauthAuthResign(const MachineInstr *MI) {
-  const bool IsAUTPAC = MI->getOpcode() == AArch64::AUTPAC;
+void AArch64AsmPrinter::emitPtrauthAuthResign(
+    Register AUTVal, AArch64PACKey::ID AUTKey, uint64_t AUTDisc,
+    const MachineOperand *AUTAddrDisc, Register Scratch,
+    std::optional<AArch64PACKey::ID> PACKey, uint64_t PACDisc,
+    Register PACAddrDisc) {
+  const bool IsAUTPAC = PACKey.has_value();
 
   // We expand AUT/AUTPAC into a sequence of the form
   //
@@ -2105,14 +2115,10 @@ void AArch64AsmPrinter::emitPtrauthAuthResign(const MachineInstr *MI) {
     break;
   }
 
-  auto AUTKey = (AArch64PACKey::ID)MI->getOperand(0).getImm();
-  uint64_t AUTDisc = MI->getOperand(1).getImm();
-  unsigned AUTAddrDisc = MI->getOperand(2).getReg();
-
-  // Compute aut discriminator into x17
+  // Compute aut discriminator
   assert(isUInt<16>(AUTDisc));
-  Register AUTDiscReg =
-      emitPtrauthDiscriminator(AUTDisc, AUTAddrDisc, AArch64::X17);
+  Register AUTDiscReg = emitPtrauthDiscriminator(
+      AUTDisc, AUTAddrDisc->getReg(), Scratch, AUTAddrDisc->isKill());
   bool AUTZero = AUTDiscReg == AArch64::XZR;
   unsigned AUTOpc = getAUTOpcodeForKey(AUTKey, AUTZero);
 
@@ -2120,8 +2126,8 @@ void AArch64AsmPrinter::emitPtrauthAuthResign(const MachineInstr *MI) {
   //  autia x16, x17  ; if !AUTZero
   MCInst AUTInst;
   AUTInst.setOpcode(AUTOpc);
-  AUTInst.addOperand(MCOperand::createReg(AArch64::X16));
-  AUTInst.addOperand(MCOperand::createReg(AArch64::X16));
+  AUTInst.addOperand(MCOperand::createReg(AUTVal));
+  AUTInst.addOperand(MCOperand::createReg(AUTVal));
   if (!AUTZero)
     AUTInst.addOperand(MCOperand::createReg(AUTDiscReg));
   EmitToStreamer(*OutStreamer, AUTInst);
@@ -2136,7 +2142,7 @@ void AArch64AsmPrinter::emitPtrauthAuthResign(const MachineInstr *MI) {
     if (IsAUTPAC && !ShouldTrap)
       EndSym = createTempSymbol("resign_end_");
 
-    emitPtrauthCheckAuthenticatedValue(AArch64::X16, AArch64::X17, AUTKey,
+    emitPtrauthCheckAuthenticatedValue(AUTVal, Scratch, AUTKey,
                                        AArch64PAuth::AuthCheckMethod::XPAC,
                                        ShouldTrap, EndSym);
   }
@@ -2147,23 +2153,19 @@ void AArch64AsmPrinter::emitPtrauthAuthResign(const MachineInstr *MI) {
   if (!IsAUTPAC)
     return;
 
-  auto PACKey = (AArch64PACKey::ID)MI->getOperand(3).getImm();
-  uint64_t PACDisc = MI->getOperand(4).getImm();
-  unsigned PACAddrDisc = MI->getOperand(5).getReg();
-
-  // Compute pac discriminator into x17
+  // Compute pac discriminator
   assert(isUInt<16>(PACDisc));
   Register PACDiscReg =
-      emitPtrauthDiscriminator(PACDisc, PACAddrDisc, AArch64::X17);
+      emitPtrauthDiscriminator(PACDisc, PACAddrDisc, Scratch);
   bool PACZero = PACDiscReg == AArch64::XZR;
-  unsigned PACOpc = getPACOpcodeForKey(PACKey, PACZero);
+  unsigned PACOpc = getPACOpcodeForKey(*PACKey, PACZero);
 
   //  pacizb x16      ; if  PACZero
   //  pacib x16, x17  ; if !PACZero
   MCInst PACInst;
   PACInst.setOpcode(PACOpc);
-  PACInst.addOperand(MCOperand::createReg(AArch64::X16));
-  PACInst.addOperand(MCOperand::createReg(AArch64::X16));
+  PACInst.addOperand(MCOperand::createReg(AUTVal));
+  PACInst.addOperand(MCOperand::createReg(AUTVal));
   if (!PACZero)
     PACInst.addOperand(MCOperand::createReg(PACDiscReg));
   EmitToStreamer(*OutStreamer, PACInst);
@@ -2862,9 +2864,26 @@ void AArch64AsmPrinter::emitInstruction(const MachineInstr *MI) {
     return;
   }
 
-  case AArch64::AUT:
+  case AArch64::AUTx16x17:
+    emitPtrauthAuthResign(AArch64::X16,
+                          (AArch64PACKey::ID)MI->getOperand(0).getImm(),
+                          MI->getOperand(1).getImm(), &MI->getOperand(2),
+                          AArch64::X17, std::nullopt, 0, 0);
+    return;
+
+  case AArch64::AUTxMxN:
+    emitPtrauthAuthResign(MI->getOperand(0).getReg(),
+                          (AArch64PACKey::ID)MI->getOperand(3).getImm(),
+                          MI->getOperand(4).getImm(), &MI->getOperand(5),
+                          MI->getOperand(1).getReg(), std::nullopt, 0, 0);
+    return;
+
   case AArch64::AUTPAC:
-    emitPtrauthAuthResign(MI);
+    emitPtrauthAuthResign(
+        AArch64::X16, (AArch64PACKey::ID)MI->getOperand(0).getImm(),
+        MI->getOperand(1).getImm(), &MI->getOperand(2), AArch64::X17,
+        (AArch64PACKey::ID)MI->getOperand(3).getImm(),
+        MI->getOperand(4).getImm(), MI->getOperand(5).getReg());
     return;
 
   case AArch64::LOADauthptrstatic:
diff --git a/llvm/lib/Target/AArch64/AArch64ISelDAGToDAG.cpp b/llvm/lib/Target/AArch64/AArch64ISelDAGToDAG.cpp
index da617b7e19266..eca7ca566cfc2 100644
--- a/llvm/lib/Target/AArch64/AArch64ISelDAGToDAG.cpp
+++ b/llvm/lib/Target/AArch64/AArch64ISelDAGToDAG.cpp
@@ -1534,12 +1534,20 @@ void AArch64DAGToDAGISel::SelectPtrauthAuth(SDNode *N) {
   std::tie(AUTConstDisc, AUTAddrDisc) =
       extractPtrauthBlendDiscriminators(AUTDisc, CurDAG);
 
-  SDValue X16Copy = CurDAG->getCopyToReg(CurDAG->getEntryNode(), DL,
-                                         AArch64::X16, Val, SDValue());
-  SDValue Ops[] = {AUTKey, AUTConstDisc, AUTAddrDisc, X16Copy.getValue(1)};
+  if (!Subtarget->isX16X17Safer()) {
+    SDValue Ops[] = {Val, AUTKey, AUTConstDisc, AUTAddrDisc};
 
-  SDNode *AUT = CurDAG->getMachineNode(AArch64::AUT, DL, MVT::i64, Ops);
-  ReplaceNode(N, AUT);
+    SDNode *AUT =
+        CurDAG->getMachineNode(AArch64::AUTxMxN, DL, MVT::i64, MVT::i64, Ops);
+    ReplaceNode(N, AUT);
+  } else {
+    SDValue X16Copy = CurDAG->getCopyToReg(CurDAG->getEntryNode(), DL,
+                                           AArch64::X16, Val, SDValue());
+    SDValue Ops[] = {AUTKey, AUTConstDisc, AUTAddrDisc, X16Copy.getValue(1)};
+
+    SDNode *AUT = CurDAG->getMachineNode(AArch64::AUTx16x17, DL, MVT::i64, Ops);
+    ReplaceNode(N, AUT);
+  }
 }
 
 void AArch64DAGToDAGISel::SelectPtrauthResign(SDNode *N) {
diff --git a/llvm/lib/Target/AArch64/AArch64InstrInfo.td b/llvm/lib/Target/AArch64/AArch64InstrInfo.td
index 0cb7b02d84a6e..761ba87c1f31d 100644
--- a/llvm/lib/Target/AArch64/AArch64InstrInfo.td
+++ b/llvm/lib/Target/AArch64/AArch64InstrInfo.td
@@ -2129,10 +2129,11 @@ let Predicates = [HasPAuth] in {
   defm LDRAB  : AuthLoad<1, "ldrab", simm10Scaled>;
 
   // AUT pseudo.
-  // This directly manipulates x16/x17, which are the only registers the OS
-  // guarantees are safe to use for sensitive operations.
-  def AUT : Pseudo<(outs), (ins i32imm:$Key, i64imm:$Disc, GPR64noip:$AddrDisc),
-                   []>, Sched<[WriteI, ReadI]> {
+  // This directly manipulates x16/x17, which are the only registers that
+  // certain OSs guarantee are safe to use for sensitive operations.
+  def AUTx16x17 : Pseudo<(outs), (ins i32imm:$Key, i64imm:$Disc,
+                                      GPR64noip:$AddrDisc),
+                         []>, Sched<[WriteI, ReadI]> {
     let isCodeGenOnly = 1;
     let hasSideEffects = 1;
     let mayStore = 0;
@@ -2142,9 +2143,22 @@ let Predicates = [HasPAuth] in {
     let Uses = [X16];
   }
 
+  def AUTxMxN : Pseudo<(outs GPR64:$AuthVal, GPR64common:$Scratch),
+                       (ins GPR64:$Val, i32imm:$Key,
+                            i64imm:$Disc, GPR64:$AddrDisc),
+                       [], "$AuthVal = $Val">, Sched<[WriteI, ReadI]> {
+    let isCodeGenOnly = 1;
+    let hasSideEffects = 0;
+    let mayStore = 0;
+    let mayLoad = 0;
+    let Size = 32;
+    let Defs = [NZCV];
+    let Uses = [];
+  }
+
   // AUT and re-PAC a value, using different keys/data.
-  // This directly manipulates x16/x17, which are the only registers the OS
-  // guarantees are safe to use for sensitive operations.
+  // This directly manipulates x16/x17, which are the only registers that
+  // certain OSs guarantee are safe to use for sensitive operations.
   def AUTPAC
       : Pseudo<(outs),
                (ins i32imm:$AUTKey, i64imm:$AUTDisc, GPR64noip:$AUTAddrDisc,
diff --git a/llvm/lib/Target/AArch64/AArch64Subtarget.cpp b/llvm/lib/Target/AArch64/AArch64Subtarget.cpp
index 68ed10570a52f..0956823346795 100644
--- a/llvm/lib/Target/AArch64/AArch64Subtarget.cpp
+++ b/llvm/lib/Target/AArch64/AArch64Subtarget.cpp
@@ -664,6 +664,12 @@ AArch64Subtarget::getPtrAuthBlockAddressDiscriminatorIfEnabled(
       (Twine(ParentFn.getName()) + " blockaddress").str());
 }
 
+bool AArch64Subtarget::isX16X17Safer() const {
+  // The Darwin kernel implements special protections for x16 and x17 so we
+  // should prefer to use those registers on that platform.
+  return isTargetDarwin();
+}
+
 bool AArch64Subtarget::enableMachinePipeliner() const {
   return getSchedModel().hasInstrSchedModel();
 }
diff --git a/llvm/lib/Target/AArch64/AArch64Subtarget.h b/llvm/lib/Target/AArch64/AArch64Subtarget.h
index f95b0fafc607f..154db3c074f71 100644
--- a/llvm/lib/Target/AArch64/AArch64Subtarget.h
+++ b/llvm/lib/Target/AArch64/AArch64Subtarget.h
@@ -318,6 +318,10 @@ class AArch64Subtarget final : public AArch64GenSubtargetInfo {
     }
   }
 
+  /// Returns whether the operating system makes it safer to store sensitive
+  /// values in x16 and x17 as opposed to other registers.
+  bool isX16X17Safer() const;
+
   /// ParseSubtargetFeatures - Parses features string setting specified
   /// subtarget options.  Definition of function is auto generated by tblgen.
   void ParseSubtargetFeatures(StringRef CPU, StringRef TuneCPU, StringRef FS);
diff --git a/llvm/lib/Target/AArch64/GISel/AArch64InstructionSelector.cpp b/llvm/lib/Target/AArch64/GISel/AArch64InstructionSelector.cpp
index d55ff5acb3dca..1381a9b70df87 100644
--- a/llvm/lib/Target/AArch64/GISel/AArch64InstructionSelector.cpp
+++ b/llvm/lib/Target/AArch64/GISel/AArch64InstructionSelector.cpp
@@ -6762,14 +6762,27 @@ bool AArch64InstructionSelector::selectIntrinsic(MachineInstr &I,
     std::tie(AUTConstDiscC, AUTAddrDisc) =
         extractPtrauthBlendDiscriminators(AUTDisc, MRI);
 
-    MIB.buildCopy({AArch64::X16}, {ValReg});
-    MIB.buildInstr(TargetOpcode::IMPLICIT_DEF, {AArch64::X17}, {});
-    MIB.buildInstr(AArch64::AUT)
-        .addImm(AUTKey)
-        .addImm(AUTConstDiscC)
-        .addUse(AUTAddrDisc)
-        .constrainAllUses(TII, TRI, RBI);
-    MIB.buildCopy({DstReg}, Register(AArch64::X16));
+    if (STI.isX16X17Safer()) {
+      MIB.buildCopy({AArch64::X16}, {ValReg});
+      MIB.buildInstr(TargetOpcode::IMPLICIT_DEF, {AArch64::X17}, {});
+      MIB.buildInstr(AArch64::AUTx16x17)
+          .addImm(AUTKey)
+          .addImm(AUTConstDiscC)
+          .addUse(AUTAddrDisc)
+          .constrainAllUses(TII, TRI, RBI);
+      MIB.buildCopy({DstReg}, Register(AArch64::X16));
+    } else {
+      Register ScratchReg =
+          MRI.createVirtualRegister(&AArch64::GPR64commonRegClass);
+      MIB.buildInstr(AArch64::AUTxMxN)
+          .addDef(DstReg)
+          .addDef(ScratchReg)
+          .addUse(ValReg)
+          .addImm(AUTKey)
+          .addImm(AUTConstDiscC)
+          .addUse(AUTAddrDisc)
+          .constrainAllUses(TII, TRI, RBI);
+    }
 
     RBI.constrainGenericRegister(DstReg, AArch64::GPR64RegClass, MRI);
     I.eraseFromParent();
diff --git a/llvm/test/CodeGen/AArch64/ptrauth-call.ll b/llvm/test/CodeGen/AArch64/ptrauth-call.ll
index bf35cf8fecbdb..700686b9f194b 100644
--- a/llvm/test/CodeGen/AArch64/ptrauth-call.ll
+++ b/llvm/test/CodeGen/AArch64/ptrauth-call.ll
@@ -169,13 +169,20 @@ define i32 @test_tailcall_ib_var(ptr %arg0, ptr %arg1) #0 {
 
 define void @test_tailcall_omit_mov_x16_x16(ptr %objptr) #0 {
 ; CHECK-LABEL: test_tailcall_omit_mov_x16_x16:
-; CHECK-NEXT:    ldr     x16, [x0]
-; CHECK-NEXT:    mov     x17, x0
-; CHECK-NEXT:    movk    x17, #6503, lsl #48
-; CHECK-NEXT:    autda   x16, x17
-; CHECK-NEXT:    ldr     x1, [x16]
-; CHECK-NEXT:    movk    x16, #54167, lsl #48
-; CHECK-NEXT:    braa    x1, x16
+; DARWIN-NEXT:    ldr     x16, [x0]
+; DARWIN-NEXT:    mov     x17, x0
+; DARWIN-NEXT:    movk    x17, #6503, lsl #48
+; DARWIN-NEXT:    autda   x16, x17
+; DARWIN-NEXT:    ldr     x1, [x16]
+; DARWIN-NEXT:    movk    x16, #54167, lsl #48
+; DARWIN-NEXT:    braa    x1, x16
+; ELF-NEXT:       ldr     x1, [x0]
+; ELF-NEXT:       mov     x8, x0
+; ELF-NEXT:       movk    x8, #6503, lsl #48
+; ELF-NEXT:       autda   x1, x8
+; ELF-NEXT:       ldr     x2, [x1]
+; ELF-NEXT:       movk    x1, #54167, lsl #48
+; ELF-NEXT:       braa    x2, x1
   %vtable.signed = load ptr, ptr %objptr, align 8
   %objptr.int = ptrtoint ptr %objptr to i64
   %vtable.discr = tail call i64 @llvm.ptrauth.blend(i64 %objptr.int, i64 6503)
@@ -191,16 +198,24 @@ define void @test_tailcall_omit_mov_x16_x16(ptr %objptr) #0 {
 define i32 @test_call_omit_extra_moves(ptr %objptr) #0 {
 ; CHECK-LABEL: test_call_omit_extra_moves:
 ; DARWIN-NEXT:   stp     x29, x30, [sp, #-16]!
-; ELF-NEXT:      str     x30, [sp, #-16]!
-; CHECK-NEXT:    ldr     x16, [x0]
-; CHECK-NEXT:    mov     x17, x0
-; CHECK-NEXT:    movk    x17, #6503, lsl #48
-; CHECK-NEXT:    autda   x16, x17
-; CHECK-NEXT:    ldr     x8, [x16]
-; CHECK-NEXT:    movk    x16, #34646, lsl #48
-; CHECK-NEXT:    blraa   x8, x16
-; CHECK-NEXT:    mov     w0, #42
+; DARWIN-NEXT:   ldr     x16, [x0]
+; DARWIN-NEXT:   mov     x17, x0
+; DARWIN-NEXT:   movk    x17, #6503, lsl #48
+; DARWIN-NEXT:   autda   x16, x17
+; DARWIN-NEXT:   ldr     x8, [x16]
+; DARWIN-NEXT:   movk    x16, #34646, lsl #48
+; DARWIN-NEXT:   blraa   x8, x16
+; DARWIN-NEXT:   mov     w0, #42
 ; DARWIN-NEXT:   ldp     x29, x30, [sp], #16
+; ELF-NEXT:      str     x30, [sp, #-16]!
+; ELF-NEXT:      ldr     x8, [x0]
+; ELF-NEXT:      mov     x9, x0
+; ELF-NEXT:      movk    x9, #6503, lsl #48
+; ELF-NEXT:      autda   x8, x9
+; ELF-NEXT:      ldr     x9, [x8]
+; ELF-NEXT:      movk    x8, #34646, lsl #48
+; ELF-NEXT:      blraa   x9, x8
+; ELF-NEXT:      mov     w0, #42
 ; ELF-NEXT:      ldr     x30, [sp], #16
 ; CHECK-NEXT:    ret
   %vtable.signed = load ptr, ptr %objptr
diff --git a/llvm/test/CodeGen/AArch64/ptrauth-fpac.ll b/llvm/test/CodeGen/AArch64/ptrauth-fpac.ll
index d5340dcebad57..8b5c07f54dc1d 100644
--- a/llvm/test/CodeGen/AArch64/ptrauth-fpac.ll
+++ b/llvm/test/CodeGen/AArch64/ptrauth-fpac.ll
@@ -1,17 +1,18 @@
 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
-; RUN: llc < %s -mtriple arm64e-apple-darwin                          -verify-machineinstrs | FileCheck %s -DL="L"  --check-prefixes=ALL,NOFPAC
-; RUN: llc < %s -mtriple arm64e-apple-darwin             -mattr=+fpac -verify-machineinstrs | FileCheck %s -DL="L"  --check-prefixes=ALL,FPAC
-; RUN: llc < %s -mtriple aarch64-linux-gnu -mattr=+pauth              -verify-machineinstrs | FileCheck %s -DL=".L" --check-prefixes=ALL,NOFPAC
-; RUN: llc < %s -mtriple aarch64-linux-gnu -mattr=+pauth -mattr=+fpac -verify-machineinstrs | FileCheck %s -DL=".L" --check-prefixes=ALL,FPAC
+; RUN: llc < %s -mtriple arm64e-apple-darwin                          -verify-machineinstrs | FileCheck %s -DL="L"  --check-prefixes=ALL,DARWIN,NOFPAC,DARWIN-NOFPAC
+; RUN: llc < %s -mtriple arm64e-apple-darwin             -mattr=+fpac -verify-machineinstrs | FileCheck %s -DL="L"  --check-prefixes=ALL,DARWIN,FPAC,DARWIN-FPAC
+; RUN: llc < %s -mtriple aarch64-linux-gnu -mattr=+pauth              -verify-machineinstrs | FileCheck %s -DL=".L" --check-prefixes=ALL,ELF,NOFPAC,ELF-NOFPAC
+; RUN: llc < %s -mtriple aarch64-linux-gnu -mattr=+pauth -mattr=+fpac -verify-machineinstrs | FileCheck %s -DL=".L" --check-prefixes=ALL,ELF,FPAC,ELF-FPAC
 
 target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
 
 define i64 @test_auth_ia(i64 %arg, i64 %arg1) {
 ; ALL-LABEL: test_auth_ia:
 ; ALL:       %bb.0:
-; ALL-NEXT:    mov x16, x0
-; ALL-NEXT:    autia x16, x1
-; ALL-NEXT:    mov x0, x16
+; DARWIN-NEXT: mov x16, x0
+; DARWIN-NEXT: autia x16, x1
+; DARWIN-NEXT: mov x0, x16
+; ELF-NEXT:    autia x0, x1
 ; ALL-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 0, i64 %arg1)
   ret i64 %tmp
@@ -20,9 +21,10 @@ define i64 @test_auth_ia(i64 %arg, i64 %arg1) {
 define i64 @test_auth_ia_zero(i64 %arg) {
 ; ALL-LABEL: test_auth_ia_zero:
 ; ALL:       %bb.0:
-; ALL-NEXT:    mov x16, x0
-; ALL-NEXT:    autiza x16
-; ALL-NEXT:    mov x0, x16
+; DARWIN-NEXT: mov x16, x0
+; DARWIN-NEXT: autiza x16
+; DARWIN-NEXT: mov x0, x16
+; ELF-NEXT:    autiza x0
 ; ALL-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 0, i64 0)
   ret i64 %tmp
@@ -31,9 +33,10 @@ define i64 @test_auth_ia_zero(i64 %arg) {
 define i64 @test_auth_ib(i64 %arg, i64 %arg1) {
 ; ALL-LABEL: test_auth_ib:
 ; ALL:       %bb.0:
-; ALL-NEXT:    mov x16, x0
-; ALL-NEXT:    autib x16, x1
-; ALL-NEXT:    mov x0, x16
+; DARWIN-NEXT: mov x16, x0
+; DARWIN-NEXT: autib x16, x1
+; DARWIN-NEXT: mov x0, x16
+; ELF-NEXT:    autib x0, x1
 ; ALL-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 1, i64 %arg1)
   ret i64 %tmp
@@ -42,9 +45,10 @@ define i64 @test_auth_ib(i64 %arg, i64 %arg1) {
 define i64 @test_auth_ib_zero(i64 %arg) {
 ; ALL-LABEL: test_auth_ib_zero:
 ; ALL:       %bb.0:
-; ALL-NEXT:    mov x16, x0
-; ALL-NEXT:    autizb x16
-; ALL-NEXT:    mov x0, x16
+; DARWIN-NEXT: mov x16, x0
+; DARWIN-NEXT: autizb x16
+; DARWIN-NEXT: mov x0, x16
+; ELF-NEXT:    autizb x0
 ; ALL-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 1, i64 0)
   ret i64 %tmp
@@ -53,9 +57,10 @@ define i64 @test_auth_ib_zero(i64 %arg) {
 define i64 @test_auth_da(i64 %arg, i64 %arg1) {
 ; ALL-LABEL: test_auth_da:
 ; ALL:       %bb.0:
-; ALL-NEXT:    mov x16, x0
-; ALL-NEXT:    autda x16, x1
-; ALL-NEXT:    mov x0, x16
+; DARWIN-NEXT: mov x16, x0
+; DARWIN-NEXT: autda x16, x1
+; DARWIN-NEXT: mov x0, x16
+; ELF-NEXT:    autda x0, x1
 ; ALL-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 2, i64 %arg1)
   ret i64 %tmp
@@ -64,9 +69,10 @@ define i64 @test_auth_da(i64 %arg, i64 %arg1) {
 define i64 @test_auth_da_zero(i64 %arg) {
 ; ALL-LABEL: test_auth_da_zero:
 ; ALL:       %bb.0:
-; ALL-NEXT:    mov x16, x0
-; ALL-NEXT:    autdza x16
-; ALL-NEXT:    mov x0, x16
+; DARWIN-NEXT: mov x16, x0
+; DARWIN-NEXT: autdza x16
+; DARWIN-NEXT: mov x0, x16
+; ELF-NEXT:    autdza x0
 ; ALL-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 2, i64 0)
   ret i64 %tmp
@@ -75,9 +81,10 @@ define i64 @test_auth_da_zero(i64 %arg) {
 define i64 @test_auth_db(i64 %arg, i64 %arg1) {
 ; ALL-LABEL: test_auth_db:
 ; ALL:       %bb.0:
-; ALL-NEXT:    mov x16, x0
-; ALL-NEXT:    autdb x16, x1
-; ALL-NEXT:    mov x0, x16
+; DARWIN-NEXT: mov x16, x0
+; DARWIN-NEXT: autdb x16, x1
+; DARWIN-NEXT: mov x0, x16
+; ELF-NEXT:    autdb x0, x1
 ; ALL-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 3, i64 %arg1)
   ret i64 %tmp
@@ -86,9 +93,10 @@ define i64 @test_auth_db(i64 %arg, i64 %arg1) {
 define i64 @test_auth_db_zero(i64 %arg) {
 ; ALL-LABEL: test_auth_db_zero:
 ; ALL:       %bb.0:
-; ALL-NEXT:    mov x16, x0
-; ALL-NEXT:    autdzb x16
-; ALL-NEXT:    mov x0, x16
+; DARWIN-NEXT: mov x16, x0
+; DARWIN-NEXT: autdzb x16
+; DARWIN-NEXT: mov x0, x16
+; ELF-NEXT:    autdzb x0
 ; ALL-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 3, i64 0)
   ret i64 %tmp
@@ -349,25 +357,38 @@ define i64 @test_resign_da_dzb(i64 %arg, i64 %arg1, i64 %arg2) {
 }
 
 define i64 @test_auth_trap_attribute(i64 %arg, i64 %arg1) "ptrauth-auth-traps" {
-; NOFPAC-LABEL: test_auth_trap_attribute:
-; NOFPAC:       %bb.0:
-; NOFPAC-NEXT:    mov x16, x0
-; NOFPAC-NEXT:    autia x16, x1
-; NOFPAC-NEXT:    mov x17, x16
-; NOFPAC-NEXT:    xpaci x17
-; NOFPAC-NEXT:    cmp x16, x17
-; NOFPAC-NEXT:    b.eq [[L]]auth_success_9
-; NOFPAC-NEXT:    brk #0xc470
-; NOFPAC-NEXT:  Lauth_success_9:
-; NOFPAC-NEXT:    mov x0, x16
-; NOFPAC-NEXT:    ret
+; ALL-LABEL: test_auth_trap_attribute:
+; DARWIN-NOFPAC:       %bb.0:
+; DARWIN-NOFPAC-NEXT:    mov x16, x0
+; DARWIN-NOFPAC-NEXT:    autia x16, x1
+; DARWIN-NOFPAC-NEXT:    mov x17, x16
+; DARWIN-NOFPAC-NEXT:    xpaci x17
+; DARWIN-NOFPAC-NEXT:    cmp x16, x17
+; DARWIN-NOFPAC-NEXT:    b.eq [[L]]auth_success_9
+; DARWIN-NOFPAC-NEXT:    brk #0xc470
+; DARWIN-NOFPAC-NEXT:  Lauth_success_9:
+; DARWIN-NOFPAC-NEXT:    mov x0, x16
+; DARWIN-NOFPAC-NEXT:    ret
 ;
-; FPAC-LABEL: test_auth_trap_attribute:
-; FPAC:       %bb.0:
-; FPAC-NEXT:    mov x16, x0
-; FPAC-NEXT:    autia x16, x1
-; FPAC-NEXT:    mov x0, x16
-; FPAC-NEXT:    ret
+; ELF-NOFPAC:       %bb.0:
+; ELF-NOFPAC-NEXT:    autia x0, x1
+; ELF-NOFPAC-NEXT:    mov x8, x0
+; ELF-NOFPAC-NEXT:    xpaci x8
+; ELF-NOFPAC-NEXT:    cmp x0, x8
+; ELF-NOFPAC-NEXT:    b.eq [[L]]auth_success_9
+; ELF-NOFPAC-NEXT:    brk #0xc470
+; ELF-NOFPAC-NEXT:  Lauth_success_9:
+; ELF-NOFPAC-NEXT:    ret
+;
+; DARWIN-FPAC:       %bb.0:
+; DARWIN-FPAC-NEXT:    mov x16, x0
+; DARWIN-FPAC-NEXT:    autia x16, x1
+; DARWIN-FPAC-NEXT:    mov x0, x16
+; DARWIN-FPAC-NEXT:    ret
+;
+; ELF-FPAC:       %bb.0:
+; ELF-FPAC-NEXT:    autia x0, x1
+; ELF-FPAC-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 0, i64 %arg1)
   ret i64 %tmp
 }
diff --git a/llvm/test/CodeGen/AArch64/ptrauth-intrinsic-auth-resign-with-blend.ll b/llvm/test/CodeGen/AArch64/ptrauth-intrinsic-auth-resign-with-blend.ll
index 74d2370c74c54..e2aea6df78250 100644
--- a/llvm/test/CodeGen/AArch64/ptrauth-intrinsic-auth-resign-with-blend.ll
+++ b/llvm/test/CodeGen/AArch64/ptrauth-intrinsic-auth-resign-with-blend.ll
@@ -33,36 +33,45 @@ target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
 
 define i64 @test_auth_blend(i64 %arg, i64 %arg1) {
 ; UNCHECKED-LABEL: test_auth_blend:
-; UNCHECKED:       %bb.0:
-; UNCHECKED-NEXT:    mov x16, x0
-; UNCHECKED-NEXT:    mov x17, x1
-; UNCHECKED-NEXT:    movk x17, #65535, lsl #48
-; UNCHECKED-NEXT:    autda x16, x17
-; UNCHECKED-NEXT:    mov x0, x16
-; UNCHECKED-NEXT:    ret
+; UNCHECKED:          %bb.0:
+; UNCHECKED-DARWIN-NEXT: mov x16, x0
+; UNCHECKED-DARWIN-NEXT: mov x17, x1
+; UNCHECKED-DARWIN-NEXT: movk x17, #65535, lsl #48
+; UNCHECKED-DARWIN-NEXT: autda x16, x17
+; UNCHECKED-DARWIN-NEXT: mov x0, x16
+; UNCHECKED-ELF-NEXT:    movk x1, #65535, lsl #48
+; UNCHECKED-ELF-NEXT:    autda x0, x1
+; UNCHECKED-NEXT:        ret
 ;
 ; CHECKED-LABEL: test_auth_blend:
-; CHECKED:       %bb.0:
-; CHECKED-NEXT:    mov x16, x0
-; CHECKED-NEXT:    mov x17, x1
-; CHECKED-NEXT:    movk x17, #65535, lsl #48
-; CHECKED-NEXT:    autda x16, x17
-; CHECKED-NEXT:    mov x0, x16
+; CHECKED:           %bb.0:
+; CHECKED-DARWIN-NEXT: mov x16, x0
+; CHECKED-DARWIN-NEXT: mov x17, x1
+; CHECKED-DARWIN-NEXT: movk x17, #65535, lsl #48
+; CHECKED-DARWIN-NEXT: autda x16, x17
+; CHECKED-DARWIN-NEXT: mov x0, x16
+; CHECKED-ELF-NEXT:    movk x1, #65535, lsl #48
+; CHECKED-ELF-NEXT:    autda x0, x1
 ; CHECKED-NEXT:    ret
 ;
 ; TRAP-LABEL: test_auth_blend:
 ; TRAP:       %bb.0:
-; TRAP-NEXT:    mov x16, x0
-; TRAP-NEXT:    mov x17, x1
-; TRAP-NEXT:    movk x17, #65535, lsl #48
-; TRAP-NEXT:    autda x16, x17
-; TRAP-NEXT:    mov x17, x16
-; TRAP-NEXT:    xpacd x17
-; TRAP-NEXT:    cmp x16, x17
+; TRAP-DARWIN-NEXT: mov x16, x0
+; TRAP-DARWIN-NEXT: mov x17, x1
+; TRAP-DARWIN-NEXT: movk x17, #65535, lsl #48
+; TRAP-DARWIN-NEXT: autda x16, x17
+; TRAP-DARWIN-NEXT: mov x17, x16
+; TRAP-DARWIN-NEXT: xpacd x17
+; TRAP-DARWIN-NEXT: cmp x16, x17
+; TRAP-ELF-NEXT: movk x1, #65535, lsl #48
+; TRAP-ELF-NEXT: autda x0, x1
+; TRAP-ELF-NEXT: mov x8, x0
+; TRAP-ELF-NEXT: xpacd x8
+; TRAP-ELF-NEXT: cmp x0, x8
 ; TRAP-NEXT:    b.eq [[L]]auth_success_0
 ; TRAP-NEXT:    brk #0xc472
 ; TRAP-NEXT:  Lauth_success_0:
-; TRAP-NEXT:    mov x0, x16
+; TRAP-DARWIN-NEXT:    mov x0, x16
 ; TRAP-NEXT:    ret
   %tmp0 = call i64 @llvm.ptrauth.blend(i64 %arg1, i64 65535)
   %tmp1 = call i64 @llvm.ptrauth.auth(i64 %arg, i32 2, i64 %tmp0)
@@ -73,9 +82,11 @@ define i64 @test_resign_blend(i64 %arg, i64 %arg1, i64 %arg2) {
 ; UNCHECKED-LABEL: test_resign_blend:
 ; UNCHECKED:       %bb.0:
 ; UNCHECKED-NEXT:    mov x16, x0
-; UNCHECKED-NEXT:    mov x17, x1
-; UNCHECKED-NEXT:    movk x17, #12345, lsl #48
-; UNCHECKED-NEXT:    autda x16, x17
+; UNCHECKED-ELF-NEXT:    movk x1, #12345, lsl #48
+; UNCHECKED-ELF-NEXT:    autda x16, x1
+; UNCHECKED-DARWIN-NEXT: mov x17, x1
+; UNCHECKED-DARWIN-NEXT: movk x17, #12345, lsl #48
+; UNCHECKED-DARWIN-NEXT: autda x16, x17
 ; UNCHECKED-NEXT:    mov x17, x2
 ; UNCHECKED-NEXT:    movk x17, #56789, lsl #48
 ; UNCHECKED-NEXT:    pacdb x16, x17
@@ -85,9 +96,11 @@ define i64 @test_resign_blend(i64 %arg, i64 %arg1, i64 %arg2) {
 ; CHECKED-LABEL: test_resign_blend:
 ; CHECKED:       %bb.0:
 ; CHECKED-NEXT:    mov x16, x0
-; CHECKED-NEXT:    mov x17, x1
-; CHECKED-NEXT:    movk x17, #12345, lsl #48
-; CHECKED-NEXT:    autda x16, x17
+; CHECKED-ELF-NEXT:    movk x1, #12345, lsl #48
+; CHECKED-ELF-NEXT:    autda x16, x1
+; CHECKED-DARWIN-NEXT: mov x17, x1
+; CHECKED-DARWIN-NEXT: movk x17, #12345, lsl #48
+; CHECKED-DARWIN-NEXT: autda x16, x17
 ; CHECKED-NEXT:    mov x17, x16
 ; CHECKED-NEXT:    xpacd x17
 ; CHECKED-NEXT:    cmp x16, x17
@@ -105,9 +118,11 @@ define i64 @test_resign_blend(i64 %arg, i64 %arg1, i64 %arg2) {
 ; TRAP-LABEL: test_resign_blend:
 ; TRAP:       %bb.0:
 ; TRAP-NEXT:    mov x16, x0
-; TRAP-NEXT:    mov x17, x1
-; TRAP-NEXT:    movk x17, #12345, lsl #48
-; TRAP-NEXT:    autda x16, x17
+; TRAP-ELF-NEXT:    movk x1, #12345, lsl #48
+; TRAP-ELF-NEXT:    autda x16, x1
+; TRAP-DARWIN-NEXT: mov x17, x1
+; TRAP-DARWIN-NEXT: movk x17, #12345, lsl #48
+; TRAP-DARWIN-NEXT: autda x16, x17
 ; TRAP-NEXT:    mov x17, x16
 ; TRAP-NEXT:    xpacd x17
 ; TRAP-NEXT:    cmp x16, x17
@@ -129,9 +144,11 @@ define i64 @test_resign_blend_and_const(i64 %arg, i64 %arg1) {
 ; UNCHECKED-LABEL: test_resign_blend_and_const:
 ; UNCHECKED:       %bb.0:
 ; UNCHECKED-NEXT:    mov x16, x0
-; UNCHECKED-NEXT:    mov x17, x1
-; UNCHECKED-NEXT:    movk x17, #12345, lsl #48
-; UNCHECKED-NEXT:    autda x16, x17
+; UNCHECKED-ELF-NEXT:    movk x1, #12345, lsl #48
+; UNCHECKED-ELF-NEXT:    autda x16, x1
+; UNCHECKED-DARWIN-NEXT: mov x17, x1
+; UNCHECKED-DARWIN-NEXT: movk x17, #12345, lsl #48
+; UNCHECKED-DARWIN-NEXT: autda x16, x17
 ; UNCHECKED-NEXT:    mov x17, #56789
 ; UNCHECKED-NEXT:    pacdb x16, x17
 ; UNCHECKED-NEXT:    mov x0, x16
@@ -140,9 +157,11 @@ define i64 @test_resign_blend_and_const(i64 %arg, i64 %arg1) {
 ; CHECKED-LABEL: test_resign_blend_and_const:
 ; CHECKED:       %bb.0:
 ; CHECKED-NEXT:    mov x16, x0
-; CHECKED-NEXT:    mov x17, x1
-; CHECKED-NEXT:    movk x17, #12345, lsl #48
-; CHECKED-NEXT:    autda x16, x17
+; CHECKED-ELF-NEXT:    movk x1, #12345, lsl #48
+; CHECKED-ELF-NEXT:    autda x16, x1
+; CHECKED-DARWIN-NEXT: mov x17, x1
+; CHECKED-DARWIN-NEXT: movk x17, #12345, lsl #48
+; CHECKED-DARWIN-NEXT: autda x16, x17
 ; CHECKED-NEXT:    mov x17, x16
 ; CHECKED-NEXT:    xpacd x17
 ; CHECKED-NEXT:    cmp x16, x17
@@ -159,9 +178,11 @@ define i64 @test_resign_blend_and_const(i64 %arg, i64 %arg1) {
 ; TRAP-LABEL: test_resign_blend_and_const:
 ; TRAP:       %bb.0:
 ; TRAP-NEXT:    mov x16, x0
-; TRAP-NEXT:    mov x17, x1
-; TRAP-NEXT:    movk x17, #12345, lsl #48
-; TRAP-NEXT:    autda x16, x17
+; TRAP-ELF-NEXT:    movk x1, #12345, lsl #48
+; TRAP-ELF-NEXT:    autda x16, x1
+; TRAP-DARWIN-NEXT: mov x17, x1
+; TRAP-DARWIN-NEXT: movk x17, #12345, lsl #48
+; TRAP-DARWIN-NEXT: autda x16, x17
 ; TRAP-NEXT:    mov x17, x16
 ; TRAP-NEXT:    xpacd x17
 ; TRAP-NEXT:    cmp x16, x17
@@ -181,9 +202,11 @@ define i64 @test_resign_blend_and_addr(i64 %arg, i64 %arg1, i64 %arg2) {
 ; UNCHECKED-LABEL: test_resign_blend_and_addr:
 ; UNCHECKED:       %bb.0:
 ; UNCHECKED-NEXT:    mov x16, x0
-; UNCHECKED-NEXT:    mov x17, x1
-; UNCHECKED-NEXT:    movk x17, #12345, lsl #48
-; UNCHECKED-NEXT:    autda x16, x17
+; UNCHECKED-ELF-NEXT:    movk x1, #12345, lsl #48
+; UNCHECKED-ELF-NEXT:    autda x16, x1
+; UNCHECKED-DARWIN-NEXT: mov x17, x1
+; UNCHECKED-DARWIN-NEXT: movk x17, #12345, lsl #48
+; UNCHECKED-DARWIN-NEXT: autda x16, x17
 ; UNCHECKED-NEXT:    pacdb x16, x2
 ; UNCHECKED-NEXT:    mov x0, x16
 ; UNCHECKED-NEXT:    ret
@@ -191,9 +214,11 @@ define i64 @test_resign_blend_and_addr(i64 %arg, i64 %arg1, i64 %arg2) {
 ; CHECKED-LABEL: test_resign_blend_and_addr:
 ; CHECKED:       %bb.0:
 ; CHECKED-NEXT:    mov x16, x0
-; CHECKED-NEXT:    mov x17, x1
-; CHECKED-NEXT:    movk x17, #12345, lsl #48
-; CHECKED-NEXT:    autda x16, x17
+; CHECKED-ELF-NEXT:    movk x1, #12345, lsl #48
+; CHECKED-ELF-NEXT:    autda x16, x1
+; CHECKED-DARWIN-NEXT: mov x17, x1
+; CHECKED-DARWIN-NEXT: movk x17, #12345, lsl #48
+; CHECKED-DARWIN-NEXT: autda x16, x17
 ; CHECKED-NEXT:    mov x17, x16
 ; CHECKED-NEXT:    xpacd x17
 ; CHECKED-NEXT:    cmp x16, x17
@@ -209,9 +234,11 @@ define i64 @test_resign_blend_and_addr(i64 %arg, i64 %arg1, i64 %arg2) {
 ; TRAP-LABEL: test_resign_blend_and_addr:
 ; TRAP:       %bb.0:
 ; TRAP-NEXT:    mov x16, x0
-; TRAP-NEXT:    mov x17, x1
-; TRAP-NEXT:    movk x17, #12345, lsl #48
-; TRAP-NEXT:    autda x16, x17
+; TRAP-ELF-NEXT:    movk x1, #12345, lsl #48
+; TRAP-ELF-NEXT:    autda x16, x1
+; TRAP-DARWIN-NEXT: mov x17, x1
+; TRAP-DARWIN-NEXT: movk x17, #12345, lsl #48
+; TRAP-DARWIN-NEXT: autda x16, x17
 ; TRAP-NEXT:    mov x17, x16
 ; TRAP-NEXT:    xpacd x17
 ; TRAP-NEXT:    cmp x16, x17
@@ -232,10 +259,10 @@ define i64 @test_auth_too_large_discriminator(i64 %arg, i64 %arg1) {
 ; UNCHECKED-NEXT:        mov w8, #65536
 ; UNCHECKED-DARWIN-NEXT: bfi x1, x8, #48, #16
 ; UNCHECKED-DARWIN-NEXT: mov x16, x0
-; UNCHECKED-ELF-NEXT:    mov x16, x0
+; UNCHECKED-DARWIN-NEXT: autda x16, x1
+; UNCHECKED-DARWIN-NEXT: mov x0, x16
 ; UNCHECKED-ELF-NEXT:    bfi x1, x8, #48, #16
-; UNCHECKED-NEXT:        autda x16, x1
-; UNCHECKED-NEXT:        mov x0, x16
+; UNCHECKED-ELF-NEXT:    autda x0, x1
 ; UNCHECKED-NEXT:        ret
 ;
 ; CHECKED-LABEL: test_auth_too_large_discriminator:
@@ -243,27 +270,29 @@ define i64 @test_auth_too_large_discriminator(i64 %arg, i64 %arg1) {
 ; CHECKED-NEXT:        mov w8, #65536
 ; CHECKED-DARWIN-NEXT: bfi x1, x8, #48, #16
 ; CHECKED-DARWIN-NEXT: mov x16, x0
-; CHECKED-ELF-NEXT:    mov x16, x0
+; CHECKED-DARWIN-NEXT: autda x16, x1
+; CHECKED-DARWIN-NEXT: mov x0, x16
 ; CHECKED-ELF-NEXT:    bfi x1, x8, #48, #16
-; CHECKED-NEXT:        autda x16, x1
-; CHECKED-NEXT:        mov x0, x16
+; CHECKED-ELF-NEXT:    autda x0, x1
 ; CHECKED-NEXT:        ret
 ;
 ; TRAP-LABEL: test_auth_too_large_discriminator:
 ; TRAP:           %bb.0:
 ; TRAP-NEXT:        mov w8, #65536
-; TRAP-DARWIN-NEXT: bfi x1, x8, #48, #16
+; TRAP-NEXT:        bfi x1, x8, #48, #16
 ; TRAP-DARWIN-NEXT: mov x16, x0
-; TRAP-ELF-NEXT:    mov x16, x0
-; TRAP-ELF-NEXT:    bfi x1, x8, #48, #16
-; TRAP-NEXT:        autda x16, x1
-; TRAP-NEXT:        mov x17, x16
-; TRAP-NEXT:        xpacd x17
-; TRAP-NEXT:        cmp x16, x17
+; TRAP-DARWIN-NEXT: autda x16, x1
+; TRAP-DARWIN-NEXT: mov x17, x16
+; TRAP-DARWIN-NEXT: xpacd x17
+; TRAP-DARWIN-NEXT: cmp x16, x17
+; TRAP-ELF-NEXT:    autda x0, x1
+; TRAP-ELF-NEXT:    mov x8, x0
+; TRAP-ELF-NEXT:    xpacd x8
+; TRAP-ELF-NEXT:    cmp x0, x8
 ; TRAP-NEXT:        b.eq [[L]]auth_success_4
 ; TRAP-NEXT:        brk #0xc472
 ; TRAP-NEXT:      Lauth_success_4:
-; TRAP-NEXT:        mov x0, x16
+; TRAP-DARWIN-NEXT: mov x0, x16
 ; TRAP-NEXT:        ret
   %tmp0 = call i64 @llvm.ptrauth.blend(i64 %arg1, i64 65536)
   %tmp1 = call i64 @llvm.ptrauth.auth(i64 %arg, i32 2, i64 %tmp0)
diff --git a/llvm/test/CodeGen/AArch64/ptrauth-intrinsic-auth-resign.ll b/llvm/test/CodeGen/AArch64/ptrauth-intrinsic-auth-resign.ll
index fdd5ae29f35ea..2634beb4e3591 100644
--- a/llvm/test/CodeGen/AArch64/ptrauth-intrinsic-auth-resign.ll
+++ b/llvm/test/CodeGen/AArch64/ptrauth-intrinsic-auth-resign.ll
@@ -1,62 +1,68 @@
 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple arm64e-apple-darwin -global-isel=0                    -verify-machineinstrs \
-; RUN:   -aarch64-ptrauth-auth-checks=none | FileCheck %s -DL="L" --check-prefix=UNCHECKED
+; RUN:   -aarch64-ptrauth-auth-checks=none | FileCheck %s -DL="L" --check-prefixes=UNCHECKED,UNCHECKED-DARWIN
 ; RUN: llc < %s -mtriple arm64e-apple-darwin -global-isel -global-isel-abort=1 -verify-machineinstrs \
-; RUN:   -aarch64-ptrauth-auth-checks=none | FileCheck %s -DL="L" --check-prefix=UNCHECKED
+; RUN:   -aarch64-ptrauth-auth-checks=none | FileCheck %s -DL="L" --check-prefixes=UNCHECKED,UNCHECKED-DARWIN
 
 ; RUN: llc < %s -mtriple arm64e-apple-darwin -global-isel=0                    -verify-machineinstrs \
-; RUN:                                     | FileCheck %s -DL="L" --check-prefix=CHECKED
+; RUN:                                     | FileCheck %s -DL="L" --check-prefixes=CHECKED,CHECKED-DARWIN
 ; RUN: llc < %s -mtriple arm64e-apple-darwin -global-isel -global-isel-abort=1 -verify-machineinstrs \
-; RUN:                                     | FileCheck %s -DL="L" --check-prefix=CHECKED
+; RUN:                                     | FileCheck %s -DL="L" --check-prefixes=CHECKED,CHECKED-DARWIN
 
 ; RUN: llc < %s -mtriple arm64e-apple-darwin -global-isel=0                    -verify-machineinstrs \
-; RUN:   -aarch64-ptrauth-auth-checks=trap | FileCheck %s -DL="L" --check-prefix=TRAP
+; RUN:   -aarch64-ptrauth-auth-checks=trap | FileCheck %s -DL="L" --check-prefixes=TRAP,TRAP-DARWIN
 ; RUN: llc < %s -mtriple arm64e-apple-darwin -global-isel -global-isel-abort=1 -verify-machineinstrs \
-; RUN:   -aarch64-ptrauth-auth-checks=trap | FileCheck %s -DL="L" --check-prefix=TRAP
+; RUN:   -aarch64-ptrauth-auth-checks=trap | FileCheck %s -DL="L" --check-prefixes=TRAP,TRAP-DARWIN
 
 ; RUN: llc < %s -mtriple aarch64-linux-gnu -mattr=+pauth -global-isel=0                    -verify-machineinstrs \
-; RUN:   -aarch64-ptrauth-auth-checks=none | FileCheck %s -DL=".L" --check-prefix=UNCHECKED
+; RUN:   -aarch64-ptrauth-auth-checks=none | FileCheck %s -DL=".L" --check-prefixes=UNCHECKED,UNCHECKED-ELF
 ; RUN: llc < %s -mtriple aarch64-linux-gnu -mattr=+pauth -global-isel -global-isel-abort=1 -verify-machineinstrs \
-; RUN:   -aarch64-ptrauth-auth-checks=none | FileCheck %s -DL=".L" --check-prefix=UNCHECKED
+; RUN:   -aarch64-ptrauth-auth-checks=none | FileCheck %s -DL=".L" --check-prefixes=UNCHECKED,UNCHECKED-ELF
 
 ; RUN: llc < %s -mtriple aarch64-linux-gnu -mattr=+pauth -global-isel=0                    -verify-machineinstrs \
-; RUN:                                     | FileCheck %s -DL=".L" --check-prefix=CHECKED
+; RUN:                                     | FileCheck %s -DL=".L" --check-prefixes=CHECKED,CHECKED-ELF
 ; RUN: llc < %s -mtriple aarch64-linux-gnu -mattr=+pauth -global-isel -global-isel-abort=1 -verify-machineinstrs \
-; RUN:                                     | FileCheck %s -DL=".L" --check-prefix=CHECKED
+; RUN:                                     | FileCheck %s -DL=".L" --check-prefixes=CHECKED,CHECKED-ELF
 
 ; RUN: llc < %s -mtriple aarch64-linux-gnu -mattr=+pauth -global-isel=0                    -verify-machineinstrs \
-; RUN:   -aarch64-ptrauth-auth-checks=trap | FileCheck %s -DL=".L" --check-prefix=TRAP
+; RUN:   -aarch64-ptrauth-auth-checks=trap | FileCheck %s -DL=".L" --check-prefixes=TRAP,TRAP-ELF
 ; RUN: llc < %s -mtriple aarch64-linux-gnu -mattr=+pauth -global-isel -global-isel-abort=1 -verify-machineinstrs \
-; RUN:   -aarch64-ptrauth-auth-checks=trap | FileCheck %s -DL=".L" --check-prefix=TRAP
+; RUN:   -aarch64-ptrauth-auth-checks=trap | FileCheck %s -DL=".L" --check-prefixes=TRAP,TRAP-ELF
 
 target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
 
 define i64 @test_auth_ia(i64 %arg, i64 %arg1) {
 ; UNCHECKED-LABEL: test_auth_ia:
-; UNCHECKED:       %bb.0:
-; UNCHECKED-NEXT:    mov x16, x0
-; UNCHECKED-NEXT:    autia x16, x1
-; UNCHECKED-NEXT:    mov x0, x16
-; UNCHECKED-NEXT:    ret
+; UNCHECKED:           %bb.0:
+; UNCHECKED-DARWIN-NEXT: mov x16, x0
+; UNCHECKED-DARWIN-NEXT: autia x16, x1
+; UNCHECKED-DARWIN-NEXT: mov x0, x16
+; UNCHECKED-ELF-NEXT:    autia x0, x1
+; UNCHECKED-NEXT:        ret
 ;
 ; CHECKED-LABEL: test_auth_ia:
-; CHECKED:       %bb.0:
-; CHECKED-NEXT:    mov x16, x0
-; CHECKED-NEXT:    autia x16, x1
-; CHECKED-NEXT:    mov x0, x16
-; CHECKED-NEXT:    ret
+; CHECKED:           %bb.0:
+; CHECKED-DARWIN-NEXT: mov x16, x0
+; CHECKED-DARWIN-NEXT: autia x16, x1
+; CHECKED-DARWIN-NEXT: mov x0, x16
+; CHECKED-ELF-NEXT:    autia x0, x1
+; CHECKED-NEXT:        ret
 ;
 ; TRAP-LABEL: test_auth_ia:
 ; TRAP:       %bb.0:
-; TRAP-NEXT:    mov x16, x0
-; TRAP-NEXT:    autia x16, x1
-; TRAP-NEXT:    mov x17, x16
-; TRAP-NEXT:    xpaci x17
-; TRAP-NEXT:    cmp x16, x17
+; TRAP-DARWIN-NEXT:   mov x16, x0
+; TRAP-DARWIN-NEXT:   autia x16, x1
+; TRAP-DARWIN-NEXT:   mov x17, x16
+; TRAP-DARWIN-NEXT:   xpaci x17
+; TRAP-DARWIN-NEXT:   cmp x16, x17
+; TRAP-ELF-NEXT:   autia x0, x1
+; TRAP-ELF-NEXT:   mov x8, x0
+; TRAP-ELF-NEXT:   xpaci x8
+; TRAP-ELF-NEXT:   cmp x0, x8
 ; TRAP-NEXT:    b.eq [[L]]auth_success_0
 ; TRAP-NEXT:    brk #0xc470
 ; TRAP-NEXT:  Lauth_success_0:
-; TRAP-NEXT:    mov x0, x16
+; TRAP-DARWIN-NEXT:    mov x0, x16
 ; TRAP-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 0, i64 %arg1)
   ret i64 %tmp
@@ -64,30 +70,36 @@ define i64 @test_auth_ia(i64 %arg, i64 %arg1) {
 
 define i64 @test_auth_ia_zero(i64 %arg) {
 ; UNCHECKED-LABEL: test_auth_ia_zero:
-; UNCHECKED:       %bb.0:
-; UNCHECKED-NEXT:    mov x16, x0
-; UNCHECKED-NEXT:    autiza x16
-; UNCHECKED-NEXT:    mov x0, x16
-; UNCHECKED-NEXT:    ret
+; UNCHECKED:           %bb.0:
+; UNCHECKED-DARWIN-NEXT: mov x16, x0
+; UNCHECKED-DARWIN-NEXT: autiza x16
+; UNCHECKED-DARWIN-NEXT: mov x0, x16
+; UNCHECKED-ELF-NEXT:    autiza x0
+; UNCHECKED-NEXT:        ret
 ;
 ; CHECKED-LABEL: test_auth_ia_zero:
-; CHECKED:       %bb.0:
-; CHECKED-NEXT:    mov x16, x0
-; CHECKED-NEXT:    autiza x16
-; CHECKED-NEXT:    mov x0, x16
-; CHECKED-NEXT:    ret
+; CHECKED:           %bb.0:
+; CHECKED-DARWIN-NEXT: mov x16, x0
+; CHECKED-DARWIN-NEXT: autiza x16
+; CHECKED-DARWIN-NEXT: mov x0, x16
+; CHECKED-ELF-NEXT:    autiza x0
+; CHECKED-NEXT:        ret
 ;
 ; TRAP-LABEL: test_auth_ia_zero:
 ; TRAP:       %bb.0:
-; TRAP-NEXT:    mov x16, x0
-; TRAP-NEXT:    autiza x16
-; TRAP-NEXT:    mov x17, x16
-; TRAP-NEXT:    xpaci x17
-; TRAP-NEXT:    cmp x16, x17
+; TRAP-DARWIN-NEXT:   mov x16, x0
+; TRAP-DARWIN-NEXT:   autiza x16
+; TRAP-DARWIN-NEXT:   mov x17, x16
+; TRAP-DARWIN-NEXT:   xpaci x17
+; TRAP-DARWIN-NEXT:   cmp x16, x17
+; TRAP-ELF-NEXT:   autiza x0
+; TRAP-ELF-NEXT:   mov x8, x0
+; TRAP-ELF-NEXT:   xpaci x8
+; TRAP-ELF-NEXT:   cmp x0, x8
 ; TRAP-NEXT:    b.eq [[L]]auth_success_1
 ; TRAP-NEXT:    brk #0xc470
 ; TRAP-NEXT:  Lauth_success_1:
-; TRAP-NEXT:    mov x0, x16
+; TRAP-DARWIN-NEXT:    mov x0, x16
 ; TRAP-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 0, i64 0)
   ret i64 %tmp
@@ -95,30 +107,36 @@ define i64 @test_auth_ia_zero(i64 %arg) {
 
 define i64 @test_auth_ib(i64 %arg, i64 %arg1) {
 ; UNCHECKED-LABEL: test_auth_ib:
-; UNCHECKED:       %bb.0:
-; UNCHECKED-NEXT:    mov x16, x0
-; UNCHECKED-NEXT:    autib x16, x1
-; UNCHECKED-NEXT:    mov x0, x16
-; UNCHECKED-NEXT:    ret
+; UNCHECKED:           %bb.0:
+; UNCHECKED-DARWIN-NEXT: mov x16, x0
+; UNCHECKED-DARWIN-NEXT: autib x16, x1
+; UNCHECKED-DARWIN-NEXT: mov x0, x16
+; UNCHECKED-ELF-NEXT:    autib x0, x1
+; UNCHECKED-NEXT:        ret
 ;
 ; CHECKED-LABEL: test_auth_ib:
-; CHECKED:       %bb.0:
-; CHECKED-NEXT:    mov x16, x0
-; CHECKED-NEXT:    autib x16, x1
-; CHECKED-NEXT:    mov x0, x16
-; CHECKED-NEXT:    ret
+; CHECKED:           %bb.0:
+; CHECKED-DARWIN-NEXT: mov x16, x0
+; CHECKED-DARWIN-NEXT: autib x16, x1
+; CHECKED-DARWIN-NEXT: mov x0, x16
+; CHECKED-ELF-NEXT:    autib x0, x1
+; CHECKED-NEXT:        ret
 ;
 ; TRAP-LABEL: test_auth_ib:
 ; TRAP:       %bb.0:
-; TRAP-NEXT:    mov x16, x0
-; TRAP-NEXT:    autib x16, x1
-; TRAP-NEXT:    mov x17, x16
-; TRAP-NEXT:    xpaci x17
-; TRAP-NEXT:    cmp x16, x17
+; TRAP-DARWIN-NEXT:   mov x16, x0
+; TRAP-DARWIN-NEXT:   autib x16, x1
+; TRAP-DARWIN-NEXT:   mov x17, x16
+; TRAP-DARWIN-NEXT:   xpaci x17
+; TRAP-DARWIN-NEXT:   cmp x16, x17
+; TRAP-ELF-NEXT:   autib x0, x1
+; TRAP-ELF-NEXT:   mov x8, x0
+; TRAP-ELF-NEXT:   xpaci x8
+; TRAP-ELF-NEXT:   cmp x0, x8
 ; TRAP-NEXT:    b.eq [[L]]auth_success_2
 ; TRAP-NEXT:    brk #0xc471
 ; TRAP-NEXT:  Lauth_success_2:
-; TRAP-NEXT:    mov x0, x16
+; TRAP-DARWIN-NEXT:    mov x0, x16
 ; TRAP-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 1, i64 %arg1)
   ret i64 %tmp
@@ -126,30 +144,36 @@ define i64 @test_auth_ib(i64 %arg, i64 %arg1) {
 
 define i64 @test_auth_ib_zero(i64 %arg) {
 ; UNCHECKED-LABEL: test_auth_ib_zero:
-; UNCHECKED:       %bb.0:
-; UNCHECKED-NEXT:    mov x16, x0
-; UNCHECKED-NEXT:    autizb x16
-; UNCHECKED-NEXT:    mov x0, x16
-; UNCHECKED-NEXT:    ret
+; UNCHECKED:           %bb.0:
+; UNCHECKED-DARWIN-NEXT: mov x16, x0
+; UNCHECKED-DARWIN-NEXT: autizb x16
+; UNCHECKED-DARWIN-NEXT: mov x0, x16
+; UNCHECKED-ELF-NEXT:    autizb x0
+; UNCHECKED-NEXT:        ret
 ;
 ; CHECKED-LABEL: test_auth_ib_zero:
-; CHECKED:       %bb.0:
-; CHECKED-NEXT:    mov x16, x0
-; CHECKED-NEXT:    autizb x16
-; CHECKED-NEXT:    mov x0, x16
-; CHECKED-NEXT:    ret
+; CHECKED:           %bb.0:
+; CHECKED-DARWIN-NEXT: mov x16, x0
+; CHECKED-DARWIN-NEXT: autizb x16
+; CHECKED-DARWIN-NEXT: mov x0, x16
+; CHECKED-ELF-NEXT:    autizb x0
+; CHECKED-NEXT:        ret
 ;
 ; TRAP-LABEL: test_auth_ib_zero:
 ; TRAP:       %bb.0:
-; TRAP-NEXT:    mov x16, x0
-; TRAP-NEXT:    autizb x16
-; TRAP-NEXT:    mov x17, x16
-; TRAP-NEXT:    xpaci x17
-; TRAP-NEXT:    cmp x16, x17
+; TRAP-DARWIN-NEXT:   mov x16, x0
+; TRAP-DARWIN-NEXT:   autizb x16
+; TRAP-DARWIN-NEXT:   mov x17, x16
+; TRAP-DARWIN-NEXT:   xpaci x17
+; TRAP-DARWIN-NEXT:   cmp x16, x17
+; TRAP-ELF-NEXT:   autizb x0
+; TRAP-ELF-NEXT:   mov x8, x0
+; TRAP-ELF-NEXT:   xpaci x8
+; TRAP-ELF-NEXT:   cmp x0, x8
 ; TRAP-NEXT:    b.eq [[L]]auth_success_3
 ; TRAP-NEXT:    brk #0xc471
 ; TRAP-NEXT:  Lauth_success_3:
-; TRAP-NEXT:    mov x0, x16
+; TRAP-DARWIN-NEXT:    mov x0, x16
 ; TRAP-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 1, i64 0)
   ret i64 %tmp
@@ -157,30 +181,36 @@ define i64 @test_auth_ib_zero(i64 %arg) {
 
 define i64 @test_auth_da(i64 %arg, i64 %arg1) {
 ; UNCHECKED-LABEL: test_auth_da:
-; UNCHECKED:       %bb.0:
-; UNCHECKED-NEXT:    mov x16, x0
-; UNCHECKED-NEXT:    autda x16, x1
-; UNCHECKED-NEXT:    mov x0, x16
-; UNCHECKED-NEXT:    ret
+; UNCHECKED:           %bb.0:
+; UNCHECKED-DARWIN-NEXT: mov x16, x0
+; UNCHECKED-DARWIN-NEXT: autda x16, x1
+; UNCHECKED-DARWIN-NEXT: mov x0, x16
+; UNCHECKED-ELF-NEXT:    autda x0, x1
+; UNCHECKED-NEXT:        ret
 ;
 ; CHECKED-LABEL: test_auth_da:
-; CHECKED:       %bb.0:
-; CHECKED-NEXT:    mov x16, x0
-; CHECKED-NEXT:    autda x16, x1
-; CHECKED-NEXT:    mov x0, x16
-; CHECKED-NEXT:    ret
+; CHECKED:           %bb.0:
+; CHECKED-DARWIN-NEXT: mov x16, x0
+; CHECKED-DARWIN-NEXT: autda x16, x1
+; CHECKED-DARWIN-NEXT: mov x0, x16
+; CHECKED-ELF-NEXT:    autda x0, x1
+; CHECKED-NEXT:        ret
 ;
 ; TRAP-LABEL: test_auth_da:
 ; TRAP:       %bb.0:
-; TRAP-NEXT:    mov x16, x0
-; TRAP-NEXT:    autda x16, x1
-; TRAP-NEXT:    mov x17, x16
-; TRAP-NEXT:    xpacd x17
-; TRAP-NEXT:    cmp x16, x17
+; TRAP-DARWIN-NEXT:   mov x16, x0
+; TRAP-DARWIN-NEXT:   autda x16, x1
+; TRAP-DARWIN-NEXT:   mov x17, x16
+; TRAP-DARWIN-NEXT:   xpacd x17
+; TRAP-DARWIN-NEXT:   cmp x16, x17
+; TRAP-ELF-NEXT:   autda x0, x1
+; TRAP-ELF-NEXT:   mov x8, x0
+; TRAP-ELF-NEXT:   xpacd x8
+; TRAP-ELF-NEXT:   cmp x0, x8
 ; TRAP-NEXT:    b.eq [[L]]auth_success_4
 ; TRAP-NEXT:    brk #0xc472
 ; TRAP-NEXT:  Lauth_success_4:
-; TRAP-NEXT:    mov x0, x16
+; TRAP-DARWIN-NEXT:    mov x0, x16
 ; TRAP-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 2, i64 %arg1)
   ret i64 %tmp
@@ -188,30 +218,36 @@ define i64 @test_auth_da(i64 %arg, i64 %arg1) {
 
 define i64 @test_auth_da_zero(i64 %arg) {
 ; UNCHECKED-LABEL: test_auth_da_zero:
-; UNCHECKED:       %bb.0:
-; UNCHECKED-NEXT:    mov x16, x0
-; UNCHECKED-NEXT:    autdza x16
-; UNCHECKED-NEXT:    mov x0, x16
-; UNCHECKED-NEXT:    ret
+; UNCHECKED:           %bb.0:
+; UNCHECKED-DARWIN-NEXT: mov x16, x0
+; UNCHECKED-DARWIN-NEXT: autdza x16
+; UNCHECKED-DARWIN-NEXT: mov x0, x16
+; UNCHECKED-ELF-NEXT:    autdza x0
+; UNCHECKED-NEXT:        ret
 ;
 ; CHECKED-LABEL: test_auth_da_zero:
-; CHECKED:       %bb.0:
-; CHECKED-NEXT:    mov x16, x0
-; CHECKED-NEXT:    autdza x16
-; CHECKED-NEXT:    mov x0, x16
-; CHECKED-NEXT:    ret
+; CHECKED:           %bb.0:
+; CHECKED-DARWIN-NEXT: mov x16, x0
+; CHECKED-DARWIN-NEXT: autdza x16
+; CHECKED-DARWIN-NEXT: mov x0, x16
+; CHECKED-ELF-NEXT:    autdza x0
+; CHECKED-NEXT:        ret
 ;
 ; TRAP-LABEL: test_auth_da_zero:
 ; TRAP:       %bb.0:
-; TRAP-NEXT:    mov x16, x0
-; TRAP-NEXT:    autdza x16
-; TRAP-NEXT:    mov x17, x16
-; TRAP-NEXT:    xpacd x17
-; TRAP-NEXT:    cmp x16, x17
+; TRAP-DARWIN-NEXT:   mov x16, x0
+; TRAP-DARWIN-NEXT:   autdza x16
+; TRAP-DARWIN-NEXT:   mov x17, x16
+; TRAP-DARWIN-NEXT:   xpacd x17
+; TRAP-DARWIN-NEXT:   cmp x16, x17
+; TRAP-ELF-NEXT:   autdza x0
+; TRAP-ELF-NEXT:   mov x8, x0
+; TRAP-ELF-NEXT:   xpacd x8
+; TRAP-ELF-NEXT:   cmp x0, x8
 ; TRAP-NEXT:    b.eq [[L]]auth_success_5
 ; TRAP-NEXT:    brk #0xc472
 ; TRAP-NEXT:  Lauth_success_5:
-; TRAP-NEXT:    mov x0, x16
+; TRAP-DARWIN-NEXT:    mov x0, x16
 ; TRAP-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 2, i64 0)
   ret i64 %tmp
@@ -219,30 +255,36 @@ define i64 @test_auth_da_zero(i64 %arg) {
 
 define i64 @test_auth_db(i64 %arg, i64 %arg1) {
 ; UNCHECKED-LABEL: test_auth_db:
-; UNCHECKED:       %bb.0:
-; UNCHECKED-NEXT:    mov x16, x0
-; UNCHECKED-NEXT:    autdb x16, x1
-; UNCHECKED-NEXT:    mov x0, x16
-; UNCHECKED-NEXT:    ret
+; UNCHECKED:           %bb.0:
+; UNCHECKED-DARWIN-NEXT: mov x16, x0
+; UNCHECKED-DARWIN-NEXT: autdb x16, x1
+; UNCHECKED-DARWIN-NEXT: mov x0, x16
+; UNCHECKED-ELF-NEXT:    autdb x0, x1
+; UNCHECKED-NEXT:        ret
 ;
 ; CHECKED-LABEL: test_auth_db:
-; CHECKED:       %bb.0:
-; CHECKED-NEXT:    mov x16, x0
-; CHECKED-NEXT:    autdb x16, x1
-; CHECKED-NEXT:    mov x0, x16
-; CHECKED-NEXT:    ret
+; CHECKED:           %bb.0:
+; CHECKED-DARWIN-NEXT: mov x16, x0
+; CHECKED-DARWIN-NEXT: autdb x16, x1
+; CHECKED-DARWIN-NEXT: mov x0, x16
+; CHECKED-ELF-NEXT:    autdb x0, x1
+; CHECKED-NEXT:        ret
 ;
 ; TRAP-LABEL: test_auth_db:
 ; TRAP:       %bb.0:
-; TRAP-NEXT:    mov x16, x0
-; TRAP-NEXT:    autdb x16, x1
-; TRAP-NEXT:    mov x17, x16
-; TRAP-NEXT:    xpacd x17
-; TRAP-NEXT:    cmp x16, x17
+; TRAP-DARWIN-NEXT:   mov x16, x0
+; TRAP-DARWIN-NEXT:   autdb x16, x1
+; TRAP-DARWIN-NEXT:   mov x17, x16
+; TRAP-DARWIN-NEXT:   xpacd x17
+; TRAP-DARWIN-NEXT:   cmp x16, x17
+; TRAP-ELF-NEXT:   autdb x0, x1
+; TRAP-ELF-NEXT:   mov x8, x0
+; TRAP-ELF-NEXT:   xpacd x8
+; TRAP-ELF-NEXT:   cmp x0, x8
 ; TRAP-NEXT:    b.eq [[L]]auth_success_6
 ; TRAP-NEXT:    brk #0xc473
 ; TRAP-NEXT:  Lauth_success_6:
-; TRAP-NEXT:    mov x0, x16
+; TRAP-DARWIN-NEXT:    mov x0, x16
 ; TRAP-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 3, i64 %arg1)
   ret i64 %tmp
@@ -250,30 +292,36 @@ define i64 @test_auth_db(i64 %arg, i64 %arg1) {
 
 define i64 @test_auth_db_zero(i64 %arg) {
 ; UNCHECKED-LABEL: test_auth_db_zero:
-; UNCHECKED:       %bb.0:
-; UNCHECKED-NEXT:    mov x16, x0
-; UNCHECKED-NEXT:    autdzb x16
-; UNCHECKED-NEXT:    mov x0, x16
-; UNCHECKED-NEXT:    ret
+; UNCHECKED:           %bb.0:
+; UNCHECKED-DARWIN-NEXT: mov x16, x0
+; UNCHECKED-DARWIN-NEXT: autdzb x16
+; UNCHECKED-DARWIN-NEXT: mov x0, x16
+; UNCHECKED-ELF-NEXT:    autdzb x0
+; UNCHECKED-NEXT:        ret
 ;
 ; CHECKED-LABEL: test_auth_db_zero:
-; CHECKED:       %bb.0:
-; CHECKED-NEXT:    mov x16, x0
-; CHECKED-NEXT:    autdzb x16
-; CHECKED-NEXT:    mov x0, x16
-; CHECKED-NEXT:    ret
+; CHECKED:           %bb.0:
+; CHECKED-DARWIN-NEXT: mov x16, x0
+; CHECKED-DARWIN-NEXT: autdzb x16
+; CHECKED-DARWIN-NEXT: mov x0, x16
+; CHECKED-ELF-NEXT:    autdzb x0
+; CHECKED-NEXT:        ret
 ;
 ; TRAP-LABEL: test_auth_db_zero:
 ; TRAP:       %bb.0:
-; TRAP-NEXT:    mov x16, x0
-; TRAP-NEXT:    autdzb x16
-; TRAP-NEXT:    mov x17, x16
-; TRAP-NEXT:    xpacd x17
-; TRAP-NEXT:    cmp x16, x17
+; TRAP-DARWIN-NEXT:   mov x16, x0
+; TRAP-DARWIN-NEXT:   autdzb x16
+; TRAP-DARWIN-NEXT:   mov x17, x16
+; TRAP-DARWIN-NEXT:   xpacd x17
+; TRAP-DARWIN-NEXT:   cmp x16, x17
+; TRAP-ELF-NEXT:   autdzb x0
+; TRAP-ELF-NEXT:   mov x8, x0
+; TRAP-ELF-NEXT:   xpacd x8
+; TRAP-ELF-NEXT:   cmp x0, x8
 ; TRAP-NEXT:    b.eq [[L]]auth_success_7
 ; TRAP-NEXT:    brk #0xc473
 ; TRAP-NEXT:  Lauth_success_7:
-; TRAP-NEXT:    mov x0, x16
+; TRAP-DARWIN-NEXT:    mov x0, x16
 ; TRAP-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 3, i64 0)
   ret i64 %tmp
@@ -535,36 +583,45 @@ define i64 @test_resign_da_dzb(i64 %arg, i64 %arg1, i64 %arg2) {
 
 define i64 @test_auth_trap_attribute(i64 %arg, i64 %arg1) "ptrauth-auth-traps" {
 ; UNCHECKED-LABEL: test_auth_trap_attribute:
-; UNCHECKED:       %bb.0:
-; UNCHECKED-NEXT:    mov x16, x0
-; UNCHECKED-NEXT:    autia x16, x1
-; UNCHECKED-NEXT:    mov x0, x16
-; UNCHECKED-NEXT:    ret
+; UNCHECKED:     %bb.0:
+; UNCHECKED-DARWIN-NEXT:  mov x16, x0
+; UNCHECKED-DARWIN-NEXT:  autia x16, x1
+; UNCHECKED-DARWIN-NEXT:  mov x0, x16
+; UNCHECKED-ELF-NEXT:  autia x0, x1
+; UNCHECKED-NEXT:  ret
 ;
 ; CHECKED-LABEL: test_auth_trap_attribute:
-; CHECKED:       %bb.0:
-; CHECKED-NEXT:    mov x16, x0
-; CHECKED-NEXT:    autia x16, x1
-; CHECKED-NEXT:    mov x17, x16
-; CHECKED-NEXT:    xpaci x17
-; CHECKED-NEXT:    cmp x16, x17
-; CHECKED-NEXT:    b.eq [[L]]auth_success_6
-; CHECKED-NEXT:    brk #0xc470
-; CHECKED-NEXT:  Lauth_success_6:
-; CHECKED-NEXT:    mov x0, x16
-; CHECKED-NEXT:    ret
+; CHECKED:      %bb.0:
+; CHECKED-DARWIN-NEXT:   mov x16, x0
+; CHECKED-DARWIN-NEXT:   autia x16, x1
+; CHECKED-DARWIN-NEXT:   mov x17, x16
+; CHECKED-DARWIN-NEXT:   xpaci x17
+; CHECKED-DARWIN-NEXT:   cmp x16, x17
+; CHECKED-ELF-NEXT:   autia x0, x1
+; CHECKED-ELF-NEXT:   mov x8, x0
+; CHECKED-ELF-NEXT:   xpaci x8
+; CHECKED-ELF-NEXT:   cmp x0, x8
+; CHECKED-NEXT:   b.eq [[L]]auth_success_6
+; CHECKED-NEXT:   brk #0xc470
+; CHECKED-NEXT: Lauth_success_6:
+; CHECKED-DARWIN-NEXT:   mov x0, x16
+; CHECKED-NEXT:   ret
 ;
 ; TRAP-LABEL: test_auth_trap_attribute:
 ; TRAP:       %bb.0:
-; TRAP-NEXT:    mov x16, x0
-; TRAP-NEXT:    autia x16, x1
-; TRAP-NEXT:    mov x17, x16
-; TRAP-NEXT:    xpaci x17
-; TRAP-NEXT:    cmp x16, x17
+; TRAP-DARWIN-NEXT:   mov x16, x0
+; TRAP-DARWIN-NEXT:   autia x16, x1
+; TRAP-DARWIN-NEXT:   mov x17, x16
+; TRAP-DARWIN-NEXT:   xpaci x17
+; TRAP-DARWIN-NEXT:   cmp x16, x17
+; TRAP-ELF-NEXT:   autia x0, x1
+; TRAP-ELF-NEXT:   mov x8, x0
+; TRAP-ELF-NEXT:   xpaci x8
+; TRAP-ELF-NEXT:   cmp x0, x8
 ; TRAP-NEXT:    b.eq [[L]]auth_success_14
 ; TRAP-NEXT:    brk #0xc470
 ; TRAP-NEXT:  Lauth_success_14:
-; TRAP-NEXT:    mov x0, x16
+; TRAP-DARWIN-NEXT:    mov x0, x16
 ; TRAP-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 0, i64 %arg1)
   ret i64 %tmp
@@ -572,33 +629,42 @@ define i64 @test_auth_trap_attribute(i64 %arg, i64 %arg1) "ptrauth-auth-traps" {
 
 define i64 @test_auth_ia_constdisc(i64 %arg) {
 ; UNCHECKED-LABEL: test_auth_ia_constdisc:
-; UNCHECKED:       %bb.0:
-; UNCHECKED-NEXT:    mov x16, x0
-; UNCHECKED-NEXT:    mov x17, #256
-; UNCHECKED-NEXT:    autia x16, x17
-; UNCHECKED-NEXT:    mov x0, x16
-; UNCHECKED-NEXT:    ret
+; UNCHECKED:           %bb.0:
+; UNCHECKED-DARWIN-NEXT: mov x16, x0
+; UNCHECKED-DARWIN-NEXT: mov x17, #256
+; UNCHECKED-DARWIN-NEXT: autia x16, x17
+; UNCHECKED-DARWIN-NEXT: mov x0, x16
+; UNCHECKED-ELF-NEXT:    mov x8, #256
+; UNCHECKED-ELF-NEXT:    autia x0, x8
+; UNCHECKED-NEXT:        ret
 ;
 ; CHECKED-LABEL: test_auth_ia_constdisc:
-; CHECKED:       %bb.0:
-; CHECKED-NEXT:    mov x16, x0
-; CHECKED-NEXT:    mov x17, #256
-; CHECKED-NEXT:    autia x16, x17
-; CHECKED-NEXT:    mov x0, x16
-; CHECKED-NEXT:    ret
+; CHECKED:           %bb.0:
+; CHECKED-DARWIN-NEXT: mov x16, x0
+; CHECKED-DARWIN-NEXT: mov x17, #256
+; CHECKED-DARWIN-NEXT: autia x16, x17
+; CHECKED-DARWIN-NEXT: mov x0, x16
+; CHECKED-ELF-NEXT:    mov x8, #256
+; CHECKED-ELF-NEXT:    autia x0, x8
+; CHECKED-NEXT:        ret
 ;
 ; TRAP-LABEL: test_auth_ia_constdisc:
 ; TRAP:       %bb.0:
-; TRAP-NEXT:    mov x16, x0
-; TRAP-NEXT:    mov x17, #256
-; TRAP-NEXT:    autia x16, x17
-; TRAP-NEXT:    mov x17, x16
-; TRAP-NEXT:    xpaci x17
-; TRAP-NEXT:    cmp x16, x17
+; TRAP-DARWIN-NEXT:    mov x16, x0
+; TRAP-DARWIN-NEXT:    mov x17, #256
+; TRAP-DARWIN-NEXT:    autia x16, x17
+; TRAP-DARWIN-NEXT:    mov x17, x16
+; TRAP-DARWIN-NEXT:    xpaci x17
+; TRAP-DARWIN-NEXT:    cmp x16, x17
+; TRAP-ELF-NEXT:    mov x8, #256
+; TRAP-ELF-NEXT:    autia x0, x8
+; TRAP-ELF-NEXT:    mov x8, x0
+; TRAP-ELF-NEXT:    xpaci x8
+; TRAP-ELF-NEXT:    cmp x0, x8
 ; TRAP-NEXT:    b.eq [[L]]auth_success_15
 ; TRAP-NEXT:    brk #0xc470
 ; TRAP-NEXT:  Lauth_success_15:
-; TRAP-NEXT:    mov x0, x16
+; TRAP-DARWIN-NEXT:    mov x0, x16
 ; TRAP-NEXT:    ret
   %tmp = call i64 @llvm.ptrauth.auth(i64 %arg, i32 0, i64 256)
   ret i64 %tmp
@@ -649,5 +715,45 @@ define i64 @test_resign_da_constdisc(i64 %arg, i64 %arg1) {
   ret i64 %tmp
 }
 
+define i64 @test_auth_ia_swapped(i64 %arg, i64 %arg1) {
+; UNCHECKED-LABEL: test_auth_ia_swapped:
+; UNCHECKED:           %bb.0:
+; UNCHECKED-DARWIN-NEXT: mov x16, x1
+; UNCHECKED-DARWIN-NEXT: autia x16, x0
+; UNCHECKED-DARWIN-NEXT: mov x0, x16
+; UNCHECKED-ELF-NEXT:    autia x1, x0
+; UNCHECKED-ELF-NEXT:    mov x0, x1
+; UNCHECKED-NEXT:        ret
+;
+; CHECKED-LABEL: test_auth_ia_swapped:
+; CHECKED:           %bb.0:
+; CHECKED-DARWIN-NEXT: mov x16, x1
+; CHECKED-DARWIN-NEXT: autia x16, x0
+; CHECKED-DARWIN-NEXT: mov x0, x16
+; CHECKED-ELF-NEXT:    autia x1, x0
+; CHECKED-ELF-NEXT:    mov x0, x1
+; CHECKED-NEXT:        ret
+;
+; TRAP-LABEL: test_auth_ia_swapped:
+; TRAP:       %bb.0:
+; TRAP-DARWIN-NEXT:   mov x16, x1
+; TRAP-DARWIN-NEXT:   autia x16, x0
+; TRAP-DARWIN-NEXT:   mov x17, x16
+; TRAP-DARWIN-NEXT:   xpaci x17
+; TRAP-DARWIN-NEXT:   cmp x16, x17
+; TRAP-ELF-NEXT:   autia x1, x0
+; TRAP-ELF-NEXT:   mov x8, x1
+; TRAP-ELF-NEXT:   xpaci x8
+; TRAP-ELF-NEXT:   cmp x1, x8
+; TRAP-NEXT:    b.eq [[L]]auth_success_17
+; TRAP-NEXT:    brk #0xc470
+; TRAP-NEXT:  Lauth_success_17:
+; TRAP-DARWIN-NEXT:    mov x0, x16
+; TRAP-ELF-NEXT:    mov x0, x1
+; TRAP-NEXT:    ret
+  %tmp = call i64 @llvm.ptrauth.auth(i64 %arg1, i32 0, i64 %arg)
+  ret i64 %tmp
+}
+
 declare i64 @llvm.ptrauth.auth(i64, i32, i64)
 declare i64 @llvm.ptrauth.resign(i64, i32, i64, i32, i64)