Merge branch 'clean-2.26' into riscv-binutils-2.26

This closes with the following two pull requests:
#6
#9

Author: palmer-dabbelt

gdb/riscv-tdep.c

@@ -65,7 +65,7 @@ struct riscv_frame_cache
   struct trad_frame_saved_reg *saved_regs;
 };
 
-static const char * const riscv_gdb_reg_names[RISCV_NUM_REGS] =
+static const char * const riscv_gdb_reg_names[RISCV_LAST_FP_REGNUM + 1] =
 {
   "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7",
   "x8",  "x9",  "x10", "x11", "x12", "x13", "x14", "x15",
@@ -76,10 +76,6 @@ static const char * const riscv_gdb_reg_names[RISCV_NUM_REGS] =
   "f8",  "f9",  "f10", "f11", "f12", "f13", "f14", "f15",
   "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
   "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
-
-#define DECLARE_CSR(name, num) #name,
-#include "opcode/riscv-opc.h"
-#undef DECLARE_CSR
 };
 
 struct register_alias
@@ -156,6 +152,9 @@ static const struct register_alias riscv_register_aliases[] =
   { "ft9", 62 },
   { "ft10", 63 },
   { "ft11", 64 },
+#define DECLARE_CSR(name, num) { #name, (num) + 65 },
+#include "opcode/riscv-opc.h"
+#undef DECLARE_CSR
 };
 
 static const gdb_byte *
@@ -189,22 +188,41 @@ value_of_riscv_user_reg (struct frame_info *frame, const void *baton)
 }
 
 static const char *
-riscv_register_name (struct gdbarch *gdbarch,
-		     int             regnum)
+register_name (struct gdbarch *gdbarch,
+	       int             regnum,
+               int             prefer_alias)
 {
   int i;
+  static char buf[20];
 
   if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
     return tdesc_register_name (gdbarch, regnum);
-  else if (regnum >= 0 && regnum < RISCV_LAST_REGNUM)
+  /* Prefer to use the alias. */
+  if (prefer_alias &&
+      regnum >= RISCV_ZERO_REGNUM && regnum <= RISCV_LAST_REGNUM)
     {
       for (i = 0; i < ARRAY_SIZE (riscv_register_aliases); ++i)
 	if (regnum == riscv_register_aliases[i].regnum)
 	  return riscv_register_aliases[i].name;
+    }
+
+  if (regnum >= RISCV_ZERO_REGNUM && regnum <= RISCV_LAST_FP_REGNUM)
       return riscv_gdb_reg_names[regnum];
+
+  if (regnum >= RISCV_FIRST_CSR_REGNUM && regnum <= RISCV_LAST_CSR_REGNUM)
+    {
+      sprintf(buf, "csr%d", regnum - RISCV_FIRST_CSR_REGNUM);
+      return buf;
     }
-  else
-    return NULL;
+
+  return NULL;
+}
+
+static const char *
+riscv_register_name (struct gdbarch *gdbarch,
+		     int             regnum)
+{
+  return register_name(gdbarch, regnum, 0);
 }
 
 static void
@@ -510,12 +528,12 @@ riscv_print_register_formatted (struct ui_file *file, struct frame_info *frame,
 
       if (!deprecated_frame_register_read (frame, regnum, raw_buffer))
 	{
-	  fprintf_filtered (file, "%-15s[Invalid]",
-			    riscv_register_name (gdbarch, regnum));
+	  fprintf_filtered (file, "%-15s[Invalid]\n",
+			    register_name (gdbarch, regnum, 1));
 	  return;
 	}
 
-      fprintf_filtered (file, "%-15s", riscv_register_name (gdbarch, regnum));
+      fprintf_filtered (file, "%-15s", register_name (gdbarch, regnum, 1));
       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
 	offset = register_size (gdbarch, regnum) - register_size (gdbarch, regnum);
       else
@@ -586,41 +604,7 @@ riscv_print_register_formatted (struct ui_file *file, struct frame_info *frame,
 				  &opts, 0, file);
 	}
     }
-}
-
-static void
-riscv_print_registers_info (struct gdbarch    *gdbarch,
-			    struct ui_file    *file,
-			    struct frame_info *frame,
-			    int                regnum,
-			    int                all)
-{
-  if (regnum != -1)
-    {
-      /* Print one specified register.  */
-      gdb_assert (regnum < RISCV_LAST_REGNUM);
-      if ('\0' == *(riscv_register_name (gdbarch, regnum)))
-	error (_("Not a valid register for the current processor type"));
-      riscv_print_register_formatted (file, frame, regnum);
-      fprintf_filtered (file, "\n");
-    }
-  else
-    for (regnum = 0; regnum < RISCV_LAST_REGNUM; ++regnum)
-      {
-	if ('\0' == *(riscv_register_name (gdbarch, regnum)))
-	  error (_("Not a valid register for the current processor type"));
-
-	/* Zero never changes, so might as well hide by default.  */
-	if (regnum == RISCV_ZERO_REGNUM && !all)
-	  continue;
-
-	/* Only show the main integer register set by default.  */
-	if (all || regnum < RISCV_FIRST_FP_REGNUM)
-	  {
-	    riscv_print_register_formatted (file, frame, regnum);
-	    fprintf_filtered (file, "\n");
-	  }
-      }
+  fprintf_filtered (file, "\n");
 }
 
 static int
@@ -630,14 +614,24 @@ riscv_register_reggroup_p (struct gdbarch  *gdbarch,
 {
   int float_p;
   int raw_p;
+  unsigned int i;
+
+  /* Used by 'info registers' and 'info registers <groupname>'.  */
 
   if (gdbarch_register_name (gdbarch, regnum) == NULL
       || gdbarch_register_name (gdbarch, regnum)[0] == '\0')
     return 0;
 
-  if (reggroup == all_reggroup)
-    return 1;
-  else if (reggroup == float_reggroup)
+  if (reggroup == all_reggroup) {
+    if (regnum < RISCV_FIRST_CSR_REGNUM)
+      return 1;
+    /* Only include CSRs that have aliases.  */
+    for (i = 0; i < ARRAY_SIZE (riscv_register_aliases); ++i) {
+	if (regnum == riscv_register_aliases[i].regnum)
+          return 1;
+    }
+    return 0;
+  } else if (reggroup == float_reggroup)
     return (regnum >= RISCV_FIRST_FP_REGNUM && regnum <= RISCV_LAST_FP_REGNUM)
 	    || (regnum == RISCV_CSR_FCSR_REGNUM
 	        || regnum == RISCV_CSR_FFLAGS_REGNUM
@@ -646,14 +640,55 @@ riscv_register_reggroup_p (struct gdbarch  *gdbarch,
     return regnum < RISCV_FIRST_FP_REGNUM;
   else if (reggroup == restore_reggroup || reggroup == save_reggroup)
     return regnum <= RISCV_LAST_FP_REGNUM;
-  else if (reggroup == system_reggroup)
-    return regnum >= RISCV_FIRST_CSR_REGNUM && regnum <= RISCV_LAST_CSR_REGNUM;
-  else if (reggroup == vector_reggroup)
+  else if (reggroup == system_reggroup) {
+    /* Only include CSRs that have aliases.  */
+    if (regnum < RISCV_FIRST_CSR_REGNUM || regnum > RISCV_LAST_CSR_REGNUM)
+      return 0;
+    for (i = 0; i < ARRAY_SIZE (riscv_register_aliases); ++i) {
+	if (regnum == riscv_register_aliases[i].regnum)
+          return 1;
+    }
+    return 0;
+  } else if (reggroup == vector_reggroup)
     return 0;
   else
     internal_error (__FILE__, __LINE__, _("unhandled reggroup"));
 }
 
+static void
+riscv_print_registers_info (struct gdbarch    *gdbarch,
+			    struct ui_file    *file,
+			    struct frame_info *frame,
+			    int                regnum,
+			    int                all)
+{
+  /* Use by 'info all-registers'.  */
+  struct reggroup *reggroup;
+
+  if (regnum != -1)
+    {
+      /* Print one specified register.  */
+      gdb_assert (regnum < RISCV_LAST_REGNUM);
+      if (NULL == register_name (gdbarch, regnum, 1))
+        error (_("Not a valid register for the current processor type"));
+      riscv_print_register_formatted (file, frame, regnum);
+      return;
+    }
+
+  if (all)
+    reggroup = all_reggroup;
+  else
+    reggroup = general_reggroup;
+  for (regnum = 0; regnum <= RISCV_LAST_REGNUM; ++regnum)
+    {
+      /* Zero never changes, so might as well hide by default.  */
+      if (regnum == RISCV_ZERO_REGNUM && !all)
+        continue;
+      if (riscv_register_reggroup_p(gdbarch, regnum, reggroup))
+        riscv_print_register_formatted (file, frame, regnum);
+    }
+}
+
 static ULONGEST
 riscv_fetch_instruction (struct gdbarch *gdbarch, CORE_ADDR addr)
 {
@@ -718,7 +753,7 @@ riscv_scan_prologue (struct gdbarch *gdbarch,
   int seen_sp_adjust = 0;
   int load_immediate_bytes = 0;
 
-  /* Can be called when there's no process, and hence when there's no THIS_FRAME. */
+  /* Can be called when there's no process, and hence when there's no THIS_FRAME.  */
   if (this_frame != NULL)
     sp = get_frame_register_signed (this_frame, RISCV_SP_REGNUM);
   else
@@ -1115,7 +1150,7 @@ riscv_gdbarch_init (struct gdbarch_info  info,
   set_gdbarch_sp_regnum (gdbarch, RISCV_SP_REGNUM);
   set_gdbarch_pc_regnum (gdbarch, RISCV_PC_REGNUM);
   set_gdbarch_ps_regnum (gdbarch, RISCV_FP_REGNUM);
-  set_gdbarch_deprecated_fp_regnum (gdbarch, RISCV_FIRST_FP_REGNUM);
+  set_gdbarch_deprecated_fp_regnum (gdbarch, RISCV_FP_REGNUM);
 
   /* Functions to supply register information.  */
   set_gdbarch_register_name (gdbarch, riscv_register_name);
@@ -1157,8 +1192,15 @@ riscv_gdbarch_init (struct gdbarch_info  info,
       tdesc_data = tdesc_data_alloc ();
 
       valid_p = 1;
-      for (i = RISCV_ZERO_REGNUM; i < RISCV_LAST_REGNUM; ++i)
-	valid_p &= tdesc_numbered_register (feature, tdesc_data, i, riscv_gdb_reg_names[i]);
+      for (i = RISCV_ZERO_REGNUM; i <= RISCV_LAST_FP_REGNUM; ++i)
+        valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
+                                            riscv_gdb_reg_names[i]);
+      for (i = RISCV_FIRST_CSR_REGNUM; i <= RISCV_LAST_CSR_REGNUM; ++i)
+        {
+          char buf[20];
+          sprintf (buf, "csr%d", i - RISCV_FIRST_CSR_REGNUM);
+          valid_p &= tdesc_numbered_register (feature, tdesc_data, i, buf);
+        }
 
       if (!valid_p)
 	tdesc_data_cleanup (tdesc_data);

gdb/riscv-tdep.h

@@ -71,17 +71,17 @@ enum {
   RISCV_FA1_REGNUM = 50,
   RISCV_LAST_FP_REGNUM = 64,	/* Last Floating Point Register */
 
-#define RISCV_FIRST_CSR_REGNUM RISCV_LAST_FP_REGNUM + 1
-#define DECLARE_CSR(name, num) RISCV_ ## num ## _REGNUM,
+  RISCV_FIRST_CSR_REGNUM = 65,  /* First CSR */
+#define DECLARE_CSR(name, num) RISCV_ ## num ## _REGNUM = RISCV_LAST_FP_REGNUM + 1 + num,
 #include "opcode/riscv-opc.h"
 #undef DECLARE_CSR
-#define RISCV_LAST_CSR_REGNUM RISCV_LAST_REGNUM - 1
+  RISCV_LAST_CSR_REGNUM = 4160,
 
   /* Leave this as the last enum.  */
-  RISCV_LAST_REGNUM
+  RISCV_NUM_REGS
 };
 
-#define RISCV_NUM_REGS (RISCV_LAST_REGNUM)
+#define RISCV_LAST_REGNUM (RISCV_NUM_REGS - 1)
 
 /* RISC-V specific per-architecture information.  */
 struct gdbarch_tdep