Clean up assembler CFI directives

[scott.linder]

Summary

• Support emitting .cfi_undefined in CodeGen
• Emit register names in assembly for .cfi_undefined, .cfi_register, and

.cfi_return_column

[AMDGPU] Implement wave64 DWARF register mapping

Implement the DWARF register mapping described in
llvm/docs/AMDGPUUsage.rst

This is currently limited to wave64 VGPRs/AGPRs.

This also includes some minor changes in AMDGPUInstPrinter and
AMDGPUMCTargetDesc to make generating CFI assembly text and ELF sections
possible to ease testing, although complete CFI support is not yet
implemented.

[scott.linder]

Intended to create multiple reviews

llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp

case MCCFIInstruction::OpGnuArgsSize:
     OutStreamer->emitCFIGnuArgsSize(Inst.getOffset());
     break;
   case MCCFIInstruction::OpEscape:
     OutStreamer->emitCFIEscape(Inst.getValues());
     break;
   case MCCFIInstruction::OpRestore:
     OutStreamer->emitCFIRestore(Inst.getRegister());
     break;
+  case MCCFIInstruction::OpUndefined:
+    OutStreamer->emitCFIUndefined(Inst.getRegister());
+    break;
   }
 }
 
 void AsmPrinter::emitDwarfDIE(const DIE &Die) const {
   // Emit the code (index) for the abbreviation.
   if (isVerbose())
     OutStreamer->AddComment("Abbrev [" + Twine(Die.getAbbrevNumber()) + "] 0x" +
                             Twine::utohexstr(Die.getOffset()) + ":0x" +

llvm/lib/MC/MCAsmStreamer.cpp

 void MCAsmStreamer::emitCFISignalFrame() {
   MCStreamer::emitCFISignalFrame();
   OS << "\t.cfi_signal_frame";
   EmitEOL();
 }
 
 void MCAsmStreamer::emitCFIUndefined(int64_t Register) {
   MCStreamer::emitCFIUndefined(Register);
-  OS << "\t.cfi_undefined " << Register;
+  OS << "\t.cfi_undefined ";
+  EmitRegisterName(Register);
   EmitEOL();
 }
 
 void MCAsmStreamer::emitCFIRegister(int64_t Register1, int64_t Register2) {
   MCStreamer::emitCFIRegister(Register1, Register2);
-  OS << "\t.cfi_register " << Register1 << ", " << Register2;
+  OS << "\t.cfi_register ";
+  EmitRegisterName(Register1);
+  OS << ", ";
+  EmitRegisterName(Register2);
   EmitEOL();
 }
 
 void MCAsmStreamer::emitCFIWindowSave() {
   MCStreamer::emitCFIWindowSave();
   OS << "\t.cfi_window_save";
   EmitEOL();
 }
 
 void MCAsmStreamer::emitCFINegateRAState() {
   MCStreamer::emitCFINegateRAState();
   OS << "\t.cfi_negate_ra_state";
   EmitEOL();
 }
 
 void MCAsmStreamer::emitCFIReturnColumn(int64_t Register) {
   MCStreamer::emitCFIReturnColumn(Register);
-  OS << "\t.cfi_return_column " << Register;
+  OS << "\t.cfi_return_column ";
+  EmitRegisterName(Register);
   EmitEOL();
 }
 
 void MCAsmStreamer::emitCFIBKeyFrame() {
   MCStreamer::emitCFIBKeyFrame();
   OS << "\t.cfi_b_key_frame";
   EmitEOL();
 }

llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUInstPrinter.h

 
 class AMDGPUInstPrinter : public MCInstPrinter {
 public:
   AMDGPUInstPrinter(const MCAsmInfo &MAI,
                     const MCInstrInfo &MII, const MCRegisterInfo &MRI)
     : MCInstPrinter(MAI, MII, MRI) {}
 
   //Autogenerated by tblgen
+  void printRegName(raw_ostream &OS, unsigned RegNo) const override;
   void printInstruction(const MCInst *MI, uint64_t Address,
                         const MCSubtargetInfo &STI, raw_ostream &O);
   static const char *getRegisterName(unsigned RegNo);
 
   void printInst(const MCInst *MI, uint64_t Address, StringRef Annot,
                  const MCSubtargetInfo &STI, raw_ostream &O) override;
   static void printRegOperand(unsigned RegNo, raw_ostream &O,
                               const MCRegisterInfo &MRI);

llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUInstPrinter.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 
 using namespace llvm;
 using namespace llvm::AMDGPU;
 
+void AMDGPUInstPrinter::printRegName(raw_ostream &OS, unsigned RegNo) const {
+  OS << getRegisterName(RegNo);
+}
+
 void AMDGPUInstPrinter::printInst(const MCInst *MI, uint64_t Address,
                                   StringRef Annot, const MCSubtargetInfo &STI,
                                   raw_ostream &OS) {
   OS.flush();
   printInstruction(MI, Address, STI, OS);
   printAnnotation(OS, Annot);
 }
 

llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCTargetDesc.cpp

static MCInstrInfo *createAMDGPUMCInstrInfo() {
   return X;
 }
 
 static MCRegisterInfo *createAMDGPUMCRegisterInfo(const Triple &TT) {
   MCRegisterInfo *X = new MCRegisterInfo();
   if (TT.getArch() == Triple::r600)
     InitR600MCRegisterInfo(X, 0);
   else
-    InitAMDGPUMCRegisterInfo(X, 0);
+    InitAMDGPUMCRegisterInfo(X, AMDGPU::PC_REG);
   return X;
 }
 
 static MCSubtargetInfo *
 createAMDGPUMCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS) {
   if (TT.getArch() == Triple::r600)
     return createR600MCSubtargetInfoImpl(TT, CPU, FS);
   return createAMDGPUMCSubtargetInfoImpl(TT, CPU, FS);

llvm/lib/Target/AMDGPU/SIRegisterInfo.td

class SIRegisterTuples<list<SubRegIndex> Indices, RegisterClass RC,
   RegisterTuples<Indices,
                  RegSeqDags<RC, last_reg, stride, size>.ret,
                  RegSeqNames<last_reg, stride, size, prefix>.ret>;
 
 //===----------------------------------------------------------------------===//
 //  Declarations that describe the SI registers
 //===----------------------------------------------------------------------===//
 class SIReg <string n, bits<16> regIdx = 0> :
-  Register<n>,
-  DwarfRegNum<[!cast<int>(HWEncoding)]> {
+  Register<n> {
   let Namespace = "AMDGPU";
 
   // This is the not yet the complete register encoding. An additional
   // bit is set for VGPRs.
   let HWEncoding = regIdx;
 }
 
 // Special Registers
 def VCC_LO : SIReg<"vcc_lo", 106>;
 def VCC_HI : SIReg<"vcc_hi", 107>;
 
 // Pseudo-registers: Used as placeholders during isel and immediately
 // replaced, never seeing the verifier.
 def PRIVATE_RSRC_REG : SIReg<"private_rsrc", 0>;
 def FP_REG : SIReg<"fp", 0>;
 def SP_REG : SIReg<"sp", 0>;
 def SCRATCH_WAVE_OFFSET_REG : SIReg<"scratch_wave_offset", 0>;
+// Pseudo-register to represent the program-counter DWARF register.
+def PC_REG : SIReg<"pc", 0>, DwarfRegNum<[16]>;
 
 // VCC for 64-bit instructions
-def VCC : RegisterWithSubRegs<"vcc", [VCC_LO, VCC_HI]>,
-          DwarfRegAlias<VCC_LO> {
+def VCC : RegisterWithSubRegs<"vcc", [VCC_LO, VCC_HI]> {
   let Namespace = "AMDGPU";
   let SubRegIndices = [sub0, sub1];
   let HWEncoding = 106;
 }
 
-def EXEC_LO : SIReg<"exec_lo", 126>;
+def EXEC_LO : SIReg<"exec_lo", 126>, DwarfRegNum<[1]>;
 def EXEC_HI : SIReg<"exec_hi", 127>;
 
-def EXEC : RegisterWithSubRegs<"exec", [EXEC_LO, EXEC_HI]>,
-           DwarfRegAlias<EXEC_LO> {
+def EXEC : RegisterWithSubRegs<"exec", [EXEC_LO, EXEC_HI]>, DwarfRegNum<[17]> {
   let Namespace = "AMDGPU";
   let SubRegIndices = [sub0, sub1];
   let HWEncoding = 126;
 }
 
 // 32-bit real registers, for MC only.
 // May be used with both 32-bit and 64-bit operands.
 def SRC_VCCZ : SIReg<"src_vccz", 251>;
def LDS_DIRECT : SIReg <"src_lds_direct", 254> {
   // encoding value in a source field, which will ultimately trigger a
   // read from m0.
   let isArtificial = 1;
 }
 
 def XNACK_MASK_LO : SIReg<"xnack_mask_lo", 104>;
 def XNACK_MASK_HI : SIReg<"xnack_mask_hi", 105>;
 
-def XNACK_MASK : RegisterWithSubRegs<"xnack_mask", [XNACK_MASK_LO, XNACK_MASK_HI]>,
-                 DwarfRegAlias<XNACK_MASK_LO> {
+def XNACK_MASK :
+    RegisterWithSubRegs<"xnack_mask", [XNACK_MASK_LO, XNACK_MASK_HI]> {
   let Namespace = "AMDGPU";
   let SubRegIndices = [sub0, sub1];
   let HWEncoding = 104;
 }
 
 // Trap handler registers
 def TBA_LO : SIReg<"tba_lo", 108>;
 def TBA_HI : SIReg<"tba_hi", 109>;
 
-def TBA : RegisterWithSubRegs<"tba", [TBA_LO, TBA_HI]>,
-          DwarfRegAlias<TBA_LO> {
+def TBA : RegisterWithSubRegs<"tba", [TBA_LO, TBA_HI]> {
   let Namespace = "AMDGPU";
   let SubRegIndices = [sub0, sub1];
   let HWEncoding = 108;
 }
 
 def TMA_LO : SIReg<"tma_lo", 110>;
 def TMA_HI : SIReg<"tma_hi", 111>;
 
-def TMA : RegisterWithSubRegs<"tma", [TMA_LO, TMA_HI]>,
-          DwarfRegAlias<TMA_LO> {
+def TMA : RegisterWithSubRegs<"tma", [TMA_LO, TMA_HI]> {
   let Namespace = "AMDGPU";
   let SubRegIndices = [sub0, sub1];
   let HWEncoding = 110;
 }
 
 foreach Index = 0-15 in {
   def TTMP#Index#_vi         : SIReg<"ttmp"#Index, !add(112, Index)>;
   def TTMP#Index#_gfx9_gfx10 : SIReg<"ttmp"#Index, !add(108, Index)>;
   def TTMP#Index             : SIReg<"ttmp"#Index, 0>;
 }
 
 multiclass FLAT_SCR_LOHI_m <string n, bits<16> ci_e, bits<16> vi_e> {
   def _ci : SIReg<n, ci_e>;
   def _vi : SIReg<n, vi_e>;
   def "" : SIReg<n, 0>;
 }
 
 class FlatReg <Register lo, Register hi, bits<16> encoding> :
-    RegisterWithSubRegs<"flat_scratch", [lo, hi]>,
-    DwarfRegAlias<lo> {
+    RegisterWithSubRegs<"flat_scratch", [lo, hi]> {
   let Namespace = "AMDGPU";
   let SubRegIndices = [sub0, sub1];
   let HWEncoding = encoding;
 }
 
 defm FLAT_SCR_LO : FLAT_SCR_LOHI_m<"flat_scratch_lo", 104, 102>; // Offset in units of 256-bytes.
 defm FLAT_SCR_HI : FLAT_SCR_LOHI_m<"flat_scratch_hi", 105, 103>; // Size is the per-thread scratch size, in bytes.
 
 def FLAT_SCR_ci : FlatReg<FLAT_SCR_LO_ci, FLAT_SCR_HI_ci, 104>;
 def FLAT_SCR_vi : FlatReg<FLAT_SCR_LO_vi, FLAT_SCR_HI_vi, 102>;
 def FLAT_SCR : FlatReg<FLAT_SCR_LO, FLAT_SCR_HI, 0>;
 
 // SGPR registers
 foreach Index = 0-105 in {
-  def SGPR#Index : SIReg <"s"#Index, Index>;
+  def SGPR#Index :
+    SIReg <"s"#Index, Index>,
+    DwarfRegNum<[!if(!le(Index, 63), !add(Index, 32), !add(Index, 1024))]>;
 }
 
 // VGPR registers
 foreach Index = 0-255 in {
-  def VGPR#Index : SIReg <"v"#Index, Index> {
+  def VGPR#Index :
+      SIReg <"v"#Index, Index>,
+      DwarfRegNum<[!add(Index, 2560)]> {
     let HWEncoding{8} = 1;
   }
 }
 
 // AccVGPR registers
 foreach Index = 0-255 in {
-  def AGPR#Index : SIReg <"a"#Index, Index> {
+  def AGPR#Index :
+      SIReg <"a"#Index, Index>,
+      DwarfRegNum<[!add(Index, 3072)]> {
     let HWEncoding{8} = 1;
   }
 }
 
 //===----------------------------------------------------------------------===//
 //  Groupings using register classes and tuples
 //===----------------------------------------------------------------------===//
 

llvm/test/CodeGen/SPARC/2013-05-17-CallFrame.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -march=sparc   < %s | FileCheck %s --check-prefix=V8
 ; RUN: llc -march=sparcv9 < %s | FileCheck %s --check-prefix=SPARC64
 
 ; (this should ideally be doing "add 4+7; and -8", instead of
 ;  "add 7; and -8; add 8"; see comments in LowerDYNAMIC_STACKALLOC)
 
 define void @variable_alloca_with_adj_call_stack(i32 %num) {
 ; V8-LABEL: variable_alloca_with_adj_call_stack:
 ; V8:         .cfi_startproc
 ; V8-NEXT:  ! %bb.0: ! %entry
 ; V8-NEXT:    save %sp, -96, %sp
 ; V8-NEXT:    .cfi_def_cfa_register %fp
 ; V8-NEXT:    .cfi_window_save
-; V8-NEXT:    .cfi_register 15, 31
+; V8-NEXT:    .cfi_register %o7, %i7
 ; V8-NEXT:    add %i0, 7, %i0
 ; V8-NEXT:    and %i0, -8, %i0
 ; V8-NEXT:    sub %sp, %i0, %i0
 ; V8-NEXT:    add %i0, -8, %sp
 ; V8-NEXT:    add %i0, 88, %o0
 ; V8-NEXT:    add %sp, -16, %sp
 ; V8-NEXT:    st %o0, [%sp+104]
 ; V8-NEXT:    st %o0, [%sp+100]

 ; V8-NEXT:    restore
 ;
 ; SPARC64-LABEL: variable_alloca_with_adj_call_stack:
 ; SPARC64:         .cfi_startproc
 ; SPARC64-NEXT:  ! %bb.0: ! %entry
 ; SPARC64-NEXT:    save %sp, -128, %sp
 ; SPARC64-NEXT:    .cfi_def_cfa_register %fp
 ; SPARC64-NEXT:    .cfi_window_save
-; SPARC64-NEXT:    .cfi_register 15, 31
+; SPARC64-NEXT:    .cfi_register %o7, %i7
 ; SPARC64-NEXT:    srl %i0, 0, %i0
 ; SPARC64-NEXT:    add %i0, 15, %i0
 ; SPARC64-NEXT:    sethi 4194303, %i1
 ; SPARC64-NEXT:    or %i1, 1008, %i1
 ; SPARC64-NEXT:    sethi 0, %i2
 ; SPARC64-NEXT:    or %i2, 1, %i2
 ; SPARC64-NEXT:    sllx %i2, 32, %i2
 ; SPARC64-NEXT:    or %i2, %i1, %i1

llvm/test/CodeGen/SPARC/exception.ll

 @.cst1 = private unnamed_addr constant [14 x i8] c"catched float\00", align 64
 
 ; V8ABS-LABEL: main:
 ; V8ABS:        .cfi_startproc
 ; V8ABS:        .cfi_personality 0, __gxx_personality_v0
 ; V8ABS:        .cfi_lsda 0,
 ; V8ABS:        .cfi_def_cfa_register {{30|%fp}}
 ; V8ABS:        .cfi_window_save
-; V8ABS:        .cfi_register 15, 31
+; V8ABS:        .cfi_register %o7, %i7
 
 ; V8ABS:        call __cxa_throw
 ; V8ABS:        call __cxa_throw
 
 ; V8ABS:        call __cxa_begin_catch
 ; V8ABS:        call __cxa_end_catch
 
 ; V8ABS:        call __cxa_begin_catch
 ; V8ABS:        call __cxa_end_catch
 
 ; V8ABS:        .cfi_endproc
 
 ; V8PIC-LABEL: main:
 ; V8PIC:        .cfi_startproc
 ; V8PIC:        .cfi_personality 155, DW.ref.__gxx_personality_v0
 ; V8PIC:        .cfi_lsda 27,
 ; V8PIC:        .cfi_def_cfa_register {{30|%fp}}
 ; V8PIC:        .cfi_window_save
-; V8PIC:        .cfi_register 15, 31
+; V8PIC:        .cfi_register %o7, %i7
 ; V8PIC:        .section .gcc_except_table
 ; V8PIC-NOT:    .section
 ; V8PIC:        .word %r_disp32(.L_ZTIi.DW.stub)
 ; V8PIC:        .data
 ; V8PIC: .L_ZTIi.DW.stub:
 ; V8PIC-NEXT:   .word _ZTIi
 
 
 ; V9ABS-LABEL: main:
 ; V9ABS:        .cfi_startproc
 ; V9ABS:        .cfi_personality 0, __gxx_personality_v0
 ; V9ABS:        .cfi_lsda 27,
 ; V9ABS:        .cfi_def_cfa_register {{30|%fp}}
 ; V9ABS:        .cfi_window_save
-; V9ABS:        .cfi_register 15, 31
+; V9ABS:        .cfi_register %o7, %i7
 ; V9ABS:        .section .gcc_except_table
 ; V9ABS-NOT:    .section
 ; V9ABS:        .xword _ZTIi
 
 ; V9PIC-LABEL: main:
 ; V9PIC:        .cfi_startproc
 ; V9PIC:        .cfi_personality 155, DW.ref.__gxx_personality_v0
 ; V9PIC:        .cfi_lsda 27,
 ; V9PIC:        .cfi_def_cfa_register {{30|%fp}}
 ; V9PIC:        .cfi_window_save
-; V9PIC:        .cfi_register 15, 31
+; V9PIC:        .cfi_register %o7, %i7
 ; V9PIC:        .section .gcc_except_table
 ; V9PIC-NOT:    .section
 ; V9PIC:        .word %r_disp32(.L_ZTIi.DW.stub)
 ; V9PIC:        .data
 ; V9PIC: .L_ZTIi.DW.stub:
 ; V9PIC-NEXT:   .xword _ZTIi
 
 define i32 @main(i32 %argc, i8** nocapture readnone %argv) unnamed_addr #0 personality i32 (i32, i64, i8*, i8*)* @__gxx_personality_v0 {

llvm/test/CodeGen/SPARC/reserved-regs.ll

 ; RUN: llc -march=sparc -verify-machineinstrs < %s | FileCheck %s
 
 @g = common global [32 x i32] zeroinitializer, align 16
 @h = common global [16 x i64] zeroinitializer, align 16
 
 ;; Ensures that we don't use registers which are supposed to be reserved.
 
 ; CHECK-LABEL: use_all_i32_regs:
 ; CHECK: save %sp
+; CHECK: .cfi_register %o7, %i7
 ; CHECK-NOT: %g0
 ; CHECK-NOT: %g1
 ; CHECK-NOT: %g5
 ; CHECK-NOT: %g6
 ; CHECK-NOT: %g7
 ; CHECK-NOT: %o6
 ; CHECK-NOT: %i6
 ; CHECK-NOT: %i7
entry:
   store volatile i32 %31, i32* getelementptr inbounds ([32 x i32], [32 x i32]* @g, i64 0, i64 30), align 8
   store volatile i32 %0, i32* getelementptr inbounds ([32 x i32], [32 x i32]* @g, i64 0, i64 31), align 4
   ret void
 }
 
 
 ; CHECK-LABEL: use_all_i64_regs:
 ; CHECK: save %sp
+; CHECK: .cfi_register %o7, %i7
 ; CHECK-NOT: %g0
 ; CHECK-NOT: %g1
 ; CHECK-NOT: %g4
 ; CHECK-NOT: %g5
 ; CHECK-NOT: %g6
 ; CHECK-NOT: %g7
 ; CHECK-NOT: %o6
 ; CHECK-NOT: %o7

llvm/test/CodeGen/SPARC/umulo-128-legalisation-lowering.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple=sparc-unknown-linux-gnu | FileCheck %s --check-prefixes=SPARC
 ; RUN: llc < %s -mtriple=sparc64-unknown-linux-gnu | FileCheck %s --check-prefixes=SPARC64
 
 define { i128, i8 } @muloti_test(i128 %l, i128 %r) unnamed_addr #0 {
 ; SPARC-LABEL: muloti_test:
 ; SPARC:         .cfi_startproc
 ; SPARC-NEXT:  ! %bb.0: ! %start
 ; SPARC-NEXT:    save %sp, -128, %sp
 ; SPARC-NEXT:    .cfi_def_cfa_register %fp
 ; SPARC-NEXT:    .cfi_window_save
-; SPARC-NEXT:    .cfi_register 15, 31
+; SPARC-NEXT:    .cfi_register %o7, %i7
 ; SPARC-NEXT:    ld [%fp+92], %l3
 ; SPARC-NEXT:    ld [%fp+96], %g2
 ; SPARC-NEXT:    umul %i2, %i5, %g3
 ; SPARC-NEXT:    rd %y, %g4
 ; SPARC-NEXT:    st %g4, [%fp+-20] ! 4-byte Folded Spill
 ; SPARC-NEXT:    umul %i4, %i3, %g4
 ; SPARC-NEXT:    rd %y, %l0
 ; SPARC-NEXT:    st %l0, [%fp+-24] ! 4-byte Folded Spill

 ;
 ; SPARC64-LABEL: muloti_test:
 ; SPARC64:         .cfi_startproc
 ; SPARC64-NEXT:    .register %g2, #scratch
 ; SPARC64-NEXT:  ! %bb.0: ! %start
 ; SPARC64-NEXT:    save %sp, -176, %sp
 ; SPARC64-NEXT:    .cfi_def_cfa_register %fp
 ; SPARC64-NEXT:    .cfi_window_save
-; SPARC64-NEXT:    .cfi_register 15, 31
+; SPARC64-NEXT:    .cfi_register %o7, %i7
 ; SPARC64-NEXT:    srax %i2, 63, %o0
 ; SPARC64-NEXT:    srax %i1, 63, %o2
 ; SPARC64-NEXT:    mov %i2, %o1
 ; SPARC64-NEXT:    call __multi3
 ; SPARC64-NEXT:    mov %i1, %o3
 ; SPARC64-NEXT:    mov %o0, %i4
 ; SPARC64-NEXT:    mov %o1, %i5
 ; SPARC64-NEXT:    srax %i0, 63, %o0

llvm/test/DebugInfo/AMDGPU/print-reg-name.s

+; RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx900 -filetype=asm %s | FileCheck %s
+
+; Check that we can print symbolic register operands in CFI instructions.
+
+.text
+f:
+.cfi_startproc
+; CHECK: .cfi_undefined s0
+.cfi_undefined s0
+.cfi_endproc

llvm/test/DebugInfo/AMDGPU/register-mapping.s

+; RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx1010 -filetype=obj %s | llvm-dwarfdump -debug-frame - | FileCheck %s
+
+; Check that we implement the DWARF register mapping.
+
+.text
+f:
+.cfi_startproc
+; CHECK: CIE
+; CHECK: Return address column: 16
+
+; CHECK: FDE
+; CHECK: DW_CFA_undefined: reg17
+.cfi_undefined exec
+
+; CHECK: DW_CFA_undefined: reg32
+.cfi_undefined s0
+; CHECK: DW_CFA_undefined: reg95
+.cfi_undefined s63
+
+; CHECK: DW_CFA_undefined: reg1088
+.cfi_undefined s64
+; CHECK: DW_CFA_undefined: reg1129
+.cfi_undefined s105
+
+; CHECK: DW_CFA_undefined: reg2560
+.cfi_undefined v0
+; CHECK: DW_CFA_undefined: reg2815
+.cfi_undefined v255
+
+; CHECK: DW_CFA_undefined: reg3072
+.cfi_undefined a0
+; CHECK: DW_CFA_undefined: reg3327
+.cfi_undefined a255
+
+.cfi_endproc

llvm/test/DebugInfo/AMDGPU/variable-locations.ll

 ; CHECK-NEXT: DW_AT_type
 ; CHECK-NEXT: DW_AT_external
 ; CHECK-NEXT: DW_AT_decl_file
 ; CHECK-NEXT: DW_AT_decl_line
 ; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (DW_OP_addr 0x0)
 @GlobB = common addrspace(1) global i32 0, align 4, !dbg !6
 
 ; CHECK: {{.*}}DW_TAG_subprogram
-; CHECK: DW_AT_frame_base [DW_FORM_block1]  (DW_OP_reg9 SGPR9)
+; CHECK: DW_AT_frame_base [DW_FORM_block1]  (DW_OP_reg{{.*}} SGPR9)
 
 define amdgpu_kernel void @kernel1(
 ; CHECK: {{.*}}DW_TAG_formal_parameter
 ; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (DW_OP_fbreg +4, DW_OP_lit1, DW_OP_swap, DW_OP_xderef)
 ; CHECK-NEXT: DW_AT_name {{.*}}"ArgN"
     i32 %ArgN,
 ; CHECK: {{.*}}DW_TAG_formal_parameter
 ; CHECK-NEXT: DW_AT_location [DW_FORM_block1] (DW_OP_fbreg +8, DW_OP_lit1, DW_OP_swap, DW_OP_xderef)

llvm/test/MC/X86/return-column.s

g:
   .type g,@function
 h:
   .cfi_startproc
   .cfi_return_column 65
   .cfi_endproc
 
 // CHECK-ASM-ROUNDTRIP-LABEL: f:
 // CHECK-ASM-ROUNDTRIP: .cfi_startproc
-// CHECK-ASM-ROUNDTRIP-NEXT: .cfi_return_column 0
+// CHECK-ASM-ROUNDTRIP-NEXT: .cfi_return_column %eax
 // CHECK-ASM-ROUNDTRIP: .cfi_endproc
 
 // CHECK-EH_FRAME: 00000000 00000014 00000000 CIE
 // CHECK-EH_FRAME:   Return address column: 0
 
 // CHECK-EH_FRAME: 0000002c 00000014 00000000 CIE
 // CHECK-EH_FRAME:   Return address column: 65
 
 // CHECK-EH_FRAME-NOT: ........ 00000014 00000000 CIE