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 the inferior process.
 204    If STEP is nonzero, single-step it.
 205    If SIGNAL is nonzero, give it that signal.  */
 206
 207 void
 208 child_resume (step, signal)
 209      int step;
 210      int signal;
 211 {
 212   errno = 0;
 213
 214   /* An address of (PTRACE_ARG3_TYPE) 1 tells ptrace to continue from where
 215      it was. (If GDB wanted it to start some other way, we have already
 216      written a new PC value to the child.)  */
 217
 218   if (step)
 219     ptrace (PT_SINGLE, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal, 0);
 220   else
 221     ptrace (PT_CONTIN, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal, 0);
 222
 223   if (errno)
 224     perror_with_name ("ptrace");
 225 }
 226
 227 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
 228    to debugger memory starting at MYADDR.   Copy to inferior if
 229    WRITE is nonzero.
 230
 231    Returns the length copied, which is either the LEN argument or zero.
 232    This xfer function does not do partial moves, since child_ops
 233    doesn't allow memory operations to cross below us in the target stack
 234    anyway.  */
 235
 236 int
 237 child_xfer_memory (memaddr, myaddr, len, write, target)
 238      CORE_ADDR memaddr;
 239      char *myaddr;
 240      int len;
 241      int write;
 242      struct target_ops *target;         /* ignored */
 243 {
 244   register int i;
 245   /* Round starting address down to longword boundary.  */
 246   register CORE_ADDR addr = memaddr & - sizeof (int);
 247   /* Round ending address up; get number of longwords that makes.  */
 248   register int count
 249     = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
 250   /* Allocate buffer of that many longwords.  */
 251   register int *buffer = (int *) alloca (count * sizeof (int));
 252
 253   if (write)
 254     {
 255       /* Fill start and end extra bytes of buffer with existing memory data.  */
 256
 257       if (addr != memaddr || len < (int)sizeof (int)) {
 258         /* Need part of initial word -- fetch it.  */
 259         buffer[0] = ptrace (addr < text_end ? PT_RIUSER : PT_RDUSER,
 260                             inferior_pid, (PTRACE_ARG3_TYPE) addr, 0, 0);
 261       }
 262
 263       if (count > 1)            /* FIXME, avoid if even boundary */
 264         {
 265           buffer[count - 1]
 266             = ptrace (addr < text_end ? PT_RIUSER : PT_RDUSER, inferior_pid,
 267                       (PTRACE_ARG3_TYPE) (addr + (count - 1) * sizeof (int)),
 268                       0, 0);
 269         }
 270
 271       /* Copy data to be written over corresponding part of buffer */
 272
 273       bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
 274
 275       /* Write the entire buffer.  */
 276
 277       for (i = 0; i < count; i++, addr += sizeof (int))
 278         {
 279 /* The HP-UX kernel crashes if you use PT_WDUSER to write into the text
 280    segment.  FIXME -- does it work to write into the data segment using
 281    WIUSER, or do these idiots really expect us to figure out which segment
 282    the address is in, so we can use a separate system call for it??!  */
 283           errno = 0;
 284           ptrace (addr < text_end ? PT_WIUSER : PT_WDUSER, inferior_pid,
 285                   (PTRACE_ARG3_TYPE) addr,
 286                   buffer[i], 0);
 287           if (errno)
 288             return 0;
 289         }
 290     }
 291   else
 292     {
 293       /* Read all the longwords */
 294       for (i = 0; i < count; i++, addr += sizeof (int))
 295         {
 296           errno = 0;
 297           buffer[i] = ptrace (addr < text_end ? PT_RIUSER : PT_RDUSER,
 298                               inferior_pid, (PTRACE_ARG3_TYPE) addr, 0, 0);
 299           if (errno)
 300             return 0;
 301           QUIT;
 302         }
 303
 304       /* Copy appropriate bytes out of the buffer.  */
 305       bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
 306     }
 307   return len;
 308 }