[PATCH]: Support 32-bit corefiles on 64-bit host (Solaris sparc)

[msnyder at cygnus dot com]

2000-05-26  Michael Snyder  <msnyder@seadog.cygnus.com>

        * core-sol2.c (fetch_core_registers): Add new code to handle
        32-bit corefiles when host is 64-bit (Solaris Sparc).

Index: core-sol2.c
===================================================================
RCS file: /cvs/src/src/gdb/core-sol2.c,v
retrieving revision 1.1.1.3
diff -p -r1.1.1.3 core-sol2.c
*** core-sol2.c	1999/10/05 23:08:07	1.1.1.3
--- core-sol2.c	2000/05/26 20:51:17
***************
*** 26,32 ****
--- 26,40 ----
     This file combines the core register fetching from core-regset.c
     and sparc-nat.c to be able to read both flavours.  */
  
+ #define _SYSCALL32
+ 
  #include "defs.h"
+ 
+ #if defined (__sparcv9)
+ /* Fails to get included by the system header files.  */
+ # include <v9/sys/privregs.h>
+ #endif
+ 
  #include <time.h>
  #include <sys/types.h>
  #include <sys/regset.h>
***************
*** 40,45 ****
--- 48,56 ----
  #include "command.h"
  #include "gdbcore.h"
  
+ /* Prototypes for supply_gregset etc. */
+ #include "gregset.h"
+ 
  static void fetch_core_registers PARAMS ((char *, unsigned, int, CORE_ADDR));
  
  static void
*************** fetch_core_registers (core_reg_sect, cor
*** 49,67 ****
       int which;
       CORE_ADDR reg_addr;	/* Unused in this version */
  {
!   prgregset_t prgregset;
!   prfpregset_t prfpregset;
  
    if (which == 0)
      {
!       if (core_reg_size == sizeof (prgregset))
  	{
  	  memcpy ((char *) &prgregset, core_reg_sect, sizeof (prgregset));
  	  supply_gregset (&prgregset);
  	}
        else if (core_reg_size == sizeof (struct regs))
  	{
! #define gregs ((struct regs *)core_reg_sect)
  	  /* G0 *always* holds 0.  */
  	  *(int *) &registers[REGISTER_BYTE (0)] = 0;
  
--- 60,94 ----
       int which;
       CORE_ADDR reg_addr;	/* Unused in this version */
  {
!   int i;
  
    if (which == 0)
      {
!       prgregset_t prgregset;
! 
!       if (core_reg_size == sizeof (prgregset_t))
  	{
  	  memcpy ((char *) &prgregset, core_reg_sect, sizeof (prgregset));
  	  supply_gregset (&prgregset);
  	}
+ #if defined (__sparcv9)
+       else if (core_reg_size == sizeof (prgregset32_t))
+ 	{
+ 	  prgreg32_t *core_gregs;
+ 
+ 	  /* Can't use memcpy here, because the core file contains
+ 	     32-bit regs; supply_register expects 64-bit regs.  */
+ 	  core_gregs = (prgreg32_t *) core_reg_sect;
+ 	  for (i = 0; i < NPRGREG; i++)
+ 	    prgregset[i] = core_gregs[i];
+ 
+ 	  supply_gregset (&prgregset);
+ 	}
+ #endif /* __sparcv9 */
        else if (core_reg_size == sizeof (struct regs))
  	{
! 	  struct regs *gregs = (struct regs *) core_reg_sect;
! 
  	  /* G0 *always* holds 0.  */
  	  *(int *) &registers[REGISTER_BYTE (0)] = 0;
  
*************** fetch_core_registers (core_reg_sect, cor
*** 97,110 ****
      }
    else if (which == 2)
      {
!       if (core_reg_size == sizeof (prfpregset))
  	{
  	  memcpy ((char *) &prfpregset, core_reg_sect, sizeof (prfpregset));
  	  supply_fpregset (&prfpregset);
  	}
        else if (core_reg_size >= sizeof (struct fpu))
  	{
! #define fpuregs  ((struct fpu *) core_reg_sect)
  	  memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], &fpuregs->fpu_fr,
  		  sizeof (fpuregs->fpu_fr));
  	  memcpy (&registers[REGISTER_BYTE (FPS_REGNUM)], &fpuregs->fpu_fsr,
--- 124,163 ----
      }
    else if (which == 2)
      {
!       prfpregset_t prfpregset;
! 
!       if (core_reg_size == sizeof (prfpregset_t))
  	{
  	  memcpy ((char *) &prfpregset, core_reg_sect, sizeof (prfpregset));
  	  supply_fpregset (&prfpregset);
  	}
+ #if defined (__sparcv9)
+       else if (core_reg_size == sizeof (prfpregset32_t))
+ 	{
+ 	  prfpregset32_t *core_fpregset;
+ 
+ 	  /* Can't use memcpy here, because the core file contains
+ 	     32-bit regs; supply_fpregset expects 64-bit regs.  */
+ 
+ 	  core_fpregset = (prfpregset32_t *) core_reg_sect;
+ 	  for (i = 0; i < 16; i++)
+ 	    prfpregset.pr_fr.pr_dregs[i] = core_fpregset->pr_fr.pr_dregs[i];
+ 	  while (i < 32)
+ 	    prfpregset.pr_fr.pr_dregs[i++] = 0;
+ 
+ 	  prfpregset.pr_fsr         = core_fpregset->pr_fsr;
+ 	  prfpregset.pr_qcnt        = core_fpregset->pr_qcnt;
+ 	  prfpregset.pr_q_entrysize = core_fpregset->pr_q_entrysize;
+ 	  prfpregset.pr_en          = core_fpregset->pr_en;
+ 	  /* We will not use the pr_q array.  */
+ 
+ 	  supply_fpregset (&prfpregset);
+ 	}
+ #endif /* __sparcv9 */
        else if (core_reg_size >= sizeof (struct fpu))
  	{
! 	  struct fpu *fpuregs = (struct fpu *) core_reg_sect;
! 
  	  memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], &fpuregs->fpu_fr,
  		  sizeof (fpuregs->fpu_fr));
  	  memcpy (&registers[REGISTER_BYTE (FPS_REGNUM)], &fpuregs->fpu_fsr,
*************** fetch_core_registers (core_reg_sect, cor
*** 116,121 ****
--- 169,175 ----
  	}
      }
  }
+ 
  
  
  /* Register that we are able to handle solaris core file formats. */