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,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "frame.h"
  23 #include "inferior.h"
  24
  25 /* Defining this means some system include files define some extra stuff.  */
  26 #define WOPR
  27 #include <sys/param.h>
  28 #include <signal.h>
  29 #include <sys/user.h>
  30 #include <fcntl.h>
  31
  32 #include <sys/ptrace.h>
  33 #include <sys/reg.h>
  34 #include <sys/trap.h>
  35
  36 #include <sys/file.h>
  37
  38 static void fetch_inferior_register (int, unsigned int);
  39
  40 static void store_inferior_register_1 (int, unsigned int, int);
  41
  42 static void store_inferior_register (int, unsigned int);
  43
  44 /* Get kernel_u_addr using HPUX-style nlist().  */
  45 CORE_ADDR kernel_u_addr;
  46
  47 struct hpnlist
  48   {
  49     char *n_name;
  50     long n_value;
  51     unsigned char n_type;
  52     unsigned char n_length;
  53     short n_almod;
  54     short n_unused;
  55   };
  56 static struct hpnlist nl[] =
  57 {
  58   {"_u", -1,},
  59   {(char *) 0,}};
  60
  61 /* read the value of the u area from the hp-ux kernel */
  62 void
  63 _initialize_hp300ux_nat ()
  64 {
  65 #ifndef HPUX_VERSION_5
  66   nlist ("/hp-ux", nl);
  67   kernel_u_addr = nl[0].n_value;
  68 #else /* HPUX version 5.  */
  69   kernel_u_addr = (CORE_ADDR) 0x0097900;
  70 #endif
  71 }
  72
  73 #define INFERIOR_AR0(u)                                                 \
  74   ((ptrace                                                              \
  75     (PT_RUAREA, inferior_pid,                                           \
  76      (PTRACE_ARG3_TYPE) ((char *) &u.u_ar0 - (char *) &u), 0, 0))               \
  77    - kernel_u_addr)
  78
  79 static void
  80 fetch_inferior_register (regno, regaddr)
  81      register int regno;
  82      register unsigned int regaddr;
  83 {
  84 #ifndef HPUX_VERSION_5
  85   if (regno == PS_REGNUM)
  86     {
  87       union
  88         {
  89           int i;
  90           short s[2];
  91         }
  92       ps_val;
  93       int regval;
  94
  95       ps_val.i = (ptrace (PT_RUAREA, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
  96                           0, 0));
  97       regval = ps_val.s[0];
  98       supply_register (regno, (char *) &regval);
  99     }
 100   else
 101 #endif /* not HPUX_VERSION_5 */
 102     {
 103       char buf[MAX_REGISTER_RAW_SIZE];
 104       register int i;
 105
 106       for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
 107         {
 108           *(int *) &buf[i] = ptrace (PT_RUAREA, inferior_pid,
 109                                      (PTRACE_ARG3_TYPE) regaddr, 0, 0);
 110           regaddr += sizeof (int);
 111         }
 112       supply_register (regno, buf);
 113     }
 114   return;
 115 }
 116
 117 static void
 118 store_inferior_register_1 (regno, regaddr, val)
 119      int regno;
 120      unsigned int regaddr;
 121      int val;
 122 {
 123   errno = 0;
 124   ptrace (PT_WUAREA, inferior_pid, (PTRACE_ARG3_TYPE) regaddr, val, 0);
 125 #if 0
 126   /* HP-UX randomly sets errno to non-zero for regno == 25.
 127      However, the value is correctly written, so ignore errno. */
 128   if (errno != 0)
 129     {
 130       char string_buf[64];
 131
 132       sprintf (string_buf, "writing register number %d", regno);
 133       perror_with_name (string_buf);
 134     }
 135 #endif
 136   return;
 137 }
 138
 139 static void
 140 store_inferior_register (regno, regaddr)
 141      register int regno;
 142      register unsigned int regaddr;
 143 {
 144 #ifndef HPUX_VERSION_5
 145   if (regno == PS_REGNUM)
 146     {
 147       union
 148         {
 149           int i;
 150           short s[2];
 151         }
 152       ps_val;
 153
 154       ps_val.i = (ptrace (PT_RUAREA, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
 155                           0, 0));
 156       ps_val.s[0] = (read_register (regno));
 157       store_inferior_register_1 (regno, regaddr, ps_val.i);
 158     }
 159   else
 160 #endif /* not HPUX_VERSION_5 */
 161     {
 162       register int i;
 163
 164       for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
 165         {
 166           store_inferior_register_1
 167             (regno, regaddr,
 168              (*(int *) &registers[(REGISTER_BYTE (regno)) + i]));
 169           regaddr += sizeof (int);
 170         }
 171     }
 172   return;
 173 }
 174
 175 void
 176 fetch_inferior_registers (regno)
 177      int regno;
 178 {
 179   struct user u;
 180   register unsigned int ar0_offset;
 181
 182   ar0_offset = (INFERIOR_AR0 (u));
 183   if (regno == -1)
 184     {
 185       for (regno = 0; (regno < FP0_REGNUM); regno++)
 186         fetch_inferior_register (regno, (REGISTER_ADDR (ar0_offset, regno)));
 187       for (; (regno < NUM_REGS); regno++)
 188         fetch_inferior_register (regno, (FP_REGISTER_ADDR (u, regno)));
 189     }
 190   else
 191     fetch_inferior_register (regno,
 192                              (regno < FP0_REGNUM
 193                               ? REGISTER_ADDR (ar0_offset, regno)
 194                               : FP_REGISTER_ADDR (u, regno)));
 195 }
 196
 197 /* Store our register values back into the inferior.
 198    If REGNO is -1, do this for all registers.
 199    Otherwise, REGNO specifies which register (so we can save time).  */
 200
 201 void
 202 store_inferior_registers (regno)
 203      register int regno;
 204 {
 205   struct user u;
 206   register unsigned int ar0_offset;
 207
 208   if (regno >= FP0_REGNUM)
 209     {
 210       store_inferior_register (regno, (FP_REGISTER_ADDR (u, regno)));
 211       return;
 212     }
 213
 214   ar0_offset = (INFERIOR_AR0 (u));
 215   if (regno >= 0)
 216     {
 217       store_inferior_register (regno, (REGISTER_ADDR (ar0_offset, regno)));
 218       return;
 219     }
 220
 221   for (regno = 0; (regno < FP0_REGNUM); regno++)
 222     store_inferior_register (regno, (REGISTER_ADDR (ar0_offset, regno)));
 223   for (; (regno < NUM_REGS); regno++)
 224     store_inferior_register (regno, (FP_REGISTER_ADDR (u, regno)));
 225   return;
 226 }
 227
 228 int
 229 getpagesize ()
 230 {
 231   return 4096;
 232 }