gdb/irix5-nat.c

   1 /* Native support for the SGI Iris running IRIX version 5, for GDB.
   2
   3    Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
   4    1998, 1999, 2000, 2001, 2002, 2004 Free Software Foundation, Inc.
   5
   6    Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
   7    and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
   8    Implemented for Irix 4.x by Garrett A. Wollman.
   9    Modified for Irix 5.x by Ian Lance Taylor.
  10
  11    This file is part of GDB.
  12
  13    This program is free software; you can redistribute it and/or modify
  14    it under the terms of the GNU General Public License as published by
  15    the Free Software Foundation; either version 2 of the License, or
  16    (at your option) any later version.
  17
  18    This program is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21    GNU General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program; if not, write to the Free Software
  25    Foundation, Inc., 59 Temple Place - Suite 330,
  26    Boston, MA 02111-1307, USA.  */
  27
  28 #include "defs.h"
  29 #include "inferior.h"
  30 #include "gdbcore.h"
  31 #include "target.h"
  32 #include "regcache.h"
  33
  34 #include "gdb_string.h"
  35 #include <sys/time.h>
  36 #include <sys/procfs.h>
  37 #include <setjmp.h>             /* For JB_XXX.  */
  38
  39 /* Prototypes for supply_gregset etc. */
  40 #include "gregset.h"
  41 #include "mips-tdep.h"
  42
  43 static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR);
  44
  45 /* Size of elements in jmpbuf */
  46
  47 #define JB_ELEMENT_SIZE 4
  48
  49 /*
  50  * See the comment in m68k-tdep.c regarding the utility of these functions.
  51  *
  52  * These definitions are from the MIPS SVR4 ABI, so they may work for
  53  * any MIPS SVR4 target.
  54  */
  55
  56 void
  57 supply_gregset (gregset_t *gregsetp)
  58 {
  59   int regi;
  60   greg_t *regp = &(*gregsetp)[0];
  61   int gregoff = sizeof (greg_t) - mips_isa_regsize (current_gdbarch);
  62   static char zerobuf[32] = {0};
  63
  64   for (regi = 0; regi <= CTX_RA; regi++)
  65     regcache_raw_supply (current_regcache, regi,
  66                          (char *) (regp + regi) + gregoff);
  67
  68   regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->pc,
  69                        (char *) (regp + CTX_EPC) + gregoff);
  70   regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->hi,
  71                        (char *) (regp + CTX_MDHI) + gregoff);
  72   regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->lo,
  73                        (char *) (regp + CTX_MDLO) + gregoff);
  74   regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->cause,
  75                        (char *) (regp + CTX_CAUSE) + gregoff);
  76
  77   /* Fill inaccessible registers with zero.  */
  78   regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->badvaddr, zerobuf);
  79 }
  80
  81 void
  82 fill_gregset (gregset_t *gregsetp, int regno)
  83 {
  84   int regi;
  85   greg_t *regp = &(*gregsetp)[0];
  86
  87   /* Under Irix6, if GDB is built with N32 ABI and is debugging an O32
  88      executable, we have to sign extend the registers to 64 bits before
  89      filling in the gregset structure.  */
  90
  91   for (regi = 0; regi <= CTX_RA; regi++)
  92     if ((regno == -1) || (regno == regi))
  93       *(regp + regi) =
  94         extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)],
  95                                 register_size (current_gdbarch, regi));
  96
  97   if ((regno == -1) || (regno == PC_REGNUM))
  98     *(regp + CTX_EPC) =
  99       extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (mips_regnum (current_gdbarch)->pc)],
 100                               register_size (current_gdbarch, mips_regnum (current_gdbarch)->pc));
 101
 102   if ((regno == -1) || (regno == mips_regnum (current_gdbarch)->cause))
 103     *(regp + CTX_CAUSE) =
 104       extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (mips_regnum (current_gdbarch)->cause)],
 105                               register_size (current_gdbarch, mips_regnum (current_gdbarch)->cause));
 106
 107   if ((regno == -1)
 108       || (regno == mips_regnum (current_gdbarch)->hi))
 109     *(regp + CTX_MDHI) =
 110       extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (mips_regnum (current_gdbarch)->hi)],
 111                               register_size (current_gdbarch, mips_regnum (current_gdbarch)->hi));
 112
 113   if ((regno == -1) || (regno == mips_regnum (current_gdbarch)->lo))
 114     *(regp + CTX_MDLO) =
 115       extract_signed_integer (&deprecated_registers[DEPRECATED_REGISTER_BYTE (mips_regnum (current_gdbarch)->lo)],
 116                               register_size (current_gdbarch, mips_regnum (current_gdbarch)->lo));
 117 }
 118
 119 /*
 120  * Now we do the same thing for floating-point registers.
 121  * We don't bother to condition on FP0_REGNUM since any
 122  * reasonable MIPS configuration has an R3010 in it.
 123  *
 124  * Again, see the comments in m68k-tdep.c.
 125  */
 126
 127 void
 128 supply_fpregset (fpregset_t *fpregsetp)
 129 {
 130   int regi;
 131   static char zerobuf[32] = {0};
 132
 133   /* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */
 134
 135   for (regi = 0; regi < 32; regi++)
 136     regcache_raw_supply (current_regcache, FP0_REGNUM + regi,
 137                          (char *) &fpregsetp->fp_r.fp_regs[regi]);
 138
 139   regcache_raw_supply (current_regcache,
 140                        mips_regnum (current_gdbarch)->fp_control_status,
 141                        (char *) &fpregsetp->fp_csr);
 142
 143   /* FIXME: how can we supply FCRIR?  SGI doesn't tell us. */
 144   regcache_raw_supply (current_regcache,
 145                        mips_regnum (current_gdbarch)->fp_implementation_revision,
 146                        zerobuf);
 147 }
 148
 149 void
 150 fill_fpregset (fpregset_t *fpregsetp, int regno)
 151 {
 152   int regi;
 153   char *from, *to;
 154
 155   /* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */
 156
 157   for (regi = FP0_REGNUM; regi < FP0_REGNUM + 32; regi++)
 158     {
 159       if ((regno == -1) || (regno == regi))
 160         {
 161           from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
 162           to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]);
 163           memcpy (to, from, register_size (current_gdbarch, regi));
 164         }
 165     }
 166
 167   if ((regno == -1)
 168       || (regno == mips_regnum (current_gdbarch)->fp_control_status))
 169     fpregsetp->fp_csr = *(unsigned *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (mips_regnum (current_gdbarch)->fp_control_status)];
 170 }
 171
 172
 173 /* Figure out where the longjmp will land.
 174    We expect the first arg to be a pointer to the jmp_buf structure from which
 175    we extract the pc (JB_PC) that we will land at.  The pc is copied into PC.
 176    This routine returns true on success. */
 177
 178 int
 179 get_longjmp_target (CORE_ADDR *pc)
 180 {
 181   char *buf;
 182   CORE_ADDR jb_addr;
 183
 184   buf = alloca (TARGET_PTR_BIT / TARGET_CHAR_BIT);
 185   jb_addr = read_register (A0_REGNUM);
 186
 187   if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
 188                           TARGET_PTR_BIT / TARGET_CHAR_BIT))
 189     return 0;
 190
 191   *pc = extract_unsigned_integer (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
 192
 193   return 1;
 194 }
 195
 196 /* Provide registers to GDB from a core file.
 197
 198    CORE_REG_SECT points to an array of bytes, which were obtained from
 199    a core file which BFD thinks might contain register contents.
 200    CORE_REG_SIZE is its size.
 201
 202    Normally, WHICH says which register set corelow suspects this is:
 203      0 --- the general-purpose register set
 204      2 --- the floating-point register set
 205    However, for Irix 5, WHICH isn't used.
 206
 207    REG_ADDR is also unused.  */
 208
 209 static void
 210 fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
 211                       int which, CORE_ADDR reg_addr)
 212 {
 213   if (core_reg_size == DEPRECATED_REGISTER_BYTES)
 214     {
 215       memcpy ((char *) deprecated_registers, core_reg_sect, core_reg_size);
 216     }
 217   else if (mips_isa_regsize (current_gdbarch) == 4 &&
 218            core_reg_size == (2 * mips_isa_regsize (current_gdbarch)) * NUM_REGS)
 219     {
 220       /* This is a core file from a N32 executable, 64 bits are saved
 221          for all registers.  */
 222       char *srcp = core_reg_sect;
 223       char *dstp = deprecated_registers;
 224       int regno;
 225
 226       for (regno = 0; regno < NUM_REGS; regno++)
 227         {
 228           if (regno >= FP0_REGNUM && regno < (FP0_REGNUM + 32))
 229             {
 230               /* FIXME, this is wrong, N32 has 64 bit FP regs, but GDB
 231                  currently assumes that they are 32 bit.  */
 232               *dstp++ = *srcp++;
 233               *dstp++ = *srcp++;
 234               *dstp++ = *srcp++;
 235               *dstp++ = *srcp++;
 236               if (register_size (current_gdbarch, regno) == 4)
 237                 {
 238                   /* copying 4 bytes from eight bytes?
 239                      I don't see how this can be right...  */
 240                   srcp += 4;
 241                 }
 242               else
 243                 {
 244                   /* copy all 8 bytes (sizeof(double)) */
 245                   *dstp++ = *srcp++;
 246                   *dstp++ = *srcp++;
 247                   *dstp++ = *srcp++;
 248                   *dstp++ = *srcp++;
 249                 }
 250             }
 251           else
 252             {
 253               srcp += 4;
 254               *dstp++ = *srcp++;
 255               *dstp++ = *srcp++;
 256               *dstp++ = *srcp++;
 257               *dstp++ = *srcp++;
 258             }
 259         }
 260     }
 261   else
 262     {
 263       warning ("wrong size gregset struct in core file");
 264       return;
 265     }
 266
 267   deprecated_registers_fetched ();
 268 }
 269
 270 /* Register that we are able to handle irix5 core file formats.
 271    This really is bfd_target_unknown_flavour */
 272
 273 static struct core_fns irix5_core_fns =
 274 {
 275   bfd_target_unknown_flavour,           /* core_flavour */
 276   default_check_format,                 /* check_format */
 277   default_core_sniffer,                 /* core_sniffer */
 278   fetch_core_registers,                 /* core_read_registers */
 279   NULL                                  /* next */
 280 };
 281
 282 void
 283 _initialize_core_irix5 (void)
 284 {
 285   deprecated_add_core_fns (&irix5_core_fns);
 286 }