self.ack_o  = Signal()    # DMI ack request
 
 
+class DbgReg(RecordObject):
+    def __init__(self, name):
+        super().__init__(name=name)
+        self.req_o     = Signal()
+        self.ack_i     = Signal()
+        self.addr_o    = Signal(7) #  includes fast SPRs, others?
+        self.data_i    = Signal(64)
+
+
 class CoreDebug(Elaboratable):
     def __init__(self, LOG_LENGTH=0): # TODO - debug log 512):
         # Length of log buffer
         self.msr            = Signal(64)
 
         # GSPR register read port
-        self.dbg_gpr_req_o     = Signal()
-        self.dbg_gpr_ack_i     = Signal()
-        self.dbg_gpr_addr_o    = Signal(7) #  includes fast SPRs, others?
-        self.dbg_gpr_data_i    = Signal(64)
+        self.dbg_gpr = DbgReg("dbg_gpr")
 
         # Core logging data
         self.log_data_i        = Signal(256)
         do_icreset   = Signal()
         terminated   = Signal()
         do_gspr_rd   = Signal()
-        gspr_index   = Signal.like(self.dbg_gpr_addr_o)
+        gspr_index   = Signal.like(self.dbg_gpr.addr_o)
 
         log_dmi_addr = Signal(32)
         log_dmi_data = Signal(64)
 
         # Single cycle register accesses on DMI except for GSPR data
         comb += self.dmi.ack_o.eq(Mux(self.dmi.addr_i == DBGCore.GSPR_DATA,
-                                      self.dbg_gpr_ack_i, self.dmi.req_i))
-        comb += self.dbg_gpr_req_o.eq(Mux(self.dmi.addr_i == DBGCore.GSPR_DATA,
+                                      self.dbg_gpr.ack_i, self.dmi.req_i))
+        comb += self.dbg_gpr.req_o.eq(Mux(self.dmi.addr_i == DBGCore.GSPR_DATA,
                                       self.dmi.req_i, 0))
 
         # Status register read composition (DBUG_CORE_STAT_xxx)
             with m.Case( DBGCore.MSR):
                 comb += self.dmi.dout.eq(self.msr)
             with m.Case( DBGCore.GSPR_DATA):
-                comb += self.dmi.dout.eq(self.dbg_gpr_data_i)
+                comb += self.dmi.dout.eq(self.dbg_gpr.data_i)
             with m.Case( DBGCore.LOG_ADDR):
                 comb += self.dmi.dout.eq(Cat(log_dmi_addr,
                                              self.log_write_addr_o))
             sync += stopping.eq(1)
             sync += terminated.eq(1)
 
-        comb += self.dbg_gpr_addr_o.eq(gspr_index)
+        comb += self.dbg_gpr.addr_o.eq(gspr_index)
 
         # Core control signals generated by the debug module
         comb += self.core_stop_o.eq(stopping & ~do_step)
         yield self.core_stopped_i
         yield self.nia
         yield self.msr
-        yield self.dbg_gpr_req_o
-        yield self.dbg_gpr_ack_i
-        yield self.dbg_gpr_addr_o
-        yield self.dbg_gpr_data_i
+        yield from self.dbg_gpr
         yield self.log_data_i
         yield self.log_read_addr_i
         yield self.log_read_data_o