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