gdb/mips-nat.c

   1 /* Low level MIPS interface to ptrace, for GDB when running under Unix.
   2    Copyright 1988, 1989, 1991, 1992 Free Software Foundation, Inc.
   3    Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU
   4    and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin.
   5
   6 This file is part of GDB.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21
  22 #include "defs.h"
  23 #include "inferior.h"
  24 #include "gdbcore.h"
  25
  26 /* For now we stub this out; sgi core format is super-hairy (and completely
  27    different in the new release).
  28    For most mips systems, this function is defined in coredep.c.   */
  29
  30 #if defined(sgi)
  31 void
  32 fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
  33      char *core_reg_sect;
  34      unsigned core_reg_size;
  35      int which;
  36      unsigned int reg_addr;
  37 {
  38   return;
  39 }
  40 #endif
  41
  42 /* Access to the inferior is only good for native systems, not cross.
  43    I am not sure why this is stubbed out on SGI...   --gnu@cygnus.com  */
  44
  45 #if defined(sgi) || !defined(GDB_TARGET_IS_MIPS)
  46
  47 /* ARGSUSED */
  48 void
  49 fetch_inferior_registers (regno)
  50      int regno;
  51 {
  52   return;
  53 }
  54
  55 /* ARGSUSED */
  56 void
  57 store_inferior_registers (regno)
  58      int regno;
  59 {
  60   return;
  61 }
  62
  63
  64 #else
  65
  66 /* DECstation native... */
  67
  68 #include <sys/ptrace.h>
  69
  70 /* Map gdb internal register number to ptrace ``address''.
  71    These ``addresses'' are defined in DECstation <sys/ptrace.h> */
  72
  73 #define REGISTER_PTRACE_ADDR(regno) \
  74    (regno < 32 ?                GPR_BASE + regno \
  75   : regno == PC_REGNUM ?        PC      \
  76   : regno == CAUSE_REGNUM ?     CAUSE   \
  77   : regno == HI_REGNUM ?        MMHI    \
  78   : regno == LO_REGNUM ?        MMLO    \
  79   : regno == FCRCS_REGNUM ?     FPC_CSR \
  80   : regno == FCRIR_REGNUM ?     FPC_EIR \
  81   : regno >= FP0_REGNUM ?       FPR_BASE + (regno - FP0_REGNUM) \
  82   : 0)
  83
  84 static const char zerobuf[MAX_REGISTER_RAW_SIZE];
  85
  86 /* Get all registers from the inferior */
  87
  88 void
  89 fetch_inferior_registers (regno)
  90      int regno;
  91 {
  92   register unsigned int regaddr;
  93   char buf[MAX_REGISTER_RAW_SIZE];
  94   register int i;
  95
  96   registers_fetched ();
  97
  98   for (regno = 1; regno < NUM_REGS; regno++)
  99     {
 100       regaddr = REGISTER_PTRACE_ADDR (regno);
 101       for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
 102         {
 103           *(int *) &buf[i] = ptrace (PT_READ_U, inferior_pid,
 104                                      (PTRACE_ARG3_TYPE) regaddr, 0);
 105           regaddr += sizeof (int);
 106         }
 107       supply_register (regno, buf);
 108     }
 109
 110   supply_register (ZERO_REGNUM, zerobuf);
 111   /* Frame ptr reg must appear to be 0; it is faked by stack handling code. */
 112   supply_register (FP_REGNUM, zerobuf);
 113 }
 114
 115 /* Store our register values back into the inferior.
 116    If REGNO is -1, do this for all registers.
 117    Otherwise, REGNO specifies which register (so we can save time).  */
 118
 119 void
 120 store_inferior_registers (regno)
 121      int regno;
 122 {
 123   register unsigned int regaddr;
 124   char buf[80];
 125
 126   if (regno == 0)
 127     return;
 128
 129   if (regno > 0)
 130     {
 131       regaddr = REGISTER_PTRACE_ADDR (regno);
 132       errno = 0;
 133       ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
 134               read_register (regno));
 135       if (errno != 0)
 136         {
 137           sprintf (buf, "writing register number %d", regno);
 138           perror_with_name (buf);
 139         }
 140     }
 141   else
 142     {
 143       for (regno = 0; regno < NUM_REGS; regno++)
 144         {
 145           if (regno == ZERO_REGNUM || regno == PS_REGNUM
 146               || regno == BADVADDR_REGNUM || regno == CAUSE_REGNUM
 147               || regno == FCRIR_REGNUM || regno == FP_REGNUM
 148               || (regno >= FIRST_EMBED_REGNUM && regno <= LAST_EMBED_REGNUM))
 149             continue;
 150           regaddr = register_addr (regno, 1);
 151           errno = 0;
 152           ptrace (6, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
 153                   read_register (regno));
 154           if (errno != 0)
 155             {
 156               sprintf (buf, "writing all regs, number %d", regno);
 157               perror_with_name (buf);
 158             }
 159         }
 160     }
 161 }
 162
 163 #endif /* sgi */
 164
 165