gdb/irix4-nat.c

   1 /* Native support for the SGI Iris running IRIX version 4, for GDB.
   2    Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1995
   3    Free Software Foundation, Inc.
   4    Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
   5    and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
   6    Implemented for Irix 4.x by Garrett A. Wollman.
   7
   8 This file is part of GDB.
   9
  10 This program is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 2 of the License, or
  13 (at your option) any later version.
  14
  15 This program is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with this program; if not, write to the Free Software
  22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  23
  24 #include "defs.h"
  25 #include "inferior.h"
  26
  27 #include <sys/time.h>
  28 #include <sys/procfs.h>
  29 #include <setjmp.h>             /* For JB_XXX.  */
  30
  31 /* Size of elements in jmpbuf */
  32
  33 #define JB_ELEMENT_SIZE 4
  34
  35 typedef unsigned int greg_t;    /* why isn't this defined? */
  36
  37 /*
  38  * See the comment in m68k-tdep.c regarding the utility of these functions.
  39  */
  40
  41 void
  42 supply_gregset (gregsetp)
  43      gregset_t *gregsetp;
  44 {
  45   register int regi;
  46   register greg_t *regp = (greg_t *)(gregsetp->gp_regs);
  47   static char zerobuf[MAX_REGISTER_RAW_SIZE] = {0};
  48
  49   /* FIXME: somewhere, there should be a #define for the meaning
  50      of this magic number 32; we should use that. */
  51   for(regi = 0; regi < 32; regi++)
  52     supply_register (regi, (char *)(regp + regi));
  53
  54   supply_register (PC_REGNUM, (char *)&(gregsetp->gp_pc));
  55   supply_register (HI_REGNUM, (char *)&(gregsetp->gp_mdhi));
  56   supply_register (LO_REGNUM, (char *)&(gregsetp->gp_mdlo));
  57   supply_register (CAUSE_REGNUM, (char *)&(gregsetp->gp_cause));
  58
  59   /* Fill inaccessible registers with zero.  */
  60   supply_register (BADVADDR_REGNUM, zerobuf);
  61 }
  62
  63 void
  64 fill_gregset (gregsetp, regno)
  65      gregset_t *gregsetp;
  66      int regno;
  67 {
  68   int regi;
  69   register greg_t *regp = (greg_t *)(gregsetp->gp_regs);
  70
  71   /* same FIXME as above wrt 32*/
  72   for (regi = 0; regi < 32; regi++)
  73     if ((regno == -1) || (regno == regi))
  74       *(regp + regi) = *(greg_t *) &registers[REGISTER_BYTE (regi)];
  75
  76   if ((regno == -1) || (regno == PC_REGNUM))
  77     gregsetp->gp_pc = *(greg_t *) &registers[REGISTER_BYTE (PC_REGNUM)];
  78
  79   if ((regno == -1) || (regno == CAUSE_REGNUM))
  80     gregsetp->gp_cause = *(greg_t *) &registers[REGISTER_BYTE (CAUSE_REGNUM)];
  81
  82   if ((regno == -1) || (regno == HI_REGNUM))
  83     gregsetp->gp_mdhi = *(greg_t *) &registers[REGISTER_BYTE (HI_REGNUM)];
  84
  85   if ((regno == -1) || (regno == LO_REGNUM))
  86     gregsetp->gp_mdlo = *(greg_t *) &registers[REGISTER_BYTE (LO_REGNUM)];
  87 }
  88
  89 /*
  90  * Now we do the same thing for floating-point registers.
  91  * We don't bother to condition on FP0_REGNUM since any
  92  * reasonable MIPS configuration has an R3010 in it.
  93  *
  94  * Again, see the comments in m68k-tdep.c.
  95  */
  96
  97 void
  98 supply_fpregset (fpregsetp)
  99      fpregset_t *fpregsetp;
 100 {
 101   register int regi;
 102   static char zerobuf[MAX_REGISTER_RAW_SIZE] = {0};
 103
 104   for (regi = 0; regi < 32; regi++)
 105     supply_register (FP0_REGNUM + regi,
 106                      (char *)&fpregsetp->fp_r.fp_regs[regi]);
 107
 108   supply_register (FCRCS_REGNUM, (char *)&fpregsetp->fp_csr);
 109
 110   /* FIXME: how can we supply FCRIR_REGNUM?  SGI doesn't tell us. */
 111   supply_register (FCRIR_REGNUM, zerobuf);
 112 }
 113
 114 void
 115 fill_fpregset (fpregsetp, regno)
 116      fpregset_t *fpregsetp;
 117      int regno;
 118 {
 119   int regi;
 120   char *from, *to;
 121
 122   for (regi = FP0_REGNUM; regi < FP0_REGNUM + 32; regi++)
 123     {
 124       if ((regno == -1) || (regno == regi))
 125         {
 126           from = (char *) &registers[REGISTER_BYTE (regi)];
 127           to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]);
 128           memcpy(to, from, REGISTER_RAW_SIZE (regi));
 129         }
 130     }
 131
 132   if ((regno == -1) || (regno == FCRCS_REGNUM))
 133     fpregsetp->fp_csr = *(unsigned *) &registers[REGISTER_BYTE(FCRCS_REGNUM)];
 134 }
 135
 136
 137 /* Figure out where the longjmp will land.
 138    We expect the first arg to be a pointer to the jmp_buf structure from which
 139    we extract the pc (JB_PC) that we will land at.  The pc is copied into PC.
 140    This routine returns true on success. */
 141
 142 int
 143 get_longjmp_target (pc)
 144      CORE_ADDR *pc;
 145 {
 146   char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT];
 147   CORE_ADDR jb_addr;
 148
 149   jb_addr = read_register (A0_REGNUM);
 150
 151   if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
 152                           TARGET_PTR_BIT / TARGET_CHAR_BIT))
 153     return 0;
 154
 155   *pc = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
 156
 157   return 1;
 158 }
 159
 160 void
 161 fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
 162      char *core_reg_sect;
 163      unsigned core_reg_size;
 164      int which;                 /* Unused */
 165      unsigned int reg_addr;     /* Unused */
 166 {
 167   if (core_reg_size != REGISTER_BYTES)
 168     {
 169       warning ("wrong size gregset struct in core file");
 170       return;
 171     }
 172
 173   memcpy ((char *)registers, core_reg_sect, core_reg_size);
 174 }