[X86] Print register names in .seh_* directives

[rnk]

Summary

Also improve assembler parser register validation for .seh_ directives.
This requires moving X86-specific seh directive handling into the x86
backend, which addresses some assembler FIXMEs.

[pengfei]

llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp

3764

I saw lots of mixed use of register name and integer number in test cases. I think it may confuse user. Shall we disable the integer number supporting, or give a warning?

llvm/test/MC/AsmParser/directive_seh.s

22

Seems duplicated

[rnk]

llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp

3764

I think we should continue to accept the numbers to be GNU as compatible. I think the directive_seh.s and seh-directive-errors.s tests are the only remaining tests that use the numbers now, and they only exist to ensure we do the right thing with them.

llvm/test/MC/AsmParser/directive_seh.s

22

Oops, this was supposed to use a the number, but my sed command turned it into a register.

[pengfei]

LGTM. But I'd like others to make a decision. Thanks!

[rnk]

In D66625#1648790, @pengfei wrote:

LGTM. But I'd like others to make a decision. Thanks!

Thanks! I was hoping to hear from @craig.topper or @RKSimon, but I've been meaning to do this for so long, I think it's time to move forward on it.

[craig.topper]

llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp

3791

Do we need to support 32-bit registers in 32-bit mode? Or is there soemthing about .seh that is only 64-bit?

[rnk]

llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp

3791

These directives should be 64-bit only. There are tests for that at llvm/test/MC/AsmParser/seh-directive-errors.s. I noticed a crash, I'll fix that in a sec.

[aganea]

llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp

3612

if (IDVal == ".seh_stackalloc") is not being handled here, but you've added X86AsmParser::parseDirectiveSEHAllocStack. Is that intended?

[rnk]

llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp

3612

No, that's a mistake, thanks. I was surprised to discover that the AArch64 SEH asm parsing code supports this directive and does something with it, so I had to move it back to MCStreamer, and forgot to delete this.

llvm/include/llvm/MC/MCStreamer.h

 class MCAsmBackend;
 class MCCodeEmitter;
 struct MCCodePaddingContext;
 class MCContext;
 struct MCDwarfFrameInfo;
 class MCExpr;
 class MCInst;
 class MCInstPrinter;
+class MCRegister;
 class MCSection;
 class MCStreamer;
 class MCSymbolRefExpr;
 class MCSubtargetInfo;
 class raw_ostream;
 class Twine;
 
 using MCSectionSubPair = std::pair<MCSection *, const MCExpr *>;
public:
   virtual void EmitWinCFIEndProc(SMLoc Loc = SMLoc());
   /// This is used on platforms, such as Windows on ARM64, that require function
   /// or funclet sizes to be emitted in .xdata before the End marker is emitted
   /// for the frame.  We cannot use the End marker, as it is not set at the
   /// point of emitting .xdata, in order to indicate that the frame is active.
   virtual void EmitWinCFIFuncletOrFuncEnd(SMLoc Loc = SMLoc());
   virtual void EmitWinCFIStartChained(SMLoc Loc = SMLoc());
   virtual void EmitWinCFIEndChained(SMLoc Loc = SMLoc());
-  virtual void EmitWinCFIPushReg(unsigned Register, SMLoc Loc = SMLoc());
-  virtual void EmitWinCFISetFrame(unsigned Register, unsigned Offset,
+  virtual void EmitWinCFIPushReg(MCRegister Register, SMLoc Loc = SMLoc());
+  virtual void EmitWinCFISetFrame(MCRegister Register, unsigned Offset,
                                   SMLoc Loc = SMLoc());
   virtual void EmitWinCFIAllocStack(unsigned Size, SMLoc Loc = SMLoc());
-  virtual void EmitWinCFISaveReg(unsigned Register, unsigned Offset,
+  virtual void EmitWinCFISaveReg(MCRegister Register, unsigned Offset,
                                  SMLoc Loc = SMLoc());
-  virtual void EmitWinCFISaveXMM(unsigned Register, unsigned Offset,
+  virtual void EmitWinCFISaveXMM(MCRegister Register, unsigned Offset,
                                  SMLoc Loc = SMLoc());
   virtual void EmitWinCFIPushFrame(bool Code, SMLoc Loc = SMLoc());
   virtual void EmitWinCFIEndProlog(SMLoc Loc = SMLoc());
   virtual void EmitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except,
                                 SMLoc Loc = SMLoc());
   virtual void EmitWinEHHandlerData(SMLoc Loc = SMLoc());
 
   virtual void emitCGProfileEntry(const MCSymbolRefExpr *From,

llvm/lib/MC/MCAsmStreamer.cpp

 #include "llvm/MC/MCCodeView.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
+#include "llvm/MC/MCRegister.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
public:
   void EmitCFINegateRAState() override;
   void EmitCFIReturnColumn(int64_t Register) override;
 
   void EmitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc) override;
   void EmitWinCFIEndProc(SMLoc Loc) override;
   void EmitWinCFIFuncletOrFuncEnd(SMLoc Loc) override;
   void EmitWinCFIStartChained(SMLoc Loc) override;
   void EmitWinCFIEndChained(SMLoc Loc) override;
-  void EmitWinCFIPushReg(unsigned Register, SMLoc Loc) override;
-  void EmitWinCFISetFrame(unsigned Register, unsigned Offset,
+  void EmitWinCFIPushReg(MCRegister Register, SMLoc Loc) override;
+  void EmitWinCFISetFrame(MCRegister Register, unsigned Offset,
                           SMLoc Loc) override;
   void EmitWinCFIAllocStack(unsigned Size, SMLoc Loc) override;
-  void EmitWinCFISaveReg(unsigned Register, unsigned Offset,
+  void EmitWinCFISaveReg(MCRegister Register, unsigned Offset,
                          SMLoc Loc) override;
-  void EmitWinCFISaveXMM(unsigned Register, unsigned Offset,
+  void EmitWinCFISaveXMM(MCRegister Register, unsigned Offset,
                          SMLoc Loc) override;
   void EmitWinCFIPushFrame(bool Code, SMLoc Loc) override;
   void EmitWinCFIEndProlog(SMLoc Loc) override;
 
   void EmitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except,
                         SMLoc Loc) override;
   void EmitWinEHHandlerData(SMLoc Loc) override;
 
void MCAsmStreamer::EmitWinEHHandlerData(SMLoc Loc) {
   MCSection *TextSec = &CurFrame->Function->getSection();
   MCSection *XData = getAssociatedXDataSection(TextSec);
   SwitchSectionNoChange(XData);
 
   OS << "\t.seh_handlerdata";
   EmitEOL();
 }
 
-void MCAsmStreamer::EmitWinCFIPushReg(unsigned Register, SMLoc Loc) {
+void MCAsmStreamer::EmitWinCFIPushReg(MCRegister Register, SMLoc Loc) {
   MCStreamer::EmitWinCFIPushReg(Register, Loc);
 
-  OS << "\t.seh_pushreg " << Register;
+  OS << "\t.seh_pushreg ";
+  InstPrinter->printRegName(OS, Register);
   EmitEOL();
 }
 
-void MCAsmStreamer::EmitWinCFISetFrame(unsigned Register, unsigned Offset,
+void MCAsmStreamer::EmitWinCFISetFrame(MCRegister Register, unsigned Offset,
                                        SMLoc Loc) {
   MCStreamer::EmitWinCFISetFrame(Register, Offset, Loc);
 
-  OS << "\t.seh_setframe " << Register << ", " << Offset;
+  OS << "\t.seh_setframe ";
+  InstPrinter->printRegName(OS, Register);
+  OS << ", " << Offset;
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitWinCFIAllocStack(unsigned Size, SMLoc Loc) {
   MCStreamer::EmitWinCFIAllocStack(Size, Loc);
 
   OS << "\t.seh_stackalloc " << Size;
   EmitEOL();
 }
 
-void MCAsmStreamer::EmitWinCFISaveReg(unsigned Register, unsigned Offset,
+void MCAsmStreamer::EmitWinCFISaveReg(MCRegister Register, unsigned Offset,
                                       SMLoc Loc) {
   MCStreamer::EmitWinCFISaveReg(Register, Offset, Loc);
 
-  OS << "\t.seh_savereg " << Register << ", " << Offset;
+  OS << "\t.seh_savereg ";
+  InstPrinter->printRegName(OS, Register);
+  OS << ", " << Offset;
   EmitEOL();
 }
 
-void MCAsmStreamer::EmitWinCFISaveXMM(unsigned Register, unsigned Offset,
+void MCAsmStreamer::EmitWinCFISaveXMM(MCRegister Register, unsigned Offset,
                                       SMLoc Loc) {
   MCStreamer::EmitWinCFISaveXMM(Register, Offset, Loc);
 
-  OS << "\t.seh_savexmm " << Register << ", " << Offset;
+  OS << "\t.seh_savexmm ";
+  InstPrinter->printRegName(OS, Register);
+  OS << ", " << Offset;
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitWinCFIPushFrame(bool Code, SMLoc Loc) {
   MCStreamer::EmitWinCFIPushFrame(Code, Loc);
 
   OS << "\t.seh_pushframe";
   if (Code)

llvm/lib/MC/MCParser/COFFAsmParser.cpp

void Initialize(MCAsmParser &Parser) override {
     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveStartChained>(
                                                            ".seh_startchained");
     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndChained>(
                                                              ".seh_endchained");
     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveHandler>(
                                                                 ".seh_handler");
     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveHandlerData>(
                                                             ".seh_handlerdata");
-    addDirectiveHandler<&COFFAsmParser::ParseSEHDirectivePushReg>(
-                                                                ".seh_pushreg");
-    addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveSetFrame>(
-                                                               ".seh_setframe");
     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveAllocStack>(
                                                              ".seh_stackalloc");
-    addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveSaveReg>(
-                                                                ".seh_savereg");
-    addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveSaveXMM>(
-                                                                ".seh_savexmm");
-    addDirectiveHandler<&COFFAsmParser::ParseSEHDirectivePushFrame>(
-                                                              ".seh_pushframe");
     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndProlog>(
                                                             ".seh_endprologue");
     addDirectiveHandler<&COFFAsmParser::ParseDirectiveSymbolAttribute>(".weak");
   }
 
   bool ParseSectionDirectiveText(StringRef, SMLoc) {
     return ParseSectionSwitch(".text",
                               COFF::IMAGE_SCN_CNT_CODE
class COFFAsmParser : public MCAsmParserExtension {
 
   // Win64 EH directives.
   bool ParseSEHDirectiveStartProc(StringRef, SMLoc);
   bool ParseSEHDirectiveEndProc(StringRef, SMLoc);
   bool ParseSEHDirectiveStartChained(StringRef, SMLoc);
   bool ParseSEHDirectiveEndChained(StringRef, SMLoc);
   bool ParseSEHDirectiveHandler(StringRef, SMLoc);
   bool ParseSEHDirectiveHandlerData(StringRef, SMLoc);
-  bool ParseSEHDirectivePushReg(StringRef, SMLoc);
-  bool ParseSEHDirectiveSetFrame(StringRef, SMLoc);
   bool ParseSEHDirectiveAllocStack(StringRef, SMLoc);
-  bool ParseSEHDirectiveSaveReg(StringRef, SMLoc);
-  bool ParseSEHDirectiveSaveXMM(StringRef, SMLoc);
-  bool ParseSEHDirectivePushFrame(StringRef, SMLoc);
   bool ParseSEHDirectiveEndProlog(StringRef, SMLoc);
 
   bool ParseAtUnwindOrAtExcept(bool &unwind, bool &except);
   bool ParseSEHRegisterNumber(unsigned &RegNo);
   bool ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc);
 
 public:
   COFFAsmParser() = default;

 }
 
 bool COFFAsmParser::ParseSEHDirectiveHandlerData(StringRef, SMLoc Loc) {
   Lex();
   getStreamer().EmitWinEHHandlerData();
   return false;
 }
 
-bool COFFAsmParser::ParseSEHDirectivePushReg(StringRef, SMLoc Loc) {
-  unsigned Reg = 0;
-  if (ParseSEHRegisterNumber(Reg))
-    return true;
-
-  if (getLexer().isNot(AsmToken::EndOfStatement))
-    return TokError("unexpected token in directive");
-
-  Lex();
-  getStreamer().EmitWinCFIPushReg(Reg, Loc);
-  return false;
-}
-
-bool COFFAsmParser::ParseSEHDirectiveSetFrame(StringRef, SMLoc Loc) {
-  unsigned Reg = 0;
-  int64_t Off;
-  if (ParseSEHRegisterNumber(Reg))
-    return true;
-  if (getLexer().isNot(AsmToken::Comma))
-    return TokError("you must specify a stack pointer offset");
-
-  Lex();
-  if (getParser().parseAbsoluteExpression(Off))
-    return true;
-
-  if (getLexer().isNot(AsmToken::EndOfStatement))
-    return TokError("unexpected token in directive");
-
-  Lex();
-  getStreamer().EmitWinCFISetFrame(Reg, Off, Loc);
-  return false;
-}
-
 bool COFFAsmParser::ParseSEHDirectiveAllocStack(StringRef, SMLoc Loc) {
   int64_t Size;
   if (getParser().parseAbsoluteExpression(Size))
     return true;
 
   if (getLexer().isNot(AsmToken::EndOfStatement))
     return TokError("unexpected token in directive");
 
   Lex();
   getStreamer().EmitWinCFIAllocStack(Size, Loc);
   return false;
 }
 
-bool COFFAsmParser::ParseSEHDirectiveSaveReg(StringRef, SMLoc Loc) {
-  unsigned Reg = 0;
-  int64_t Off;
-  if (ParseSEHRegisterNumber(Reg))
-    return true;
-  if (getLexer().isNot(AsmToken::Comma))
-    return TokError("you must specify an offset on the stack");
-
-  Lex();
-  if (getParser().parseAbsoluteExpression(Off))
-    return true;
-
-  if (getLexer().isNot(AsmToken::EndOfStatement))
-    return TokError("unexpected token in directive");
-
-  Lex();
-  // FIXME: Err on %xmm* registers
-  getStreamer().EmitWinCFISaveReg(Reg, Off, Loc);
-  return false;
-}
-
-// FIXME: This method is inherently x86-specific. It should really be in the
-// x86 backend.
-bool COFFAsmParser::ParseSEHDirectiveSaveXMM(StringRef, SMLoc Loc) {
-  unsigned Reg = 0;
-  int64_t Off;
-  if (ParseSEHRegisterNumber(Reg))
-    return true;
-  if (getLexer().isNot(AsmToken::Comma))
-    return TokError("you must specify an offset on the stack");
-
-  Lex();
-  if (getParser().parseAbsoluteExpression(Off))
-    return true;
-
-  if (getLexer().isNot(AsmToken::EndOfStatement))
-    return TokError("unexpected token in directive");
-
-  Lex();
-  // FIXME: Err on non-%xmm* registers
-  getStreamer().EmitWinCFISaveXMM(Reg, Off, Loc);
-  return false;
-}
-
-bool COFFAsmParser::ParseSEHDirectivePushFrame(StringRef, SMLoc Loc) {
-  bool Code = false;
-  StringRef CodeID;
-  if (getLexer().is(AsmToken::At)) {
-    SMLoc startLoc = getLexer().getLoc();
-    Lex();
-    if (!getParser().parseIdentifier(CodeID)) {
-      if (CodeID != "code")
-        return Error(startLoc, "expected @code");
-      Code = true;
-    }
-  }
-
-  if (getLexer().isNot(AsmToken::EndOfStatement))
-    return TokError("unexpected token in directive");
-
-  Lex();
-  getStreamer().EmitWinCFIPushFrame(Code, Loc);
-  return false;
-}
-
 bool COFFAsmParser::ParseSEHDirectiveEndProlog(StringRef, SMLoc Loc) {
   Lex();
   getStreamer().EmitWinCFIEndProlog(Loc);
   return false;
 }
 
 bool COFFAsmParser::ParseAtUnwindOrAtExcept(bool &unwind, bool &except) {
   StringRef identifier;
   if (getLexer().isNot(AsmToken::At))
     return TokError("a handler attribute must begin with '@'");
   SMLoc startLoc = getLexer().getLoc();
   Lex();
   if (getParser().parseIdentifier(identifier))
     return Error(startLoc, "expected @unwind or @except");
   if (identifier == "unwind")
     unwind = true;
   else if (identifier == "except")
     except = true;
   else
     return Error(startLoc, "expected @unwind or @except");
   return false;
 }
 
-bool COFFAsmParser::ParseSEHRegisterNumber(unsigned &RegNo) {
-  SMLoc startLoc = getLexer().getLoc();
-  if (getLexer().is(AsmToken::Percent)) {
-    const MCRegisterInfo *MRI = getContext().getRegisterInfo();
-    SMLoc endLoc;
-    unsigned LLVMRegNo;
-    if (getParser().getTargetParser().ParseRegister(LLVMRegNo,startLoc,endLoc))
-      return true;
-
-#if 0
-    // FIXME: TargetAsmInfo::getCalleeSavedRegs() commits a serious layering
-    // violation so this validation code is disabled.
-
-    // Check that this is a non-volatile register.
-    const unsigned *NVRegs = TAI.getCalleeSavedRegs();
-    unsigned i;
-    for (i = 0; NVRegs[i] != 0; ++i)
-      if (NVRegs[i] == LLVMRegNo)
-        break;
-    if (NVRegs[i] == 0)
-      return Error(startLoc, "expected non-volatile register");
-#endif
-
-    int SEHRegNo = MRI->getSEHRegNum(LLVMRegNo);
-    if (SEHRegNo < 0)
-      return Error(startLoc,"register can't be represented in SEH unwind info");
-    RegNo = SEHRegNo;
-  }
-  else {
-    int64_t n;
-    if (getParser().parseAbsoluteExpression(n))
-      return true;
-    if (n > 15)
-      return Error(startLoc, "register number is too high");
-    RegNo = n;
-  }
-
-  return false;
-}
-
 namespace llvm {
 
 MCAsmParserExtension *createCOFFAsmParser() {
   return new COFFAsmParser;
 }
 
 } // end namespace llvm

llvm/lib/MC/MCStreamer.cpp

 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeView.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCObjectFileInfo.h"
+#include "llvm/MC/MCRegister.h"
+#include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCWin64EH.h"
 #include "llvm/MC/MCWinEH.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"

 MCSection *MCStreamer::getAssociatedXDataSection(const MCSection *TextSec) {
   return getWinCFISection(getContext(), &NextWinCFIID,
                           getContext().getObjectFileInfo()->getXDataSection(),
                           TextSec);
 }
 
 void MCStreamer::EmitSyntaxDirective() {}
 
-void MCStreamer::EmitWinCFIPushReg(unsigned Register, SMLoc Loc) {
+static unsigned encodeSEHRegNum(MCContext &Ctx, MCRegister Reg) {
+  return Ctx.getRegisterInfo()->getSEHRegNum(Reg);
+}
+
+void MCStreamer::EmitWinCFIPushReg(MCRegister Register, SMLoc Loc) {
   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
   if (!CurFrame)
     return;
 
   MCSymbol *Label = EmitCFILabel();
 
-  WinEH::Instruction Inst = Win64EH::Instruction::PushNonVol(Label, Register);
+  WinEH::Instruction Inst = Win64EH::Instruction::PushNonVol(
+      Label, encodeSEHRegNum(Context, Register));
   CurFrame->Instructions.push_back(Inst);
 }
 
-void MCStreamer::EmitWinCFISetFrame(unsigned Register, unsigned Offset,
+void MCStreamer::EmitWinCFISetFrame(MCRegister Register, unsigned Offset,
                                     SMLoc Loc) {
   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
   if (!CurFrame)
     return;
   if (CurFrame->LastFrameInst >= 0)
     return getContext().reportError(
         Loc, "frame register and offset can be set at most once");
   if (Offset & 0x0F)
     return getContext().reportError(Loc, "offset is not a multiple of 16");
   if (Offset > 240)
     return getContext().reportError(
         Loc, "frame offset must be less than or equal to 240");
 
   MCSymbol *Label = EmitCFILabel();
 
-  WinEH::Instruction Inst =
-      Win64EH::Instruction::SetFPReg(Label, Register, Offset);
+  WinEH::Instruction Inst = Win64EH::Instruction::SetFPReg(
+      Label, encodeSEHRegNum(getContext(), Register), Offset);
   CurFrame->LastFrameInst = CurFrame->Instructions.size();
   CurFrame->Instructions.push_back(Inst);
 }
 
 void MCStreamer::EmitWinCFIAllocStack(unsigned Size, SMLoc Loc) {
   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
   if (!CurFrame)
     return;
   if (Size == 0)
     return getContext().reportError(Loc,
                                     "stack allocation size must be non-zero");
   if (Size & 7)
     return getContext().reportError(
         Loc, "stack allocation size is not a multiple of 8");
 
   MCSymbol *Label = EmitCFILabel();
 
   WinEH::Instruction Inst = Win64EH::Instruction::Alloc(Label, Size);
   CurFrame->Instructions.push_back(Inst);
 }
 
-void MCStreamer::EmitWinCFISaveReg(unsigned Register, unsigned Offset,
+void MCStreamer::EmitWinCFISaveReg(MCRegister Register, unsigned Offset,
                                    SMLoc Loc) {
   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
   if (!CurFrame)
     return;
 
   if (Offset & 7)
     return getContext().reportError(
         Loc, "register save offset is not 8 byte aligned");
 
   MCSymbol *Label = EmitCFILabel();
 
-  WinEH::Instruction Inst =
-      Win64EH::Instruction::SaveNonVol(Label, Register, Offset);
+  WinEH::Instruction Inst = Win64EH::Instruction::SaveNonVol(
+      Label, encodeSEHRegNum(Context, Register), Offset);
   CurFrame->Instructions.push_back(Inst);
 }
 
-void MCStreamer::EmitWinCFISaveXMM(unsigned Register, unsigned Offset,
+void MCStreamer::EmitWinCFISaveXMM(MCRegister Register, unsigned Offset,
                                    SMLoc Loc) {
   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
   if (!CurFrame)
     return;
   if (Offset & 0x0F)
     return getContext().reportError(Loc, "offset is not a multiple of 16");
 
   MCSymbol *Label = EmitCFILabel();
 
-  WinEH::Instruction Inst =
-      Win64EH::Instruction::SaveXMM(Label, Register, Offset);
+  WinEH::Instruction Inst = Win64EH::Instruction::SaveXMM(
+      Label, encodeSEHRegNum(Context, Register), Offset);
   CurFrame->Instructions.push_back(Inst);
 }
 
 void MCStreamer::EmitWinCFIPushFrame(bool Code, SMLoc Loc) {
   WinEH::FrameInfo *CurFrame = EnsureValidWinFrameInfo(Loc);
   if (!CurFrame)
     return;
   if (!CurFrame->Instructions.empty())

llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp

private:
   bool parseDirectiveFPOSetFrame(SMLoc L);
   bool parseDirectiveFPOPushReg(SMLoc L);
   bool parseDirectiveFPOStackAlloc(SMLoc L);
   bool parseDirectiveFPOStackAlign(SMLoc L);
   bool parseDirectiveFPOEndPrologue(SMLoc L);
   bool parseDirectiveFPOEndProc(SMLoc L);
   bool parseDirectiveFPOData(SMLoc L);
 
+  /// SEH directives.
+  bool parseSEHRegisterNumber(unsigned RegClassID, unsigned &RegNo);
+  bool parseDirectiveSEHPushReg(SMLoc);
+  bool parseDirectiveSEHSetFrame(SMLoc);
+  bool parseDirectiveSEHAllocStack(SMLoc);
+  bool parseDirectiveSEHSaveReg(SMLoc);
+  bool parseDirectiveSEHSaveXMM(SMLoc);
+  bool parseDirectiveSEHPushFrame(SMLoc);
+
   unsigned checkTargetMatchPredicate(MCInst &Inst) override;
 
   bool validateInstruction(MCInst &Inst, const OperandVector &Ops);
   bool processInstruction(MCInst &Inst, const OperandVector &Ops);
 
   /// Wrapper around MCStreamer::EmitInstruction(). Possibly adds
   /// instrumentation around Inst.
   void EmitInstruction(MCInst &Inst, OperandVector &Operands, MCStreamer &Out);
bool X86AsmParser::ParseDirective(AsmToken DirectiveID) {
   else if (IDVal == ".cv_fpo_stackalloc")
     return parseDirectiveFPOStackAlloc(DirectiveID.getLoc());
   else if (IDVal == ".cv_fpo_stackalign")
     return parseDirectiveFPOStackAlign(DirectiveID.getLoc());
   else if (IDVal == ".cv_fpo_endprologue")
     return parseDirectiveFPOEndPrologue(DirectiveID.getLoc());
   else if (IDVal == ".cv_fpo_endproc")
     return parseDirectiveFPOEndProc(DirectiveID.getLoc());
+  else if (IDVal == ".seh_pushreg")
+    return parseDirectiveSEHPushReg(DirectiveID.getLoc());
+  else if (IDVal == ".seh_setframe")
+    return parseDirectiveSEHSetFrame(DirectiveID.getLoc());
+  else if (IDVal == ".seh_savereg")
+    return parseDirectiveSEHSaveReg(DirectiveID.getLoc());
+  else if (IDVal == ".seh_savexmm")
+    return parseDirectiveSEHSaveXMM(DirectiveID.getLoc());
+  else if (IDVal == ".seh_pushframe")
+    return parseDirectiveSEHPushFrame(DirectiveID.getLoc());
 
   return true;
 }
 
 /// parseDirectiveEven
 ///  ::= .even
 bool X86AsmParser::parseDirectiveEven(SMLoc L) {
   if (parseToken(AsmToken::EndOfStatement, "unexpected token in directive"))
     return false;

 // .cv_fpo_endproc
 bool X86AsmParser::parseDirectiveFPOEndProc(SMLoc L) {
   MCAsmParser &Parser = getParser();
   if (Parser.parseEOL("unexpected tokens"))
     return addErrorSuffix(" in '.cv_fpo_endproc' directive");
   return getTargetStreamer().emitFPOEndProc(L);
 }
 
+bool X86AsmParser::parseSEHRegisterNumber(unsigned RegClassID,
+                                          unsigned &RegNo) {
+  SMLoc startLoc = getLexer().getLoc();
+  const MCRegisterInfo *MRI = getContext().getRegisterInfo();
+
+  // A percent indicates a symbolic register name. Parse it as usual and check
+  // the register class.
+  if (getLexer().is(AsmToken::Percent)) {
+    SMLoc endLoc;
+    if (getParser().getTargetParser().ParseRegister(RegNo, startLoc, endLoc))
+      return true;
+
+    if (!X86MCRegisterClasses[RegClassID].contains(RegNo)) {
+      return Error(startLoc,
+                   "register is not supported for use with this directive");
+    }
+  } else {
+    // Otherwise, an integer number matching the encoding of the desired
+    // register may appear.
+    int64_t EncodedReg;
+    if (getParser().parseAbsoluteExpression(EncodedReg))
+      return true;
+
+    // The SEH register number is the same as the encoding register number. Map
+    // from the encoding back to the LLVM register number.
+    RegNo = 0;
+    for (MCPhysReg Reg : X86MCRegisterClasses[RegClassID]) {
+      if (MRI->getEncodingValue(Reg) == EncodedReg) {
+        RegNo = Reg;
+        break;
+      }
+    }
+    if (RegNo == 0) {
+      return Error(startLoc,
+                   "incorrect register number for use with this directive");
+    }
+  }
+
+  return false;
+}
+
+bool X86AsmParser::parseDirectiveSEHPushReg(SMLoc Loc) {
+  unsigned Reg = 0;
+  if (parseSEHRegisterNumber(X86::GR64RegClassID, Reg))
+    return true;
+
+  if (getLexer().isNot(AsmToken::EndOfStatement))
+    return TokError("unexpected token in directive");
+
+  getParser().Lex();
+  getStreamer().EmitWinCFIPushReg(Reg, Loc);
+  return false;
+}
+
+bool X86AsmParser::parseDirectiveSEHSetFrame(SMLoc Loc) {
+  unsigned Reg = 0;
+  int64_t Off;
+  if (parseSEHRegisterNumber(X86::GR64RegClassID, Reg))
+    return true;
+  if (getLexer().isNot(AsmToken::Comma))
+    return TokError("you must specify a stack pointer offset");
+
+  getParser().Lex();
+  if (getParser().parseAbsoluteExpression(Off))
+    return true;
+
+  if (getLexer().isNot(AsmToken::EndOfStatement))
+    return TokError("unexpected token in directive");
+
+  getParser().Lex();
+  getStreamer().EmitWinCFISetFrame(Reg, Off, Loc);
+  return false;
+}
+
+bool X86AsmParser::parseDirectiveSEHAllocStack(SMLoc Loc) {
+  int64_t Size;
+  if (getParser().parseAbsoluteExpression(Size))
+    return true;
+
+  if (getLexer().isNot(AsmToken::EndOfStatement))
+    return TokError("unexpected token in directive");
+
+  getParser().Lex();
+  getStreamer().EmitWinCFIAllocStack(Size, Loc);
+  return false;
+}
+
+bool X86AsmParser::parseDirectiveSEHSaveReg(SMLoc Loc) {
+  unsigned Reg = 0;
+  int64_t Off;
+  if (parseSEHRegisterNumber(X86::GR64RegClassID, Reg))
+    return true;
+  if (getLexer().isNot(AsmToken::Comma))
+    return TokError("you must specify an offset on the stack");
+
+  getParser().Lex();
+  if (getParser().parseAbsoluteExpression(Off))
+    return true;
+
+  if (getLexer().isNot(AsmToken::EndOfStatement))
+    return TokError("unexpected token in directive");
+
+  getParser().Lex();
+  getStreamer().EmitWinCFISaveReg(Reg, Off, Loc);
+  return false;
+}
+
+bool X86AsmParser::parseDirectiveSEHSaveXMM(SMLoc Loc) {
+  unsigned Reg = 0;
+  int64_t Off;
+  if (parseSEHRegisterNumber(X86::VR128XRegClassID, Reg))
+    return true;
+  if (getLexer().isNot(AsmToken::Comma))
+    return TokError("you must specify an offset on the stack");
+
+  getParser().Lex();
+  if (getParser().parseAbsoluteExpression(Off))
+    return true;
+
+  if (getLexer().isNot(AsmToken::EndOfStatement))
+    return TokError("unexpected token in directive");
+
+  getParser().Lex();
+  getStreamer().EmitWinCFISaveXMM(Reg, Off, Loc);
+  return false;
+}
+
+bool X86AsmParser::parseDirectiveSEHPushFrame(SMLoc Loc) {
+  bool Code = false;
+  StringRef CodeID;
+  if (getLexer().is(AsmToken::At)) {
+    SMLoc startLoc = getLexer().getLoc();
+    getParser().Lex();
+    if (!getParser().parseIdentifier(CodeID)) {
+      if (CodeID != "code")
+        return Error(startLoc, "expected @code");
+      Code = true;
+    }
+  }
+
+  if (getLexer().isNot(AsmToken::EndOfStatement))
+    return TokError("unexpected token in directive");
+
+  getParser().Lex();
+  getStreamer().EmitWinCFIPushFrame(Code, Loc);
+  return false;
+}
+
 // Force static initialization.
 extern "C" void LLVMInitializeX86AsmParser() {
   RegisterMCAsmParser<X86AsmParser> X(getTheX86_32Target());
   RegisterMCAsmParser<X86AsmParser> Y(getTheX86_64Target());
 }
 
 #define GET_REGISTER_MATCHER
 #define GET_MATCHER_IMPLEMENTATION
 #define GET_SUBTARGET_FEATURE_NAME
 #include "X86GenAsmMatcher.inc"

llvm/lib/Target/X86/X86MCInstLower.cpp

static void printConstant(const Constant *COp, raw_ostream &CS) {
   } else {
     CS << "?";
   }
 }
 
 void X86AsmPrinter::EmitSEHInstruction(const MachineInstr *MI) {
   assert(MF->hasWinCFI() && "SEH_ instruction in function without WinCFI?");
   assert(getSubtarget().isOSWindows() && "SEH_ instruction Windows only");
-  const X86RegisterInfo *RI =
-      MF->getSubtarget<X86Subtarget>().getRegisterInfo();
 
   // Use the .cv_fpo directives if we're emitting CodeView on 32-bit x86.
   if (EmitFPOData) {
     X86TargetStreamer *XTS =
         static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer());
     switch (MI->getOpcode()) {
     case X86::SEH_PushReg:
       XTS->emitFPOPushReg(MI->getOperand(0).getImm());
default:
       llvm_unreachable("expected SEH_ instruction");
     }
     return;
   }
 
   // Otherwise, use the .seh_ directives for all other Windows platforms.
   switch (MI->getOpcode()) {
   case X86::SEH_PushReg:
-    OutStreamer->EmitWinCFIPushReg(
-        RI->getSEHRegNum(MI->getOperand(0).getImm()));
+    OutStreamer->EmitWinCFIPushReg(MI->getOperand(0).getImm());
     break;
 
   case X86::SEH_SaveReg:
-    OutStreamer->EmitWinCFISaveReg(RI->getSEHRegNum(MI->getOperand(0).getImm()),
+    OutStreamer->EmitWinCFISaveReg(MI->getOperand(0).getImm(),
                                    MI->getOperand(1).getImm());
     break;
 
   case X86::SEH_SaveXMM:
-    OutStreamer->EmitWinCFISaveXMM(RI->getSEHRegNum(MI->getOperand(0).getImm()),
+    OutStreamer->EmitWinCFISaveXMM(MI->getOperand(0).getImm(),
                                    MI->getOperand(1).getImm());
     break;
 
   case X86::SEH_StackAlloc:
     OutStreamer->EmitWinCFIAllocStack(MI->getOperand(0).getImm());
     break;
 
   case X86::SEH_SetFrame:
-    OutStreamer->EmitWinCFISetFrame(
-        RI->getSEHRegNum(MI->getOperand(0).getImm()),
+    OutStreamer->EmitWinCFISetFrame(MI->getOperand(0).getImm(),
                                     MI->getOperand(1).getImm());
     break;
 
   case X86::SEH_PushFrame:
     OutStreamer->EmitWinCFIPushFrame(MI->getOperand(0).getImm());
     break;
 
   case X86::SEH_EndPrologue:
     OutStreamer->EmitWinCFIEndProlog();
void X86AsmPrinter::EmitInstruction(const MachineInstr *MI) {
   // size). The pairs of 1bit masks up to 16 bit masks all use the same spill size,
   // they all are stored using MASKPAIR16STORE, loaded using MASKPAIR16LOAD.
   //
   // The displacement value might wrap around in theory, thus the asserts in both
   // cases.
   case X86::MASKPAIR16LOAD: {
     int64_t Disp = MI->getOperand(1 + X86::AddrDisp).getImm();
     assert(Disp >= 0 && Disp <= INT32_MAX - 2 && "Unexpected displacement");
-    const X86RegisterInfo *RI =
-      MF->getSubtarget<X86Subtarget>().getRegisterInfo();
     Register Reg = MI->getOperand(0).getReg();
     Register Reg0 = RI->getSubReg(Reg, X86::sub_mask_0);
     Register Reg1 = RI->getSubReg(Reg, X86::sub_mask_1);
 
     // Load the first mask register
     MCInstBuilder MIB = MCInstBuilder(X86::KMOVWkm);
     MIB.addReg(Reg0);
     for (int i = 0; i < X86::AddrNumOperands; ++i) {
case X86::MASKPAIR16LOAD: {
     }
     EmitAndCountInstruction(MIB);
     return;
   }
 
   case X86::MASKPAIR16STORE: {
     int64_t Disp = MI->getOperand(X86::AddrDisp).getImm();
     assert(Disp >= 0 && Disp <= INT32_MAX - 2 && "Unexpected displacement");
-    const X86RegisterInfo *RI =
-      MF->getSubtarget<X86Subtarget>().getRegisterInfo();
     Register Reg = MI->getOperand(X86::AddrNumOperands).getReg();
     Register Reg0 = RI->getSubReg(Reg, X86::sub_mask_0);
     Register Reg1 = RI->getSubReg(Reg, X86::sub_mask_1);
 
     // Store the first mask register
     MCInstBuilder MIB = MCInstBuilder(X86::KMOVWmk);
     for (int i = 0; i < X86::AddrNumOperands; ++i)
       MIB.addOperand(MCInstLowering.LowerMachineOperand(MI, MI->getOperand(i)).getValue());

llvm/test/CodeGen/X86/avx512-regcall-Mask.ll

 ; X32-NEXT:    movl %ecx, %edx
 ; X32-NEXT:    addl $88, %esp
 ; X32-NEXT:    popl %edi
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: caller_argv64i1:
 ; WIN64:       # %bb.0: # %entry
 ; WIN64-NEXT:    pushq %r15
-; WIN64-NEXT:    .seh_pushreg 15
+; WIN64-NEXT:    .seh_pushreg %r15
 ; WIN64-NEXT:    pushq %r14
-; WIN64-NEXT:    .seh_pushreg 14
+; WIN64-NEXT:    .seh_pushreg %r14
 ; WIN64-NEXT:    pushq %r12
-; WIN64-NEXT:    .seh_pushreg 12
+; WIN64-NEXT:    .seh_pushreg %r12
 ; WIN64-NEXT:    pushq %rsi
-; WIN64-NEXT:    .seh_pushreg 6
+; WIN64-NEXT:    .seh_pushreg %rsi
 ; WIN64-NEXT:    pushq %rdi
-; WIN64-NEXT:    .seh_pushreg 7
+; WIN64-NEXT:    .seh_pushreg %rdi
 ; WIN64-NEXT:    subq $48, %rsp
 ; WIN64-NEXT:    .seh_stackalloc 48
 ; WIN64-NEXT:    vmovaps %xmm7, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 7, 32
+; WIN64-NEXT:    .seh_savexmm %xmm7, 32
 ; WIN64-NEXT:    vmovaps %xmm6, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 6, 16
+; WIN64-NEXT:    .seh_savexmm %xmm6, 16
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    movabsq $4294967298, %rax # imm = 0x100000002
 ; WIN64-NEXT:    movq %rax, (%rsp)
 ; WIN64-NEXT:    movq %rax, %rcx
 ; WIN64-NEXT:    movq %rax, %rdx
 ; WIN64-NEXT:    movq %rax, %rdi
 ; WIN64-NEXT:    movq %rax, %r8
 ; WIN64-NEXT:    movq %rax, %r9

 ; X32-NEXT:    kmovd %ecx, %k1
 ; X32-NEXT:    kunpckdq %k0, %k1, %k0
 ; X32-NEXT:    vpmovm2b %k0, %zmm0
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: caller_retv64i1:
 ; WIN64:       # %bb.0: # %entry
 ; WIN64-NEXT:    pushq %rsi
-; WIN64-NEXT:    .seh_pushreg 6
+; WIN64-NEXT:    .seh_pushreg %rsi
 ; WIN64-NEXT:    pushq %rdi
-; WIN64-NEXT:    .seh_pushreg 7
+; WIN64-NEXT:    .seh_pushreg %rdi
 ; WIN64-NEXT:    subq $40, %rsp
 ; WIN64-NEXT:    .seh_stackalloc 40
 ; WIN64-NEXT:    vmovaps %xmm7, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 7, 16
+; WIN64-NEXT:    .seh_savexmm %xmm7, 16
 ; WIN64-NEXT:    vmovaps %xmm6, (%rsp) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 6, 0
+; WIN64-NEXT:    .seh_savexmm %xmm6, 0
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    callq test_retv64i1
 ; WIN64-NEXT:    kmovq %rax, %k0
 ; WIN64-NEXT:    vpmovm2b %k0, %zmm0
 ; WIN64-NEXT:    vmovaps (%rsp), %xmm6 # 16-byte Reload
 ; WIN64-NEXT:    vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm7 # 16-byte Reload
 ; WIN64-NEXT:    addq $40, %rsp
 ; WIN64-NEXT:    popq %rdi

 ; X32-NEXT:    addl $72, %esp
 ; X32-NEXT:    popl %esp
 ; X32-NEXT:    vzeroupper
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: test_argv32i1:
 ; WIN64:       # %bb.0: # %entry
 ; WIN64-NEXT:    pushq %r11
-; WIN64-NEXT:    .seh_pushreg 11
+; WIN64-NEXT:    .seh_pushreg %r11
 ; WIN64-NEXT:    pushq %r10
-; WIN64-NEXT:    .seh_pushreg 10
+; WIN64-NEXT:    .seh_pushreg %r10
 ; WIN64-NEXT:    pushq %rsp
-; WIN64-NEXT:    .seh_pushreg 4
+; WIN64-NEXT:    .seh_pushreg %rsp
 ; WIN64-NEXT:    subq $32, %rsp
 ; WIN64-NEXT:    .seh_stackalloc 32
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    kmovd %edx, %k0
 ; WIN64-NEXT:    kmovd %ecx, %k1
 ; WIN64-NEXT:    kmovd %eax, %k2
 ; WIN64-NEXT:    vpmovm2b %k2, %zmm0
 ; WIN64-NEXT:    vpmovm2b %k1, %zmm1

 ; X32-NEXT:    movl $1, %ecx
 ; X32-NEXT:    movl $1, %edx
 ; X32-NEXT:    calll _test_argv32i1
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: caller_argv32i1:
 ; WIN64:       # %bb.0: # %entry
 ; WIN64-NEXT:    pushq %rsi
-; WIN64-NEXT:    .seh_pushreg 6
+; WIN64-NEXT:    .seh_pushreg %rsi
 ; WIN64-NEXT:    pushq %rdi
-; WIN64-NEXT:    .seh_pushreg 7
+; WIN64-NEXT:    .seh_pushreg %rdi
 ; WIN64-NEXT:    subq $40, %rsp
 ; WIN64-NEXT:    .seh_stackalloc 40
 ; WIN64-NEXT:    vmovaps %xmm7, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 7, 16
+; WIN64-NEXT:    .seh_savexmm %xmm7, 16
 ; WIN64-NEXT:    vmovaps %xmm6, (%rsp) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 6, 0
+; WIN64-NEXT:    .seh_savexmm %xmm6, 0
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    movl $1, %eax
 ; WIN64-NEXT:    movl $1, %ecx
 ; WIN64-NEXT:    movl $1, %edx
 ; WIN64-NEXT:    callq test_argv32i1
 ; WIN64-NEXT:    vmovaps (%rsp), %xmm6 # 16-byte Reload
 ; WIN64-NEXT:    vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm7 # 16-byte Reload
 ; WIN64-NEXT:    addq $40, %rsp

 ; X32:       # %bb.0: # %entry
 ; X32-NEXT:    calll _test_retv32i1
 ; X32-NEXT:    incl %eax
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: caller_retv32i1:
 ; WIN64:       # %bb.0: # %entry
 ; WIN64-NEXT:    pushq %rsi
-; WIN64-NEXT:    .seh_pushreg 6
+; WIN64-NEXT:    .seh_pushreg %rsi
 ; WIN64-NEXT:    pushq %rdi
-; WIN64-NEXT:    .seh_pushreg 7
+; WIN64-NEXT:    .seh_pushreg %rdi
 ; WIN64-NEXT:    subq $40, %rsp
 ; WIN64-NEXT:    .seh_stackalloc 40
 ; WIN64-NEXT:    vmovaps %xmm7, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 7, 16
+; WIN64-NEXT:    .seh_savexmm %xmm7, 16
 ; WIN64-NEXT:    vmovaps %xmm6, (%rsp) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 6, 0
+; WIN64-NEXT:    .seh_savexmm %xmm6, 0
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    callq test_retv32i1
 ; WIN64-NEXT:    incl %eax
 ; WIN64-NEXT:    vmovaps (%rsp), %xmm6 # 16-byte Reload
 ; WIN64-NEXT:    vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm7 # 16-byte Reload
 ; WIN64-NEXT:    addq $40, %rsp
 ; WIN64-NEXT:    popq %rdi
 ; WIN64-NEXT:    popq %rsi

 ; X32-NEXT:    vmovups {{[-0-9]+}}(%e{{[sb]}}p), %xmm7 # 16-byte Reload
 ; X32-NEXT:    addl $72, %esp
 ; X32-NEXT:    popl %esp
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: test_argv16i1:
 ; WIN64:       # %bb.0:
 ; WIN64-NEXT:    pushq %r11
-; WIN64-NEXT:    .seh_pushreg 11
+; WIN64-NEXT:    .seh_pushreg %r11
 ; WIN64-NEXT:    pushq %r10
-; WIN64-NEXT:    .seh_pushreg 10
+; WIN64-NEXT:    .seh_pushreg %r10
 ; WIN64-NEXT:    pushq %rsp
-; WIN64-NEXT:    .seh_pushreg 4
+; WIN64-NEXT:    .seh_pushreg %rsp
 ; WIN64-NEXT:    subq $32, %rsp
 ; WIN64-NEXT:    .seh_stackalloc 32
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    kmovd %edx, %k0
 ; WIN64-NEXT:    kmovd %ecx, %k1
 ; WIN64-NEXT:    kmovd %eax, %k2
 ; WIN64-NEXT:    vpmovm2b %k2, %zmm0
 ; WIN64-NEXT:    vpmovm2b %k1, %zmm1

 ; X32-NEXT:    movl $1, %ecx
 ; X32-NEXT:    movl $1, %edx
 ; X32-NEXT:    calll _test_argv16i1
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: caller_argv16i1:
 ; WIN64:       # %bb.0: # %entry
 ; WIN64-NEXT:    pushq %rsi
-; WIN64-NEXT:    .seh_pushreg 6
+; WIN64-NEXT:    .seh_pushreg %rsi
 ; WIN64-NEXT:    pushq %rdi
-; WIN64-NEXT:    .seh_pushreg 7
+; WIN64-NEXT:    .seh_pushreg %rdi
 ; WIN64-NEXT:    subq $40, %rsp
 ; WIN64-NEXT:    .seh_stackalloc 40
 ; WIN64-NEXT:    vmovaps %xmm7, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 7, 16
+; WIN64-NEXT:    .seh_savexmm %xmm7, 16
 ; WIN64-NEXT:    vmovaps %xmm6, (%rsp) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 6, 0
+; WIN64-NEXT:    .seh_savexmm %xmm6, 0
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    movl $1, %eax
 ; WIN64-NEXT:    movl $1, %ecx
 ; WIN64-NEXT:    movl $1, %edx
 ; WIN64-NEXT:    callq test_argv16i1
 ; WIN64-NEXT:    vmovaps (%rsp), %xmm6 # 16-byte Reload
 ; WIN64-NEXT:    vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm7 # 16-byte Reload
 ; WIN64-NEXT:    addq $40, %rsp

 ; X32-NEXT:    # kill: def $ax killed $ax def $eax
 ; X32-NEXT:    incl %eax
 ; X32-NEXT:    # kill: def $ax killed $ax killed $eax
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: caller_retv16i1:
 ; WIN64:       # %bb.0: # %entry
 ; WIN64-NEXT:    pushq %rsi
-; WIN64-NEXT:    .seh_pushreg 6
+; WIN64-NEXT:    .seh_pushreg %rsi
 ; WIN64-NEXT:    pushq %rdi
-; WIN64-NEXT:    .seh_pushreg 7
+; WIN64-NEXT:    .seh_pushreg %rdi
 ; WIN64-NEXT:    subq $40, %rsp
 ; WIN64-NEXT:    .seh_stackalloc 40
 ; WIN64-NEXT:    vmovaps %xmm7, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 7, 16
+; WIN64-NEXT:    .seh_savexmm %xmm7, 16
 ; WIN64-NEXT:    vmovaps %xmm6, (%rsp) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 6, 0
+; WIN64-NEXT:    .seh_savexmm %xmm6, 0
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    callq test_retv16i1
 ; WIN64-NEXT:    # kill: def $ax killed $ax def $eax
 ; WIN64-NEXT:    incl %eax
 ; WIN64-NEXT:    # kill: def $ax killed $ax killed $eax
 ; WIN64-NEXT:    vmovaps (%rsp), %xmm6 # 16-byte Reload
 ; WIN64-NEXT:    vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm7 # 16-byte Reload
 ; WIN64-NEXT:    addq $40, %rsp

 ; X32-NEXT:    vmovups {{[-0-9]+}}(%e{{[sb]}}p), %xmm7 # 16-byte Reload
 ; X32-NEXT:    addl $72, %esp
 ; X32-NEXT:    popl %esp
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: test_argv8i1:
 ; WIN64:       # %bb.0:
 ; WIN64-NEXT:    pushq %r11
-; WIN64-NEXT:    .seh_pushreg 11
+; WIN64-NEXT:    .seh_pushreg %r11
 ; WIN64-NEXT:    pushq %r10
-; WIN64-NEXT:    .seh_pushreg 10
+; WIN64-NEXT:    .seh_pushreg %r10
 ; WIN64-NEXT:    pushq %rsp
-; WIN64-NEXT:    .seh_pushreg 4
+; WIN64-NEXT:    .seh_pushreg %rsp
 ; WIN64-NEXT:    subq $32, %rsp
 ; WIN64-NEXT:    .seh_stackalloc 32
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    kmovd %edx, %k0
 ; WIN64-NEXT:    kmovd %ecx, %k1
 ; WIN64-NEXT:    kmovd %eax, %k2
 ; WIN64-NEXT:    vpmovm2w %k2, %zmm0
 ; WIN64-NEXT:    vpmovm2w %k1, %zmm1

 ; X32-NEXT:    movl $1, %ecx
 ; X32-NEXT:    movl $1, %edx
 ; X32-NEXT:    calll _test_argv8i1
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: caller_argv8i1:
 ; WIN64:       # %bb.0: # %entry
 ; WIN64-NEXT:    pushq %rsi
-; WIN64-NEXT:    .seh_pushreg 6
+; WIN64-NEXT:    .seh_pushreg %rsi
 ; WIN64-NEXT:    pushq %rdi
-; WIN64-NEXT:    .seh_pushreg 7
+; WIN64-NEXT:    .seh_pushreg %rdi
 ; WIN64-NEXT:    subq $40, %rsp
 ; WIN64-NEXT:    .seh_stackalloc 40
 ; WIN64-NEXT:    vmovaps %xmm7, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 7, 16
+; WIN64-NEXT:    .seh_savexmm %xmm7, 16
 ; WIN64-NEXT:    vmovaps %xmm6, (%rsp) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 6, 0
+; WIN64-NEXT:    .seh_savexmm %xmm6, 0
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    movl $1, %eax
 ; WIN64-NEXT:    movl $1, %ecx
 ; WIN64-NEXT:    movl $1, %edx
 ; WIN64-NEXT:    callq test_argv8i1
 ; WIN64-NEXT:    vmovaps (%rsp), %xmm6 # 16-byte Reload
 ; WIN64-NEXT:    vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm7 # 16-byte Reload
 ; WIN64-NEXT:    addq $40, %rsp

 ; X32-NEXT:    vpmovm2w %k0, %zmm0
 ; X32-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; X32-NEXT:    vzeroupper
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: caller_retv8i1:
 ; WIN64:       # %bb.0: # %entry
 ; WIN64-NEXT:    pushq %rsi
-; WIN64-NEXT:    .seh_pushreg 6
+; WIN64-NEXT:    .seh_pushreg %rsi
 ; WIN64-NEXT:    pushq %rdi
-; WIN64-NEXT:    .seh_pushreg 7
+; WIN64-NEXT:    .seh_pushreg %rdi
 ; WIN64-NEXT:    subq $40, %rsp
 ; WIN64-NEXT:    .seh_stackalloc 40
 ; WIN64-NEXT:    vmovaps %xmm7, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 7, 16
+; WIN64-NEXT:    .seh_savexmm %xmm7, 16
 ; WIN64-NEXT:    vmovaps %xmm6, (%rsp) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 6, 0
+; WIN64-NEXT:    .seh_savexmm %xmm6, 0
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    callq test_retv8i1
 ; WIN64-NEXT:    # kill: def $al killed $al def $eax
 ; WIN64-NEXT:    kmovd %eax, %k0
 ; WIN64-NEXT:    vpmovm2w %k0, %zmm0
 ; WIN64-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; WIN64-NEXT:    vmovaps (%rsp), %xmm6 # 16-byte Reload
 ; WIN64-NEXT:    vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm7 # 16-byte Reload

llvm/test/CodeGen/X86/avx512-regcall-NoMask.ll

 ; X32-NEXT:    calll _test_argReti1
 ; X32-NEXT:    incb %al
 ; X32-NEXT:    popl %esp
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: test_CallargReti1:
 ; WIN64:       # %bb.0:
 ; WIN64-NEXT:    pushq %rsp
-; WIN64-NEXT:    .seh_pushreg 4
+; WIN64-NEXT:    .seh_pushreg %rsp
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    incb %al
 ; WIN64-NEXT:    movzbl %al, %eax
 ; WIN64-NEXT:    callq test_argReti1
 ; WIN64-NEXT:    incb %al
 ; WIN64-NEXT:    popq %rsp
 ; WIN64-NEXT:    retq
 ; WIN64-NEXT:    .seh_handlerdata

 ; X32-NEXT:    calll _test_argReti8
 ; X32-NEXT:    incb %al
 ; X32-NEXT:    popl %esp
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: test_CallargReti8:
 ; WIN64:       # %bb.0:
 ; WIN64-NEXT:    pushq %rsp
-; WIN64-NEXT:    .seh_pushreg 4
+; WIN64-NEXT:    .seh_pushreg %rsp
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    incb %al
 ; WIN64-NEXT:    movzbl %al, %eax
 ; WIN64-NEXT:    callq test_argReti8
 ; WIN64-NEXT:    incb %al
 ; WIN64-NEXT:    popq %rsp
 ; WIN64-NEXT:    retq
 ; WIN64-NEXT:    .seh_handlerdata

 ; X32-NEXT:    incl %eax
 ; X32-NEXT:    # kill: def $ax killed $ax killed $eax
 ; X32-NEXT:    popl %esp
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: test_CallargReti16:
 ; WIN64:       # %bb.0:
 ; WIN64-NEXT:    pushq %rsp
-; WIN64-NEXT:    .seh_pushreg 4
+; WIN64-NEXT:    .seh_pushreg %rsp
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    incl %eax
 ; WIN64-NEXT:    callq test_argReti16
 ; WIN64-NEXT:    # kill: def $ax killed $ax def $eax
 ; WIN64-NEXT:    incl %eax
 ; WIN64-NEXT:    # kill: def $ax killed $ax killed $eax
 ; WIN64-NEXT:    popq %rsp
 ; WIN64-NEXT:    retq

 ; X32-NEXT:    calll _test_argReti32
 ; X32-NEXT:    incl %eax
 ; X32-NEXT:    popl %esp
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: test_CallargReti32:
 ; WIN64:       # %bb.0:
 ; WIN64-NEXT:    pushq %rsp
-; WIN64-NEXT:    .seh_pushreg 4
+; WIN64-NEXT:    .seh_pushreg %rsp
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    incl %eax
 ; WIN64-NEXT:    callq test_argReti32
 ; WIN64-NEXT:    incl %eax
 ; WIN64-NEXT:    popq %rsp
 ; WIN64-NEXT:    retq
 ; WIN64-NEXT:    .seh_handlerdata
 ; WIN64-NEXT:    .text

 ; X32-NEXT:    addl $1, %eax
 ; X32-NEXT:    adcl $0, %ecx
 ; X32-NEXT:    popl %esp
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: test_CallargReti64:
 ; WIN64:       # %bb.0:
 ; WIN64-NEXT:    pushq %rsp
-; WIN64-NEXT:    .seh_pushreg 4
+; WIN64-NEXT:    .seh_pushreg %rsp
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    incq %rax
 ; WIN64-NEXT:    callq test_argReti64
 ; WIN64-NEXT:    incq %rax
 ; WIN64-NEXT:    popq %rsp
 ; WIN64-NEXT:    retq
 ; WIN64-NEXT:    .seh_handlerdata
 ; WIN64-NEXT:    .text

 ; X32-NEXT:    vmovups (%esp), %xmm4 # 16-byte Reload
 ; X32-NEXT:    addl $24, %esp
 ; X32-NEXT:    popl %esp
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: test_CallargRetFloat:
 ; WIN64:       # %bb.0:
 ; WIN64-NEXT:    pushq %rsp
-; WIN64-NEXT:    .seh_pushreg 4
+; WIN64-NEXT:    .seh_pushreg %rsp
 ; WIN64-NEXT:    subq $16, %rsp
 ; WIN64-NEXT:    .seh_stackalloc 16
 ; WIN64-NEXT:    vmovaps %xmm8, (%rsp) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 8, 0
+; WIN64-NEXT:    .seh_savexmm %xmm8, 0
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    vmovss {{.*#+}} xmm8 = mem[0],zero,zero,zero
 ; WIN64-NEXT:    vaddss %xmm8, %xmm0, %xmm0
 ; WIN64-NEXT:    callq test_argRetFloat
 ; WIN64-NEXT:    vaddss %xmm8, %xmm0, %xmm0
 ; WIN64-NEXT:    vmovaps (%rsp), %xmm8 # 16-byte Reload
 ; WIN64-NEXT:    addq $16, %rsp
 ; WIN64-NEXT:    popq %rsp

 ; X32-NEXT:    vmovups (%esp), %xmm4 # 16-byte Reload
 ; X32-NEXT:    addl $24, %esp
 ; X32-NEXT:    popl %esp
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: test_CallargRetDouble:
 ; WIN64:       # %bb.0:
 ; WIN64-NEXT:    pushq %rsp
-; WIN64-NEXT:    .seh_pushreg 4
+; WIN64-NEXT:    .seh_pushreg %rsp
 ; WIN64-NEXT:    subq $16, %rsp
 ; WIN64-NEXT:    .seh_stackalloc 16
 ; WIN64-NEXT:    vmovaps %xmm8, (%rsp) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 8, 0
+; WIN64-NEXT:    .seh_savexmm %xmm8, 0
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    vmovsd {{.*#+}} xmm8 = mem[0],zero
 ; WIN64-NEXT:    vaddsd %xmm8, %xmm0, %xmm0
 ; WIN64-NEXT:    callq test_argRetDouble
 ; WIN64-NEXT:    vaddsd %xmm8, %xmm0, %xmm0
 ; WIN64-NEXT:    vmovaps (%rsp), %xmm8 # 16-byte Reload
 ; WIN64-NEXT:    addq $16, %rsp
 ; WIN64-NEXT:    popq %rsp

 ; X32-NEXT:    calll _test_argRetf80
 ; X32-NEXT:    fadd %st, %st(0)
 ; X32-NEXT:    popl %esp
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: test_CallargRetf80:
 ; WIN64:       # %bb.0:
 ; WIN64-NEXT:    pushq %rsp
-; WIN64-NEXT:    .seh_pushreg 4
+; WIN64-NEXT:    .seh_pushreg %rsp
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    fadd %st, %st(0)
 ; WIN64-NEXT:    callq test_argRetf80
 ; WIN64-NEXT:    fadd %st, %st(0)
 ; WIN64-NEXT:    popq %rsp
 ; WIN64-NEXT:    retq
 ; WIN64-NEXT:    .seh_handlerdata
 ; WIN64-NEXT:    .text

 ; X32-NEXT:    calll _test_argRetPointer
 ; X32-NEXT:    incl %eax
 ; X32-NEXT:    popl %esp
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: test_CallargRetPointer:
 ; WIN64:       # %bb.0:
 ; WIN64-NEXT:    pushq %rsp
-; WIN64-NEXT:    .seh_pushreg 4
+; WIN64-NEXT:    .seh_pushreg %rsp
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    incl %eax
 ; WIN64-NEXT:    callq test_argRetPointer
 ; WIN64-NEXT:    incl %eax
 ; WIN64-NEXT:    popq %rsp
 ; WIN64-NEXT:    retq
 ; WIN64-NEXT:    .seh_handlerdata
 ; WIN64-NEXT:    .text

 ; X32-NEXT:    vmovups {{[-0-9]+}}(%e{{[sb]}}p), %xmm4 # 16-byte Reload
 ; X32-NEXT:    addl $40, %esp
 ; X32-NEXT:    popl %esp
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: test_CallargRet128Vector:
 ; WIN64:       # %bb.0:
 ; WIN64-NEXT:    pushq %rsp
-; WIN64-NEXT:    .seh_pushreg 4
+; WIN64-NEXT:    .seh_pushreg %rsp
 ; WIN64-NEXT:    subq $32, %rsp
 ; WIN64-NEXT:    .seh_stackalloc 32
 ; WIN64-NEXT:    vmovaps %xmm8, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
-; WIN64-NEXT:    .seh_savexmm 8, 16
+; WIN64-NEXT:    .seh_savexmm %xmm8, 16
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    vmovdqa %xmm1, %xmm8
 ; WIN64-NEXT:    vpslld $31, %xmm0, %xmm1
 ; WIN64-NEXT:    vpmovd2m %xmm1, %k1
 ; WIN64-NEXT:    kmovw %k1, {{[-0-9]+}}(%r{{[sb]}}p) # 2-byte Spill
 ; WIN64-NEXT:    vmovdqa %xmm8, %xmm1
 ; WIN64-NEXT:    vmovdqa %xmm8, %xmm2
 ; WIN64-NEXT:    callq test_argRet128Vector

 ; X32-NEXT:    vmovdqa32 %ymm1, %ymm0 {%k1}
 ; X32-NEXT:    addl $88, %esp
 ; X32-NEXT:    popl %esp
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: test_CallargRet256Vector:
 ; WIN64:       # %bb.0:
 ; WIN64-NEXT:    pushq %rsp
-; WIN64-NEXT:    .seh_pushreg 4
+; WIN64-NEXT:    .seh_pushreg %rsp
 ; WIN64-NEXT:    subq $80, %rsp
 ; WIN64-NEXT:    .seh_stackalloc 80
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    vmovdqu %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 ; WIN64-NEXT:    kmovd %eax, %k1
 ; WIN64-NEXT:    kmovw %k1, {{[-0-9]+}}(%r{{[sb]}}p) # 2-byte Spill
 ; WIN64-NEXT:    vmovdqa %ymm0, %ymm1
 ; WIN64-NEXT:    callq test_argRet256Vector

 ; X32-NEXT:    vmovdqa32 %zmm1, %zmm0 {%k1}
 ; X32-NEXT:    addl $184, %esp
 ; X32-NEXT:    popl %esp
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: test_CallargRet512Vector:
 ; WIN64:       # %bb.0:
 ; WIN64-NEXT:    pushq %rsp
-; WIN64-NEXT:    .seh_pushreg 4
+; WIN64-NEXT:    .seh_pushreg %rsp
 ; WIN64-NEXT:    subq $176, %rsp
 ; WIN64-NEXT:    .seh_stackalloc 176
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    vmovdqu64 %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 ; WIN64-NEXT:    kmovd %eax, %k1
 ; WIN64-NEXT:    kmovw %k1, {{[-0-9]+}}(%r{{[sb]}}p) # 2-byte Spill
 ; WIN64-NEXT:    vmovdqa64 %zmm0, %zmm1
 ; WIN64-NEXT:    callq test_argRet512Vector

llvm/test/CodeGen/X86/catchpad-realign-savexmm.ll

 
 catch:
   %p = catchpad within %cs1 [i8* null, i32 64, i8* null]
   catchret from %p to label %return
 }
 
 ; CHECK: f: # @f
 ; CHECK: pushq   %rbp
-; CHECK: .seh_pushreg 5
+; CHECK: .seh_pushreg %rbp
 ; CHECK: subq    $64, %rsp
 ; CHECK: .seh_stackalloc 64
 ; CHECK: leaq    64(%rsp), %rbp
-; CHECK: .seh_setframe 5, 64
+; CHECK: .seh_setframe %rbp, 64
 ; CHECK: movaps  %xmm6, -16(%rbp)        # 16-byte Spill
-; CHECK: .seh_savexmm 6, 48
+; CHECK: .seh_savexmm %xmm6, 48
 ; CHECK: .seh_endprologue
 ; CHECK: movq    $-2, -24(%rbp)
 ; CHECK: movsd   fp_global(%rip), %xmm6  # xmm6 = mem[0],zero
 ; CHECK: callq   g
 ; CHECK: addsd   __real@3ff0000000000000(%rip), %xmm6
 ; CHECK: movsd   %xmm6, fp_global(%rip)
 ; CHECK: .Ltmp{{.*}}
 ; CHECK: callq   g
 ; CHECK: .Ltmp{{.*}}
 ; CHECK: .LBB{{.*}} # Block address taken
 ; CHECK: movaps  -16(%rbp), %xmm6
 ; CHECK: addq    $64, %rsp
 ; CHECK: popq    %rbp
 ; CHECK: retq
 ; CHECK: .seh_handlerdata
 ; CHECK: # %catch
 ; CHECK: movq    %rdx, 16(%rsp)
 ; CHECK: pushq   %rbp
-; CHECK: .seh_pushreg 5
+; CHECK: .seh_pushreg %rbp
 ; CHECK: subq    $48, %rsp
 ; CHECK: .seh_stackalloc 48
 ; CHECK: leaq    64(%rdx), %rbp
 ; CHECK: movapd  %xmm6, 32(%rsp)
-; CHECK: .seh_savexmm 6, 32
+; CHECK: .seh_savexmm %xmm6, 32
 ; CHECK: .seh_endprologue
 ; CHECK: movapd  32(%rsp), %xmm6
 ; CHECK: leaq    .LBB0_1(%rip), %rax
 ; CHECK: addq    $48, %rsp
 ; CHECK: popq    %rbp
 ; CHECK: retq # CATCHRET

llvm/test/CodeGen/X86/cleanuppad-realign.ll

 ; X86:         movl    28(%esi), %ebp
 ; We used to have a bug where we clobbered ESI after the prologue.
 ; X86-NOT:  movl {{.*}}, %esi
 ; X86:         popl    %ebp
 ; X86:         retl                            # CLEANUPRET
 
 ; X64-LABEL: realigned_cleanup: # @realigned_cleanup
 ; X64:         pushq   %rbp
-; X64:         .seh_pushreg 5
+; X64:         .seh_pushreg %rbp
 ; X64:         pushq   %rbx
-; X64:         .seh_pushreg 3
+; X64:         .seh_pushreg %rbx
 ; X64:         subq    $104, %rsp
 ; X64:         .seh_stackalloc 104
 ; X64:         leaq    96(%rsp), %rbp
-; X64:         .seh_setframe 5, 96
+; X64:         .seh_setframe %rbp, 96
 ; X64:         .seh_endprologue
 ; X64:         andq    $-32, %rsp
 ; X64:         movq    %rsp, %rbx
 ; RBP will reload from this offset.
 ; X64:         movq    %rbp, 56(%rbx)
 ; X64:         movq    $-2, (%rbp)
 
 ; X64-LABEL: "?dtor$2@?0?realigned_cleanup@4HA":
 ; X64:         movq    %rdx, 16(%rsp)
 ; X64:         pushq   %rbp
-; X64:         .seh_pushreg 5
+; X64:         .seh_pushreg %rbp
 ; X64:         pushq   %rbx
-; X64:         .seh_pushreg 3
+; X64:         .seh_pushreg %rbx
 ; X64:         subq    $40, %rsp
 ; X64:         .seh_stackalloc 40
 ; X64:         leaq    96(%rdx), %rbp
 ; X64:         .seh_endprologue
 ; X64:         andq    $-32, %rdx
 ; X64:         movq    %rdx, %rbx
 ; X64-NOT:  mov{{.*}}, %rbx
 ; X64:         popq    %rbp
 ; X64:         retq                            # CLEANUPRET

llvm/test/CodeGen/X86/conditional-tailcall.ll

 ; CHECK64-NEXT:    .cfi_def_cfa_offset 8
 ; CHECK64-NEXT:    jmp bar # TAILCALL
 ; CHECK64-NEXT:    # encoding: [0xeb,A]
 ; CHECK64-NEXT:    # fixup A - offset: 1, value: bar-1, kind: FK_PCRel_1
 ;
 ; WIN64-LABEL: f_non_leaf:
 ; WIN64:       # %bb.0: # %entry
 ; WIN64-NEXT:    pushq %rbx # encoding: [0x53]
-; WIN64-NEXT:    .seh_pushreg 3
+; WIN64-NEXT:    .seh_pushreg %rbx
 ; WIN64-NEXT:    .seh_endprologue
 ; WIN64-NEXT:    #APP
 ; WIN64-NEXT:    #NO_APP
 ; WIN64-NEXT:    cmpl %edx, %ecx # encoding: [0x39,0xd1]
 ; WIN64-NEXT:    jne .LBB1_2 # encoding: [0x75,A]
 ; WIN64-NEXT:    # fixup A - offset: 1, value: .LBB1_2-1, kind: FK_PCRel_1
 ; WIN64-NEXT:  # %bb.1: # %bb1
 ; WIN64-NEXT:    popq %rbx # encoding: [0x5b]

llvm/test/CodeGen/X86/gcc_except_table.ll

 ; APPLE: .cfi_def_cfa_offset 16
 ; APPLE: callq __Unwind_Resume
 ; APPLE: .cfi_endproc
 ; APPLE: GCC_except_table0:
 ; APPLE: Lexception0:
 
 ; MINGW64: .seh_proc
 ; MINGW64: .seh_handler __gxx_personality_v0
-; MINGW64: .seh_setframe 5, 32
+; MINGW64: .seh_setframe %rbp, 32
 ; MINGW64: callq _Unwind_Resume
 ; MINGW64: .seh_handlerdata
 ; MINGW64: .seh_endproc
 ; MINGW64: GCC_except_table0:
 ; MINGW64: Lexception0:
 
 ; MINGW32: .cfi_startproc
 ; MINGW32: .cfi_personality 0, ___gxx_personality_v0

llvm/test/CodeGen/X86/localescape.ll

define void @alloc_func(i32 %n) {
   ret void
 }
 
 ; X64-LABEL: alloc_func:
 ; X64: pushq   %rbp
 ; X64: subq    $16, %rsp
 ; X64: .seh_stackalloc 16
 ; X64: leaq    16(%rsp), %rbp
-; X64: .seh_setframe 5, 16
+; X64: .seh_setframe %rbp, 16
 ; X64: .set .Lalloc_func$frame_escape_0, -4
 ; X64: .set .Lalloc_func$frame_escape_1, -12
 ; X64: movl $42, -4(%rbp)
 ; X64: movl $13, -12(%rbp)
 ; X64: movq   %rbp, %rcx
 ; X64: callq print_framealloc_from_fp
 ; X64: retq
 

llvm/test/CodeGen/X86/musttail-varargs.ll

 ; LINUX-X32-NEXT:    .cfi_def_cfa_offset 16
 ; LINUX-X32-NEXT:    popq %rbp
 ; LINUX-X32-NEXT:    .cfi_def_cfa_offset 8
 ; LINUX-X32-NEXT:    jmpq *%r11 # TAILCALL
 ;
 ; WINDOWS-LABEL: f_thunk:
 ; WINDOWS:       # %bb.0:
 ; WINDOWS-NEXT:    pushq %r14
-; WINDOWS-NEXT:    .seh_pushreg 14
+; WINDOWS-NEXT:    .seh_pushreg %r14
 ; WINDOWS-NEXT:    pushq %rsi
-; WINDOWS-NEXT:    .seh_pushreg 6
+; WINDOWS-NEXT:    .seh_pushreg %rsi
 ; WINDOWS-NEXT:    pushq %rdi
-; WINDOWS-NEXT:    .seh_pushreg 7
+; WINDOWS-NEXT:    .seh_pushreg %rdi
 ; WINDOWS-NEXT:    pushq %rbp
-; WINDOWS-NEXT:    .seh_pushreg 5
+; WINDOWS-NEXT:    .seh_pushreg %rbp
 ; WINDOWS-NEXT:    pushq %rbx
-; WINDOWS-NEXT:    .seh_pushreg 3
+; WINDOWS-NEXT:    .seh_pushreg %rbx
 ; WINDOWS-NEXT:    subq $64, %rsp
 ; WINDOWS-NEXT:    .seh_stackalloc 64
 ; WINDOWS-NEXT:    .seh_endprologue
 ; WINDOWS-NEXT:    movl %eax, %r14d
 ; WINDOWS-NEXT:    movq %r9, %rsi
 ; WINDOWS-NEXT:    movq %r8, %rdi
 ; WINDOWS-NEXT:    movq %rdx, %rbx
 ; WINDOWS-NEXT:    movq %rcx, %rbp

llvm/test/CodeGen/X86/seh-catchpad.ll

__except.ret:                                     ; preds = %catch.dispatch.7
   %cp3 = catchpad within %cs2 [i8* bitcast (i32 (i8*, i8*)* @"\01?filt$0@0@main@@" to i8*)]
   catchret from %cp3 to label %__except.9
 }
 
 ; CHECK: main:                                   # @main
 ; CHECK: .seh_proc main
 ; CHECK:         .seh_handler __C_specific_handler, @unwind, @except
 ; CHECK:         pushq   %rbp
-; CHECK:         .seh_pushreg 5
+; CHECK:         .seh_pushreg %rbp
 ; CHECK:         subq    $32, %rsp
 ; CHECK:         .seh_stackalloc 32
 ; CHECK:         leaq    32(%rsp), %rbp
-; CHECK:         .seh_setframe 5, 32
+; CHECK:         .seh_setframe %rbp, 32
 ; CHECK:         .seh_endprologue
 ; CHECK: .Ltmp0:
 ; CHECK:         movl    $1, %ecx
 ; CHECK:         xorl    %edx, %edx
 ; CHECK:         callq   do_div
 ; CHECK: .Ltmp1:
 ; CHECK: .LBB1_[[epilogue:[0-9]+]]:                                # %__try.cont.12
 ; CHECK:         xorl    %eax, %eax

 ; CHECK:         .seh_endproc
 
 ; CHECK: "?dtor$[[finbb]]@?0?main@4HA":
 ; CHECK: .seh_proc "?dtor$[[finbb]]@?0?main@4HA"
 ; CHECK-NOT:         .seh_handler
 ; CHECK: .LBB1_[[finbb]]:                                # %ehcleanup
 ; CHECK:         movq    %rdx, 16(%rsp)
 ; CHECK:         pushq   %rbp
-; CHECK:         .seh_pushreg 5
+; CHECK:         .seh_pushreg %rbp
 ; CHECK:         subq    $32, %rsp
 ; CHECK:         .seh_stackalloc 32
 ; CHECK:         leaq    32(%rdx), %rbp
 ; CHECK:         .seh_endprologue
 ; CHECK:         callq   "?fin$0@0@main@@"
 ; CHECK:         nop
 ; CHECK:         addq    $32, %rsp
 ; CHECK:         popq    %rbp

llvm/test/CodeGen/X86/win-catchpad-csrs.ll

 ; X86: $handlerMap$0$try_catch_catch:
 ; X86:   .long   0
 ; X86:   .long   "??_R0H@8"
 ; X86:   .long   0
 ; X86:   .long   "?catch$[[catch1bb]]@?0?try_catch_catch@4HA"
 
 ; X64-LABEL: try_catch_catch:
 ; X64: pushq %rbp
-; X64: .seh_pushreg 5
+; X64: .seh_pushreg %rbp
 ; X64: pushq %rsi
-; X64: .seh_pushreg 6
+; X64: .seh_pushreg %rsi
 ; X64: pushq %rdi
-; X64: .seh_pushreg 7
+; X64: .seh_pushreg %rdi
 ; X64: pushq %rbx
-; X64: .seh_pushreg 3
+; X64: .seh_pushreg %rbx
 ; X64: subq $40, %rsp
 ; X64: .seh_stackalloc 40
 ; X64: leaq 32(%rsp), %rbp
-; X64: .seh_setframe 5, 32
+; X64: .seh_setframe %rbp, 32
 ; X64: .seh_endprologue
 ; X64: movq $-2, (%rbp)
 ; X64: callq getint
 ; X64: callq getint
 ; X64: callq getint
 ; X64: callq getint
 ; X64: callq useints
 ; X64: movl $1, %ecx
 ; X64: callq f
 ; X64: [[contbb:\.LBB0_[0-9]+]]: # Block address taken
 ; X64-NEXT:                      # %try.cont
 ; X64: addq $40, %rsp
 ; X64: popq %rbp
 ; X64: retq
 
 ; X64: "?catch$[[catch1bb:[0-9]+]]@?0?try_catch_catch@4HA":
 ; X64: LBB0_[[catch1bb]]: # %handler1{{$}}
 ; X64: movq %rdx, 16(%rsp)
 ; X64: pushq %rbp
-; X64: .seh_pushreg 5
+; X64: .seh_pushreg %rbp
 ; X64: pushq %rsi
-; X64: .seh_pushreg 6
+; X64: .seh_pushreg %rsi
 ; X64: pushq %rdi
-; X64: .seh_pushreg 7
+; X64: .seh_pushreg %rdi
 ; X64: pushq %rbx
-; X64: .seh_pushreg 3
+; X64: .seh_pushreg %rbx
 ; X64: subq $40, %rsp
 ; X64: .seh_stackalloc 40
 ; X64: leaq 32(%rdx), %rbp
 ; X64: .seh_endprologue
 ; X64: movl $2, %ecx
 ; X64: callq f
 ; X64: leaq [[contbb]](%rip), %rax
 ; X64: addq $40, %rsp
handler1:
   catchret from %0 to label %try.cont
 
 try.cont:
   ret i32 0
 }
 
 ; X64-LABEL: try_one_csr:
 ; X64: pushq %rbp
-; X64: .seh_pushreg 5
+; X64: .seh_pushreg %rbp
 ; X64: pushq %rsi
-; X64: .seh_pushreg 6
+; X64: .seh_pushreg %rsi
 ; X64-NOT: pushq
 ; X64: subq $40, %rsp
 ; X64: .seh_stackalloc 40
 ; X64: leaq 32(%rsp), %rbp
-; X64: .seh_setframe 5, 32
+; X64: .seh_setframe %rbp, 32
 ; X64: .seh_endprologue
 ; X64: callq getint
 ; X64: callq getint
 ; X64: callq useints
 ; X64: movl $1, %ecx
 ; X64: callq f
 ; X64: [[contbb:\.LBB1_[0-9]+]]: # Block address taken
 ; X64-NEXT:                      # %try.cont
 ; X64: addq $40, %rsp
 ; X64-NOT: popq
 ; X64: popq %rsi
 ; X64: popq %rbp
 ; X64: retq
 
 ; X64: "?catch$[[catch1bb:[0-9]+]]@?0?try_one_csr@4HA":
 ; X64: LBB1_[[catch1bb]]: # %handler1{{$}}
 ; X64: movq %rdx, 16(%rsp)
 ; X64: pushq %rbp
-; X64: .seh_pushreg 5
+; X64: .seh_pushreg %rbp
 ; X64: pushq %rsi
-; X64: .seh_pushreg 6
+; X64: .seh_pushreg %rsi
 ; X64: subq $40, %rsp
 ; X64: .seh_stackalloc 40
 ; X64: leaq 32(%rdx), %rbp
 ; X64: .seh_endprologue
 ; X64: leaq [[contbb]](%rip), %rax
 ; X64: addq $40, %rsp
 ; X64: popq %rsi
 ; X64: popq %rbp
handler1:
   catchret from %cp1 to label %try.cont
 
 try.cont:
   ret i32 0
 }
 
 ; X64-LABEL: try_no_csr:
 ; X64: pushq %rbp
-; X64: .seh_pushreg 5
+; X64: .seh_pushreg %rbp
 ; X64-NOT: pushq
 ; X64: subq $48, %rsp
 ; X64: .seh_stackalloc 48
 ; X64: leaq 48(%rsp), %rbp
-; X64: .seh_setframe 5, 48
+; X64: .seh_setframe %rbp, 48
 ; X64: .seh_endprologue
 ; X64: movl $1, %ecx
 ; X64: callq f
 ; X64: [[contbb:\.LBB2_[0-9]+]]: # Block address taken
 ; X64-NEXT:                      # %try.cont
 ; X64: addq $48, %rsp
 ; X64-NOT: popq
 ; X64: popq %rbp
 ; X64: retq
 
 ; X64: "?catch$[[catch1bb:[0-9]+]]@?0?try_no_csr@4HA":
 ; X64: LBB2_[[catch1bb]]: # %handler1{{$}}
 ; X64: movq %rdx, 16(%rsp)
 ; X64: pushq %rbp
-; X64: .seh_pushreg 5
+; X64: .seh_pushreg %rbp
 ; X64: subq $32, %rsp
 ; X64: .seh_stackalloc 32
 ; X64: leaq 48(%rdx), %rbp
 ; X64: .seh_endprologue
 ; X64: leaq [[contbb]](%rip), %rax
 ; X64: addq $32, %rsp
 ; X64: popq %rbp
 ; X64: retq
 
 ; X64: $handlerMap$0$try_no_csr:
 ; X64:   .long   0
 ; X64:   .long   "??_R0H@8"@IMGREL
 ; X64:   .long   0
 ; X64:   .long   "?catch$[[catch1bb]]@?0?try_no_csr@4HA"@IMGREL
 ; X64:   .long   56

llvm/test/CodeGen/X86/win-catchpad.ll

 ; X86-NEXT:   .long   64
 ; X86-NEXT:   .long   0
 ; X86-NEXT:   .long   0
 ; X86-NEXT:   .long   "?catch$[[catch2bb]]@?0?try_catch_catch@4HA"
 
 ; X64-LABEL: try_catch_catch:
 ; X64: Lfunc_begin0:
 ; X64: pushq %rbp
-; X64: .seh_pushreg 5
+; X64: .seh_pushreg %rbp
 ; X64: subq $[[STCK_ALLOC:.*]], %rsp
 ; X64: .seh_stackalloc [[STCK_ALLOC]]
 ; X64: leaq [[STCK_ALLOC]](%rsp), %rbp
-; X64: .seh_setframe 5, [[STCK_ALLOC]]
+; X64: .seh_setframe %rbp, [[STCK_ALLOC]]
 ; X64: .seh_endprologue
 ; X64: movq $-2, -16(%rbp)
 ; X64: .Ltmp0
 ; X64-DAG: leaq -[[local_offs:[0-9]+]](%rbp), %rdx
 ; X64-DAG: movl $1, %ecx
 ; X64: callq f
 ; X64: [[contbb:\.LBB0_[0-9]+]]: # Block address taken
 ; X64-NEXT:                      # %try.cont
 ; X64: addq $[[STCK_ALLOC]], %rsp
 ; X64: popq %rbp
 ; X64: retq
 
 ; X64: "?catch$[[catch1bb:[0-9]+]]@?0?try_catch_catch@4HA":
 ; X64: LBB0_[[catch1bb]]: # %handler1{{$}}
 ; X64: movq %rdx, 16(%rsp)
 ; X64: pushq %rbp
-; X64: .seh_pushreg 5
+; X64: .seh_pushreg %rbp
 ; X64: subq $32, %rsp
 ; X64: .seh_stackalloc 32
 ; X64: leaq [[STCK_ALLOC]](%rdx), %rbp
 ; X64: .seh_endprologue
 ; X64-DAG: leaq -[[local_offs]](%rbp), %rdx
 ; X64-DAG: movl -4(%rbp), %ecx
 ; X64: callq f
 ; X64: leaq [[contbb]](%rip), %rax
 ; X64-NEXT: addq $32, %rsp
 ; X64-NEXT: popq %rbp
 ; X64-NEXT: retq
 
 ; X64: "?catch$[[catch2bb:[0-9]+]]@?0?try_catch_catch@4HA":
 ; X64: LBB0_[[catch2bb]]: # %handler2{{$}}
 ; X64: movq %rdx, 16(%rsp)
 ; X64: pushq %rbp
-; X64: .seh_pushreg 5
+; X64: .seh_pushreg %rbp
 ; X64: subq $32, %rsp
 ; X64: .seh_stackalloc 32
 ; X64: leaq [[STCK_ALLOC]](%rdx), %rbp
 ; X64: .seh_endprologue
 ; X64-DAG: leaq -[[local_offs]](%rbp), %rdx
 ; X64-DAG: movl $3, %ecx
 ; X64: callq f
 ; X64: leaq [[contbb]](%rip), %rax

 ; X86-NEXT:   .long   64
 ; X86-NEXT:   .long   0
 ; X86-NEXT:   .long   0
 ; X86-NEXT:   .long   "?catch$[[catchbb]]@?0?branch_to_normal_dest@4HA"
 
 ; X64-LABEL: branch_to_normal_dest:
 ; X64: # %entry
 ; X64: pushq %rbp
-; X64: .seh_pushreg 5
+; X64: .seh_pushreg %rbp
 ; X64: subq $48, %rsp
 ; X64: .seh_stackalloc 48
 ; X64: leaq 48(%rsp), %rbp
-; X64: .seh_setframe 5, 48
+; X64: .seh_setframe %rbp, 48
 ; X64: .seh_endprologue
 ; X64: .Ltmp[[before_call:[0-9]+]]:
 ; X64: callq f
 ; X64: .Ltmp[[after_call:[0-9]+]]:
 ; X64: [[contbb:\.LBB1_[0-9]+]]: # Block address taken
 ; X64-NEXT:                      # %try.cont
 ; X64: addq $48, %rsp
 ; X64: popq %rbp
 ; X64: retq
 
 ; X64: "?catch$[[catchbb:[0-9]+]]@?0?branch_to_normal_dest@4HA":
 ; X64: LBB1_[[catchbb]]: # %catch{{$}}
 ; X64: movq %rdx, 16(%rsp)
 ; X64: pushq %rbp
-; X64: .seh_pushreg 5
+; X64: .seh_pushreg %rbp
 ; X64: subq $32, %rsp
 ; X64: .seh_stackalloc 32
 ; X64: leaq 48(%rdx), %rbp
 ; X64: .seh_endprologue
 ; X64: .LBB1_[[normal_dest_bb:[0-9]+]]: # %loop
 ; X64: callq   getbool
 ; X64: testb   $1, %al
 ; X64: jne     .LBB1_[[normal_dest_bb]]

llvm/test/CodeGen/X86/win-funclet-cfi.ll

 ; CHECK: "?dtor$[[cleanup:[0-9]+]]@?0??f@@YAXXZ@4HA":
 ; CHECK: .seh_proc "?dtor$[[cleanup]]@?0??f@@YAXXZ@4HA"
 ; CHECK-NOT: .seh_handler __CxxFrameHandler3
 ; CHECK: LBB0_[[cleanup]]: # %cleanupblock{{$}}
 
 ; Emit CFI for pushing RBP.
 ; CHECK: movq    %rdx, 16(%rsp)
 ; CHECK: pushq   %rbp
-; CHECK: .seh_pushreg 5
+; CHECK: .seh_pushreg %rbp
 
 ; Emit CFI for allocating from the stack pointer.
 ; CHECK: subq    $32, %rsp
 ; CHECK: .seh_stackalloc 32
 
 ; CHECK: leaq    48(%rdx), %rbp
 ; CHECK-NOT: .seh_setframe
 

 ; CHECK: "?catch$[[catch:[0-9]+]]@?0??f@@YAXXZ@4HA":
 ; CHECK: .seh_proc "?catch$[[catch]]@?0??f@@YAXXZ@4HA"
 ; CHECK-NEXT: .seh_handler __CxxFrameHandler3, @unwind, @except
 ; CHECK: LBB0_[[catch]]: # %catch{{$}}
 
 ; Emit CFI for pushing RBP.
 ; CHECK: movq    %rdx, 16(%rsp)
 ; CHECK: pushq   %rbp
-; CHECK: .seh_pushreg 5
+; CHECK: .seh_pushreg %rbp
 
 ; Emit CFI for allocating from the stack pointer.
 ; CHECK: subq    $32, %rsp
 ; CHECK: .seh_stackalloc 32
 
 ; CHECK: leaq    48(%rdx), %rbp
 ; CHECK-NOT: .seh_setframe
 

llvm/test/CodeGen/X86/win64-funclet-savexmm.ll

 
 try.cont:                                         ; preds = %catchret.dest, %invoke.cont
   ret void
 }
 
 ; CHECK: # %catch
 ; CHECK: movq    %rdx, 16(%rsp)
 ; CHECK: pushq   %rbp
-; CHECK: .seh_pushreg 5
+; CHECK: .seh_pushreg %rbp
 ; CHECK: pushq   %rbx
-; CHECK: .seh_pushreg 3
+; CHECK: .seh_pushreg %rbx
 ; CHECK: subq    $88, %rsp
 ; CHECK: .seh_stackalloc 88
 ; CHECK: leaq    112(%rdx), %rbp
 ; CHECK: vmovaps %xmm8, 48(%rsp)
-; CHECK: .seh_savexmm 8, 48
+; CHECK: .seh_savexmm %xmm8, 48
 ; CHECK: vmovaps %xmm7, 64(%rsp)
-; CHECK: .seh_savexmm 7, 64
+; CHECK: .seh_savexmm %xmm7, 64
 ; CHECK: vmovaps %xmm6, 80(%rsp)
-; CHECK: .seh_savexmm 6, 80
+; CHECK: .seh_savexmm %xmm6, 80
 ; CHECK: .seh_endprologue
 ; CHECK: movl   -{{[0-9]+}}(%rbp), %ecx
 ; CHECK: vmovaps 80(%rsp), %xmm6
 ; CHECK: vmovaps 64(%rsp), %xmm7
 ; CHECK: vmovaps 48(%rsp), %xmm8
 ; CHECK: leaq    .LBB0_1(%rip), %rax
 ; CHECK: addq    $88, %rsp
 ; CHECK: popq    %rbx

llvm/test/CodeGen/X86/win64_eh.ll

 entry:
   %s = alloca i32, align 64
   call void asm sideeffect "", "~{rbx},~{rdi},~{xmm6},~{xmm7}"()
   ret void
 }
 ; WIN64-LABEL: foo5:
 ; WIN64: .seh_proc foo5
 ; WIN64: pushq %rbp
-; WIN64: .seh_pushreg 5
+; WIN64: .seh_pushreg %rbp
 ; WIN64: pushq %rdi
-; WIN64: .seh_pushreg 7
+; WIN64: .seh_pushreg %rdi
 ; WIN64: pushq %rbx
-; WIN64: .seh_pushreg 3
+; WIN64: .seh_pushreg %rbx
 ; NORM:  subq  $96, %rsp
 ; ATOM:  leaq -96(%rsp), %rsp
 ; WIN64: .seh_stackalloc 96
 ; WIN64: leaq  96(%rsp), %rbp
-; WIN64: .seh_setframe 5, 96
+; WIN64: .seh_setframe %rbp, 96
 ; WIN64: movaps  %xmm7, -16(%rbp)        # 16-byte Spill
-; WIN64: .seh_savexmm 7, 80
+; WIN64: .seh_savexmm %xmm7, 80
 ; WIN64: movaps  %xmm6, -32(%rbp)        # 16-byte Spill
-; WIN64: .seh_savexmm 6, 64
+; WIN64: .seh_savexmm %xmm6, 64
 ; WIN64: .seh_endprologue
 ; WIN64: andq  $-64, %rsp
 ; WIN64: movaps  -32(%rbp), %xmm6        # 16-byte Reload
 ; WIN64: movaps  -16(%rbp), %xmm7        # 16-byte Reload
 ; WIN64: movq  %rbp, %rsp
 ; WIN64: popq  %rbx
 ; WIN64: popq  %rdi
 ; WIN64: popq  %rbp
 ; WIN64: retq
 ; WIN64: .seh_endproc

llvm/test/CodeGen/X86/win64_frame.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple=x86_64-pc-win32              | FileCheck %s --check-prefix=ALL --check-prefix=PUSHF
 ; RUN: llc < %s -mtriple=x86_64-pc-win32 -mattr=+sahf | FileCheck %s --check-prefix=ALL --check-prefix=SAHF
 
 define i32 @f1(i32 %p1, i32 %p2, i32 %p3, i32 %p4, i32 %p5) "no-frame-pointer-elim"="true" {
 ; ALL-LABEL: f1:
 ; ALL:       # %bb.0:
 ; ALL-NEXT:    pushq %rbp
-; ALL-NEXT:    .seh_pushreg 5
+; ALL-NEXT:    .seh_pushreg %rbp
 ; ALL-NEXT:    movq %rsp, %rbp
-; ALL-NEXT:    .seh_setframe 5, 0
+; ALL-NEXT:    .seh_setframe %rbp, 0
 ; ALL-NEXT:    .seh_endprologue
 ; ALL-NEXT:    movl 48(%rbp), %eax
 ; ALL-NEXT:    popq %rbp
 ; ALL-NEXT:    retq
 ; ALL-NEXT:    .seh_handlerdata
 ; ALL-NEXT:    .text
 ; ALL-NEXT:    .seh_endproc
   ret i32 %p5
 }
 
 define void @f2(i32 %p, ...) "no-frame-pointer-elim"="true" {
 ; ALL-LABEL: f2:
 ; ALL:       # %bb.0:
 ; ALL-NEXT:    pushq %rbp
-; ALL-NEXT:    .seh_pushreg 5
+; ALL-NEXT:    .seh_pushreg %rbp
 ; ALL-NEXT:    pushq %rax
 ; ALL-NEXT:    .seh_stackalloc 8
 ; ALL-NEXT:    movq %rsp, %rbp
-; ALL-NEXT:    .seh_setframe 5, 0
+; ALL-NEXT:    .seh_setframe %rbp, 0
 ; ALL-NEXT:    .seh_endprologue
 ; ALL-NEXT:    movq %rdx, 32(%rbp)
 ; ALL-NEXT:    movq %r8, 40(%rbp)
 ; ALL-NEXT:    movq %r9, 48(%rbp)
 ; ALL-NEXT:    leaq 32(%rbp), %rax
 ; ALL-NEXT:    movq %rax, (%rbp)
 ; ALL-NEXT:    addq $8, %rsp
 ; ALL-NEXT:    popq %rbp
 ; ALL-NEXT:    retq
 ; ALL-NEXT:    .seh_handlerdata
 ; ALL-NEXT:    .text
 ; ALL-NEXT:    .seh_endproc
   %ap = alloca i8, align 8
   call void @llvm.va_start(i8* %ap)
   ret void
 }
 
 define i8* @f3() "no-frame-pointer-elim"="true" {
 ; ALL-LABEL: f3:
 ; ALL:       # %bb.0:
 ; ALL-NEXT:    pushq %rbp
-; ALL-NEXT:    .seh_pushreg 5
+; ALL-NEXT:    .seh_pushreg %rbp
 ; ALL-NEXT:    movq %rsp, %rbp
-; ALL-NEXT:    .seh_setframe 5, 0
+; ALL-NEXT:    .seh_setframe %rbp, 0
 ; ALL-NEXT:    .seh_endprologue
 ; ALL-NEXT:    movq 8(%rbp), %rax
 ; ALL-NEXT:    popq %rbp
 ; ALL-NEXT:    retq
 ; ALL-NEXT:    .seh_handlerdata
 ; ALL-NEXT:    .text
 ; ALL-NEXT:    .seh_endproc
   %ra = call i8* @llvm.returnaddress(i32 0)
   ret i8* %ra
 }
 
 define i8* @f4() "no-frame-pointer-elim"="true" {
 ; ALL-LABEL: f4:
 ; ALL:       # %bb.0:
 ; ALL-NEXT:    pushq %rbp
-; ALL-NEXT:    .seh_pushreg 5
+; ALL-NEXT:    .seh_pushreg %rbp
 ; ALL-NEXT:    subq $304, %rsp # imm = 0x130
 ; ALL-NEXT:    .seh_stackalloc 304
 ; ALL-NEXT:    leaq {{[0-9]+}}(%rsp), %rbp
-; ALL-NEXT:    .seh_setframe 5, 128
+; ALL-NEXT:    .seh_setframe %rbp, 128
 ; ALL-NEXT:    .seh_endprologue
 ; ALL-NEXT:    movq 184(%rbp), %rax
 ; ALL-NEXT:    addq $304, %rsp # imm = 0x130
 ; ALL-NEXT:    popq %rbp
 ; ALL-NEXT:    retq
 ; ALL-NEXT:    .seh_handlerdata
 ; ALL-NEXT:    .text
 ; ALL-NEXT:    .seh_endproc
   alloca [300 x i8]
   %ra = call i8* @llvm.returnaddress(i32 0)
   ret i8* %ra
 }
 
 declare void @external(i8*)
 
 define void @f5() "no-frame-pointer-elim"="true" {
 ; ALL-LABEL: f5:
 ; ALL:       # %bb.0:
 ; ALL-NEXT:    pushq %rbp
-; ALL-NEXT:    .seh_pushreg 5
+; ALL-NEXT:    .seh_pushreg %rbp
 ; ALL-NEXT:    subq $336, %rsp # imm = 0x150
 ; ALL-NEXT:    .seh_stackalloc 336
 ; ALL-NEXT:    leaq {{[0-9]+}}(%rsp), %rbp
-; ALL-NEXT:    .seh_setframe 5, 128
+; ALL-NEXT:    .seh_setframe %rbp, 128
 ; ALL-NEXT:    .seh_endprologue
 ; ALL-NEXT:    leaq -92(%rbp), %rcx
 ; ALL-NEXT:    callq external
 ; ALL-NEXT:    nop
 ; ALL-NEXT:    addq $336, %rsp # imm = 0x150
 ; ALL-NEXT:    popq %rbp
 ; ALL-NEXT:    retq
 ; ALL-NEXT:    .seh_handlerdata
 ; ALL-NEXT:    .text
 ; ALL-NEXT:    .seh_endproc
   %a = alloca [300 x i8]
   %gep = getelementptr [300 x i8], [300 x i8]* %a, i32 0, i32 0
   call void @external(i8* %gep)
   ret void
 }
 
 define void @f6(i32 %p, ...) "no-frame-pointer-elim"="true" {
 ; ALL-LABEL: f6:
 ; ALL:       # %bb.0:
 ; ALL-NEXT:    pushq %rbp
-; ALL-NEXT:    .seh_pushreg 5
+; ALL-NEXT:    .seh_pushreg %rbp
 ; ALL-NEXT:    subq $336, %rsp # imm = 0x150
 ; ALL-NEXT:    .seh_stackalloc 336
 ; ALL-NEXT:    leaq {{[0-9]+}}(%rsp), %rbp
-; ALL-NEXT:    .seh_setframe 5, 128
+; ALL-NEXT:    .seh_setframe %rbp, 128
 ; ALL-NEXT:    .seh_endprologue
 ; ALL-NEXT:    leaq -92(%rbp), %rcx
 ; ALL-NEXT:    callq external
 ; ALL-NEXT:    nop
 ; ALL-NEXT:    addq $336, %rsp # imm = 0x150
 ; ALL-NEXT:    popq %rbp
 ; ALL-NEXT:    retq
 ; ALL-NEXT:    .seh_handlerdata
 ; ALL-NEXT:    .text
 ; ALL-NEXT:    .seh_endproc
   %a = alloca [300 x i8]
   %gep = getelementptr [300 x i8], [300 x i8]* %a, i32 0, i32 0
   call void @external(i8* %gep)
   ret void
 }
 
 define i32 @f7(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) "no-frame-pointer-elim"="true" {
 ; ALL-LABEL: f7:
 ; ALL:       # %bb.0:
 ; ALL-NEXT:    pushq %rbp
-; ALL-NEXT:    .seh_pushreg 5
+; ALL-NEXT:    .seh_pushreg %rbp
 ; ALL-NEXT:    subq $304, %rsp # imm = 0x130
 ; ALL-NEXT:    .seh_stackalloc 304
 ; ALL-NEXT:    leaq {{[0-9]+}}(%rsp), %rbp
-; ALL-NEXT:    .seh_setframe 5, 128
+; ALL-NEXT:    .seh_setframe %rbp, 128
 ; ALL-NEXT:    .seh_endprologue
 ; ALL-NEXT:    andq $-64, %rsp
 ; ALL-NEXT:    movl 224(%rbp), %eax
 ; ALL-NEXT:    leaq 176(%rbp), %rsp
 ; ALL-NEXT:    popq %rbp
 ; ALL-NEXT:    retq
 ; ALL-NEXT:    .seh_handlerdata
 ; ALL-NEXT:    .text
 ; ALL-NEXT:    .seh_endproc
   alloca [300 x i8], align 64
   ret i32 %e
 }
 
 define i32 @f8(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) "no-frame-pointer-elim"="true" {
 ; ALL-LABEL: f8:
 ; ALL:       # %bb.0:
 ; ALL-NEXT:    pushq %rbp
-; ALL-NEXT:    .seh_pushreg 5
+; ALL-NEXT:    .seh_pushreg %rbp
 ; ALL-NEXT:    pushq %rsi
-; ALL-NEXT:    .seh_pushreg 6
+; ALL-NEXT:    .seh_pushreg %rsi
 ; ALL-NEXT:    pushq %rbx
-; ALL-NEXT:    .seh_pushreg 3
+; ALL-NEXT:    .seh_pushreg %rbx
 ; ALL-NEXT:    subq $352, %rsp # imm = 0x160
 ; ALL-NEXT:    .seh_stackalloc 352
 ; ALL-NEXT:    leaq {{[0-9]+}}(%rsp), %rbp
-; ALL-NEXT:    .seh_setframe 5, 128
+; ALL-NEXT:    .seh_setframe %rbp, 128
 ; ALL-NEXT:    .seh_endprologue
 ; ALL-NEXT:    andq $-64, %rsp
 ; ALL-NEXT:    movq %rsp, %rbx
 ; ALL-NEXT:    movl 288(%rbp), %esi
 ; ALL-NEXT:    movl %ecx, %eax
 ; ALL-NEXT:    leaq 15(,%rax,4), %rax
 ; ALL-NEXT:    andq $-16, %rax
 ; ALL-NEXT:    callq __chkstk
; ALL-NEXT:    .seh_endproc
   call void @external(i8* %gep)
   ret i32 %e
 }
 
 define i64 @f9() {
 ; ALL-LABEL: f9:
 ; ALL:       # %bb.0: # %entry
 ; ALL-NEXT:    pushq %rbp
-; ALL-NEXT:    .seh_pushreg 5
+; ALL-NEXT:    .seh_pushreg %rbp
 ; ALL-NEXT:    movq %rsp, %rbp
-; ALL-NEXT:    .seh_setframe 5, 0
+; ALL-NEXT:    .seh_setframe %rbp, 0
 ; ALL-NEXT:    .seh_endprologue
 ; ALL-NEXT:    pushfq
 ; ALL-NEXT:    popq %rax
 ; ALL-NEXT:    popq %rbp
 ; ALL-NEXT:    retq
 ; ALL-NEXT:    .seh_handlerdata
 ; ALL-NEXT:    .text
 ; ALL-NEXT:    .seh_endproc
 entry:
   %call = call i64 @llvm.x86.flags.read.u64()
   ret i64 %call
 }
 
 declare i64 @dummy()
 
 define i64 @f10(i64* %foo, i64 %bar, i64 %baz) {
 ; ALL-LABEL: f10:
 ; ALL:       # %bb.0:
 ; ALL-NEXT:    pushq %rsi
-; ALL-NEXT:    .seh_pushreg 6
+; ALL-NEXT:    .seh_pushreg %rsi
 ; ALL-NEXT:    pushq %rbx
-; ALL-NEXT:    .seh_pushreg 3
+; ALL-NEXT:    .seh_pushreg %rbx
 ; ALL-NEXT:    subq $40, %rsp
 ; ALL-NEXT:    .seh_stackalloc 40
 ; ALL-NEXT:    .seh_endprologue
 ; ALL-NEXT:    movq %rdx, %rsi
 ; ALL-NEXT:    movq %rdx, %rax
 ; ALL-NEXT:    lock cmpxchgq %r8, (%rcx)
 ; ALL-NEXT:    sete %bl
 ; ALL-NEXT:    callq dummy
; ALL-NEXT:    .seh_endproc
   %sel = select i1 %p, i64 %call, i64 %bar
   ret i64 %sel
 }
 
 define i8* @f11() "no-frame-pointer-elim"="true" {
 ; ALL-LABEL: f11:
 ; ALL:       # %bb.0:
 ; ALL-NEXT:    pushq %rbp
-; ALL-NEXT:    .seh_pushreg 5
+; ALL-NEXT:    .seh_pushreg %rbp
 ; ALL-NEXT:    movq %rsp, %rbp
-; ALL-NEXT:    .seh_setframe 5, 0
+; ALL-NEXT:    .seh_setframe %rbp, 0
 ; ALL-NEXT:    .seh_endprologue
 ; ALL-NEXT:    leaq 8(%rbp), %rax
 ; ALL-NEXT:    popq %rbp
 ; ALL-NEXT:    retq
 ; ALL-NEXT:    .seh_handlerdata
 ; ALL-NEXT:    .text
 ; ALL-NEXT:    .seh_endproc
   %aora = call i8* @llvm.addressofreturnaddress()

llvm/test/CodeGen/X86/x86-64-flags-intrinsics.ll

 ; RUN: llc -verify-machineinstrs < %s | FileCheck %s
 target triple = "x86_64-pc-win32"
 
 declare i64 @llvm.x86.flags.read.u64()
 declare void @llvm.x86.flags.write.u64(i64)
 
 define i64 @read_flags() {
 entry:
   %flags = call i64 @llvm.x86.flags.read.u64()
   ret i64 %flags
 }
 
 ; CHECK-LABEL: read_flags:
 ; CHECK:      pushq   %rbp
-; CHECK:      .seh_pushreg 5
+; CHECK:      .seh_pushreg %rbp
 ; CHECK:      movq    %rsp, %rbp
-; CHECK:      .seh_setframe 5, 0
+; CHECK:      .seh_setframe %rbp, 0
 ; CHECK:      .seh_endprologue
 ; CHECK-NEXT: pushfq
 ; CHECK-NEXT: popq    %rax
 ; CHECK-NEXT: popq    %rbp
 
 define void @write_flags(i64 %arg) {
 entry:
   call void @llvm.x86.flags.write.u64(i64 %arg)
   ret void
 }
 
 ; CHECK-LABEL: write_flags:
 ; CHECK:      pushq   %rbp
-; CHECK:      .seh_pushreg 5
+; CHECK:      .seh_pushreg %rbp
 ; CHECK:      movq    %rsp, %rbp
-; CHECK:      .seh_setframe 5, 0
+; CHECK:      .seh_setframe %rbp, 0
 ; CHECK:      .seh_endprologue
 ; CHECK-NEXT: pushq   %rcx
 ; CHECK-NEXT: popfq
 ; CHECK-NEXT: popq    %rbp

llvm/test/MC/AsmParser/directive_seh.s

 # RUN: llvm-mc -triple x86_64-pc-win32 %s | FileCheck %s
 
     .text
     .globl func
     .def func; .scl 2; .type 32; .endef
     .seh_proc func
 # CHECK: .seh_proc func
 func:
     .seh_pushframe @code
 # CHECK: .seh_pushframe @code
     subq $24, %rsp
     .seh_stackalloc 24
 # CHECK: .seh_stackalloc 24
     movq %rsi, 16(%rsp)
     .seh_savereg %rsi, 16
-# CHECK: .seh_savereg 6, 16
+# CHECK: .seh_savereg %rsi, 16
+    .seh_savereg 6, 16
+# CHECK: .seh_savereg %rsi, 16
     movups %xmm8, (%rsp)
     .seh_savexmm %xmm8, 0
-# CHECK: .seh_savexmm 8, 0
+# CHECK: .seh_savexmm %xmm8, 0
+    .seh_savexmm 8, 0
+# CHECK: .seh_savexmm %xmm8, 0
     pushq %rbx
+    .seh_pushreg %rbx
+# CHECK: .seh_pushreg %rbx
     .seh_pushreg 3
-# CHECK: .seh_pushreg 3
+# CHECK: .seh_pushreg %rbx
     mov %rsp, %rbx
     .seh_setframe 3, 0
+# CHECK: .seh_setframe %rbx, 0
     .seh_endprologue
+# CHECK: .seh_endprologue
     .seh_handler __C_specific_handler, @except
+# CHECK: .seh_handler __C_specific_handler, @except
     .seh_handlerdata
+# CHECK-NOT: .section{{.*}}.xdata
+# CHECK: .seh_handlerdata
     .long 0
     .text
     .seh_startchained
     .seh_endprologue
     .seh_endchained
-# CHECK: .seh_setframe 3, 0
-# CHECK: .seh_endprologue
-# CHECK: .seh_handler __C_specific_handler, @except
-# CHECK-NOT: .section{{.*}}.xdata
-# CHECK: .seh_handlerdata
 # CHECK: .text
 # CHECK: .seh_startchained
 # CHECK: .seh_endprologue
 # CHECK: .seh_endchained
     lea (%rbx), %rsp
     pop %rbx
     addq $24, %rsp
     ret
     .seh_endproc
 # CHECK: .seh_endproc

llvm/test/MC/AsmParser/seh-directive-errors.s

 # RUN: not llvm-mc -triple x86_64-windows-msvc %s -filetype=obj -o /dev/null 2>&1 | FileCheck %s --implicit-check-not=error:
   .text
 
-  .seh_pushreg 6
+  .seh_pushreg %rsi
   # CHECK: :[[@LINE-1]]:{{[0-9]+}}: error: .seh_ directive must appear within an active frame
 
   .seh_stackalloc 32
   # CHECK: :[[@LINE-1]]:{{[0-9]+}}: error: .seh_ directive must appear within an active frame
 
   .def   f;
   .scl  2;
   .type 32;
   .endef
   .globl  f                       # -- Begin function f
   .p2align  4, 0x90
 f:                                      # @f
 .seh_proc f
   pushq %rsi
-  .seh_pushreg 6
+  .seh_pushreg %rsi
   pushq %rdi
-  .seh_pushreg 7
+  .seh_pushreg %rdi
   pushq %rbx
-  .seh_pushreg 3
+  .seh_pushreg %rbx
   subq  $32, %rsp
   .seh_stackalloc 0
   # CHECK: :[[@LINE-1]]:{{[0-9]+}}: error: stack allocation size must be non-zero
   .seh_stackalloc 7
   # CHECK: :[[@LINE-1]]:{{[0-9]+}}: error: stack allocation size is not a multiple of 8
   .seh_stackalloc 32
   .seh_endprologue
   nop
   addq  $32, %rsp
   popq  %rbx
   popq  %rdi
   popq  %rsi
   retq
   .seh_handlerdata
   .text
   .seh_endproc
 
 
-  .seh_pushreg 6
+  .seh_pushreg %rsi
   # CHECK: :[[@LINE-1]]:{{[0-9]+}}: error: .seh_ directive must appear within an active frame
 
 g:
   .seh_proc g
   pushq %rbp
-  .seh_pushreg 3
+  .seh_pushreg %rbx
   pushq %rsi
-  .seh_pushreg 6
+  .seh_pushreg %rsi
   .seh_endprologue
   .seh_setframe 3 255
   # CHECK: :[[@LINE-1]]:{{[0-9]+}}: error: you must specify a stack pointer offset
   .seh_setframe 3, 255
   # CHECK: :[[@LINE-1]]:{{[0-9]+}}: error: offset is not a multiple of 16
   .seh_setframe 3, 256
   # CHECK: :[[@LINE-1]]:{{[0-9]+}}: error: frame offset must be less than or equal to 240
   .seh_setframe 3, 128

 h:                                      # @h
 .seh_proc h
 # %bb.0:                                # %entry
         subq    $72, %rsp
         .seh_stackalloc 72
         movaps  %xmm7, 48(%rsp)         # 16-byte Spill
         .seh_savexmm 7 44
   # CHECK: :[[@LINE-1]]:{{[0-9]+}}: error: you must specify an offset on the stack
-        .seh_savexmm 7, 44
+        .seh_savexmm %xmm7, 44
   # CHECK: :[[@LINE-1]]:{{[0-9]+}}: error: offset is not a multiple of 16
-        .seh_savexmm 7, 48
+        .seh_savexmm %xmm7, 48
         movaps  %xmm6, 32(%rsp)         # 16-byte Spill
-        .seh_savexmm 6, 32
+        .seh_savexmm %xmm6, 32
         .seh_endprologue
         movapd  %xmm0, %xmm6
         callq   getdbl
         movapd  %xmm0, %xmm7
         addsd   %xmm6, %xmm7
         callq   getdbl
         addsd   %xmm7, %xmm0
         movaps  32(%rsp), %xmm6         # 16-byte Reload
         movaps  48(%rsp), %xmm7         # 16-byte Reload
         addq    $72, %rsp
         retq
         .seh_handlerdata
         .text
         .seh_endproc
                                         # -- End function
+
+  .globl i
+  .def i; .scl 2; .type 32; .endef
+        .p2align        4, 0x90
+i:
+  .seh_proc i
+  pushq %rbp
+  .seh_pushreg 17
+# CHECK: :[[@LINE-1]]:{{[0-9]+}}: error: incorrect register number for use with this directive
+  pushq %rbx
+  .seh_pushreg %xmm0
+# CHECK: :[[@LINE-1]]:{{[0-9]+}}: error: register is not supported for use with this directive
+  leaq 16(%rsp), %rbp
+  .seh_setframe %xmm0, 16
+# CHECK: :[[@LINE-1]]:{{[0-9]+}}: error: register is not supported for use with this directive
+  .seh_endprologue
+  ret
+  .seh_endproc

llvm/test/MC/COFF/seh-align3.s

 // CHECK-NEXT: ]
 
 // Generates two unwind codes.
 // Requires no padding of the unwind code array.
     .globl func
     .def func; .scl 2; .type 32; .endef
     .seh_proc func
     push %r12
-    .seh_pushreg 12
+    .seh_pushreg %r12
     push %r13
-    .seh_pushreg 13
+    .seh_pushreg %r13
     .seh_handler __C_specific_handler, @except, @unwind
     .seh_handlerdata
     .long 0xcafebabe
     .text
     .seh_endprologue
 func:
     pop %r13
     pop %r12
     ret
     .seh_endproc

llvm/test/MC/COFF/seh-linkonce.s

 // RUN: llvm-mc -triple x86_64-pc-win32 -filetype=obj %s | llvm-readobj --sections --section-symbols | FileCheck %s
 
         .text
         .def     weak_func;
         .scl    2;
         .type   32;
         .endef
         .section        .text,"xr",discard,weak_func
         .globl  weak_func
         .align  16, 0x90
 weak_func:                              # @weak_func
 .Ltmp0:
 .seh_proc weak_func
 # %bb.0:                                # %entry
         pushq   %rbp
 .Ltmp1:
-        .seh_pushreg 5
+        .seh_pushreg %rbp
         movq    %rsp, %rbp
 .Ltmp2:
-        .seh_setframe 5, 0
+        .seh_setframe %rbp, 0
 .Ltmp3:
         .seh_endprologue
         xorl    %eax, %eax
         popq    %rbp
         retq
 .Leh_func_end0:
 .Ltmp4:
         .seh_endproc

llvm/test/MC/COFF/seh.s

func:
     .seh_pushframe @code
     subq $24, %rsp
     .seh_stackalloc 24
     movq %rsi, 16(%rsp)
     .seh_savereg %rsi, 16
     movups %xmm8, (%rsp)
     .seh_savexmm %xmm8, 0
     pushq %rbx
-    .seh_pushreg 3
+    .seh_pushreg %rbx
     mov %rsp, %rbx
     .seh_setframe 3, 0
     .seh_endprologue
     .seh_handler __C_specific_handler, @except
     .seh_handlerdata
     .long 0
     .text
     .seh_startchained

llvm/test/tools/llvm-objdump/Inputs/win64-unwind.exe.coff-x86_64.asm

     .text
     .globl func
     .def func; .scl 2; .type 32; .endef
     .seh_proc func
 func:
     .seh_pushframe @code
     subq $24, %rsp
     .seh_stackalloc 24
     movq %rsi, 16(%rsp)
     .seh_savereg %rsi, 16
     movups %xmm8, (%rsp)
     .seh_savexmm %xmm8, 0
     pushq %rbx
-    .seh_pushreg 3
+    .seh_pushreg %rbx
     mov %rsp, %rbx
     .seh_setframe 3, 0
     .seh_endprologue
     .seh_handler __C_specific_handler, @except
     .seh_handlerdata
     .long 0
     .text
     .seh_startchained