[AArch64] [SEH] Rename pac_sign_return_address to pac_sign_lr

[mstorsjo]

Summary

This new opcode was initially documented as "pac_sign_return_address"
in https://github.com/MicrosoftDocs/cpp-docs/pull/4202, but was
soon afterwards renamed into "pac_sign_lr" in
https://github.com/MicrosoftDocs/cpp-docs/pull/4209, as the other
name was unwieldy, and there were no other external references to
that name anywhere.

Rename our external .seh assembler directive - it hasn't been merged
for very long yet, so there's probably no external use to account for.

Rename all other internal references to the opcode similarly.

[efriedma]

LGTM

llvm/include/llvm/Support/Win64EH.h

enum UnwindOpcodes {
   UOP_SetFP,
   UOP_AddFP,
   UOP_Nop,
   UOP_End,
   UOP_SaveNext,
   UOP_TrapFrame,
   UOP_Context,
   UOP_ClearUnwoundToCall,
-  UOP_PACSignReturnAddress,
+  UOP_PACSignLR,
   // The following set of unwind opcodes is for ARM.  They are documented at
   // https://docs.microsoft.com/en-us/cpp/build/arm-exception-handling
 
   // Stack allocations use UOP_AllocSmall, UOP_AllocLarge from above, plus
   // the following. AllocSmall, AllocLarge and AllocHuge represent a 16 bit
   // instruction, while the WideAlloc* opcodes represent a 32 bit instruction.
   // Small can represent a stack offset of 0x7f*4 (252) bytes, Medium can
   // represent up to 0x3ff*4 (4092) bytes, Large up to 0xffff*4 (262140) bytes,

llvm/lib/MC/MCWin64EH.cpp

case Win64EH::UOP_PushMachFrame:
       Count += 1;
       break;
     case Win64EH::UOP_Context:
       Count += 1;
       break;
     case Win64EH::UOP_ClearUnwoundToCall:
       Count += 1;
       break;
-    case Win64EH::UOP_PACSignReturnAddress:
+    case Win64EH::UOP_PACSignLR:
       Count += 1;
       break;
     }
   }
   return Count;
 }
 
 // Unwind opcode encodings and restrictions are documented at
static void ARM64EmitUnwindCode(MCStreamer &streamer,
   case Win64EH::UOP_Context:
     b = 0xEA;
     streamer.emitInt8(b);
     break;
   case Win64EH::UOP_ClearUnwoundToCall:
     b = 0xEC;
     streamer.emitInt8(b);
     break;
-  case Win64EH::UOP_PACSignReturnAddress:
+  case Win64EH::UOP_PACSignLR:
     b = 0xFC;
     streamer.emitInt8(b);
     break;
   }
 }
 
 // Returns the epilog symbol of an epilog with the exact same unwind code
 // sequence, if it exists.  Otherwise, returns nullptr.
static bool tryARM64PackedUnwind(WinEH::FrameInfo *info, uint32_t FuncLength,
   // prologs/epilogs.
   for (const WinEH::Instruction &Inst : info->Instructions) {
     switch (Inst.Operation) {
     case Win64EH::UOP_End:
       if (Location != Start)
         return false;
       Location = Start2;
       break;
-    case Win64EH::UOP_PACSignReturnAddress:
+    case Win64EH::UOP_PACSignLR:
       if (Location != Start2)
         return false;
       PAC = true;
       Location = Start3;
       break;
     case Win64EH::UOP_SaveR19R20X:
       if (Location != Start2 && Location != Start3)
         return false;

llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

private:
   bool parseDirectiveSEHNop(SMLoc L);
   bool parseDirectiveSEHSaveNext(SMLoc L);
   bool parseDirectiveSEHEpilogStart(SMLoc L);
   bool parseDirectiveSEHEpilogEnd(SMLoc L);
   bool parseDirectiveSEHTrapFrame(SMLoc L);
   bool parseDirectiveSEHMachineFrame(SMLoc L);
   bool parseDirectiveSEHContext(SMLoc L);
   bool parseDirectiveSEHClearUnwoundToCall(SMLoc L);
-  bool parseDirectiveSEHPACSignReturnAddress(SMLoc L);
+  bool parseDirectiveSEHPACSignLR(SMLoc L);
 
   bool validateInstruction(MCInst &Inst, SMLoc &IDLoc,
                            SmallVectorImpl<SMLoc> &Loc);
   bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
                                OperandVector &Operands, MCStreamer &Out,
                                uint64_t &ErrorInfo,
                                bool MatchingInlineAsm) override;
 /// @name Auto-generated Match Functions
else if (IsMachO) {
     else if (IDVal == ".seh_trap_frame")
       parseDirectiveSEHTrapFrame(Loc);
     else if (IDVal == ".seh_pushframe")
       parseDirectiveSEHMachineFrame(Loc);
     else if (IDVal == ".seh_context")
       parseDirectiveSEHContext(Loc);
     else if (IDVal == ".seh_clear_unwound_to_call")
       parseDirectiveSEHClearUnwoundToCall(Loc);
-    else if (IDVal == ".seh_pac_sign_return_address")
-      parseDirectiveSEHPACSignReturnAddress(Loc);
+    else if (IDVal == ".seh_pac_sign_lr")
+      parseDirectiveSEHPACSignLR(Loc);
     else
       return true;
   } else
     return true;
   return false;
 }
 
 static void ExpandCryptoAEK(AArch64::ArchKind ArchKind,

 
 /// parseDirectiveSEHClearUnwoundToCall
 /// ::= .seh_clear_unwound_to_call
 bool AArch64AsmParser::parseDirectiveSEHClearUnwoundToCall(SMLoc L) {
   getTargetStreamer().emitARM64WinCFIClearUnwoundToCall();
   return false;
 }
 
-/// parseDirectiveSEHPACSignReturnAddress
-/// ::= .seh_pac_sign_return_address
-bool AArch64AsmParser::parseDirectiveSEHPACSignReturnAddress(SMLoc L) {
-  getTargetStreamer().emitARM64WinCFIPACSignReturnAddress();
+/// parseDirectiveSEHPACSignLR
+/// ::= .seh_pac_sign_lr
+bool AArch64AsmParser::parseDirectiveSEHPACSignLR(SMLoc L) {
+  getTargetStreamer().emitARM64WinCFIPACSignLR();
   return false;
 }
 
 bool
 AArch64AsmParser::classifySymbolRef(const MCExpr *Expr,
                                     AArch64MCExpr::VariantKind &ELFRefKind,
                                     MCSymbolRefExpr::VariantKind &DarwinRefKind,
                                     int64_t &Addend) {

llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.cpp

class AArch64TargetAsmStreamer : public AArch64TargetStreamer {
   void emitARM64WinCFIEpilogStart() override { OS << "\t.seh_startepilogue\n"; }
   void emitARM64WinCFIEpilogEnd() override { OS << "\t.seh_endepilogue\n"; }
   void emitARM64WinCFITrapFrame() override { OS << "\t.seh_trap_frame\n"; }
   void emitARM64WinCFIMachineFrame() override { OS << "\t.seh_pushframe\n"; }
   void emitARM64WinCFIContext() override { OS << "\t.seh_context\n"; }
   void emitARM64WinCFIClearUnwoundToCall() override {
     OS << "\t.seh_clear_unwound_to_call\n";
   }
-  void emitARM64WinCFIPACSignReturnAddress() override {
-    OS << "\t.seh_pac_sign_return_address\n";
+  void emitARM64WinCFIPACSignLR() override {
+    OS << "\t.seh_pac_sign_lr\n";
   }
 
 public:
   AArch64TargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS);
 };
 
 AArch64TargetAsmStreamer::AArch64TargetAsmStreamer(MCStreamer &S,
                                                    formatted_raw_ostream &OS)

llvm/lib/Target/AArch64/MCTargetDesc/AArch64TargetStreamer.h

public:
   virtual void emitARM64WinCFISaveNext() {}
   virtual void emitARM64WinCFIPrologEnd() {}
   virtual void emitARM64WinCFIEpilogStart() {}
   virtual void emitARM64WinCFIEpilogEnd() {}
   virtual void emitARM64WinCFITrapFrame() {}
   virtual void emitARM64WinCFIMachineFrame() {}
   virtual void emitARM64WinCFIContext() {}
   virtual void emitARM64WinCFIClearUnwoundToCall() {}
-  virtual void emitARM64WinCFIPACSignReturnAddress() {}
+  virtual void emitARM64WinCFIPACSignLR() {}
 
 private:
   std::unique_ptr<AssemblerConstantPools> ConstantPools;
 };
 
 class AArch64TargetELFStreamer : public AArch64TargetStreamer {
 private:
   AArch64ELFStreamer &getStreamer();
public:
   void emitARM64WinCFISaveNext() override;
   void emitARM64WinCFIPrologEnd() override;
   void emitARM64WinCFIEpilogStart() override;
   void emitARM64WinCFIEpilogEnd() override;
   void emitARM64WinCFITrapFrame() override;
   void emitARM64WinCFIMachineFrame() override;
   void emitARM64WinCFIContext() override;
   void emitARM64WinCFIClearUnwoundToCall() override;
-  void emitARM64WinCFIPACSignReturnAddress() override;
+  void emitARM64WinCFIPACSignLR() override;
 
 private:
   void emitARM64WinUnwindCode(unsigned UnwindCode, int Reg, int Offset);
 };
 
 MCTargetStreamer *
 createAArch64ObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI);
 
 } // end namespace llvm
 
 #endif

llvm/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFStreamer.cpp

 void AArch64TargetWinCOFFStreamer::emitARM64WinCFIContext() {
   emitARM64WinUnwindCode(Win64EH::UOP_Context, -1, 0);
 }
 
 void AArch64TargetWinCOFFStreamer::emitARM64WinCFIClearUnwoundToCall() {
   emitARM64WinUnwindCode(Win64EH::UOP_ClearUnwoundToCall, -1, 0);
 }
 
-void AArch64TargetWinCOFFStreamer::emitARM64WinCFIPACSignReturnAddress() {
-  emitARM64WinUnwindCode(Win64EH::UOP_PACSignReturnAddress, -1, 0);
+void AArch64TargetWinCOFFStreamer::emitARM64WinCFIPACSignLR() {
+  emitARM64WinUnwindCode(Win64EH::UOP_PACSignLR, -1, 0);
 }
 
 MCWinCOFFStreamer *llvm::createAArch64WinCOFFStreamer(
     MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
     std::unique_ptr<MCObjectWriter> OW, std::unique_ptr<MCCodeEmitter> Emitter,
     bool RelaxAll, bool IncrementalLinkerCompatible) {
   auto *S = new AArch64WinCOFFStreamer(Context, std::move(MAB),
                                        std::move(Emitter), std::move(OW));
   S->getAssembler().setIncrementalLinkerCompatible(IncrementalLinkerCompatible);
   return S;
 }

llvm/test/MC/AArch64/seh-packed-unwind.s

func15:
     .seh_save_fplr_x 32
     .seh_endepilogue
     ret
     .seh_endproc
 
 func16:
     .seh_proc func16
     pacibsp
-    .seh_pac_sign_return_address
+    .seh_pac_sign_lr
     stp x29, lr,  [sp, #-32]!
     .seh_save_fplr_x 32
     mov x29, sp
     .seh_set_fp
     .seh_endprologue
     nop
     .seh_startepilogue
     ldp x29, lr, [sp], #32
     .seh_save_fplr_x 32
     autibsp
-    .seh_pac_sign_return_address
+    .seh_pac_sign_lr
     .seh_endepilogue
     ret
     .seh_endproc
 
 func17:
     .seh_proc func17
     pacibsp
-    .seh_pac_sign_return_address
+    .seh_pac_sign_lr
     stp x19, x20, [sp, #-16]!
     .seh_save_r19r20_x 16
     stp x29, lr,  [sp, #-32]!
     .seh_save_fplr_x 32
     mov x29, sp
     .seh_set_fp
     .seh_endprologue
     nop
     .seh_startepilogue
     mov sp,  x29
     .seh_set_fp
     ldp x29, lr,  [sp], #32
     .seh_save_fplr_x 32
     ldp x19, x20, [sp], #16
     .seh_save_r19r20_x 16
     autibsp
-    .seh_pac_sign_return_address
+    .seh_pac_sign_lr
     .seh_endepilogue
     ret
     .seh_endproc
 
 func18:
     .seh_proc func18
     pacibsp
-    .seh_pac_sign_return_address
+    .seh_pac_sign_lr
     stp x19, x20, [sp, #-16]!
     .seh_save_r19r20_x 16
     sub sp,  sp,  #4080
     .seh_stackalloc 4080
     sub sp,  sp,  #16
     .seh_stackalloc 16
     stp x29, lr,  [sp, #0]
     .seh_save_fplr 0
     mov x29, sp
     .seh_set_fp
     .seh_endprologue
     nop
     .seh_startepilogue
     mov sp,  x29
     .seh_set_fp
     ldp x29, lr,  [sp, #0]
     .seh_save_fplr 0
     add sp,  sp,  #16
     .seh_stackalloc 16
     add sp,  sp,  #4080
     .seh_stackalloc 4080
     ldp x19, x20, [sp], #16
     .seh_save_r19r20_x 16
     autibsp
-    .seh_pac_sign_return_address
+    .seh_pac_sign_lr
     .seh_endepilogue
     ret
     .seh_endproc
 
 nonpacked1:
     .seh_proc nonpacked1
     // Can't be packed; can't save integer registers after float registers.
     stp d8,  d9,  [sp, #-32]!
nonpacked13:
     .text
     .seh_endproc
 
 nonpacked14:
     .seh_proc nonpacked14
     // Can't be packed; a signed return address can only be expressed if
     // we save both x29 and lr on the stack.
     pacibsp
-    .seh_pac_sign_return_address
+    .seh_pac_sign_lr
     str lr,       [sp, #-32]!
     .seh_save_reg_x lr, 32
     .seh_endprologue
     nop
     .seh_startepilogue
     ldr lr,       [sp], #32
     .seh_save_reg_x lr, 32
     autibsp
-    .seh_pac_sign_return_address
+    .seh_pac_sign_lr
     .seh_endepilogue
     ret
     .seh_endproc
 
 nonpacked15:
     .seh_proc nonpacked15
     // Can't be packed; a signed return address can only be expressed if
     // we save both x29 and lr on the stack.
     pacibsp
-    .seh_pac_sign_return_address
+    .seh_pac_sign_lr
     stp x19, x20, [sp, #-32]!
     .seh_save_r19r20_x 32
     stp x21, lr,  [sp, #16]
     .seh_save_lrpair x21, 16
     sub sp,  sp,  #16
     .seh_stackalloc 16
     .seh_endprologue
     nop
     .seh_startepilogue
     add sp,  sp,  #16
     .seh_stackalloc 16
     ldp x21, lr,  [sp, #16]
     .seh_save_lrpair x21, 16
     ldp x19, x20, [sp], #32
     .seh_save_r19r20_x 32
     autibsp
-    .seh_pac_sign_return_address
+    .seh_pac_sign_lr
     .seh_endepilogue
     ret
     .seh_endproc

llvm/test/MC/AArch64/seh.s

func:
     .seh_trap_frame
     nop
     .seh_pushframe
     nop
     .seh_context
     nop
     .seh_clear_unwound_to_call
     pacibsp
-    .seh_pac_sign_return_address
+    .seh_pac_sign_lr
     .seh_endprologue
     nop
     .seh_startepilogue
     add sp, sp, #24
     .seh_stackalloc 24
     .seh_endepilogue
     ret
     .seh_handler __C_specific_handler, @except

llvm/tools/llvm-readobj/ARMWinEHPrinter.h

class Decoder {
   bool opcode_trap_frame(const uint8_t *Opcodes, unsigned &Offset,
                          unsigned Length, bool Prologue);
   bool opcode_machine_frame(const uint8_t *Opcodes, unsigned &Offset,
                             unsigned Length, bool Prologue);
   bool opcode_context(const uint8_t *Opcodes, unsigned &Offset, unsigned Length,
                       bool Prologue);
   bool opcode_clear_unwound_to_call(const uint8_t *Opcodes, unsigned &Offset,
                                     unsigned Length, bool Prologue);
-  bool opcode_pac_sign_return_address(const uint8_t *Opcodes, unsigned &Offset,
-                                      unsigned Length, bool Prologue);
+  bool opcode_pac_sign_lr(const uint8_t *Opcodes, unsigned &Offset,
 
   void decodeOpcodes(ArrayRef<uint8_t> Opcodes, unsigned Offset,
                      bool Prologue);
 
   void printGPRMask(uint16_t Mask);
   void printVFPMask(uint32_t Mask);
 
   ErrorOr<object::SectionRef>

llvm/tools/llvm-readobj/ARMWinEHPrinter.cpp

const Decoder::RingEntry Decoder::Ring64[] = {
     {0xff, 0xe4, 1, &Decoder::opcode_end},
     {0xff, 0xe5, 1, &Decoder::opcode_end_c},
     {0xff, 0xe6, 1, &Decoder::opcode_save_next},
     {0xff, 0xe7, 3, &Decoder::opcode_save_any_reg},
     {0xff, 0xe8, 1, &Decoder::opcode_trap_frame},
     {0xff, 0xe9, 1, &Decoder::opcode_machine_frame},
     {0xff, 0xea, 1, &Decoder::opcode_context},
     {0xff, 0xec, 1, &Decoder::opcode_clear_unwound_to_call},
-    {0xff, 0xfc, 1, &Decoder::opcode_pac_sign_return_address},
+    {0xff, 0xfc, 1, &Decoder::opcode_pac_sign_lr},
 };
 
 static void printRange(raw_ostream &OS, ListSeparator &LS, unsigned First,
                        unsigned Last, char Letter) {
   if (First == Last)
     OS << LS << Letter << First;
   else
     OS << LS << Letter << First << "-" << Letter << Last;

 bool Decoder::opcode_clear_unwound_to_call(const uint8_t *OC, unsigned &Offset,
                                            unsigned Length, bool Prologue) {
   SW.startLine() << format("0x%02x                ; clear unwound to call\n",
                            OC[Offset]);
   ++Offset;
   return false;
 }
 
-bool Decoder::opcode_pac_sign_return_address(const uint8_t *OC,
-                                             unsigned &Offset, unsigned Length,
-                                             bool Prologue) {
+bool Decoder::opcode_pac_sign_lr(const uint8_t *OC, unsigned &Offset,
+                                 unsigned Length, bool Prologue) {
   if (Prologue)
     SW.startLine() << format("0x%02x                ; pacibsp\n", OC[Offset]);
   else
     SW.startLine() << format("0x%02x                ; autibsp\n", OC[Offset]);
   ++Offset;
   return false;
 }