2003-05-08 Andrew Cagney <cagney@redhat.com>

	* regcache.h (max_register_size): Delete declaration.
	* regcache.c (max_register_size): Delete function.
	(struct regcache_descr): Delete field "max_register_size".
	(init_regcache_descr, init_legacy_regcache_descr): Assert that all
	registers fit in MAX_REGISTER_SIZE.
	(regcache_save): Replace max_register_size with MAX_REGISTER_SIZE.
	(regcache_restore, regcache_xfer_part, regcache_dump): Ditto.
	* thread-db.c: Replace max_register_size with MAX_REGISTER_SIZE.
	* sh-tdep.c, rom68k-rom.c, remote-sim.c, remote-mips.c: Ditto.
	* remote-e7000.c, monitor.c, mipsv4-nat.c, mips-nat.c: Ditto.
	* m68klinux-nat.c, lynx-nat.c, irix4-nat.c: Ditto.
	* hpux-thread.c, hppah-nat.c, hppab-nat.c, hppa-tdep.c: Ditto.
	* dve3900-rom.c, hppa-tdep.c: Ditto.

20 files changed, 58 insertions, 65 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 12ec09b70f4..9c58b41c498 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,19 @@
+2003-05-08  Andrew Cagney  <cagney@redhat.com>
+
+	* regcache.h (max_register_size): Delete declaration.
+	* regcache.c (max_register_size): Delete function.
+	(struct regcache_descr): Delete field "max_register_size".
+	(init_regcache_descr, init_legacy_regcache_descr): Assert that all
+	registers fit in MAX_REGISTER_SIZE.
+	(regcache_save): Replace max_register_size with MAX_REGISTER_SIZE.
+	(regcache_restore, regcache_xfer_part, regcache_dump): Ditto.
+	* thread-db.c: Replace max_register_size with MAX_REGISTER_SIZE.
+	* sh-tdep.c, rom68k-rom.c, remote-sim.c, remote-mips.c: Ditto.
+	* remote-e7000.c, monitor.c, mipsv4-nat.c, mips-nat.c: Ditto.
+	* m68klinux-nat.c, lynx-nat.c, irix4-nat.c: Ditto.
+	* hpux-thread.c, hppah-nat.c, hppab-nat.c, hppa-tdep.c: Ditto.
+	* dve3900-rom.c, hppa-tdep.c: Ditto.
+
 2003-05-08  David Carlton  <carlton@math.stanford.edu>
 
 	* valops.c (push_word): Fix typo.
diff --git a/gdb/dve3900-rom.c b/gdb/dve3900-rom.c
index e7329f8988a..02a273c10e1 100644
--- a/gdb/dve3900-rom.c
+++ b/gdb/dve3900-rom.c
@@ -455,7 +455,7 @@ static void
 fetch_bitmapped_register (int regno, struct bit_field *bf)
 {
   unsigned long val;
-  unsigned char *regbuf = alloca (max_register_size (current_gdbarch));
+  unsigned char regbuf[MAX_REGISTER_SIZE];
   char *regname = NULL;
 
   if (regno >= sizeof (r3900_regnames) / sizeof (r3900_regnames[0]))
diff --git a/gdb/hppa-tdep.c b/gdb/hppa-tdep.c
index db8d5105542..d524bae33c1 100644
--- a/gdb/hppa-tdep.c
+++ b/gdb/hppa-tdep.c
@@ -2630,7 +2630,7 @@ pa_register_look_aside (char *raw_regs, int regnum, long *raw_val)
   int start;
 
 
-  char *buf = alloca (max_register_size (current_gdbarch));
+  char buf[MAX_REGISTER_SIZE];
   long long reg_val;
 
   if (!know_which)
@@ -2827,8 +2827,8 @@ pa_strcat_registers (char *raw_regs, int regnum, int fpregs,
 static void
 pa_print_fp_reg (int i)
 {
-  char *raw_buffer = alloca (max_register_size (current_gdbarch));
-  char *virtual_buffer = alloca (max_register_size (current_gdbarch));
+  char raw_buffer[MAX_REGISTER_SIZE];
+  char virtual_buffer[MAX_REGISTER_SIZE];
 
   /* Get 32bits of data.  */
   frame_register_read (deprecated_selected_frame, i, raw_buffer);
@@ -2870,8 +2870,8 @@ pa_print_fp_reg (int i)
 static void
 pa_strcat_fp_reg (int i, struct ui_file *stream, enum precision_type precision)
 {
-  char *raw_buffer = alloca (max_register_size (current_gdbarch));
-  char *virtual_buffer = alloca (max_register_size (current_gdbarch));
+  char raw_buffer[MAX_REGISTER_SIZE];
+  char virtual_buffer[MAX_REGISTER_SIZE];
 
   fputs_filtered (REGISTER_NAME (i), stream);
   print_spaces_filtered (8 - strlen (REGISTER_NAME (i)), stream);
@@ -2885,7 +2885,7 @@ pa_strcat_fp_reg (int i, struct ui_file *stream, enum precision_type precision)
   if (precision == double_precision && (i % 2) == 0)
     {
 
-      char *raw_buf = alloca (max_register_size (current_gdbarch));
+      char raw_buf[MAX_REGISTER_SIZE];
 
       /* Get the data in raw format for the 2nd half.  */
       frame_register_read (deprecated_selected_frame, i + 1, raw_buf);
diff --git a/gdb/hppab-nat.c b/gdb/hppab-nat.c
index 3ec3a57e9ac..dc3e6b6fb9c 100644
--- a/gdb/hppab-nat.c
+++ b/gdb/hppab-nat.c
@@ -55,7 +55,7 @@ static void
 fetch_register (int regno)
 {
   register unsigned int regaddr;
-  char *buf = alloca (max_register_size (current_gdbarch));
+  char buf[MAX_REGISTER_SIZE];
   register int i;
 
   /* Offset of registers within the u area.  */
diff --git a/gdb/hppah-nat.c b/gdb/hppah-nat.c
index b953d2546f6..0b8b04f9778 100644
--- a/gdb/hppah-nat.c
+++ b/gdb/hppah-nat.c
@@ -190,7 +190,7 @@ store_inferior_registers (int regno)
 static void
 fetch_register (int regno)
 {
-  char *buf = alloca (max_register_size (current_gdbarch));
+  char buf[MAX_REGISTER_SIZE];
   unsigned int addr, len, offset;
   int i;
 
diff --git a/gdb/hpux-thread.c b/gdb/hpux-thread.c
index b585ca540ce..7a7b74174a1 100644
--- a/gdb/hpux-thread.c
+++ b/gdb/hpux-thread.c
@@ -285,7 +285,7 @@ hpux_thread_fetch_registers (int regno)
 	child_ops.to_fetch_registers (regno);
       else
 	{
-	  unsigned char *buf = alloca (max_register_size (current_gdbarch));
+	  unsigned char buf[MAX_REGISTER_SIZE];
 	  CORE_ADDR sp;
 
 	  sp = (CORE_ADDR) tcb_ptr->static_ctx.sp - 160;
@@ -347,7 +347,7 @@ hpux_thread_store_registers (int regno)
 	child_ops.to_store_registers (regno);
       else
 	{
-	  unsigned char *buf = alloca (max_register_size (current_gdbarch));
+	  unsigned char buf[MAX_REGISTER_SIZE];
 	  CORE_ADDR sp;
 
 	  sp = (CORE_ADDR) tcb_ptr->static_ctx.sp - 160;
diff --git a/gdb/irix4-nat.c b/gdb/irix4-nat.c
index b44c5bbba49..63ca71e6bc6 100644
--- a/gdb/irix4-nat.c
+++ b/gdb/irix4-nat.c
@@ -51,8 +51,8 @@ supply_gregset (gregset_t *gregsetp)
 {
   register int regi;
   register greg_t *regp = (greg_t *) (gregsetp->gp_regs);
-  char *zerobuf = alloca (max_register_size (current_gdbarch));
-  memset (zerobuf, 0, max_register_size (current_gdbarch));
+  char zerobuf[MAX_REGISTER_SIZE];
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   /* FIXME: somewhere, there should be a #define for the meaning
      of this magic number 32; we should use that. */
@@ -104,8 +104,8 @@ void
 supply_fpregset (fpregset_t *fpregsetp)
 {
   register int regi;
-  char *zerobuf = alloca (max_register_size (current_gdbarch));
-  memset (zerobuf, 0, max_register_size (current_gdbarch));
+  char zerobuf[MAX_REGISTER_SIZE];
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   for (regi = 0; regi < 32; regi++)
     supply_register (FP0_REGNUM + regi,
diff --git a/gdb/lynx-nat.c b/gdb/lynx-nat.c
index 4be7fb8e1ab..f425cb9c37a 100644
--- a/gdb/lynx-nat.c
+++ b/gdb/lynx-nat.c
@@ -283,7 +283,7 @@ fetch_inferior_registers (int regno)
   if (whatregs & WHATREGS_GEN)
     {
       struct econtext ec;	/* general regs */
-      char *buf = alloca (max_register_size (current_gdbarch));
+      char buf[MAX_REGISTER_SIZE];
       int retval;
       int i;
 
@@ -512,7 +512,7 @@ fetch_inferior_registers (int regno)
   ecp = registers_addr (PIDGET (inferior_ptid));
 
   {
-    char *buf = alloca (max_register_size (current_gdbarch));
+    char buf[MAX_REGISTER_SIZE];
     for (regno = reglo; regno <= reghi; regno++)
       {
 	int ptrace_fun = PTRACE_PEEKTHREAD;
diff --git a/gdb/m68klinux-nat.c b/gdb/m68klinux-nat.c
index 0cf82fbabbf..e077deadc27 100644
--- a/gdb/m68klinux-nat.c
+++ b/gdb/m68klinux-nat.c
@@ -135,7 +135,7 @@ fetch_register (int regno)
   char mess[128];		/* For messages */
   register int i;
   unsigned int offset;		/* Offset of registers within the u area.  */
-  char *buf = alloca (max_register_size (current_gdbarch));
+  char buf[MAX_REGISTER_SIZE];
   int tid;
 
   if (CANNOT_FETCH_REGISTER (regno))
diff --git a/gdb/mips-nat.c b/gdb/mips-nat.c
index 3aaaa91c339..1a29c3e317a 100644
--- a/gdb/mips-nat.c
+++ b/gdb/mips-nat.c
@@ -70,10 +70,10 @@ void
 fetch_inferior_registers (int regno)
 {
   register unsigned int regaddr;
-  char *buf = alloca (max_register_size (current_gdbarch));
+  char buf[MAX_REGISTER_SIZE];
   register int i;
-  char *zerobuf = alloca (max_register_size (current_gdbarch));
-  memset (zerobuf, 0, max_register_size (current_gdbarch));
+  char zerobuf[MAX_REGISTER_SIZE];
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   deprecated_registers_fetched ();
 
@@ -174,8 +174,8 @@ fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
   int bad_reg = -1;
   register reg_ptr = -reg_addr;	/* Original u.u_ar0 is -reg_addr. */
 
-  char *zerobuf = alloca (max_register_size (current_gdbarch));
-  memset (zerobuf, 0, max_register_size (current_gdbarch));
+  char zerobuf[MAX_REGISTER_SIZE];
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
 
   /* If u.u_ar0 was an absolute address in the core file, relativize it now,
diff --git a/gdb/mipsv4-nat.c b/gdb/mipsv4-nat.c
index 874bef4f399..65ffa0dc629 100644
--- a/gdb/mipsv4-nat.c
+++ b/gdb/mipsv4-nat.c
@@ -47,8 +47,8 @@ supply_gregset (gregset_t *gregsetp)
 {
   register int regi;
   register greg_t *regp = &(*gregsetp)[0];
-  char *zerobuf = alloca (max_register_size (current_gdbarch));
-  memset (zerobuf, 0, max_register_size (current_gdbarch));
+  char zerobuf[MAX_REGISTER_SIZE];
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   for (regi = 0; regi <= CXT_RA; regi++)
     supply_register (regi, (char *) (regp + regi));
@@ -102,8 +102,8 @@ void
 supply_fpregset (fpregset_t *fpregsetp)
 {
   register int regi;
-  char *zerobuf = alloca (max_register_size (current_gdbarch));
-  memset (zerobuf, 0, max_register_size (current_gdbarch));
+  char zerobuf[MAX_REGISTER_SIZE];
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
 
   for (regi = 0; regi < 32; regi++)
     supply_register (FP0_REGNUM + regi,
diff --git a/gdb/monitor.c b/gdb/monitor.c
index 20c89f8096d..ede61bb6998 100644
--- a/gdb/monitor.c
+++ b/gdb/monitor.c
@@ -896,7 +896,7 @@ char *
 monitor_supply_register (int regno, char *valstr)
 {
   ULONGEST val;
-  unsigned char *regbuf = alloca (max_register_size (current_gdbarch));
+  unsigned char regbuf[MAX_REGISTER_SIZE];
   char *p;
 
   val = 0;
diff --git a/gdb/regcache.c b/gdb/regcache.c
index ec60d972e15..acf3044fa3c 100644
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -78,9 +78,6 @@ struct regcache_descr
   long *register_offset;
   long *sizeof_register;
 
-  /* Useful constant.  Largest of all the registers.  */
-  long max_register_size;
-
   /* Cached table containing the type of each register.  */
   struct type **register_type;
 };
@@ -109,7 +106,6 @@ init_legacy_regcache_descr (struct gdbarch *gdbarch,
      read_register_bytes() and write_register_bytes() registers.  */
   descr->sizeof_register = XCALLOC (descr->nr_cooked_registers, long);
   descr->register_offset = XCALLOC (descr->nr_cooked_registers, long);
-  descr->max_register_size = 0;
   for (i = 0; i < descr->nr_cooked_registers; i++)
     {
       /* FIXME: cagney/2001-12-04: This code shouldn't need to use
@@ -119,10 +115,8 @@ init_legacy_regcache_descr (struct gdbarch *gdbarch,
          entirely avoid this uglyness.  */
       descr->register_offset[i] = REGISTER_BYTE (i);
       descr->sizeof_register[i] = REGISTER_RAW_SIZE (i);
-      if (descr->max_register_size < REGISTER_RAW_SIZE (i))
-	descr->max_register_size = REGISTER_RAW_SIZE (i);
-      if (descr->max_register_size < REGISTER_VIRTUAL_SIZE (i))
-	descr->max_register_size = REGISTER_VIRTUAL_SIZE (i);
+      gdb_assert (MAX_REGISTER_SIZE >= REGISTER_RAW_SIZE (i));
+      gdb_assert (MAX_REGISTER_SIZE >= REGISTER_VIRTUAL_SIZE (i));
     }
 
   /* Compute the real size of the register buffer.  Start out by
@@ -219,14 +213,12 @@ init_regcache_descr (struct gdbarch *gdbarch)
     long offset = 0;
     descr->sizeof_register = XCALLOC (descr->nr_cooked_registers, long);
     descr->register_offset = XCALLOC (descr->nr_cooked_registers, long);
-    descr->max_register_size = 0;
     for (i = 0; i < descr->nr_cooked_registers; i++)
       {
 	descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
 	descr->register_offset[i] = offset;
 	offset += descr->sizeof_register[i];
-	if (descr->max_register_size < descr->sizeof_register[i])
-	  descr->max_register_size = descr->sizeof_register[i];
+	gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
       }
     /* Set the real size of the register cache buffer.  */
     descr->sizeof_cooked_registers = offset;
@@ -290,13 +282,6 @@ register_type (struct gdbarch *gdbarch, int regnum)
    the regcache descr.  */
 
 int
-max_register_size (struct gdbarch *gdbarch)
-{
-  struct regcache_descr *descr = regcache_descr (gdbarch);
-  return descr->max_register_size;
-}
-
-int
 register_size (struct gdbarch *gdbarch, int regnum)
 {
   struct regcache_descr *descr = regcache_descr (gdbarch);
@@ -379,7 +364,7 @@ regcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read,
 	       void *src)
 {
   struct gdbarch *gdbarch = dst->descr->gdbarch;
-  void *buf = alloca (max_register_size (gdbarch));
+  char buf[MAX_REGISTER_SIZE];
   int regnum;
   /* The DST should be `read-only', if it wasn't then the save would
      end up trying to write the register values back out to the
@@ -413,7 +398,7 @@ regcache_restore (struct regcache *dst,
 		  void *src)
 {
   struct gdbarch *gdbarch = dst->descr->gdbarch;
-  void *buf = alloca (max_register_size (gdbarch));
+  char buf[MAX_REGISTER_SIZE];
   int regnum;
   /* The dst had better not be read-only.  If it is, the `restore'
      doesn't make much sense.  */
@@ -1090,7 +1075,7 @@ regcache_xfer_part (struct regcache *regcache, int regnum,
 		    regcache_read_ftype *read, regcache_write_ftype *write)
 {
   struct regcache_descr *descr = regcache->descr;
-  bfd_byte *reg = alloca (descr->max_register_size);
+  bfd_byte reg[MAX_REGISTER_SIZE];
   gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
   gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
   /* Something to do?  */
@@ -1480,7 +1465,7 @@ regcache_dump (struct regcache *regcache, struct ui_file *file,
   int footnote_register_offset = 0;
   int footnote_register_type_name_null = 0;
   long register_offset = 0;
-  unsigned char *buf = alloca (regcache->descr->max_register_size);
+  unsigned char buf[MAX_REGISTER_SIZE];
 
 #if 0
   fprintf_unfiltered (file, "legacy_p %d\n", regcache->descr->legacy_p);
@@ -1492,8 +1477,6 @@ regcache_dump (struct regcache *regcache, struct ui_file *file,
 		      regcache->descr->sizeof_raw_registers);
   fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
 		      regcache->descr->sizeof_raw_register_valid_p);
-  fprintf_unfiltered (file, "max_register_size %ld\n",
-		      regcache->descr->max_register_size);
   fprintf_unfiltered (file, "NUM_REGS %d\n", NUM_REGS);
   fprintf_unfiltered (file, "NUM_PSEUDO_REGS %d\n", NUM_PSEUDO_REGS);
 #endif
diff --git a/gdb/regcache.h b/gdb/regcache.h
index 2368cf0ff43..5d77095810b 100644
--- a/gdb/regcache.h
+++ b/gdb/regcache.h
@@ -127,12 +127,6 @@ extern int register_offset_hack (struct gdbarch *gdbarch, int regnum);
 extern struct type *register_type (struct gdbarch *gdbarch, int regnum);
 
 
-/* Return the size of the largest register.  Used when allocating
-   space for an aribtrary register value.  */
-
-extern int max_register_size (struct gdbarch *gdbarch);
-
-
 /* Return the size of register REGNUM.  All registers should have only
    one size.
 
diff --git a/gdb/remote-e7000.c b/gdb/remote-e7000.c
index 3b9a9414dde..643c6b6fe1b 100644
--- a/gdb/remote-e7000.c
+++ b/gdb/remote-e7000.c
@@ -785,7 +785,7 @@ void
 fetch_regs_from_dump (int (*nextchar) (), char *want)
 {
   int regno;
-  char *buf = alloca (max_register_size (current_gdbarch));
+  char buf[MAX_REGISTER_SIZE];
 
   int thischar = nextchar ();
 
diff --git a/gdb/remote-mips.c b/gdb/remote-mips.c
index 17994f9d4da..d1e3705a4c8 100644
--- a/gdb/remote-mips.c
+++ b/gdb/remote-mips.c
@@ -1791,7 +1791,7 @@ mips_wait (ptid_t ptid, struct target_waitstatus *status)
 		    &rpc, &rfp, &rsp, flags);
   if (nfields >= 3)
     {
-      char *buf = alloca (max_register_size (current_gdbarch));
+      char buf[MAX_REGISTER_SIZE];
 
       store_unsigned_integer (buf, REGISTER_RAW_SIZE (PC_REGNUM), rpc);
       supply_register (PC_REGNUM, buf);
@@ -1972,7 +1972,7 @@ mips_fetch_registers (int regno)
     }
 
   {
-    char *buf = alloca (max_register_size (current_gdbarch));
+    char buf[MAX_REGISTER_SIZE];
 
     /* We got the number the register holds, but gdb expects to see a
        value in the target byte ordering.  */
diff --git a/gdb/remote-sim.c b/gdb/remote-sim.c
index da4a96ccfd4..f7b9e89b0ba 100644
--- a/gdb/remote-sim.c
+++ b/gdb/remote-sim.c
@@ -359,7 +359,7 @@ gdbsim_store_register (int regno)
     }
   else if (REGISTER_SIM_REGNO (regno) >= 0)
     {
-      char *tmp = alloca (max_register_size (current_gdbarch));
+      char tmp[MAX_REGISTER_SIZE];
       int nr_bytes;
       deprecated_read_register_gen (regno, tmp);
       nr_bytes = sim_store_register (gdbsim_desc,
diff --git a/gdb/rom68k-rom.c b/gdb/rom68k-rom.c
index 57c0a182327..6b0926bf408 100644
--- a/gdb/rom68k-rom.c
+++ b/gdb/rom68k-rom.c
@@ -88,7 +88,7 @@ static char *
 rom68k_supply_one_register (int regno, unsigned char *hex)
 {
   ULONGEST value;
-  unsigned char *regbuf = alloca (max_register_size (current_gdbarch));
+  unsigned char regbuf[MAX_REGISTER_SIZE];
 
   value = 0;
   while (*hex != '\0')
diff --git a/gdb/sh-tdep.c b/gdb/sh-tdep.c
index e70d74f0d77..0ef65de2c02 100644
--- a/gdb/sh-tdep.c
+++ b/gdb/sh-tdep.c
@@ -4087,7 +4087,7 @@ sh64_do_pseudo_register (int regnum)
 static void
 sh_do_register (int regnum)
 {
-  char *raw_buffer = alloca (max_register_size (current_gdbarch));
+  char raw_buffer[MAX_REGISTER_SIZE];
 
   fputs_filtered (REGISTER_NAME (regnum), gdb_stdout);
   print_spaces_filtered (15 - strlen (REGISTER_NAME (regnum)), gdb_stdout);
diff --git a/gdb/thread-db.c b/gdb/thread-db.c
index bac464151fa..0a6138b3afa 100644
--- a/gdb/thread-db.c
+++ b/gdb/thread-db.c
@@ -945,7 +945,7 @@ thread_db_store_registers (int regno)
 
   if (regno != -1)
     {
-      char *raw = alloca (max_register_size (current_gdbarch));
+      char raw[MAX_REGISTER_SIZE];
 
       deprecated_read_register_gen (regno, raw);
       thread_db_fetch_registers (-1);