[2/10] Remove &builtin_type_ from tdep code (amd64/s390/sparc64)

[2/10] Remove &builtin_type_ from tdep code (amd64/s390/sparc64)

[Ulrich Weigand]

Hello,

a number of platforms (amd64, s390, sparc64) were using a global data
structure containing pointers to types describing the register types.
This is broken if those types need to be platform-specific.

The following patch removes those global data structures, and converts
the affected architectures to simply return the types dynamically from
the register_type callback, as all other platforms do as well.

Tested on s390-ibm-linux and s390x-ibm-linux.

I'd appreciate testers of the amd64 and sparc64 parts of this patch!

Bye,
Ulrich


ChangeLog:

	* amd64-tdep.c (struct amd64_register_info): Remove.
	(amd64_register_info): Remove.
	(amd64_register_names): New static variable.
	(AMD64_NUM_REGS): Use amd64_register_names instead of
	amd64_register_info.
	(amd64_register_name): Likewise.
	(amd64_register_type): Do not refer to amd64_register_info.

	* s390-tdep.c (struct s390_register_info): Remove.
	(s390_register_info): Remove.
	(s390_register_name): Do not refer to s390_register_info.
	(s390_register_type): Likewise.

	* sparc64-tdep.c (struct sparc64_register_info): Remove.
	(sparc64_register_info, sparc64_pseudo_register_info): Remove.
	(sparc64_register_names, sparc64_pseudo_register_names): New.
	(SPARC64_NUM_REGS, SPARC64_NUM_PSEUDO_REGS): Use
	sparc64_register_names and sparc64_pseudo_register_names instead of
	sparc64_register_info and sparc64_pseudo_register_info.
	(sparc64_register_name): Likewise.
	(sparc64_register_type): Do not refer to sparc64_register_info
	and sparc64_pseudo_register_info.


diff -urNp gdb-orig/gdb/amd64-tdep.c gdb-head/gdb/amd64-tdep.c
--- gdb-orig/gdb/amd64-tdep.c	2007-06-08 22:17:44.631156737 +0200
+++ gdb-head/gdb/amd64-tdep.c	2007-06-08 22:18:17.267377769 +0200
@@ -51,81 +51,26 @@
 
 /* Register information.  */
 
-struct amd64_register_info
+static const char *amd64_register_names[] = 
 {
-  char *name;
-  struct type **type;
-};
-
-static struct amd64_register_info const amd64_register_info[] =
-{
-  { "rax", &builtin_type_int64 },
-  { "rbx", &builtin_type_int64 },
-  { "rcx", &builtin_type_int64 },
-  { "rdx", &builtin_type_int64 },
-  { "rsi", &builtin_type_int64 },
-  { "rdi", &builtin_type_int64 },
-  { "rbp", &builtin_type_void_data_ptr },
-  { "rsp", &builtin_type_void_data_ptr },
+  "rax", "rbx", "rcx", "rdx", "rsi", "rdi", "rbp", "rsp",
 
   /* %r8 is indeed register number 8.  */
-  { "r8", &builtin_type_int64 },
-  { "r9", &builtin_type_int64 },
-  { "r10", &builtin_type_int64 },
-  { "r11", &builtin_type_int64 },
-  { "r12", &builtin_type_int64 },
-  { "r13", &builtin_type_int64 },
-  { "r14", &builtin_type_int64 },
-  { "r15", &builtin_type_int64 },
-  { "rip", &builtin_type_void_func_ptr },
-  { "eflags", &i386_eflags_type },
-  { "cs", &builtin_type_int32 },
-  { "ss", &builtin_type_int32 },
-  { "ds", &builtin_type_int32 },
-  { "es", &builtin_type_int32 },
-  { "fs", &builtin_type_int32 },
-  { "gs", &builtin_type_int32 },
+  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
+  "rip", "eflags", "cs", "ss", "ds", "es", "fs", "gs",
 
   /* %st0 is register number 24.  */
-  { "st0", &builtin_type_i387_ext },
-  { "st1", &builtin_type_i387_ext },
-  { "st2", &builtin_type_i387_ext },
-  { "st3", &builtin_type_i387_ext },
-  { "st4", &builtin_type_i387_ext },
-  { "st5", &builtin_type_i387_ext },
-  { "st6", &builtin_type_i387_ext },
-  { "st7", &builtin_type_i387_ext },
-  { "fctrl", &builtin_type_int32 },
-  { "fstat", &builtin_type_int32 },
-  { "ftag", &builtin_type_int32 },
-  { "fiseg", &builtin_type_int32 },
-  { "fioff", &builtin_type_int32 },
-  { "foseg", &builtin_type_int32 },
-  { "fooff", &builtin_type_int32 },
-  { "fop", &builtin_type_int32 },
+  "st0", "st1", "st2", "st3", "st4", "st5", "st6", "st7",
+  "fctrl", "fstat", "ftag", "fiseg", "fioff", "foseg", "fooff", "fop",
 
   /* %xmm0 is register number 40.  */
-  { "xmm0", &i386_sse_type },
-  { "xmm1", &i386_sse_type },
-  { "xmm2", &i386_sse_type },
-  { "xmm3", &i386_sse_type },
-  { "xmm4", &i386_sse_type },
-  { "xmm5", &i386_sse_type },
-  { "xmm6", &i386_sse_type },
-  { "xmm7", &i386_sse_type },
-  { "xmm8", &i386_sse_type },
-  { "xmm9", &i386_sse_type },
-  { "xmm10", &i386_sse_type },
-  { "xmm11", &i386_sse_type },
-  { "xmm12", &i386_sse_type },
-  { "xmm13", &i386_sse_type },
-  { "xmm14", &i386_sse_type },
-  { "xmm15", &i386_sse_type },
-  { "mxcsr", &i386_mxcsr_type }
+  "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
+  "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
+  "mxcsr",
 };
 
 /* Total number of registers.  */
-#define AMD64_NUM_REGS	ARRAY_SIZE (amd64_register_info)
+#define AMD64_NUM_REGS	ARRAY_SIZE (amd64_register_names)
 
 /* Return the name of register REGNUM.  */
 
@@ -133,7 +78,7 @@ const char *
 amd64_register_name (int regnum)
 {
   if (regnum >= 0 && regnum < AMD64_NUM_REGS)
-    return amd64_register_info[regnum].name;
+    return amd64_register_names[regnum];
 
   return NULL;
 }
@@ -144,9 +89,28 @@ amd64_register_name (int regnum)
 struct type *
 amd64_register_type (struct gdbarch *gdbarch, int regnum)
 {
-  gdb_assert (regnum >= 0 && regnum < AMD64_NUM_REGS);
+  if (regnum >= AMD64_RAX_REGNUM && regnum <= AMD64_RDI_REGNUM)
+    return builtin_type_int64;
+  if (regnum == AMD64_RBP_REGNUM || regnum == AMD64_RSP_REGNUM)
+    return builtin_type_void_data_ptr;
+  if (regnum >= AMD64_R8_REGNUM && regnum <= AMD64_R15_REGNUM)
+    return builtin_type_int64;
+  if (regnum == AMD64_RIP_REGNUM)
+    return builtin_type_void_func_ptr;
+  if (regnum == AMD64_EFLAGS_REGNUM)
+    return i386_eflags_type;
+  if (regnum >= AMD64_CS_REGNUM && regnum <= AMD64_GS_REGNUM)
+    return builtin_type_int32;
+  if (regnum >= AMD64_ST0_REGNUM && regnum <= AMD64_ST0_REGNUM + 7)
+    return builtin_type_i387_ext;
+  if (regnum >= AMD64_FCTRL_REGNUM && regnum <= AMD64_FCRTL_REGNUM + 7)
+    return builtin_type_int32;
+  if (regnum >= AMD64_XMM0_REGNUM && regnum <= AMD64_XMM0_REGNUM + 15)
+    return i386_sse_type;
+  if (regnum == AMD64_MXCSR_REGNUM)
+    return i386_mxcsr_type;
 
-  return *amd64_register_info[regnum].type;
+  internal_error (__FILE__, __LINE__, _("invalid regnum"));
 }
 
 /* DWARF Register Number Mapping as defined in the System V psABI,
diff -urNp gdb-orig/gdb/s390-tdep.c gdb-head/gdb/s390-tdep.c
--- gdb-orig/gdb/s390-tdep.c	2007-06-08 22:17:44.877121321 +0200
+++ gdb-head/gdb/s390-tdep.c	2007-06-08 22:18:51.043701627 +0200
@@ -65,97 +65,54 @@ struct gdbarch_tdep
 };
 
 
-/* Register information.  */
-
-struct s390_register_info
-{
-  char *name;
-  struct type **type;
-};
-
-static struct s390_register_info s390_register_info[S390_NUM_TOTAL_REGS] = 
-{
-  /* Program Status Word.  */
-  { "pswm", &builtin_type_long },
-  { "pswa", &builtin_type_long },
-
-  /* General Purpose Registers.  */
-  { "r0", &builtin_type_long },
-  { "r1", &builtin_type_long },
-  { "r2", &builtin_type_long },
-  { "r3", &builtin_type_long },
-  { "r4", &builtin_type_long },
-  { "r5", &builtin_type_long },
-  { "r6", &builtin_type_long },
-  { "r7", &builtin_type_long },
-  { "r8", &builtin_type_long },
-  { "r9", &builtin_type_long },
-  { "r10", &builtin_type_long },
-  { "r11", &builtin_type_long },
-  { "r12", &builtin_type_long },
-  { "r13", &builtin_type_long },
-  { "r14", &builtin_type_long },
-  { "r15", &builtin_type_long },
-
-  /* Access Registers.  */
-  { "acr0", &builtin_type_int },
-  { "acr1", &builtin_type_int },
-  { "acr2", &builtin_type_int },
-  { "acr3", &builtin_type_int },
-  { "acr4", &builtin_type_int },
-  { "acr5", &builtin_type_int },
-  { "acr6", &builtin_type_int },
-  { "acr7", &builtin_type_int },
-  { "acr8", &builtin_type_int },
-  { "acr9", &builtin_type_int },
-  { "acr10", &builtin_type_int },
-  { "acr11", &builtin_type_int },
-  { "acr12", &builtin_type_int },
-  { "acr13", &builtin_type_int },
-  { "acr14", &builtin_type_int },
-  { "acr15", &builtin_type_int },
-
-  /* Floating Point Control Word.  */
-  { "fpc", &builtin_type_int },
-
-  /* Floating Point Registers.  */
-  { "f0", &builtin_type_double },
-  { "f1", &builtin_type_double },
-  { "f2", &builtin_type_double },
-  { "f3", &builtin_type_double },
-  { "f4", &builtin_type_double },
-  { "f5", &builtin_type_double },
-  { "f6", &builtin_type_double },
-  { "f7", &builtin_type_double },
-  { "f8", &builtin_type_double },
-  { "f9", &builtin_type_double },
-  { "f10", &builtin_type_double },
-  { "f11", &builtin_type_double },
-  { "f12", &builtin_type_double },
-  { "f13", &builtin_type_double },
-  { "f14", &builtin_type_double },
-  { "f15", &builtin_type_double },
-
-  /* Pseudo registers.  */
-  { "pc", &builtin_type_void_func_ptr },
-  { "cc", &builtin_type_int },
-};
-
 /* Return the name of register REGNUM.  */
 static const char *
 s390_register_name (int regnum)
 {
+  static const char *register_names[S390_NUM_TOTAL_REGS] =
+    {
+      /* Program Status Word.  */
+      "pswm", "pswa",
+      /* General Purpose Registers.  */
+      "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
+      "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
+      /* Access Registers.  */
+      "acr0", "acr1", "acr2", "acr3", "acr4", "acr5", "acr6", "acr7",
+      "acr8", "acr9", "acr10", "acr11", "acr12", "acr13", "acr14", "acr15",
+      /* Floating Point Control Word.  */
+      "fpc",
+      /* Floating Point Registers.  */
+      "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
+      "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
+      /* Pseudo registers.  */
+      "pc", "cc",
+    };
+
   gdb_assert (regnum >= 0 && regnum < S390_NUM_TOTAL_REGS);
-  return s390_register_info[regnum].name;
+  return register_names[regnum];
 }
 
 /* Return the GDB type object for the "standard" data type of data in
-   register REGNUM. */
+   register REGNUM.  */
 static struct type *
 s390_register_type (struct gdbarch *gdbarch, int regnum)
 {
-  gdb_assert (regnum >= 0 && regnum < S390_NUM_TOTAL_REGS);
-  return *s390_register_info[regnum].type;
+  if (regnum == S390_PSWM_REGNUM || regnum == S390_PSWA_REGNUM)
+    return builtin_type_long;
+  if (regnum >= S390_R0_REGNUM && regnum <= S390_R15_REGNUM)
+    return builtin_type_long;
+  if (regnum >= S390_A0_REGNUM && regnum <= S390_A15_REGNUM)
+    return builtin_type_int;
+  if (regnum == S390_FPC_REGNUM)
+    return builtin_type_int;
+  if (regnum >= S390_F0_REGNUM && regnum <= S390_F15_REGNUM)
+    return builtin_type_double;
+  if (regnum == S390_PC_REGNUM)
+    return builtin_type_void_func_ptr;
+  if (regnum == S390_CC_REGNUM)
+    return builtin_type_int;
+
+  internal_error (__FILE__, __LINE__, _("invalid regnum"));
 }
 
 /* DWARF Register Mapping.  */
diff -urNp gdb-orig/gdb/sparc64-tdep.c gdb-head/gdb/sparc64-tdep.c
--- gdb-orig/gdb/sparc64-tdep.c	2007-06-08 22:17:44.886120026 +0200
+++ gdb-head/gdb/sparc64-tdep.c	2007-06-08 22:18:17.287374889 +0200
@@ -179,181 +179,50 @@ sparc64_init_types (void)
 
 /* Register information.  */
 
-struct sparc64_register_info
+static const char *sparc64_register_names[] =
 {
-  char *name;
-  struct type **type;
-};
-
-static struct sparc64_register_info sparc64_register_info[] =
-{
-  { "g0", &builtin_type_int64 },
-  { "g1", &builtin_type_int64 },
-  { "g2", &builtin_type_int64 },
-  { "g3", &builtin_type_int64 },
-  { "g4", &builtin_type_int64 },
-  { "g5", &builtin_type_int64 },
-  { "g6", &builtin_type_int64 },
-  { "g7", &builtin_type_int64 },
-
-  { "o0", &builtin_type_int64 },
-  { "o1", &builtin_type_int64 },
-  { "o2", &builtin_type_int64 },
-  { "o3", &builtin_type_int64 },
-  { "o4", &builtin_type_int64 },
-  { "o5", &builtin_type_int64 },
-  { "sp", &builtin_type_void_data_ptr },
-  { "o7", &builtin_type_int64 },
-
-  { "l0", &builtin_type_int64 },
-  { "l1", &builtin_type_int64 },
-  { "l2", &builtin_type_int64 },
-  { "l3", &builtin_type_int64 },
-  { "l4", &builtin_type_int64 },
-  { "l5", &builtin_type_int64 },
-  { "l6", &builtin_type_int64 },
-  { "l7", &builtin_type_int64 },
-
-  { "i0", &builtin_type_int64 },
-  { "i1", &builtin_type_int64 },
-  { "i2", &builtin_type_int64 },
-  { "i3", &builtin_type_int64 },
-  { "i4", &builtin_type_int64 },
-  { "i5", &builtin_type_int64 },
-  { "fp", &builtin_type_void_data_ptr },
-  { "i7", &builtin_type_int64 },
-
-  { "f0", &builtin_type_float },
-  { "f1", &builtin_type_float },
-  { "f2", &builtin_type_float },
-  { "f3", &builtin_type_float },
-  { "f4", &builtin_type_float },
-  { "f5", &builtin_type_float },
-  { "f6", &builtin_type_float },
-  { "f7", &builtin_type_float },
-  { "f8", &builtin_type_float },
-  { "f9", &builtin_type_float },
-  { "f10", &builtin_type_float },
-  { "f11", &builtin_type_float },
-  { "f12", &builtin_type_float },
-  { "f13", &builtin_type_float },
-  { "f14", &builtin_type_float },
-  { "f15", &builtin_type_float },
-  { "f16", &builtin_type_float },
-  { "f17", &builtin_type_float },
-  { "f18", &builtin_type_float },
-  { "f19", &builtin_type_float },
-  { "f20", &builtin_type_float },
-  { "f21", &builtin_type_float },
-  { "f22", &builtin_type_float },
-  { "f23", &builtin_type_float },
-  { "f24", &builtin_type_float },
-  { "f25", &builtin_type_float },
-  { "f26", &builtin_type_float },
-  { "f27", &builtin_type_float },
-  { "f28", &builtin_type_float },
-  { "f29", &builtin_type_float },
-  { "f30", &builtin_type_float },
-  { "f31", &builtin_type_float },
-  { "f32", &builtin_type_double },
-  { "f34", &builtin_type_double },
-  { "f36", &builtin_type_double },
-  { "f38", &builtin_type_double },
-  { "f40", &builtin_type_double },
-  { "f42", &builtin_type_double },
-  { "f44", &builtin_type_double },
-  { "f46", &builtin_type_double },
-  { "f48", &builtin_type_double },
-  { "f50", &builtin_type_double },
-  { "f52", &builtin_type_double },
-  { "f54", &builtin_type_double },
-  { "f56", &builtin_type_double },
-  { "f58", &builtin_type_double },
-  { "f60", &builtin_type_double },
-  { "f62", &builtin_type_double },
+  "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", &builtin_type_void_func_ptr },
-  { "npc", &builtin_type_void_func_ptr },
+  "pc", "npc",
   
-  /* This raw register contains the contents of %cwp, %pstate, %asi
-     and %ccr as laid out in a %tstate register.  */
-  /* FIXME: Give it a name until we start using register groups.  */
-  { "state", &builtin_type_int64 },
-
-  { "fsr", &sparc64_fsr_type },
-  { "fprs", &sparc64_fprs_type },
-
-  /* "Although Y is a 64-bit register, its high-order 32 bits are
-     reserved and always read as 0."  */
-  { "y", &builtin_type_int64 }
+  /* FIXME: Give "state" a name until we start using register groups.  */
+  "state",
+  "fsr",
+  "fprs",
+  "y",
 };
 
 /* Total number of registers.  */
-#define SPARC64_NUM_REGS ARRAY_SIZE (sparc64_register_info)
+#define SPARC64_NUM_REGS ARRAY_SIZE (sparc64_register_names)
 
 /* We provide the aliases %d0..%d62 and %q0..%q60 for the floating
    registers as "psuedo" registers.  */
 
-static struct sparc64_register_info sparc64_pseudo_register_info[] =
+static const char *sparc64_pseudo_register_names[] =
 {
-  { "cwp", &builtin_type_int64 },
-  { "pstate", &sparc64_pstate_type },
-  { "asi", &builtin_type_int64 },
-  { "ccr", &builtin_type_int64 },
-
-  { "d0", &builtin_type_double },
-  { "d2", &builtin_type_double },
-  { "d4", &builtin_type_double },
-  { "d6", &builtin_type_double },
-  { "d8", &builtin_type_double },
-  { "d10", &builtin_type_double },
-  { "d12", &builtin_type_double },
-  { "d14", &builtin_type_double },
-  { "d16", &builtin_type_double },
-  { "d18", &builtin_type_double },
-  { "d20", &builtin_type_double },
-  { "d22", &builtin_type_double },
-  { "d24", &builtin_type_double },
-  { "d26", &builtin_type_double },
-  { "d28", &builtin_type_double },
-  { "d30", &builtin_type_double },
-  { "d32", &builtin_type_double },
-  { "d34", &builtin_type_double },
-  { "d36", &builtin_type_double },
-  { "d38", &builtin_type_double },
-  { "d40", &builtin_type_double },
-  { "d42", &builtin_type_double },
-  { "d44", &builtin_type_double },
-  { "d46", &builtin_type_double },
-  { "d48", &builtin_type_double },
-  { "d50", &builtin_type_double },
-  { "d52", &builtin_type_double },
-  { "d54", &builtin_type_double },
-  { "d56", &builtin_type_double },
-  { "d58", &builtin_type_double },
-  { "d60", &builtin_type_double },
-  { "d62", &builtin_type_double },
-
-  { "q0", &builtin_type_long_double },
-  { "q4", &builtin_type_long_double },
-  { "q8", &builtin_type_long_double },
-  { "q12", &builtin_type_long_double },
-  { "q16", &builtin_type_long_double },
-  { "q20", &builtin_type_long_double },
-  { "q24", &builtin_type_long_double },
-  { "q28", &builtin_type_long_double },
-  { "q32", &builtin_type_long_double },
-  { "q36", &builtin_type_long_double },
-  { "q40", &builtin_type_long_double },
-  { "q44", &builtin_type_long_double },
-  { "q48", &builtin_type_long_double },
-  { "q52", &builtin_type_long_double },
-  { "q56", &builtin_type_long_double },
-  { "q60", &builtin_type_long_double }
+  "cwp", "pstate", "asi", "ccr",
+
+  "d0", "d2", "d4", "d6", "d8", "d10", "d12", "d14",
+  "d16", "d18", "d20", "d22", "d24", "d26", "d28", "d30",
+  "d32", "d34", "d36", "d38", "d40", "d42", "d44", "d46",
+  "d48", "d50", "d52", "d54", "d56", "d58", "d60", "d62",
+
+  "q0", "q4", "q8", "q12", "q16", "q20", "q24", "q28",
+  "q32", "q36", "q40", "q44", "q48", "q52", "q56", "q60",
 };
 
 /* Total number of pseudo registers.  */
-#define SPARC64_NUM_PSEUDO_REGS ARRAY_SIZE (sparc64_pseudo_register_info)
+#define SPARC64_NUM_PSEUDO_REGS ARRAY_SIZE (sparc64_pseudo_register_names)
 
 /* Return the name of register REGNUM.  */
 
@@ -361,11 +230,11 @@ static const char *
 sparc64_register_name (int regnum)
 {
   if (regnum >= 0 && regnum < SPARC64_NUM_REGS)
-    return sparc64_register_info[regnum].name;
+    return sparc64_register_names[regnum];
 
   if (regnum >= SPARC64_NUM_REGS
       && regnum < SPARC64_NUM_REGS + SPARC64_NUM_PSEUDO_REGS)
-    return sparc64_pseudo_register_info[regnum - SPARC64_NUM_REGS].name;
+    return sparc64_pseudo_register_names[regnum - SPARC64_NUM_REGS];
 
   return NULL;
 }
@@ -376,12 +245,47 @@ sparc64_register_name (int regnum)
 static struct type *
 sparc64_register_type (struct gdbarch *gdbarch, int regnum)
 {
-  if (regnum >= SPARC64_NUM_REGS
-      && regnum < SPARC64_NUM_REGS + SPARC64_NUM_PSEUDO_REGS)
-    return *sparc64_pseudo_register_info[regnum - SPARC64_NUM_REGS].type;
+  /* Raw registers.  */
+
+  if (regnum == SPARC_SP_REGNUM || regnum == SPARC_FP_REGNUM)
+    return builtin_type_void_data_ptr;
+  if (regnum >= SPARC_G0_REGNUM && regnum <= SPARC_I7_REGNUM)
+    return builtin_type_int64;
+  if (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F31_REGNUM)
+    return builtin_type_float;
+  if (regnum >= SPARC64_F32_REGNUM && regnum <= SPARC64_F62_REGNUM)
+    return builtin_type_double;
+  if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
+    return builtin_type_void_func_ptr;
+  /* This raw register contains the contents of %cwp, %pstate, %asi
+     and %ccr as laid out in a %tstate register.  */
+  if (regnum == SPARC64_STATE_REGNUM)
+    return builtin_type_int64;
+  if (regnum == SPARC64_FSR_REGNUM)
+    return sparc64_fsr_type;
+  if (regnum == SPARC64_FPRS_REGNUM)
+    return sparc64_fprs_type;
+  /* "Although Y is a 64-bit register, its high-order 32 bits are
+     reserved and always read as 0."  */
+  if (regnum == SPARC64_Y_REGNUM)
+    return builtin_type_int64;
+
+  /* Pseudo registers.  */
+
+  if (regnum == SPARC64_CWP_REGNUM)
+    return builtin_type_int64;
+  if (regnum == SPARC64_PSTATE_REGNUM)
+    return sparc64_pstate_type;
+  if (regnum == SPARC64_ASI_REGNUM)
+    return builtin_type_int64;
+  if (regnum == SPARC64_CCR_REGNUM)
+    return builtin_type_int64;
+  if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D62_REGNUM)
+    return builtin_type_double;
+  if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q60_REGNUM)
+    return builtin_type_long_double;
 
-  gdb_assert (regnum >= 0 && regnum < SPARC64_NUM_REGS);
-  return *sparc64_register_info[regnum].type;
+  internal_error (__FILE__, __LINE__, _("invalid regnum"));
 }
 
 static void
-- 
  Dr. Ulrich Weigand
  GNU Toolchain for Linux on System z and Cell BE
  Ulrich.Weigand@de.ibm.com

Re: [2/10] Remove &builtin_type_ from tdep code (amd64/s390/sparc64)

[Daniel Jacobowitz]

On Sat, Jun 09, 2007 at 01:14:58AM +0200, Ulrich Weigand wrote:
> Hello,
> 
> a number of platforms (amd64, s390, sparc64) were using a global data
> structure containing pointers to types describing the register types.
> This is broken if those types need to be platform-specific.
> 
> The following patch removes those global data structures, and converts
> the affected architectures to simply return the types dynamically from
> the register_type callback, as all other platforms do as well.
> 
> Tested on s390-ibm-linux and s390x-ibm-linux.
> 
> I'd appreciate testers of the amd64 and sparc64 parts of this patch!

/space/fsf/commit/src/gdb/amd64-tdep.c:106: error:
'AMD64_FCRTL_REGNUM' undeclared (first use in this function)

With that fixed, x86_64-linux test results are unchanged.

-- 
Daniel Jacobowitz
CodeSourcery

Re: [2/10] Remove &builtin_type_ from tdep code (amd64/s390/sparc64)

[Daniel Jacobowitz]

On Sat, Jun 09, 2007 at 01:14:58AM +0200, Ulrich Weigand wrote:
> Hello,
> 
> a number of platforms (amd64, s390, sparc64) were using a global data
> structure containing pointers to types describing the register types.
> This is broken if those types need to be platform-specific.
> 
> The following patch removes those global data structures, and converts
> the affected architectures to simply return the types dynamically from
> the register_type callback, as all other platforms do as well.

In-flight collision warning: the m68k ColdFire patch may reintroduce an
occurance of this, for the long double type.

-- 
Daniel Jacobowitz
CodeSourcery

Re: [2/10] Remove &builtin_type_ from tdep code (amd64/s390/sparc64)

[Ulrich Weigand]

Daniel Jacobowitz wrote:

> /space/fsf/commit/src/gdb/amd64-tdep.c:106: error:
> 'AMD64_FCRTL_REGNUM' undeclared (first use in this function)

Huh, I wonder how I missed that; I thought I'd at least
compiled all the tdep files ...

> With that fixed, x86_64-linux test results are unchanged.

Thanks for the test!

Bye,
Ulrich

-- 
  Dr. Ulrich Weigand
  GNU Toolchain for Linux on System z and Cell BE
  Ulrich.Weigand@de.ibm.com

Re: [2/10] Remove &builtin_type_ from tdep code (amd64/s390/sparc64)

[Ulrich Weigand]

Daniel Jacobowitz wrote:
> On Sat, Jun 09, 2007 at 01:14:58AM +0200, Ulrich Weigand wrote:
> > Hello,
> > 
> > a number of platforms (amd64, s390, sparc64) were using a global data
> > structure containing pointers to types describing the register types.
> > This is broken if those types need to be platform-specific.
> > 
> > The following patch removes those global data structures, and converts
> > the affected architectures to simply return the types dynamically from
> > the register_type callback, as all other platforms do as well.
> 
> In-flight collision warning: the m68k ColdFire patch may reintroduce an
> occurance of this, for the long double type.

Ah, good catch: 

+  /* Type of an fpreg.  NULL if there are no fpregs.  This is a
+     pointer to the pointer to type struct, because when architecture
+     init function is running, the types for the old architecture are swapped
+     out, and the types for the new architecture are not yet swapped in,
+     so all types that don't have specific sizes (like builting_type_double)
+     are NULL.  */
+  struct type **fpreg_type;

Vladimir, would you mind rewriting this?  I'd suggest to remove the
fpreg_type variable, and instead check the "flavour" in m68k_register_type.

Bye,
Ulrich

-- 
  Dr. Ulrich Weigand
  GNU Toolchain for Linux on System z and Cell BE
  Ulrich.Weigand@de.ibm.com

Re: [2/10] Remove &builtin_type_ from tdep code (amd64/s390/sparc64)

[Vladimir Prus]

On Tuesday 12 June 2007 19:14, Daniel Jacobowitz wrote:
> On Sat, Jun 09, 2007 at 01:14:58AM +0200, Ulrich Weigand wrote:
> > Hello,
> > 
> > a number of platforms (amd64, s390, sparc64) were using a global data
> > structure containing pointers to types describing the register types.
> > This is broken if those types need to be platform-specific.
> > 
> > The following patch removes those global data structures, and converts
> > the affected architectures to simply return the types dynamically from
> > the register_type callback, as all other platforms do as well.
> 
> In-flight collision warning: the m68k ColdFire patch may reintroduce an
> occurance of this, for the long double type.

Current version of the patch indeed has this:

	+  if (flavour == m68k_coldfire_flavour)
	+    tdep->fpreg_type = &builtin_type_double;
	+  else
	+    tdep->fpreg_type = &builtin_type_m68881_ext;

I suppose I can change m68k_register_type to directly return
the type, but I'm not sure why

	return builtin_type_double;

is better than:

	return *x;

where x = &builtin_type_double;

Ulrich, can you explain that to me?

Thanks,
Volodya

Re: [2/10] Remove &builtin_type_ from tdep code (amd64/s390/sparc64)

[Ulrich Weigand]

Vladimir Prus wrote:

> I suppose I can change m68k_register_type to directly return
> the type, but I'm not sure why
> 
> 	return builtin_type_double;
> 
> is better than:
> 
> 	return *x;
> 
> where x = &builtin_type_double;

builtin_type_double is currently a global variable that is
gdbarch-swapped, i.e. whenever current_gdbarch switches, the
value of that global variable is re-set.

This is awkward and makes is hard to use any other gdbarch
(that is not currently installed as current_gdbarch) reliably,
which is what my patch set is intended to fix.

To that purpose, the builtin_type_double global variable will
go away, and is (temporarily) replaced by a macro

  #define builtin_type_double
          builtin_type (current_gdbarch)->builtin_double

However, this macro is not fully equivalent; in particular it
is no longer possible to use &builtin_type_double.


Longer term, that compatibility macro will go away as well,
and your
   return builtin_type_double;
should be replaced by
   return builtin_type (gdbarch)->builtin_double;

using the "gdbarch" you get as input to ..._register_type
instead of the global current_gdbarch.  (If you prefer,
you can certainly use that form right away.)

Bye,
Ulrich

-- 
  Dr. Ulrich Weigand
  GNU Toolchain for Linux on System z and Cell BE
  Ulrich.Weigand@de.ibm.com

Re: [2/10] Remove &builtin_type_ from tdep code (amd64/s390/sparc64)

[Daniel Jacobowitz]

On Wed, Jun 13, 2007 at 03:06:11PM +0200, Ulrich Weigand wrote:
> To that purpose, the builtin_type_double global variable will
> go away, and is (temporarily) replaced by a macro
> 
>   #define builtin_type_double
>           builtin_type (current_gdbarch)->builtin_double
> 
> However, this macro is not fully equivalent; in particular it
> is no longer possible to use &builtin_type_double.

You keep saying this, but is it true? :-)

You can't take the address of a function's return value, but you can
take the address of a dereference.  Of course using
&builtin_type_double in m68k_gdbarch_init won't work since
current_gdbarch is NULL then.  But we should be able to save
builtin_type (gdbarch)->builtin_double if we wanted to, I think.

-- 
Daniel Jacobowitz
CodeSourcery

Re: [2/10] Remove &builtin_type_ from tdep code (amd64/s390/sparc64)

[Ulrich Weigand]

Daniel Jacobowitz wrote:
> On Wed, Jun 13, 2007 at 03:06:11PM +0200, Ulrich Weigand wrote:
> > However, this macro is not fully equivalent; in particular it
> > is no longer possible to use &builtin_type_double.
> 
> You keep saying this, but is it true? :-)

Well, you can take the address, but you won't get the gdbarch-swap
effect any more.  So if you were relying on that, it'll break ...

> You can't take the address of a function's return value, but you can
> take the address of a dereference.  Of course using
> &builtin_type_double in m68k_gdbarch_init won't work since
> current_gdbarch is NULL then.  But we should be able to save
> builtin_type (gdbarch)->builtin_double if we wanted to, I think.

Not really, as the per-gdbarch data elements are allocated only
*after* gdbarch_init returns.  (At least those installed using
gdbarch_data_register_post_init as builtin_type is.)

So calling builtin_type (gdbarch) within m68k_gdbarch_init should
itself return NULL.

Bye,
Ulrich

-- 
  Dr. Ulrich Weigand
  GNU Toolchain for Linux on System z and Cell BE
  Ulrich.Weigand@de.ibm.com

Re: [2/10] Remove &builtin_type_ from tdep code (amd64/s390/sparc64)

[Daniel Jacobowitz]

On Wed, Jun 13, 2007 at 03:17:09PM +0200, Ulrich Weigand wrote:
> Daniel Jacobowitz wrote:
> > On Wed, Jun 13, 2007 at 03:06:11PM +0200, Ulrich Weigand wrote:
> > > However, this macro is not fully equivalent; in particular it
> > > is no longer possible to use &builtin_type_double.
> > 
> > You keep saying this, but is it true? :-)
> 
> Well, you can take the address, but you won't get the gdbarch-swap
> effect any more.  So if you were relying on that, it'll break ...

Right.  Fortunately here we don't need the swap effect, since we have
the right gdbarch - but I'd forgotten about post_init.

-- 
Daniel Jacobowitz
CodeSourcery

Re: [2/10] Remove &builtin_type_ from tdep code (amd64/s390/sparc64)

[Ulrich Weigand]

Daniel Jacobowitz wrote:
> On Wed, Jun 13, 2007 at 03:17:09PM +0200, Ulrich Weigand wrote:
> > Daniel Jacobowitz wrote:
> > > On Wed, Jun 13, 2007 at 03:06:11PM +0200, Ulrich Weigand wrote:
> > > > However, this macro is not fully equivalent; in particular it
> > > > is no longer possible to use &builtin_type_double.
> > > 
> > > You keep saying this, but is it true? :-)
> > 
> > Well, you can take the address, but you won't get the gdbarch-swap
> > effect any more.  So if you were relying on that, it'll break ...
> 
> Right.  Fortunately here we don't need the swap effect, since we have
> the right gdbarch - but I'd forgotten about post_init.

Also, in nearly all the cases an address of a builtin_type_ was taken,
it was in the context of a static initialization expression -- and
*there*, the macro would indeed be an error, as it no longer
represents a constant expression.

Bye,
Ulrich

-- 
  Dr. Ulrich Weigand
  GNU Toolchain for Linux on System z and Cell BE
  Ulrich.Weigand@de.ibm.com