* sparc-tdep.c (sparc_extract_struct_value_address): Make it

	work correctly on little-endian hosts.
	(sparc_push_arguments): New function.
	(gdb_print_insn_sparc): New function.
	(_initialize_sparc_tdep): Make gdb_print_insn_sparc the default
	disassembler, so that SPARClite-specific instructions will
	be recognized.
	* sparcl-tdep.c (readchar): Print debugging information.
	(debug_serial_write): New function, a replacement for SERIAL_WRITE
	that prints debugging information.
	* config/sparc/tm-sparc.h (PUSH_ARGUMENTS): Define.
	(sparc_push_arguments): Declare.

1 files changed, 136 insertions, 26 deletions

diff --git a/gdb/sparc-tdep.c b/gdb/sparc-tdep.c
index bd85d28..2b970a6 100644
--- a/gdb/sparc-tdep.c
+++ b/gdb/sparc-tdep.c
@@ -1,5 +1,5 @@
 /* Target-dependent code for the SPARC for GDB, the GNU debugger.
-   Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996
+   Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997
    Free Software Foundation, Inc.
 
 This file is part of GDB.
@@ -27,6 +27,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "target.h"
 #include "value.h"
 #include "bfd.h"
+#include "gdb_string.h"
 
 #ifdef	USE_PROC_FS
 #include <sys/procfs.h>
@@ -75,14 +76,12 @@ int deferred_stores = 0;	/* Cumulates stores we want to do eventually. */
 /* Sign extension macros.  */
 #define X_SIMM13(i) ((X_IMM13 (i) ^ 0x1000) - 0x1000)
 #define X_DISP22(i) ((X_IMM22 (i) ^ 0x200000) - 0x200000)
-#ifdef GDB_TARGET_IS_SPARC64
 #define X_CC(i) (((i) >> 20) & 3)
 #define X_P(i) (((i) >> 19) & 1)
 #define X_DISP19(i) ((((i) & 0x7ffff) ^ 0x40000) - 0x40000)
 #define X_RCOND(i) (((i) >> 25) & 7)
 #define X_DISP16(i) ((((((i) >> 6) && 0xc000) | ((i) & 0x3fff)) ^ 0x8000) - 0x8000)
 #define X_FCN(i) (((i) >> 25) & 31)
-#endif
 
 typedef enum
 {
@@ -109,6 +108,8 @@ static binsn_quantum break_mem[3];
 
 int one_stepped;
 
+static branch_type isbranch PARAMS ((long, CORE_ADDR, CORE_ADDR *));
+
 /* single_step() is called just before we want to resume the inferior,
    if we want to single-step it but there is no hardware or kernel single-step
    support (as on all SPARCs).  We find all the possible targets of the
@@ -119,9 +120,9 @@ int one_stepped;
 
 void
 single_step (ignore)
-     int ignore; /* pid, but we don't need it */
+     enum target_signal ignore; /* pid, but we don't need it */
 {
-  branch_type br, isbranch();
+  branch_type br;
   CORE_ADDR pc;
   long pc_instruction;
 
@@ -206,14 +207,24 @@ sparc_init_extra_frame_info (fromleaf, fi)
   if (fi->next)
     {
       char buf[MAX_REGISTER_RAW_SIZE];
-      int err;
 
       /* Compute ->frame as if not flat.  If it is flat, we'll change
 	 it later.  */
-      /* FIXME: If error reading memory, should just stop backtracing, rather
-	 than error().  */
-      get_saved_register (buf, 0, 0, fi, FP_REGNUM, 0);
-      fi->frame = extract_address (buf, REGISTER_RAW_SIZE (FP_REGNUM));
+      if (fi->next->next != NULL
+	  && (fi->next->next->signal_handler_caller
+	      || frame_in_dummy (fi->next->next))
+	  && frameless_look_for_prologue (fi->next))
+	{
+	  /* A frameless function interrupted by a signal did not change
+	     the frame pointer, fix up frame pointer accordingly.  */
+	  fi->frame = FRAME_FP (fi->next);
+	  fi->bottom = fi->next->bottom;
+	}
+      else
+	{
+	  get_saved_register (buf, 0, 0, fi, FP_REGNUM, 0);
+	  fi->frame = extract_address (buf, REGISTER_RAW_SIZE (FP_REGNUM));
+	}
     }
 
   /* Decide whether this is a function with a ``flat register window''
@@ -289,7 +300,9 @@ sparc_extract_struct_value_address (regbuf)
   return extract_address (regbuf + REGISTER_BYTE (O0_REGNUM),
 			  REGISTER_RAW_SIZE (O0_REGNUM));
 #else
-  return read_memory_integer (((int *)(regbuf)) [SP_REGNUM] + (16 * SPARC_INTREG_SIZE), 
+  CORE_ADDR sp = extract_address (&regbuf [REGISTER_BYTE (SP_REGNUM)],
+				  REGISTER_RAW_SIZE (SP_REGNUM));
+  return read_memory_integer (sp + (16 * SPARC_INTREG_SIZE), 
 	       		      TARGET_PTR_BIT / TARGET_CHAR_BIT);
 #endif
 }
@@ -335,6 +348,17 @@ sparc_frame_saved_pc (frame)
 			  scbuf, sizeof (scbuf));
       return extract_address (scbuf, sizeof (scbuf));
     }
+  else if (frame->next != NULL
+	   && (frame->next->signal_handler_caller
+	       || frame_in_dummy (frame->next))
+	   && frameless_look_for_prologue (frame))
+    {
+      /* A frameless function interrupted by a signal did not save
+	 the PC, it is still in %o7.  */
+      get_saved_register (buf, (int *)NULL, (CORE_ADDR *)NULL,
+			  frame, O7_REGNUM, (enum lval_type *)NULL);
+      return PC_ADJUST (extract_address (buf, SPARC_INTREG_SIZE));
+    }
   if (frame->flat)
     addr = frame->pc_addr;
   else
@@ -517,24 +541,23 @@ skip_prologue (start_pc, frameless_p)
 
    This isn't static as it's used by remote-sa.sparc.c.  */
 
-branch_type
+static branch_type
 isbranch (instruction, addr, target)
      long instruction;
      CORE_ADDR addr, *target;
 {
   branch_type val = not_branch;
-  long int offset;		/* Must be signed for sign-extend.  */
+  long int offset = 0;		/* Must be signed for sign-extend.  */
 
   *target = 0;
 
   if (X_OP (instruction) == 0
       && (X_OP2 (instruction) == 2
 	  || X_OP2 (instruction) == 6
-#ifdef GDB_TARGET_IS_SPARC64
 	  || X_OP2 (instruction) == 1
 	  || X_OP2 (instruction) == 3
 	  || X_OP2 (instruction) == 5
-#else
+#ifndef GDB_TARGET_IS_SPARC64
 	  || X_OP2 (instruction) == 7
 #endif
 	  ))
@@ -552,7 +575,6 @@ isbranch (instruction, addr, target)
 #endif
 	  offset = 4 * X_DISP22 (instruction);
 	  break;
-#ifdef GDB_TARGET_IS_SPARC64
 	case 1:
 	case 5:
 	  offset = 4 * X_DISP19 (instruction);
@@ -560,7 +582,6 @@ isbranch (instruction, addr, target)
 	case 3:
 	  offset = 4 * X_DISP16 (instruction);
 	  break;
-#endif
 	}
       *target = addr + offset;
     }
@@ -630,6 +651,22 @@ get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
 
 
   frame1 = frame->next;
+
+  /* Get saved PC from the frame info if not in innermost frame.  */
+  if (regnum == PC_REGNUM && frame1 != NULL)
+    {
+      if (lval != NULL)
+	*lval = not_lval;
+      if (raw_buffer != NULL)
+	{
+	  /* Put it back in target format.  */
+	  store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), frame->pc);
+	}
+      if (addrp != NULL)
+	*addrp = 0;
+      return;
+    }
+
   while (frame1 != NULL)
     {
       if (frame1->pc >= (frame1->bottom ? frame1->bottom :
@@ -863,27 +900,27 @@ sparc_frame_find_saved_regs (fi, saved_regs_addr)
       for (regnum = G1_REGNUM; regnum < G1_REGNUM+7; regnum++)
 	saved_regs_addr->regs[regnum] =
 	  frame_addr + (regnum - G0_REGNUM) * SPARC_INTREG_SIZE
-	    - (FP_REGISTER_BYTES + 8 * SPARC_INTREG_SIZE);
+	    - DUMMY_STACK_REG_BUF_SIZE + 16 * SPARC_INTREG_SIZE;
       for (regnum = I0_REGNUM; regnum < I0_REGNUM+8; regnum++)
 	saved_regs_addr->regs[regnum] =
 	  frame_addr + (regnum - I0_REGNUM) * SPARC_INTREG_SIZE
-	    - (FP_REGISTER_BYTES + 16 * SPARC_INTREG_SIZE);
+	    - DUMMY_STACK_REG_BUF_SIZE + 8 * SPARC_INTREG_SIZE;
 #ifdef FP0_REGNUM
       for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 32; regnum++)
 	saved_regs_addr->regs[regnum] =
 	  frame_addr + (regnum - FP0_REGNUM) * 4
-	    - (FP_REGISTER_BYTES);
+	    - DUMMY_STACK_REG_BUF_SIZE + 24 * SPARC_INTREG_SIZE;
 #ifdef GDB_TARGET_IS_SPARC64
       for (regnum = FP0_REGNUM + 32; regnum < FP_MAX_REGNUM; regnum++)
 	saved_regs_addr->regs[regnum] =
 	  frame_addr + 32 * 4 + (regnum - FP0_REGNUM - 32) * 8
-	    - (FP_REGISTER_BYTES);
+	    - DUMMY_STACK_REG_BUF_SIZE + 24 * SPARC_INTREG_SIZE;
 #endif
 #endif /* FP0_REGNUM */
       for (regnum = Y_REGNUM; regnum < NUM_REGS; regnum++)
 	saved_regs_addr->regs[regnum] =
-	  frame_addr + (regnum - Y_REGNUM) * SPARC_INTREG_SIZE - 0xe0;
-	    - (FP_REGISTER_BYTES + 24 * SPARC_INTREG_SIZE);
+	  frame_addr + (regnum - Y_REGNUM) * SPARC_INTREG_SIZE 
+	    - DUMMY_STACK_REG_BUF_SIZE;
       frame_addr = fi->bottom ?
 	fi->bottom : read_register (SP_REGNUM);
     }
@@ -1094,7 +1131,7 @@ sparc_pc_adjust(pc)
   char buf[4];
   int err;
 
-  err = target_read_memory (pc + 8, buf, sizeof(long));
+  err = target_read_memory (pc + 8, buf, 4);
   insn = extract_unsigned_integer (buf, 4);
   if ((err == 0) && (insn & 0xffc00000) == 0)
     return pc+12;
@@ -1409,7 +1446,7 @@ void
 sparc_print_register_hook (regno)
      int regno;
 {
-  unsigned LONGEST val;
+  ULONGEST val;
 
   /* Handle double/quad versions of lower 32 fp regs.  */
   if (regno >= FP0_REGNUM && regno < FP0_REGNUM + 32
@@ -1546,9 +1583,82 @@ sparc_print_register_hook (regno)
 
 #endif
 
+int
+gdb_print_insn_sparc (memaddr, info)
+     bfd_vma memaddr;
+     disassemble_info *info;
+{
+  /* It's necessary to override mach again because print_insn messes it up. */
+  info->mach = TM_PRINT_INSN_MACH;
+  return print_insn_sparc (memaddr, info);
+}
+
+/* The SPARC passes the arguments on the stack; arguments smaller
+   than an int are promoted to an int.  */
+
+CORE_ADDR
+sparc_push_arguments (nargs, args, sp, struct_return, struct_addr)
+     int nargs;
+     value_ptr *args;
+     CORE_ADDR sp;
+     int struct_return;
+     CORE_ADDR struct_addr;
+{
+  int i;
+  int accumulate_size = 0;
+  struct sparc_arg
+    {
+      char *contents;
+      int len;
+      int offset;
+    };
+  struct sparc_arg *sparc_args =
+      (struct sparc_arg*)alloca (nargs * sizeof (struct sparc_arg));
+  struct sparc_arg *m_arg;
+
+  /* Promote arguments if necessary, and calculate their stack offsets
+     and sizes. */
+  for (i = 0, m_arg = sparc_args; i < nargs; i++, m_arg++)
+    {
+      value_ptr arg = args[i];
+      struct type *arg_type = check_typedef (VALUE_TYPE (arg));
+      /* Cast argument to long if necessary as the compiler does it too.  */
+      switch (TYPE_CODE (arg_type))
+	{
+	case TYPE_CODE_INT:
+	case TYPE_CODE_BOOL:
+	case TYPE_CODE_CHAR:
+	case TYPE_CODE_RANGE:
+	case TYPE_CODE_ENUM:
+	  if (TYPE_LENGTH (arg_type) < TYPE_LENGTH (builtin_type_long))
+	    {
+	      arg_type = builtin_type_long;
+	      arg = value_cast (arg_type, arg);
+	    }
+	  break;
+	default:
+	  break;
+	}
+      m_arg->len = TYPE_LENGTH (arg_type);
+      m_arg->offset = accumulate_size;
+      accumulate_size = (accumulate_size + m_arg->len + 3) & ~3;
+      m_arg->contents = VALUE_CONTENTS(arg);
+    }
+
+  /* Make room for the arguments on the stack.  */
+  accumulate_size += CALL_DUMMY_STACK_ADJUST;
+  sp = ((sp - accumulate_size) & ~7) + CALL_DUMMY_STACK_ADJUST;
+
+  /* `Push' arguments on the stack.  */
+  for (i = nargs; m_arg--, --i >= 0; )
+    write_memory(sp + m_arg->offset, m_arg->contents, m_arg->len);
+
+  return sp;
+}
+
 void
 _initialize_sparc_tdep ()
 {
-  tm_print_insn = print_insn_sparc;
+  tm_print_insn = gdb_print_insn_sparc;
   tm_print_insn_info.mach = TM_PRINT_INSN_MACH;  /* Selects sparc/sparclite */
 }