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 #ifdef FIVE_ARG_PTRACE
  31
  32 /* Deal with HPUX 8.0 braindamage.  */
  33 #define ptrace(a,b,c,d) ptrace(a,b,c,d,0)
  34
  35 #endif
  36
  37 #ifndef PT_ATTACH
  38 #define PT_ATTACH PTRACE_ATTACH
  39 #endif
  40
  41 #ifndef PT_DETACH
  42 #define PT_DETACH PTRACE_DETACH
  43 #endif
  44
  45 /* This function simply calls ptrace with the given arguments.
  46    It exists so that all calls to ptrace are isolated in this
  47    machine-dependent file. */
  48
  49 int
  50 call_ptrace (request, pid, addr, data)
  51      int request, pid;
  52      PTRACE_ARG3_TYPE addr;
  53      int data;
  54 {
  55   return ptrace (request, pid, addr, data);
  56 }
  57
  58 #ifdef DEBUG_PTRACE
  59 /* For the rest of the file, use an extra level of indirection */
  60 /* This lets us breakpoint usefully on call_ptrace. */
  61 #define ptrace call_ptrace
  62 #endif
  63
  64 void
  65 kill_inferior ()
  66 {
  67   if (inferior_pid == 0)
  68     return;
  69   ptrace (PT_KILL, inferior_pid, (PTRACE_ARG3_TYPE) 0, 0);
  70   wait ((int *)0);
  71   target_mourn_inferior ();
  72 }
  73
  74 #ifdef ATTACH_DETACH
  75
  76 /* Start debugging the process whose number is PID.  */
  77 int
  78 attach (pid)
  79      int pid;
  80 {
  81   errno = 0;
  82   ptrace (PT_ATTACH, pid, (PTRACE_ARG3_TYPE) 0, 0);
  83   if (errno)
  84     perror_with_name ("ptrace");
  85   attach_flag = 1;
  86   return pid;
  87 }
  88
  89 /* Stop debugging the process whose number is PID
  90    and continue it with signal number SIGNAL.
  91    SIGNAL = 0 means just continue it.  */
  92
  93 void
  94 detach (signal)
  95      int signal;
  96 {
  97   errno = 0;
  98   ptrace (PT_DETACH, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
  99   if (errno)
 100     perror_with_name ("ptrace");
 101   attach_flag = 0;
 102 }
 103 #endif /* ATTACH_DETACH */
 104 \f
 105
 106
 107 /* KERNEL_U_ADDR is the amount to subtract from u.u_ar0
 108    to get the offset in the core file of the register values.  */
 109 #if defined (KERNEL_U_ADDR_BSD)
 110 /* Get kernel_u_addr using BSD-style nlist().  */
 111 CORE_ADDR kernel_u_addr;
 112
 113 #include <a.out.gnu.h>          /* For struct nlist */
 114
 115 void
 116 _initialize_kernel_u_addr ()
 117 {
 118   struct nlist names[2];
 119
 120   names[0].n_un.n_name = "_u";
 121   names[1].n_un.n_name = NULL;
 122   if (nlist ("/vmunix", names) == 0)
 123     kernel_u_addr = names[0].n_value;
 124   else
 125     fatal ("Unable to get kernel u area address.");
 126 }
 127 #endif /* KERNEL_U_ADDR_BSD.  */
 128
 129 #if defined (KERNEL_U_ADDR_HPUX)
 130 /* Get kernel_u_addr using HPUX-style nlist().  */
 131 CORE_ADDR kernel_u_addr;
 132
 133 struct hpnlist {
 134         char *          n_name;
 135         long            n_value;
 136         unsigned char   n_type;
 137         unsigned char   n_length;
 138         short           n_almod;
 139         short           n_unused;
 140 };
 141 static struct hpnlist nl[] = {{ "_u", -1, }, { (char *) 0, }};
 142
 143 /* read the value of the u area from the hp-ux kernel */
 144 void _initialize_kernel_u_addr ()
 145 {
 146     struct user u;
 147     nlist ("/hp-ux", &nl);
 148     kernel_u_addr = nl[0].n_value;
 149 }
 150 #endif /* KERNEL_U_ADDR_HPUX.  */
 151
 152 #if !defined (offsetof)
 153 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
 154 #endif
 155
 156 /* U_REGS_OFFSET is the offset of the registers within the u area.  */
 157 #if !defined (U_REGS_OFFSET)
 158 #define U_REGS_OFFSET \
 159   ptrace (PT_READ_U, inferior_pid, \
 160           (PTRACE_ARG3_TYPE) (offsetof (struct user, u_ar0)), 0) \
 161     - KERNEL_U_ADDR
 162 #endif
 163
 164 /* Fetch one register.  */
 165
 166 static void
 167 fetch_register (regno)
 168      int regno;
 169 {
 170   register unsigned int regaddr;
 171   char buf[MAX_REGISTER_RAW_SIZE];
 172   char mess[128];                               /* For messages */
 173   register int i;
 174
 175   /* Offset of registers within the u area.  */
 176   unsigned int offset;
 177
 178   offset = U_REGS_OFFSET;
 179
 180   regaddr = register_addr (regno, offset);
 181   for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
 182     {
 183       errno = 0;
 184       *(int *) &buf[i] = ptrace (PT_RUREGS, inferior_pid,
 185                                  (PTRACE_ARG3_TYPE) regaddr, 0);
 186       regaddr += sizeof (int);
 187       if (errno != 0)
 188         {
 189           sprintf (mess, "reading register %s (#%d)", reg_names[regno], regno);
 190           perror_with_name (mess);
 191         }
 192     }
 193   supply_register (regno, buf);
 194 }
 195
 196 /* Fetch all registers, or just one, from the child process.  */
 197
 198 void
 199 fetch_inferior_registers (regno)
 200      int regno;
 201 {
 202   if (regno == -1)
 203     for (regno = 0; regno < NUM_REGS; regno++)
 204       fetch_register (regno);
 205   else
 206     fetch_register (regno);
 207 }
 208
 209 /* Store our register values back into the inferior.
 210    If REGNO is -1, do this for all registers.
 211    Otherwise, REGNO specifies which register (so we can save time).  */
 212
 213 void
 214 store_inferior_registers (regno)
 215      int regno;
 216 {
 217   register unsigned int regaddr;
 218   char buf[80];
 219   extern char registers[];
 220   register int i;
 221
 222   unsigned int offset = U_REGS_OFFSET;
 223
 224   if (regno >= 0)
 225     {
 226       regaddr = register_addr (regno, offset);
 227       for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(int))
 228         {
 229           errno = 0;
 230           ptrace (PT_WUREGS, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
 231                   *(int *) &registers[REGISTER_BYTE (regno) + i]);
 232           if (errno != 0)
 233             {
 234               sprintf (buf, "writing register number %d(%d)", regno, i);
 235               perror_with_name (buf);
 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           regaddr = register_addr (regno, offset);
 247           for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(int))
 248             {
 249               errno = 0;
 250               ptrace (PT_WUREGS, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
 251                       *(int *) &registers[REGISTER_BYTE (regno) + i]);
 252               if (errno != 0)
 253                 {
 254                   sprintf (buf, "writing register number %d(%d)", regno, i);
 255                   perror_with_name (buf);
 256                 }
 257               regaddr += sizeof(int);
 258             }
 259         }
 260     }
 261   return;
 262 }
 263
 264 /* Resume execution of the inferior process.
 265    If STEP is nonzero, single-step it.
 266    If SIGNAL is nonzero, give it that signal.  */
 267
 268 void
 269 child_resume (step, signal)
 270      int step;
 271      int signal;
 272 {
 273   errno = 0;
 274
 275   /* An address of (PTRACE_ARG3_TYPE) 1 tells ptrace to continue from where
 276      it was. (If GDB wanted it to start some other way, we have already
 277      written a new PC value to the child.)  */
 278
 279   if (step)
 280     ptrace (PT_STEP, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
 281   else
 282     ptrace (PT_CONTINUE, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
 283
 284   if (errno)
 285     perror_with_name ("ptrace");
 286 }
 287
 288 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
 289    in the NEW_SUN_PTRACE case.
 290    It ought to be straightforward.  But it appears that writing did
 291    not write the data that I specified.  I cannot understand where
 292    it got the data that it actually did write.  */
 293
 294 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
 295    to debugger memory starting at MYADDR.   Copy to inferior if
 296    WRITE is nonzero.
 297
 298    Returns the length copied, which is either the LEN argument or zero.
 299    This xfer function does not do partial moves, since child_ops
 300    doesn't allow memory operations to cross below us in the target stack
 301    anyway.  */
 302
 303 int
 304 child_xfer_memory (memaddr, myaddr, len, write, target)
 305      CORE_ADDR memaddr;
 306      char *myaddr;
 307      int len;
 308      int write;
 309      struct target_ops *target;         /* ignored */
 310 {
 311   register int i;
 312   /* Round starting address down to longword boundary.  */
 313   register CORE_ADDR addr = memaddr & - sizeof (int);
 314   /* Round ending address up; get number of longwords that makes.  */
 315   register int count
 316     = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
 317   /* Allocate buffer of that many longwords.  */
 318   register int *buffer = (int *) alloca (count * sizeof (int));
 319
 320   if (write)
 321     {
 322       /* Fill start and end extra bytes of buffer with existing memory data.  */
 323
 324       if (addr != memaddr || len < (int)sizeof (int)) {
 325         /* Need part of initial word -- fetch it.  */
 326         buffer[0] = ptrace (PT_READ_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
 327                             0);
 328       }
 329
 330       if (count > 1)            /* FIXME, avoid if even boundary */
 331         {
 332           buffer[count - 1]
 333             = ptrace (PT_READ_I, inferior_pid,
 334                       (PTRACE_ARG3_TYPE) (addr + (count - 1) * sizeof (int)),
 335                       0);
 336         }
 337
 338       /* Copy data to be written over corresponding part of buffer */
 339
 340       bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
 341
 342       /* Write the entire buffer.  */
 343
 344       for (i = 0; i < count; i++, addr += sizeof (int))
 345         {
 346           errno = 0;
 347           ptrace (PT_WRITE_D, inferior_pid, (PTRACE_ARG3_TYPE) addr,
 348                   buffer[i]);
 349           if (errno)
 350             {
 351               /* Using the appropriate one (I or D) is necessary for
 352                  Gould NP1, at least.  */
 353               errno = 0;
 354               ptrace (PT_WRITE_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
 355                       buffer[i]);
 356             }
 357           if (errno)
 358             return 0;
 359         }
 360     }
 361   else
 362     {
 363       /* Read all the longwords */
 364       for (i = 0; i < count; i++, addr += sizeof (int))
 365         {
 366           errno = 0;
 367           buffer[i] = ptrace (PT_READ_I, inferior_pid,
 368                               (PTRACE_ARG3_TYPE) addr, 0);
 369           if (errno)
 370             return 0;
 371           QUIT;
 372         }
 373
 374       /* Copy appropriate bytes out of the buffer.  */
 375       bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
 376     }
 377   return len;
 378 }
 379