Support for target descriptions layered on top of sparc32/sparc64

which describe more registers than native ones.

Pseudo registers always come after the real registers.

One more step forward to modernize sparc tdep's.

Submitted to upstream as:

https://sourceware.org/bugzilla/show_bug.cgi?id=20936

--- gdb-7.11/gdb/sparc64-tdep.c.orig	2016-11-13 22:23:36.747445049 -0800

+++ gdb-7.11/gdb/sparc64-tdep.c	2016-11-13 22:23:47.678340579 -0800

@@ -31,6 +31,7 @@

 #include "objfiles.h"

 #include "osabi.h"

 #include "regcache.h"

+#include "target-descriptions.h"

 #include "target.h"

 #include "value.h"

@@ -251,28 +252,29 @@

 /* Register information.  */

+#define SPARC64_FPU_REGISTERS                             \

+  "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",         \

+  "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",   \

+  "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", \

+  "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", \

+  "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46", \

+  "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62"

+#define SPARC64_CP0_REGISTERS                                             \

+  "pc", "npc",                                                            \

+  /* FIXME: Give "state" a name until we start using register groups.  */ \

+  "state",                                                                \

+  "fsr",                                                                  \

+  "fprs",                                                                 \

+  "y"

+static const char *sparc64_fpu_register_names[] = { SPARC64_FPU_REGISTERS };

+static const char *sparc64_cp0_register_names[] = { SPARC64_CP0_REGISTERS };

+

 static const char *sparc64_register_names[] =

 {

-  "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",

-  "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",

-  "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",

-  "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",

-

-  "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",

-  "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",

-  "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",

-  "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",

-  "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46",

-  "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62",

-

-  "pc", "npc",

-  

-  /* FIXME: Give "state" a name until we start using register groups.  */

-  "state",

-  "fsr",

-  "fprs",

-  "y",

+  SPARC_CORE_REGISTERS,

+  SPARC64_FPU_REGISTERS,

+  SPARC64_CP0_REGISTERS

 };

 /* Total number of registers.  */

@@ -298,7 +300,19 @@

 #define SPARC64_NUM_PSEUDO_REGS ARRAY_SIZE (sparc64_pseudo_register_names)

 /* Return the name of register REGNUM.  */

+static const char *

+sparc64_pseudo_register_name (struct gdbarch *gdbarch, int regnum)

+{

+  regnum -= gdbarch_num_regs (gdbarch);

+  if (regnum < SPARC64_NUM_PSEUDO_REGS)

+    return sparc64_pseudo_register_names[regnum];

+

+  internal_error (__FILE__, __LINE__,

+                  _("sparc64_pseudo_register_name: bad register number %d"),

+                  regnum);

+}

+

 static const char *

 sparc64_register_name (struct gdbarch *gdbarch, int regnum)

 {

@@ -305,9 +319,8 @@

   if (regnum >= 0 && regnum < SPARC64_NUM_REGS)

     return sparc64_register_names[regnum];

-  if (regnum >= SPARC64_NUM_REGS

-      && regnum < SPARC64_NUM_REGS + SPARC64_NUM_PSEUDO_REGS)

-    return sparc64_pseudo_register_names[regnum - SPARC64_NUM_REGS];

+  if (regnum >= gdbarch_num_regs (gdbarch))

+    return sparc64_pseudo_register_name (gdbarch, regnum);

   return NULL;

 }

@@ -314,7 +327,29 @@

 /* Return the GDB type object for the "standard" data type of data in

    register REGNUM.  */

+static struct type *

+sparc64_pseudo_register_type (struct gdbarch *gdbarch, int regnum)

+{

+  regnum -= gdbarch_num_regs (gdbarch);

+  if (regnum == SPARC64_CWP_REGNUM)

+    return builtin_type (gdbarch)->builtin_int64;

+  if (regnum == SPARC64_PSTATE_REGNUM)

+    return sparc64_pstate_type (gdbarch);

+  if (regnum == SPARC64_ASI_REGNUM)

+    return builtin_type (gdbarch)->builtin_int64;

+  if (regnum == SPARC64_CCR_REGNUM)

+    return sparc64_ccr_type (gdbarch);

+  if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D62_REGNUM)

+    return builtin_type (gdbarch)->builtin_double;

+  if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q60_REGNUM)

+    return builtin_type (gdbarch)->builtin_long_double;

+

+  internal_error (__FILE__, __LINE__,

+                  _("sparc64_pseudo_register_type: bad register number %d"),

+                  regnum);

+}

+

 static struct type *

 sparc64_register_type (struct gdbarch *gdbarch, int regnum)

 {

@@ -344,20 +379,9 @@

     return builtin_type (gdbarch)->builtin_int64;

   /* Pseudo registers.  */

+  if (regnum >= gdbarch_num_regs (gdbarch))

+    return sparc64_pseudo_register_type (gdbarch, regnum);

-  if (regnum == SPARC64_CWP_REGNUM)

-    return builtin_type (gdbarch)->builtin_int64;

-  if (regnum == SPARC64_PSTATE_REGNUM)

-    return sparc64_pstate_type (gdbarch);

-  if (regnum == SPARC64_ASI_REGNUM)

-    return builtin_type (gdbarch)->builtin_int64;

-  if (regnum == SPARC64_CCR_REGNUM)

-    return sparc64_ccr_type (gdbarch);

-  if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D62_REGNUM)

-    return builtin_type (gdbarch)->builtin_double;

-  if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q60_REGNUM)

-    return builtin_type (gdbarch)->builtin_long_double;

-

   internal_error (__FILE__, __LINE__, _("invalid regnum"));

 }

@@ -369,7 +393,7 @@

   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   enum register_status status;

-  gdb_assert (regnum >= SPARC64_NUM_REGS);

+  regnum -= gdbarch_num_regs (gdbarch);

   if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM)

     {

@@ -446,8 +470,9 @@

 			       int regnum, const gdb_byte *buf)

 {

   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

-  gdb_assert (regnum >= SPARC64_NUM_REGS);

+  regnum -= gdbarch_num_regs (gdbarch);

+

   if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM)

     {

       regnum = SPARC_F0_REGNUM + 2 * (regnum - SPARC64_D0_REGNUM);

@@ -663,6 +688,7 @@

 sparc64_store_floating_fields (struct regcache *regcache, struct type *type,

 			       const gdb_byte *valbuf, int element, int bitpos)

 {

+  struct gdbarch *gdbarch = get_regcache_arch (regcache);

   int len = TYPE_LENGTH (type);

   gdb_assert (element < 16);

@@ -677,7 +703,7 @@

 	  gdb_assert (bitpos == 0);

 	  gdb_assert ((element % 2) == 0);

-	  regnum = SPARC64_Q0_REGNUM + element / 2;

+	  regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM + element / 2;

 	  regcache_cooked_write (regcache, regnum, valbuf);

 	}

       else if (len == 8)

@@ -684,7 +710,8 @@

 	{

 	  gdb_assert (bitpos == 0 || bitpos == 64);

-	  regnum = SPARC64_D0_REGNUM + element + bitpos / 64;

+	  regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM

+                   + element + bitpos / 64;

 	  regcache_cooked_write (regcache, regnum, valbuf + (bitpos / 8));

 	}

       else

@@ -737,6 +764,8 @@

 sparc64_extract_floating_fields (struct regcache *regcache, struct type *type,

 				 gdb_byte *valbuf, int bitpos)

 {

+  struct gdbarch *gdbarch = get_regcache_arch (regcache);

+

   if (sparc64_floating_p (type))

     {

       int len = TYPE_LENGTH (type);

@@ -746,7 +775,8 @@

 	{

 	  gdb_assert (bitpos == 0 || bitpos == 128);

-	  regnum = SPARC64_Q0_REGNUM + bitpos / 128;

+	  regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM

+                   + bitpos / 128;

 	  regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8));

 	}

       else if (len == 8)

@@ -753,7 +783,7 @@

 	{

 	  gdb_assert (bitpos % 64 == 0 && bitpos >= 0 && bitpos < 256);

-	  regnum = SPARC64_D0_REGNUM + bitpos / 64;

+	  regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + bitpos / 64;

 	  regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8));

 	}

       else

@@ -936,13 +966,13 @@

 	  /* Float Complex or double Complex arguments.  */

 	  if (element < 16)

 	    {

-	      regnum = SPARC64_D0_REGNUM + element;

+	      regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + element;

 	      if (len == 16)

 		{

-		  if (regnum < SPARC64_D30_REGNUM)

+		  if (regnum < gdbarch_num_regs (gdbarch) + SPARC64_D30_REGNUM)

 		    regcache_cooked_write (regcache, regnum + 1, valbuf + 8);

-		  if (regnum < SPARC64_D10_REGNUM)

+		  if (regnum < gdbarch_num_regs (gdbarch) + SPARC64_D10_REGNUM)

 		    regcache_cooked_write (regcache,

 					   SPARC_O0_REGNUM + element + 1,

 					   valbuf + 8);

@@ -957,12 +987,14 @@

 	      if (element % 2)

 		element++;

 	      if (element < 16)

-		regnum = SPARC64_Q0_REGNUM + element / 2;

+		regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM

+                         + element / 2;

 	    }

 	  else if (len == 8)

 	    {

 	      if (element < 16)

-		regnum = SPARC64_D0_REGNUM + element;

+		regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM

+                         + element;

 	    }

 	  else if (len == 4)

 	    {

@@ -977,7 +1009,8 @@

 	      valbuf = buf;

 	      len = 8;

 	      if (element < 16)

-		regnum = SPARC64_D0_REGNUM + element;

+		regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM

+                         + element;

 	    }

 	}

       else

@@ -994,19 +1027,24 @@

 	  /* If we're storing the value in a floating-point register,

              also store it in the corresponding %0 register(s).  */

-	  if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D10_REGNUM)

-	    {

-	      gdb_assert (element < 6);

-	      regnum = SPARC_O0_REGNUM + element;

-	      regcache_cooked_write (regcache, regnum, valbuf);

-	    }

-	  else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q8_REGNUM)

-	    {

-	      gdb_assert (element < 5);

-	      regnum = SPARC_O0_REGNUM + element;

-	      regcache_cooked_write (regcache, regnum, valbuf);

-	      regcache_cooked_write (regcache, regnum + 1, valbuf + 8);

-	    }

+	  if (regnum >= gdbarch_num_regs (gdbarch))

+            {

+              regnum -= gdbarch_num_regs (gdbarch);

+

+              if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D10_REGNUM)

+	        {

+	          gdb_assert (element < 6);

+	          regnum = SPARC_O0_REGNUM + element;

+	          regcache_cooked_write (regcache, regnum, valbuf);

+                }

+              else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q8_REGNUM)

+                {

+                  gdb_assert (element < 5);

+                  regnum = SPARC_O0_REGNUM + element;

+                  regcache_cooked_write (regcache, regnum, valbuf);

+                  regcache_cooked_write (regcache, regnum + 1, valbuf + 8);

+	        }

+            }

 	}

       /* Always store the argument in memory.  */

@@ -1210,6 +1248,10 @@

   tdep->pc_regnum = SPARC64_PC_REGNUM;

   tdep->npc_regnum = SPARC64_NPC_REGNUM;

+  tdep->fpu_register_names = sparc64_fpu_register_names;

+  tdep->fpu_registers_num = ARRAY_SIZE (sparc64_fpu_register_names);

+  tdep->cp0_register_names = sparc64_cp0_register_names;

+  tdep->cp0_registers_num = ARRAY_SIZE (sparc64_cp0_register_names);

   /* This is what all the fuss is about.  */

   set_gdbarch_long_bit (gdbarch, 64);

@@ -1220,6 +1262,8 @@

   set_gdbarch_register_name (gdbarch, sparc64_register_name);

   set_gdbarch_register_type (gdbarch, sparc64_register_type);

   set_gdbarch_num_pseudo_regs (gdbarch, SPARC64_NUM_PSEUDO_REGS);

+  set_tdesc_pseudo_register_name (gdbarch, sparc64_pseudo_register_name);

+  set_tdesc_pseudo_register_type (gdbarch, sparc64_pseudo_register_type);

   set_gdbarch_pseudo_register_read (gdbarch, sparc64_pseudo_register_read);

   set_gdbarch_pseudo_register_write (gdbarch, sparc64_pseudo_register_write);