gdb/hppab-nat.c

   1 /* Machine-dependent hooks for the unix child process stratum.  This
   2    code is for the HP PA-RISC cpu.
   3
   4    Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
   5
   6    Contributed by the Center for Software Science at the
   7    University of Utah (pa-gdb-bugs@cs.utah.edu).
   8
   9 This file is part of GDB.
  10
  11 This program is free software; you can redistribute it and/or modify
  12 it under the terms of the GNU General Public License as published by
  13 the Free Software Foundation; either version 2 of the License, or
  14 (at your option) any later version.
  15
  16 This program is distributed in the hope that it will be useful,
  17 but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 GNU General Public License for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with this program; if not, write to the Free Software
  23 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  24
  25 #include "defs.h"
  26 #include "inferior.h"
  27 #include "target.h"
  28 #include <sys/ptrace.h>
  29
  30 #ifndef PT_ATTACH
  31 #define PT_ATTACH PTRACE_ATTACH
  32 #endif
  33
  34 #ifndef PT_DETACH
  35 #define PT_DETACH PTRACE_DETACH
  36 #endif
  37
  38 /* This function simply calls ptrace with the given arguments.
  39    It exists so that all calls to ptrace are isolated in this
  40    machine-dependent file. */
  41
  42 int
  43 call_ptrace (request, pid, addr, data)
  44      int request, pid;
  45      PTRACE_ARG3_TYPE addr;
  46      int data;
  47 {
  48   return ptrace (request, pid, addr, data, 0);
  49 }
  50
  51 /* Use an extra level of indirection for ptrace calls.
  52    This lets us breakpoint usefully on call_ptrace.   It also
  53    allows us to pass an extra argument to ptrace without
  54    using an ANSI-C specific macro.  */
  55
  56 #define ptrace call_ptrace
  57
  58 void
  59 kill_inferior ()
  60 {
  61   if (inferior_pid == 0)
  62     return;
  63   ptrace (PT_KILL, inferior_pid, (PTRACE_ARG3_TYPE) 0, 0);
  64   wait ((int *)0);
  65   target_mourn_inferior ();
  66 }
  67
  68 #ifdef ATTACH_DETACH
  69
  70 /* Start debugging the process whose number is PID.  */
  71 int
  72 attach (pid)
  73      int pid;
  74 {
  75   errno = 0;
  76   ptrace (PT_ATTACH, pid, (PTRACE_ARG3_TYPE) 0, 0);
  77   if (errno)
  78     perror_with_name ("ptrace");
  79   attach_flag = 1;
  80   return pid;
  81 }
  82
  83 /* Stop debugging the process whose number is PID
  84    and continue it with signal number SIGNAL.
  85    SIGNAL = 0 means just continue it.  */
  86
  87 void
  88 detach (signal)
  89      int signal;
  90 {
  91   errno = 0;
  92   ptrace (PT_DETACH, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
  93   if (errno)
  94     perror_with_name ("ptrace");
  95   attach_flag = 0;
  96 }
  97 #endif /* ATTACH_DETACH */
  98 \f
  99
 100
 101 /* KERNEL_U_ADDR is the amount to subtract from u.u_ar0
 102    to get the offset in the core file of the register values.  */
 103 #if defined (KERNEL_U_ADDR_BSD)
 104 /* Get kernel_u_addr using BSD-style nlist().  */
 105 CORE_ADDR kernel_u_addr;
 106
 107 #include <a.out.gnu.h>          /* For struct nlist */
 108
 109 void
 110 _initialize_kernel_u_addr ()
 111 {
 112   struct nlist names[2];
 113
 114   names[0].n_un.n_name = "_u";
 115   names[1].n_un.n_name = NULL;
 116   if (nlist ("/vmunix", names) == 0)
 117     kernel_u_addr = names[0].n_value;
 118   else
 119     fatal ("Unable to get kernel u area address.");
 120 }
 121 #endif /* KERNEL_U_ADDR_BSD.  */
 122
 123 #if defined (KERNEL_U_ADDR_HPUX)
 124 /* Get kernel_u_addr using HPUX-style nlist().  */
 125 CORE_ADDR kernel_u_addr;
 126
 127 struct hpnlist {
 128         char *          n_name;
 129         long            n_value;
 130         unsigned char   n_type;
 131         unsigned char   n_length;
 132         short           n_almod;
 133         short           n_unused;
 134 };
 135 static struct hpnlist nl[] = {{ "_u", -1, }, { (char *) 0, }};
 136
 137 /* read the value of the u area from the hp-ux kernel */
 138 void _initialize_kernel_u_addr ()
 139 {
 140     struct user u;
 141     nlist ("/hp-ux", &nl);
 142     kernel_u_addr = nl[0].n_value;
 143 }
 144 #endif /* KERNEL_U_ADDR_HPUX.  */
 145
 146 #if !defined (offsetof)
 147 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
 148 #endif
 149
 150 /* U_REGS_OFFSET is the offset of the registers within the u area.  */
 151 #if !defined (U_REGS_OFFSET)
 152 #define U_REGS_OFFSET \
 153   ptrace (PT_READ_U, inferior_pid, \
 154           (PTRACE_ARG3_TYPE) (offsetof (struct user, u_ar0)), 0) \
 155     - KERNEL_U_ADDR
 156 #endif
 157
 158 /* Fetch one register.  */
 159
 160 static void
 161 fetch_register (regno)
 162      int regno;
 163 {
 164   register unsigned int regaddr;
 165   char buf[MAX_REGISTER_RAW_SIZE];
 166   register int i;
 167
 168   /* Offset of registers within the u area.  */
 169   unsigned int offset;
 170
 171   offset = U_REGS_OFFSET;
 172
 173   regaddr = register_addr (regno, offset);
 174   for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
 175     {
 176       errno = 0;
 177       *(int *) &buf[i] = ptrace (PT_RUREGS, inferior_pid,
 178                                  (PTRACE_ARG3_TYPE) regaddr, 0);
 179       regaddr += sizeof (int);
 180       if (errno != 0)
 181         {
 182           /* Warning, not error, in case we are attached; sometimes the
 183              kernel doesn't let us at the registers.  */
 184           char *err = safe_strerror (errno);
 185           char *msg = alloca (strlen (err) + 128);
 186           sprintf (msg, "reading register %s: %s", reg_names[regno], err);
 187           warning (msg);
 188           goto error_exit;
 189         }
 190     }
 191   supply_register (regno, buf);
 192  error_exit:;
 193 }
 194
 195 /* Fetch all registers, or just one, from the child process.  */
 196
 197 void
 198 fetch_inferior_registers (regno)
 199      int regno;
 200 {
 201   if (regno == -1)
 202     for (regno = 0; regno < NUM_REGS; regno++)
 203       fetch_register (regno);
 204   else
 205     fetch_register (regno);
 206 }
 207
 208 /* Store our register values back into the inferior.
 209    If REGNO is -1, do this for all registers.
 210    Otherwise, REGNO specifies which register (so we can save time).  */
 211
 212 void
 213 store_inferior_registers (regno)
 214      int regno;
 215 {
 216   register unsigned int regaddr;
 217   extern char registers[];
 218   register int i;
 219
 220   unsigned int offset = U_REGS_OFFSET;
 221
 222   if (regno >= 0)
 223     {
 224       regaddr = register_addr (regno, offset);
 225       for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(int))
 226         {
 227           errno = 0;
 228           ptrace (PT_WUREGS, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
 229                   *(int *) &registers[REGISTER_BYTE (regno) + i]);
 230           if (errno != 0)
 231             {
 232               char *err = safe_strerror (errno);
 233               char *msg = alloca (strlen (err) + 128);
 234               sprintf (msg, "writing register %s: %s", reg_names[regno], err);
 235               warning (msg);
 236             }
 237           regaddr += sizeof(int);
 238         }
 239     }
 240   else
 241     {
 242       for (regno = 0; regno < NUM_REGS; regno++)
 243         {
 244           if (CANNOT_STORE_REGISTER (regno))
 245             continue;
 246           store_inferior_registers (regno);
 247         }
 248     }
 249   return;
 250 }
 251
 252 /* Resume execution of process PID.
 253    If STEP is nonzero, single-step it.
 254    If SIGNAL is nonzero, give it that signal.  */
 255
 256 void
 257 child_resume (pid, step, signal)
 258      int pid;
 259      int step;
 260      int signal;
 261 {
 262   errno = 0;
 263
 264   if (pid == -1)
 265     pid = inferior_pid;
 266
 267   /* An address of (PTRACE_ARG3_TYPE) 1 tells ptrace to continue from where
 268      it was. (If GDB wanted it to start some other way, we have already
 269      written a new PC value to the child.)  */
 270
 271   if (step)
 272     ptrace (PT_STEP, pid, (PTRACE_ARG3_TYPE) 1, signal);
 273   else
 274     ptrace (PT_CONTINUE, pid, (PTRACE_ARG3_TYPE) 1, signal);
 275
 276   if (errno)
 277     perror_with_name ("ptrace");
 278 }
 279
 280 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
 281    in the NEW_SUN_PTRACE case.
 282    It ought to be straightforward.  But it appears that writing did
 283    not write the data that I specified.  I cannot understand where
 284    it got the data that it actually did write.  */
 285
 286 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
 287    to debugger memory starting at MYADDR.   Copy to inferior if
 288    WRITE is nonzero.
 289
 290    Returns the length copied, which is either the LEN argument or zero.
 291    This xfer function does not do partial moves, since child_ops
 292    doesn't allow memory operations to cross below us in the target stack
 293    anyway.  */
 294
 295 int
 296 child_xfer_memory (memaddr, myaddr, len, write, target)
 297      CORE_ADDR memaddr;
 298      char *myaddr;
 299      int len;
 300      int write;
 301      struct target_ops *target;         /* ignored */
 302 {
 303   register int i;
 304   /* Round starting address down to longword boundary.  */
 305   register CORE_ADDR addr = memaddr & - sizeof (int);
 306   /* Round ending address up; get number of longwords that makes.  */
 307   register int count
 308     = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
 309   /* Allocate buffer of that many longwords.  */
 310   register int *buffer = (int *) alloca (count * sizeof (int));
 311
 312   if (write)
 313     {
 314       /* Fill start and end extra bytes of buffer with existing memory data.  */
 315
 316       if (addr != memaddr || len < (int)sizeof (int)) {
 317         /* Need part of initial word -- fetch it.  */
 318         buffer[0] = ptrace (PT_READ_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
 319                             0);
 320       }
 321
 322       if (count > 1)            /* FIXME, avoid if even boundary */
 323         {
 324           buffer[count - 1]
 325             = ptrace (PT_READ_I, inferior_pid,
 326                       (PTRACE_ARG3_TYPE) (addr + (count - 1) * sizeof (int)),
 327                       0);
 328         }
 329
 330       /* Copy data to be written over corresponding part of buffer */
 331
 332       memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
 333
 334       /* Write the entire buffer.  */
 335
 336       for (i = 0; i < count; i++, addr += sizeof (int))
 337         {
 338           errno = 0;
 339           ptrace (PT_WRITE_D, inferior_pid, (PTRACE_ARG3_TYPE) addr,
 340                   buffer[i]);
 341           if (errno)
 342             {
 343               /* Using the appropriate one (I or D) is necessary for
 344                  Gould NP1, at least.  */
 345               errno = 0;
 346               ptrace (PT_WRITE_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
 347                       buffer[i]);
 348             }
 349           if (errno)
 350             return 0;
 351         }
 352     }
 353   else
 354     {
 355       /* Read all the longwords */
 356       for (i = 0; i < count; i++, addr += sizeof (int))
 357         {
 358           errno = 0;
 359           buffer[i] = ptrace (PT_READ_I, inferior_pid,
 360                               (PTRACE_ARG3_TYPE) addr, 0);
 361           if (errno)
 362             return 0;
 363           QUIT;
 364         }
 365
 366       /* Copy appropriate bytes out of the buffer.  */
 367       memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
 368     }
 369   return len;
 370 }
 371