gdb/hppah-nat.c

   1 /* Machine-dependent hooks for the unix child process stratum, for HPUX PA-RISC.
   2
   3    Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993
   4    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
  26 #include "defs.h"
  27 #include "inferior.h"
  28 #include "target.h"
  29 #include <sys/ptrace.h>
  30
  31 extern CORE_ADDR text_end;
  32
  33 static void fetch_register ();
  34
  35 /* This function simply calls ptrace with the given arguments.
  36    It exists so that all calls to ptrace are isolated in this
  37    machine-dependent file. */
  38 int
  39 call_ptrace (request, pid, addr, data)
  40      int request, pid;
  41      PTRACE_ARG3_TYPE addr;
  42      int data;
  43 {
  44   return ptrace (request, pid, addr, data, 0);
  45 }
  46
  47 void
  48 kill_inferior ()
  49 {
  50   if (inferior_pid == 0)
  51     return;
  52   ptrace (PT_EXIT, inferior_pid, (PTRACE_ARG3_TYPE) 0, 0, 0);
  53   wait ((int *)0);
  54   target_mourn_inferior ();
  55 }
  56
  57 /* Start debugging the process whose number is PID.  */
  58 int
  59 attach (pid)
  60      int pid;
  61 {
  62   errno = 0;
  63   ptrace (PT_ATTACH, pid, (PTRACE_ARG3_TYPE) 0, 0, 0);
  64   if (errno)
  65     perror_with_name ("ptrace");
  66   attach_flag = 1;
  67   return pid;
  68 }
  69
  70 /* Stop debugging the process whose number is PID
  71    and continue it with signal number SIGNAL.
  72    SIGNAL = 0 means just continue it.  */
  73
  74 void
  75 detach (signal)
  76      int signal;
  77 {
  78   errno = 0;
  79   ptrace (PT_DETACH, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal, 0);
  80   if (errno)
  81     perror_with_name ("ptrace");
  82   attach_flag = 0;
  83 }
  84
  85 /* Fetch all registers, or just one, from the child process.  */
  86
  87 void
  88 fetch_inferior_registers (regno)
  89      int regno;
  90 {
  91   if (regno == -1)
  92     for (regno = 0; regno < NUM_REGS; regno++)
  93       fetch_register (regno);
  94   else
  95     fetch_register (regno);
  96 }
  97
  98 /* Store our register values back into the inferior.
  99    If REGNO is -1, do this for all registers.
 100    Otherwise, REGNO specifies which register (so we can save time).  */
 101
 102 void
 103 store_inferior_registers (regno)
 104      int regno;
 105 {
 106   register unsigned int regaddr;
 107   char buf[80];
 108   extern char registers[];
 109   register int i;
 110   unsigned int offset = U_REGS_OFFSET;
 111   int scratch;
 112
 113   if (regno >= 0)
 114     {
 115       regaddr = register_addr (regno, offset);
 116       errno = 0;
 117       if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM)
 118         {
 119           scratch = *(int *) &registers[REGISTER_BYTE (regno)] | 0x3;
 120           ptrace (PT_WUREGS, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
 121                   scratch, 0);
 122           if (errno != 0)
 123             {
 124               /* Error, even if attached.  Failing to write these two
 125                  registers is pretty serious.  */
 126               sprintf (buf, "writing register number %d", regno);
 127               perror_with_name (buf);
 128             }
 129         }
 130       else
 131         for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(int))
 132           {
 133             errno = 0;
 134             ptrace (PT_WUREGS, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
 135                     *(int *) &registers[REGISTER_BYTE (regno) + i], 0);
 136             if (errno != 0)
 137               {
 138                 /* Warning, not error, in case we are attached; sometimes the
 139                    kernel doesn't let us at the registers.  */
 140                 char *err = safe_strerror (errno);
 141                 char *msg = alloca (strlen (err) + 128);
 142                 sprintf (msg, "writing register %s: %s",
 143                          reg_names[regno], err);
 144                 warning (msg);
 145                 goto error_exit;
 146               }
 147             regaddr += sizeof(int);
 148           }
 149     }
 150   else
 151     {
 152       for (regno = 0; regno < NUM_REGS; regno++)
 153         {
 154           if (CANNOT_STORE_REGISTER (regno))
 155             continue;
 156           store_inferior_registers (regno);
 157         }
 158     }
 159  error_exit:
 160   return;
 161 }
 162
 163 /* Fetch one register.  */
 164
 165 static void
 166 fetch_register (regno)
 167      int regno;
 168 {
 169   register unsigned int regaddr;
 170   char buf[MAX_REGISTER_RAW_SIZE];
 171   char mess[128];                               /* For messages */
 172   register int i;
 173
 174   /* Offset of registers within the u area.  */
 175   unsigned int offset;
 176
 177   offset = U_REGS_OFFSET;
 178
 179   regaddr = register_addr (regno, offset);
 180   for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
 181     {
 182       errno = 0;
 183       *(int *) &buf[i] = ptrace (PT_RUREGS, inferior_pid,
 184                                  (PTRACE_ARG3_TYPE) regaddr, 0, 0);
 185       regaddr += sizeof (int);
 186       if (errno != 0)
 187         {
 188           /* Warning, not error, in case we are attached; sometimes the
 189              kernel doesn't let us at the registers.  */
 190           char *err = safe_strerror (errno);
 191           char *msg = alloca (strlen (err) + 128);
 192           sprintf (msg, "reading register %s: %s", reg_names[regno], err);
 193           warning (msg);
 194           goto error_exit;
 195         }
 196     }
 197   if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM)
 198     buf[3] &= ~0x3;
 199   supply_register (regno, buf);
 200  error_exit:;
 201 }
 202
 203 /* Resume execution of process PID.
 204    If STEP is nonzero, single-step it.
 205    If SIGNAL is nonzero, give it that signal.  */
 206
 207 void
 208 child_resume (pid, step, signal)
 209      int pid;
 210      int step;
 211      int signal;
 212 {
 213   errno = 0;
 214
 215   /* An address of (PTRACE_ARG3_TYPE) 1 tells ptrace to continue from where
 216      it was. (If GDB wanted it to start some other way, we have already
 217      written a new PC value to the child.)  */
 218
 219   if (step)
 220     ptrace (PT_SINGLE, pid, (PTRACE_ARG3_TYPE) 1, signal, 0);
 221   else
 222     ptrace (PT_CONTIN, pid, (PTRACE_ARG3_TYPE) 1, signal, 0);
 223
 224   if (errno)
 225     perror_with_name ("ptrace");
 226 }
 227
 228 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
 229    to debugger memory starting at MYADDR.   Copy to inferior if
 230    WRITE is nonzero.
 231
 232    Returns the length copied, which is either the LEN argument or zero.
 233    This xfer function does not do partial moves, since child_ops
 234    doesn't allow memory operations to cross below us in the target stack
 235    anyway.  */
 236
 237 int
 238 child_xfer_memory (memaddr, myaddr, len, write, target)
 239      CORE_ADDR memaddr;
 240      char *myaddr;
 241      int len;
 242      int write;
 243      struct target_ops *target;         /* ignored */
 244 {
 245   register int i;
 246   /* Round starting address down to longword boundary.  */
 247   register CORE_ADDR addr = memaddr & - sizeof (int);
 248   /* Round ending address up; get number of longwords that makes.  */
 249   register int count
 250     = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
 251   /* Allocate buffer of that many longwords.  */
 252   register int *buffer = (int *) alloca (count * sizeof (int));
 253
 254   if (write)
 255     {
 256       /* Fill start and end extra bytes of buffer with existing memory data.  */
 257
 258       if (addr != memaddr || len < (int)sizeof (int)) {
 259         /* Need part of initial word -- fetch it.  */
 260         buffer[0] = ptrace (addr < text_end ? PT_RIUSER : PT_RDUSER,
 261                             inferior_pid, (PTRACE_ARG3_TYPE) addr, 0, 0);
 262       }
 263
 264       if (count > 1)            /* FIXME, avoid if even boundary */
 265         {
 266           buffer[count - 1]
 267             = ptrace (addr < text_end ? PT_RIUSER : PT_RDUSER, inferior_pid,
 268                       (PTRACE_ARG3_TYPE) (addr + (count - 1) * sizeof (int)),
 269                       0, 0);
 270         }
 271
 272       /* Copy data to be written over corresponding part of buffer */
 273
 274       memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
 275
 276       /* Write the entire buffer.  */
 277
 278       for (i = 0; i < count; i++, addr += sizeof (int))
 279         {
 280 /* The HP-UX kernel crashes if you use PT_WDUSER to write into the text
 281    segment.  FIXME -- does it work to write into the data segment using
 282    WIUSER, or do these idiots really expect us to figure out which segment
 283    the address is in, so we can use a separate system call for it??!  */
 284           errno = 0;
 285           ptrace (addr < text_end ? PT_WIUSER : PT_WDUSER, inferior_pid,
 286                   (PTRACE_ARG3_TYPE) addr,
 287                   buffer[i], 0);
 288           if (errno)
 289             return 0;
 290         }
 291     }
 292   else
 293     {
 294       /* Read all the longwords */
 295       for (i = 0; i < count; i++, addr += sizeof (int))
 296         {
 297           errno = 0;
 298           buffer[i] = ptrace (addr < text_end ? PT_RIUSER : PT_RDUSER,
 299                               inferior_pid, (PTRACE_ARG3_TYPE) addr, 0, 0);
 300           if (errno)
 301             return 0;
 302           QUIT;
 303         }
 304
 305       /* Copy appropriate bytes out of the buffer.  */
 306       memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
 307     }
 308   return len;
 309 }