gdb/hp300ux-nat.c

   1 /* HP/UX native interface for HP 300's, for GDB when running under Unix.
   2    Copyright 1986, 1987, 1989, 1991, 1992, 1993 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "defs.h"
  21 #include "frame.h"
  22 #include "inferior.h"
  23
  24 /* Defining this means some system include files define some extra stuff.  */
  25 #define WOPR
  26 #include <sys/param.h>
  27 #include <signal.h>
  28 #include <sys/user.h>
  29 #include <fcntl.h>
  30
  31 #include <sys/ptrace.h>
  32 #include <sys/reg.h>
  33 #include <sys/trap.h>
  34
  35 #include <sys/file.h>
  36
  37 static void
  38 fetch_inferior_register PARAMS ((int, unsigned int));
  39
  40 static void
  41 store_inferior_register_1 PARAMS ((int, unsigned int, int));
  42
  43 static void
  44 store_inferior_register PARAMS ((int, unsigned int));
  45
  46 /* Get kernel_u_addr using HPUX-style nlist().  */
  47 CORE_ADDR kernel_u_addr;
  48
  49 struct hpnlist {
  50         char *          n_name;
  51         long            n_value;
  52         unsigned char   n_type;
  53         unsigned char   n_length;
  54         short           n_almod;
  55         short           n_unused;
  56 };
  57 static struct hpnlist nl[] = {{ "_u", -1, }, { (char *) 0, }};
  58
  59 /* read the value of the u area from the hp-ux kernel */
  60 void
  61 _initialize_hp300ux_nat ()
  62 {
  63 #ifndef HPUX_VERSION_5
  64     nlist ("/hp-ux", nl);
  65     kernel_u_addr = nl[0].n_value;
  66 #else /* HPUX version 5.  */
  67     kernel_u_addr = (CORE_ADDR) 0x0097900;
  68 #endif
  69 }
  70
  71 #define INFERIOR_AR0(u)                                                 \
  72   ((ptrace                                                              \
  73     (PT_RUAREA, inferior_pid,                                           \
  74      (PTRACE_ARG3_TYPE) ((char *) &u.u_ar0 - (char *) &u), 0, 0))               \
  75    - kernel_u_addr)
  76
  77 static void
  78 fetch_inferior_register (regno, regaddr)
  79      register int regno;
  80      register unsigned int regaddr;
  81 {
  82 #ifndef HPUX_VERSION_5
  83   if (regno == PS_REGNUM)
  84     {
  85       union { int i; short s[2]; } ps_val;
  86       int regval;
  87
  88       ps_val.i = (ptrace (PT_RUAREA, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
  89                           0, 0));
  90       regval = ps_val.s[0];
  91       supply_register (regno, (char *)&regval);
  92     }
  93   else
  94 #endif /* not HPUX_VERSION_5 */
  95     {
  96       char buf[MAX_REGISTER_RAW_SIZE];
  97       register int i;
  98
  99       for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
 100         {
 101           *(int *) &buf[i] = ptrace (PT_RUAREA, inferior_pid,
 102                                      (PTRACE_ARG3_TYPE) regaddr, 0, 0);
 103           regaddr += sizeof (int);
 104         }
 105       supply_register (regno, buf);
 106     }
 107   return;
 108 }
 109
 110 static void
 111 store_inferior_register_1 (regno, regaddr, val)
 112      int regno;
 113      unsigned int regaddr;
 114      int val;
 115 {
 116   errno = 0;
 117   ptrace (PT_WUAREA, inferior_pid, (PTRACE_ARG3_TYPE) regaddr, val, 0);
 118 #if 0
 119   /* HP-UX randomly sets errno to non-zero for regno == 25.
 120      However, the value is correctly written, so ignore errno. */
 121   if (errno != 0)
 122     {
 123       char string_buf[64];
 124
 125       sprintf (string_buf, "writing register number %d", regno);
 126       perror_with_name (string_buf);
 127     }
 128 #endif
 129   return;
 130 }
 131
 132 static void
 133 store_inferior_register (regno, regaddr)
 134      register int regno;
 135      register unsigned int regaddr;
 136 {
 137 #ifndef HPUX_VERSION_5
 138   if (regno == PS_REGNUM)
 139     {
 140       union { int i; short s[2]; } ps_val;
 141
 142       ps_val.i = (ptrace (PT_RUAREA, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
 143                           0, 0));
 144       ps_val.s[0] = (read_register (regno));
 145       store_inferior_register_1 (regno, regaddr, ps_val.i);
 146     }
 147   else
 148 #endif /* not HPUX_VERSION_5 */
 149     {
 150       register int i;
 151
 152       for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
 153         {
 154           store_inferior_register_1
 155             (regno, regaddr,
 156              (*(int *) &registers[(REGISTER_BYTE (regno)) + i]));
 157           regaddr += sizeof (int);
 158         }
 159     }
 160   return;
 161 }
 162
 163 void
 164 fetch_inferior_registers (regno)
 165      int regno;
 166 {
 167   struct user u;
 168   register unsigned int ar0_offset;
 169
 170   ar0_offset = (INFERIOR_AR0 (u));
 171   if (regno == -1)
 172     {
 173       for (regno = 0; (regno < FP0_REGNUM); regno++)
 174         fetch_inferior_register (regno, (REGISTER_ADDR (ar0_offset, regno)));
 175       for (; (regno < NUM_REGS); regno++)
 176         fetch_inferior_register (regno, (FP_REGISTER_ADDR (u, regno)));
 177     }
 178   else
 179     fetch_inferior_register (regno,
 180                              (regno < FP0_REGNUM
 181                               ? REGISTER_ADDR (ar0_offset, regno)
 182                               : FP_REGISTER_ADDR (u, regno)));
 183 }
 184
 185 /* Store our register values back into the inferior.
 186    If REGNO is -1, do this for all registers.
 187    Otherwise, REGNO specifies which register (so we can save time).  */
 188
 189 void
 190 store_inferior_registers (regno)
 191      register int regno;
 192 {
 193   struct user u;
 194   register unsigned int ar0_offset;
 195
 196   if (regno >= FP0_REGNUM)
 197     {
 198       store_inferior_register (regno, (FP_REGISTER_ADDR (u, regno)));
 199       return;
 200     }
 201
 202   ar0_offset = (INFERIOR_AR0 (u));
 203   if (regno >= 0)
 204     {
 205       store_inferior_register (regno, (REGISTER_ADDR (ar0_offset, regno)));
 206       return;
 207     }
 208
 209   for (regno = 0; (regno < FP0_REGNUM); regno++)
 210     store_inferior_register (regno, (REGISTER_ADDR (ar0_offset, regno)));
 211   for (; (regno < NUM_REGS); regno++)
 212     store_inferior_register (regno, (FP_REGISTER_ADDR (u, regno)));
 213   return;
 214 }
 215
 216 int
 217 getpagesize ()
 218 {
 219   return 4096;
 220 }