gdb/symm-nat.c

   1 /* Sequent Symmetry host interface, for GDB when running under Unix.
   2    Copyright 1986, 1987, 1989, 1991, 1992, 1994 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,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 /* FIXME, some 387-specific items of use taken from i387-tdep.c -- ought to be
  22    merged back in. */
  23
  24 #include "defs.h"
  25 #include "frame.h"
  26 #include "inferior.h"
  27 #include "symtab.h"
  28 #include "target.h"
  29
  30 /* FIXME: What is the _INKERNEL define for?  */
  31 #define _INKERNEL
  32 #include <signal.h>
  33 #undef _INKERNEL
  34 #include <sys/wait.h>
  35 #include <sys/param.h>
  36 #include <sys/user.h>
  37 #include <sys/proc.h>
  38 #include <sys/dir.h>
  39 #include <sys/ioctl.h>
  40 #include "gdb_stat.h"
  41 #ifdef _SEQUENT_
  42 #include <sys/ptrace.h>
  43 #else
  44 /* Dynix has only machine/ptrace.h, which is already included by sys/user.h  */
  45 /* Dynix has no mptrace call */
  46 #define mptrace ptrace
  47 #endif
  48 #include "gdbcore.h"
  49 #include <fcntl.h>
  50 #include <sgtty.h>
  51 #define TERMINAL struct sgttyb
  52
  53 #include "gdbcore.h"
  54
  55 void
  56 store_inferior_registers (int regno)
  57 {
  58   struct pt_regset regs;
  59   int i;
  60
  61   /* FIXME: Fetching the registers is a kludge to initialize all elements
  62      in the fpu and fpa status. This works for normal debugging, but
  63      might cause problems when calling functions in the inferior.
  64      At least fpu_control and fpa_pcr (probably more) should be added
  65      to the registers array to solve this properly.  */
  66   mptrace (XPT_RREGS, inferior_pid, (PTRACE_ARG3_TYPE) & regs, 0);
  67
  68   regs.pr_eax = *(int *) &registers[REGISTER_BYTE (0)];
  69   regs.pr_ebx = *(int *) &registers[REGISTER_BYTE (5)];
  70   regs.pr_ecx = *(int *) &registers[REGISTER_BYTE (2)];
  71   regs.pr_edx = *(int *) &registers[REGISTER_BYTE (1)];
  72   regs.pr_esi = *(int *) &registers[REGISTER_BYTE (6)];
  73   regs.pr_edi = *(int *) &registers[REGISTER_BYTE (7)];
  74   regs.pr_esp = *(int *) &registers[REGISTER_BYTE (14)];
  75   regs.pr_ebp = *(int *) &registers[REGISTER_BYTE (15)];
  76   regs.pr_eip = *(int *) &registers[REGISTER_BYTE (16)];
  77   regs.pr_flags = *(int *) &registers[REGISTER_BYTE (17)];
  78   for (i = 0; i < 31; i++)
  79     {
  80       regs.pr_fpa.fpa_regs[i] =
  81         *(int *) &registers[REGISTER_BYTE (FP1_REGNUM + i)];
  82     }
  83   memcpy (regs.pr_fpu.fpu_stack[0], &registers[REGISTER_BYTE (ST0_REGNUM)], 10);
  84   memcpy (regs.pr_fpu.fpu_stack[1], &registers[REGISTER_BYTE (ST1_REGNUM)], 10);
  85   memcpy (regs.pr_fpu.fpu_stack[2], &registers[REGISTER_BYTE (ST2_REGNUM)], 10);
  86   memcpy (regs.pr_fpu.fpu_stack[3], &registers[REGISTER_BYTE (ST3_REGNUM)], 10);
  87   memcpy (regs.pr_fpu.fpu_stack[4], &registers[REGISTER_BYTE (ST4_REGNUM)], 10);
  88   memcpy (regs.pr_fpu.fpu_stack[5], &registers[REGISTER_BYTE (ST5_REGNUM)], 10);
  89   memcpy (regs.pr_fpu.fpu_stack[6], &registers[REGISTER_BYTE (ST6_REGNUM)], 10);
  90   memcpy (regs.pr_fpu.fpu_stack[7], &registers[REGISTER_BYTE (ST7_REGNUM)], 10);
  91   mptrace (XPT_WREGS, inferior_pid, (PTRACE_ARG3_TYPE) & regs, 0);
  92 }
  93
  94 void
  95 fetch_inferior_registers (int regno)
  96 {
  97   int i;
  98   struct pt_regset regs;
  99
 100   registers_fetched ();
 101
 102   mptrace (XPT_RREGS, inferior_pid, (PTRACE_ARG3_TYPE) & regs, 0);
 103   *(int *) &registers[REGISTER_BYTE (EAX_REGNUM)] = regs.pr_eax;
 104   *(int *) &registers[REGISTER_BYTE (EBX_REGNUM)] = regs.pr_ebx;
 105   *(int *) &registers[REGISTER_BYTE (ECX_REGNUM)] = regs.pr_ecx;
 106   *(int *) &registers[REGISTER_BYTE (EDX_REGNUM)] = regs.pr_edx;
 107   *(int *) &registers[REGISTER_BYTE (ESI_REGNUM)] = regs.pr_esi;
 108   *(int *) &registers[REGISTER_BYTE (EDI_REGNUM)] = regs.pr_edi;
 109   *(int *) &registers[REGISTER_BYTE (EBP_REGNUM)] = regs.pr_ebp;
 110   *(int *) &registers[REGISTER_BYTE (ESP_REGNUM)] = regs.pr_esp;
 111   *(int *) &registers[REGISTER_BYTE (EIP_REGNUM)] = regs.pr_eip;
 112   *(int *) &registers[REGISTER_BYTE (EFLAGS_REGNUM)] = regs.pr_flags;
 113   for (i = 0; i < FPA_NREGS; i++)
 114     {
 115       *(int *) &registers[REGISTER_BYTE (FP1_REGNUM + i)] =
 116         regs.pr_fpa.fpa_regs[i];
 117     }
 118   memcpy (&registers[REGISTER_BYTE (ST0_REGNUM)], regs.pr_fpu.fpu_stack[0], 10);
 119   memcpy (&registers[REGISTER_BYTE (ST1_REGNUM)], regs.pr_fpu.fpu_stack[1], 10);
 120   memcpy (&registers[REGISTER_BYTE (ST2_REGNUM)], regs.pr_fpu.fpu_stack[2], 10);
 121   memcpy (&registers[REGISTER_BYTE (ST3_REGNUM)], regs.pr_fpu.fpu_stack[3], 10);
 122   memcpy (&registers[REGISTER_BYTE (ST4_REGNUM)], regs.pr_fpu.fpu_stack[4], 10);
 123   memcpy (&registers[REGISTER_BYTE (ST5_REGNUM)], regs.pr_fpu.fpu_stack[5], 10);
 124   memcpy (&registers[REGISTER_BYTE (ST6_REGNUM)], regs.pr_fpu.fpu_stack[6], 10);
 125   memcpy (&registers[REGISTER_BYTE (ST7_REGNUM)], regs.pr_fpu.fpu_stack[7], 10);
 126 }
 127 \f
 128 /* FIXME:  This should be merged with i387-tdep.c as well. */
 129 static
 130 print_fpu_status (struct pt_regset ep)
 131 {
 132   int i;
 133   int bothstatus;
 134   int top;
 135   int fpreg;
 136   unsigned char *p;
 137
 138   printf_unfiltered ("80387:");
 139   if (ep.pr_fpu.fpu_ip == 0)
 140     {
 141       printf_unfiltered (" not in use.\n");
 142       return;
 143     }
 144   else
 145     {
 146       printf_unfiltered ("\n");
 147     }
 148   if (ep.pr_fpu.fpu_status != 0)
 149     {
 150       print_387_status_word (ep.pr_fpu.fpu_status);
 151     }
 152   print_387_control_word (ep.pr_fpu.fpu_control);
 153   printf_unfiltered ("last exception: ");
 154   printf_unfiltered ("opcode 0x%x; ", ep.pr_fpu.fpu_rsvd4);
 155   printf_unfiltered ("pc 0x%x:0x%x; ", ep.pr_fpu.fpu_cs, ep.pr_fpu.fpu_ip);
 156   printf_unfiltered ("operand 0x%x:0x%x\n", ep.pr_fpu.fpu_data_offset, ep.pr_fpu.fpu_op_sel);
 157
 158   top = (ep.pr_fpu.fpu_status >> 11) & 7;
 159
 160   printf_unfiltered ("regno  tag  msb              lsb  value\n");
 161   for (fpreg = 7; fpreg >= 0; fpreg--)
 162     {
 163       double val;
 164
 165       printf_unfiltered ("%s %d: ", fpreg == top ? "=>" : "  ", fpreg);
 166
 167       switch ((ep.pr_fpu.fpu_tag >> (fpreg * 2)) & 3)
 168         {
 169         case 0:
 170           printf_unfiltered ("valid ");
 171           break;
 172         case 1:
 173           printf_unfiltered ("zero  ");
 174           break;
 175         case 2:
 176           printf_unfiltered ("trap  ");
 177           break;
 178         case 3:
 179           printf_unfiltered ("empty ");
 180           break;
 181         }
 182       for (i = 9; i >= 0; i--)
 183         printf_unfiltered ("%02x", ep.pr_fpu.fpu_stack[fpreg][i]);
 184
 185       i387_to_double ((char *) ep.pr_fpu.fpu_stack[fpreg], (char *) &val);
 186       printf_unfiltered ("  %g\n", val);
 187     }
 188   if (ep.pr_fpu.fpu_rsvd1)
 189     warning ("rsvd1 is 0x%x\n", ep.pr_fpu.fpu_rsvd1);
 190   if (ep.pr_fpu.fpu_rsvd2)
 191     warning ("rsvd2 is 0x%x\n", ep.pr_fpu.fpu_rsvd2);
 192   if (ep.pr_fpu.fpu_rsvd3)
 193     warning ("rsvd3 is 0x%x\n", ep.pr_fpu.fpu_rsvd3);
 194   if (ep.pr_fpu.fpu_rsvd5)
 195     warning ("rsvd5 is 0x%x\n", ep.pr_fpu.fpu_rsvd5);
 196 }
 197
 198
 199 print_1167_control_word (unsigned int pcr)
 200 {
 201   int pcr_tmp;
 202
 203   pcr_tmp = pcr & FPA_PCR_MODE;
 204   printf_unfiltered ("\tMODE= %#x; RND= %#x ", pcr_tmp, pcr_tmp & 12);
 205   switch (pcr_tmp & 12)
 206     {
 207     case 0:
 208       printf_unfiltered ("RN (Nearest Value)");
 209       break;
 210     case 1:
 211       printf_unfiltered ("RZ (Zero)");
 212       break;
 213     case 2:
 214       printf_unfiltered ("RP (Positive Infinity)");
 215       break;
 216     case 3:
 217       printf_unfiltered ("RM (Negative Infinity)");
 218       break;
 219     }
 220   printf_unfiltered ("; IRND= %d ", pcr_tmp & 2);
 221   if (0 == pcr_tmp & 2)
 222     {
 223       printf_unfiltered ("(same as RND)\n");
 224     }
 225   else
 226     {
 227       printf_unfiltered ("(toward zero)\n");
 228     }
 229   pcr_tmp = pcr & FPA_PCR_EM;
 230   printf_unfiltered ("\tEM= %#x", pcr_tmp);
 231   if (pcr_tmp & FPA_PCR_EM_DM)
 232     printf_unfiltered (" DM");
 233   if (pcr_tmp & FPA_PCR_EM_UOM)
 234     printf_unfiltered (" UOM");
 235   if (pcr_tmp & FPA_PCR_EM_PM)
 236     printf_unfiltered (" PM");
 237   if (pcr_tmp & FPA_PCR_EM_UM)
 238     printf_unfiltered (" UM");
 239   if (pcr_tmp & FPA_PCR_EM_OM)
 240     printf_unfiltered (" OM");
 241   if (pcr_tmp & FPA_PCR_EM_ZM)
 242     printf_unfiltered (" ZM");
 243   if (pcr_tmp & FPA_PCR_EM_IM)
 244     printf_unfiltered (" IM");
 245   printf_unfiltered ("\n");
 246   pcr_tmp = FPA_PCR_CC;
 247   printf_unfiltered ("\tCC= %#x", pcr_tmp);
 248   if (pcr_tmp & FPA_PCR_20MHZ)
 249     printf_unfiltered (" 20MHZ");
 250   if (pcr_tmp & FPA_PCR_CC_Z)
 251     printf_unfiltered (" Z");
 252   if (pcr_tmp & FPA_PCR_CC_C2)
 253     printf_unfiltered (" C2");
 254
 255   /* Dynix defines FPA_PCR_CC_C0 to 0x100 and ptx defines
 256      FPA_PCR_CC_C1 to 0x100.  Use whichever is defined and assume
 257      the OS knows what it is doing.  */
 258 #ifdef FPA_PCR_CC_C1
 259   if (pcr_tmp & FPA_PCR_CC_C1)
 260     printf_unfiltered (" C1");
 261 #else
 262   if (pcr_tmp & FPA_PCR_CC_C0)
 263     printf_unfiltered (" C0");
 264 #endif
 265
 266   switch (pcr_tmp)
 267     {
 268     case FPA_PCR_CC_Z:
 269       printf_unfiltered (" (Equal)");
 270       break;
 271 #ifdef FPA_PCR_CC_C1
 272     case FPA_PCR_CC_C1:
 273 #else
 274     case FPA_PCR_CC_C0:
 275 #endif
 276       printf_unfiltered (" (Less than)");
 277       break;
 278     case 0:
 279       printf_unfiltered (" (Greater than)");
 280       break;
 281       case FPA_PCR_CC_Z |
 282 #ifdef FPA_PCR_CC_C1
 283         FPA_PCR_CC_C1
 284 #else
 285         FPA_PCR_CC_C0
 286 #endif
 287     | FPA_PCR_CC_C2:
 288       printf_unfiltered (" (Unordered)");
 289       break;
 290     default:
 291       printf_unfiltered (" (Undefined)");
 292       break;
 293     }
 294   printf_unfiltered ("\n");
 295   pcr_tmp = pcr & FPA_PCR_AE;
 296   printf_unfiltered ("\tAE= %#x", pcr_tmp);
 297   if (pcr_tmp & FPA_PCR_AE_DE)
 298     printf_unfiltered (" DE");
 299   if (pcr_tmp & FPA_PCR_AE_UOE)
 300     printf_unfiltered (" UOE");
 301   if (pcr_tmp & FPA_PCR_AE_PE)
 302     printf_unfiltered (" PE");
 303   if (pcr_tmp & FPA_PCR_AE_UE)
 304     printf_unfiltered (" UE");
 305   if (pcr_tmp & FPA_PCR_AE_OE)
 306     printf_unfiltered (" OE");
 307   if (pcr_tmp & FPA_PCR_AE_ZE)
 308     printf_unfiltered (" ZE");
 309   if (pcr_tmp & FPA_PCR_AE_EE)
 310     printf_unfiltered (" EE");
 311   if (pcr_tmp & FPA_PCR_AE_IE)
 312     printf_unfiltered (" IE");
 313   printf_unfiltered ("\n");
 314 }
 315
 316 print_1167_regs (regs)
 317      long regs[FPA_NREGS];
 318
 319 {
 320   int i;
 321
 322   union
 323     {
 324       double d;
 325       long l[2];
 326     }
 327   xd;
 328   union
 329     {
 330       float f;
 331       long l;
 332     }
 333   xf;
 334
 335
 336   for (i = 0; i < FPA_NREGS; i++)
 337     {
 338       xf.l = regs[i];
 339       printf_unfiltered ("%%fp%d: raw= %#x, single= %f", i + 1, regs[i], xf.f);
 340       if (!(i & 1))
 341         {
 342           printf_unfiltered ("\n");
 343         }
 344       else
 345         {
 346           xd.l[1] = regs[i];
 347           xd.l[0] = regs[i + 1];
 348           printf_unfiltered (", double= %f\n", xd.d);
 349         }
 350     }
 351 }
 352
 353 print_fpa_status (struct pt_regset ep)
 354 {
 355
 356   printf_unfiltered ("WTL 1167:");
 357   if (ep.pr_fpa.fpa_pcr != 0)
 358     {
 359       printf_unfiltered ("\n");
 360       print_1167_control_word (ep.pr_fpa.fpa_pcr);
 361       print_1167_regs (ep.pr_fpa.fpa_regs);
 362     }
 363   else
 364     {
 365       printf_unfiltered (" not in use.\n");
 366     }
 367 }
 368
 369 #if 0                           /* disabled because it doesn't go through the target vector.  */
 370 i386_float_info (void)
 371 {
 372   char ubuf[UPAGES * NBPG];
 373   struct pt_regset regset;
 374
 375   if (have_inferior_p ())
 376     {
 377       PTRACE_READ_REGS (inferior_pid, (PTRACE_ARG3_TYPE) & regset);
 378     }
 379   else
 380     {
 381       int corechan = bfd_cache_lookup (core_bfd);
 382       if (lseek (corechan, 0, 0) < 0)
 383         {
 384           perror ("seek on core file");
 385         }
 386       if (myread (corechan, ubuf, UPAGES * NBPG) < 0)
 387         {
 388           perror ("read on core file");
 389         }
 390       /* only interested in the floating point registers */
 391       regset.pr_fpu = ((struct user *) ubuf)->u_fpusave;
 392       regset.pr_fpa = ((struct user *) ubuf)->u_fpasave;
 393     }
 394   print_fpu_status (regset);
 395   print_fpa_status (regset);
 396 }
 397 #endif
 398
 399 static volatile int got_sigchld;
 400
 401 /*ARGSUSED */
 402 /* This will eventually be more interesting. */
 403 void
 404 sigchld_handler (int signo)
 405 {
 406   got_sigchld++;
 407 }
 408
 409 /*
 410  * Signals for which the default action does not cause the process
 411  * to die.  See <sys/signal.h> for where this came from (alas, we
 412  * can't use those macros directly)
 413  */
 414 #ifndef sigmask
 415 #define sigmask(s) (1 << ((s) - 1))
 416 #endif
 417 #define SIGNALS_DFL_SAFE sigmask(SIGSTOP) | sigmask(SIGTSTP) | \
 418         sigmask(SIGTTIN) | sigmask(SIGTTOU) | sigmask(SIGCHLD) | \
 419         sigmask(SIGCONT) | sigmask(SIGWINCH) | sigmask(SIGPWR) | \
 420         sigmask(SIGURG) | sigmask(SIGPOLL)
 421
 422 #ifdef ATTACH_DETACH
 423 /*
 424  * Thanks to XPT_MPDEBUGGER, we have to mange child_wait().
 425  */
 426 int
 427 child_wait (int pid, struct target_waitstatus *status)
 428 {
 429   int save_errno, rv, xvaloff, saoff, sa_hand;
 430   struct pt_stop pt;
 431   struct user u;
 432   sigset_t set;
 433   /* Host signal number for a signal which the inferior terminates with, or
 434      0 if it hasn't terminated due to a signal.  */
 435   static int death_by_signal = 0;
 436 #ifdef SVR4_SHARED_LIBS         /* use this to distinguish ptx 2 vs ptx 4 */
 437   prstatus_t pstatus;
 438 #endif
 439
 440   do
 441     {
 442       set_sigint_trap ();       /* Causes SIGINT to be passed on to the
 443                                    attached process. */
 444       save_errno = errno;
 445
 446       got_sigchld = 0;
 447
 448       sigemptyset (&set);
 449
 450       while (got_sigchld == 0)
 451         {
 452           sigsuspend (&set);
 453         }
 454
 455       clear_sigint_trap ();
 456
 457       rv = mptrace (XPT_STOPSTAT, 0, (char *) &pt, 0);
 458       if (-1 == rv)
 459         {
 460           printf ("XPT_STOPSTAT: errno %d\n", errno);   /* DEBUG */
 461           continue;
 462         }
 463
 464       pid = pt.ps_pid;
 465
 466       if (pid != inferior_pid)
 467         {
 468           /* NOTE: the mystery fork in csh/tcsh needs to be ignored.
 469            * We should not return new children for the initial run
 470            * of a process until it has done the exec.
 471            */
 472           /* inferior probably forked; send it on its way */
 473           rv = mptrace (XPT_UNDEBUG, pid, 0, 0);
 474           if (-1 == rv)
 475             {
 476               printf ("child_wait: XPT_UNDEBUG: pid %d: %s\n", pid,
 477                       safe_strerror (errno));
 478             }
 479           continue;
 480         }
 481       /* FIXME: Do we deal with fork notification correctly?  */
 482       switch (pt.ps_reason)
 483         {
 484         case PTS_FORK:
 485           /* multi proc: treat like PTS_EXEC */
 486           /*
 487            * Pretend this didn't happen, since gdb isn't set up
 488            * to deal with stops on fork.
 489            */
 490           rv = ptrace (PT_CONTSIG, pid, 1, 0);
 491           if (-1 == rv)
 492             {
 493               printf ("PTS_FORK: PT_CONTSIG: error %d\n", errno);
 494             }
 495           continue;
 496         case PTS_EXEC:
 497           /*
 498            * Pretend this is a SIGTRAP.
 499            */
 500           status->kind = TARGET_WAITKIND_STOPPED;
 501           status->value.sig = TARGET_SIGNAL_TRAP;
 502           break;
 503         case PTS_EXIT:
 504           /*
 505            * Note: we stop before the exit actually occurs.  Extract
 506            * the exit code from the uarea.  If we're stopped in the
 507            * exit() system call, the exit code will be in
 508            * u.u_ap[0].  An exit due to an uncaught signal will have
 509            * something else in here, see the comment in the default:
 510            * case, below.  Finally,let the process exit.
 511            */
 512           if (death_by_signal)
 513             {
 514               status->kind = TARGET_WAITKIND_SIGNALED;
 515               status->value.sig = target_signal_from_host (death_by_signal);
 516               death_by_signal = 0;
 517               break;
 518             }
 519           xvaloff = (unsigned long) &u.u_ap[0] - (unsigned long) &u;
 520           errno = 0;
 521           rv = ptrace (PT_RUSER, pid, (char *) xvaloff, 0);
 522           status->kind = TARGET_WAITKIND_EXITED;
 523           status->value.integer = rv;
 524           /*
 525            * addr & data to mptrace() don't matter here, since
 526            * the process is already dead.
 527            */
 528           rv = mptrace (XPT_UNDEBUG, pid, 0, 0);
 529           if (-1 == rv)
 530             {
 531               printf ("child_wait: PTS_EXIT: XPT_UNDEBUG: pid %d error %d\n", pid,
 532                       errno);
 533             }
 534           break;
 535         case PTS_WATCHPT_HIT:
 536           internal_error ("PTS_WATCHPT_HIT\n");
 537           break;
 538         default:
 539           /* stopped by signal */
 540           status->kind = TARGET_WAITKIND_STOPPED;
 541           status->value.sig = target_signal_from_host (pt.ps_reason);
 542           death_by_signal = 0;
 543
 544           if (0 == (SIGNALS_DFL_SAFE & sigmask (pt.ps_reason)))
 545             {
 546               break;
 547             }
 548           /* else default action of signal is to die */
 549 #ifdef SVR4_SHARED_LIBS
 550           rv = ptrace (PT_GET_PRSTATUS, pid, (char *) &pstatus, 0);
 551           if (-1 == rv)
 552             error ("child_wait: signal %d PT_GET_PRSTATUS: %s\n",
 553                    pt.ps_reason, safe_strerror (errno));
 554           if (pstatus.pr_cursig != pt.ps_reason)
 555             {
 556               printf ("pstatus signal %d, pt signal %d\n",
 557                       pstatus.pr_cursig, pt.ps_reason);
 558             }
 559           sa_hand = (int) pstatus.pr_action.sa_handler;
 560 #else
 561           saoff = (unsigned long) &u.u_sa[0] - (unsigned long) &u;
 562           saoff += sizeof (struct sigaction) * (pt.ps_reason - 1);
 563           errno = 0;
 564           sa_hand = ptrace (PT_RUSER, pid, (char *) saoff, 0);
 565           if (errno)
 566             error ("child_wait: signal %d: RUSER: %s\n",
 567                    pt.ps_reason, safe_strerror (errno));
 568 #endif
 569           if ((int) SIG_DFL == sa_hand)
 570             {
 571               /* we will be dying */
 572               death_by_signal = pt.ps_reason;
 573             }
 574           break;
 575         }
 576
 577     }
 578   while (pid != inferior_pid);  /* Some other child died or stopped */
 579
 580   return pid;
 581 }
 582 #else /* !ATTACH_DETACH */
 583 /*
 584  * Simple child_wait() based on inftarg.c child_wait() for use until
 585  * the MPDEBUGGER child_wait() works properly.  This will go away when
 586  * that is fixed.
 587  */
 588 child_wait (int pid, struct target_waitstatus *ourstatus)
 589 {
 590   int save_errno;
 591   int status;
 592
 593   do
 594     {
 595       pid = wait (&status);
 596       save_errno = errno;
 597
 598       if (pid == -1)
 599         {
 600           if (save_errno == EINTR)
 601             continue;
 602           fprintf (stderr, "Child process unexpectedly missing: %s.\n",
 603                    safe_strerror (save_errno));
 604           ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 605           ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
 606           return -1;
 607         }
 608     }
 609   while (pid != inferior_pid);  /* Some other child died or stopped */
 610   store_waitstatus (ourstatus, status);
 611   return pid;
 612 }
 613 #endif /* ATTACH_DETACH */
 614 \f
 615
 616
 617 /* This function simply calls ptrace with the given arguments.
 618    It exists so that all calls to ptrace are isolated in this
 619    machine-dependent file. */
 620 int
 621 call_ptrace (int request, int pid, PTRACE_ARG3_TYPE addr, int data)
 622 {
 623   return ptrace (request, pid, addr, data);
 624 }
 625
 626 int
 627 call_mptrace (int request, int pid, PTRACE_ARG3_TYPE addr, int data)
 628 {
 629   return mptrace (request, pid, addr, data);
 630 }
 631
 632 #if defined (DEBUG_PTRACE)
 633 /* For the rest of the file, use an extra level of indirection */
 634 /* This lets us breakpoint usefully on call_ptrace. */
 635 #define ptrace call_ptrace
 636 #define mptrace call_mptrace
 637 #endif
 638
 639 void
 640 kill_inferior (void)
 641 {
 642   if (inferior_pid == 0)
 643     return;
 644
 645   /* For MPDEBUGGER, don't use PT_KILL, since the child will stop
 646      again with a PTS_EXIT.  Just hit him with SIGKILL (so he stops)
 647      and detach. */
 648
 649   kill (inferior_pid, SIGKILL);
 650 #ifdef ATTACH_DETACH
 651   detach (SIGKILL);
 652 #else /* ATTACH_DETACH */
 653   ptrace (PT_KILL, inferior_pid, 0, 0);
 654   wait ((int *) NULL);
 655 #endif /* ATTACH_DETACH */
 656   target_mourn_inferior ();
 657 }
 658
 659 /* Resume execution of the inferior process.
 660    If STEP is nonzero, single-step it.
 661    If SIGNAL is nonzero, give it that signal.  */
 662
 663 void
 664 child_resume (int pid, int step, enum target_signal signal)
 665 {
 666   errno = 0;
 667
 668   if (pid == -1)
 669     pid = inferior_pid;
 670
 671   /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where
 672      it was.  (If GDB wanted it to start some other way, we have already
 673      written a new PC value to the child.)
 674
 675      If this system does not support PT_SSTEP, a higher level function will
 676      have called single_step() to transmute the step request into a
 677      continue request (by setting breakpoints on all possible successor
 678      instructions), so we don't have to worry about that here.  */
 679
 680   if (step)
 681     ptrace (PT_SSTEP, pid, (PTRACE_ARG3_TYPE) 1, signal);
 682   else
 683     ptrace (PT_CONTSIG, pid, (PTRACE_ARG3_TYPE) 1, signal);
 684
 685   if (errno)
 686     perror_with_name ("ptrace");
 687 }
 688 \f
 689 #ifdef ATTACH_DETACH
 690 /* Start debugging the process whose number is PID.  */
 691 int
 692 attach (int pid)
 693 {
 694   sigset_t set;
 695   int rv;
 696
 697   rv = mptrace (XPT_DEBUG, pid, 0, 0);
 698   if (-1 == rv)
 699     {
 700       error ("mptrace(XPT_DEBUG): %s", safe_strerror (errno));
 701     }
 702   rv = mptrace (XPT_SIGNAL, pid, 0, SIGSTOP);
 703   if (-1 == rv)
 704     {
 705       error ("mptrace(XPT_SIGNAL): %s", safe_strerror (errno));
 706     }
 707   attach_flag = 1;
 708   return pid;
 709 }
 710
 711 void
 712 detach (int signo)
 713 {
 714   int rv;
 715
 716   rv = mptrace (XPT_UNDEBUG, inferior_pid, 1, signo);
 717   if (-1 == rv)
 718     {
 719       error ("mptrace(XPT_UNDEBUG): %s", safe_strerror (errno));
 720     }
 721   attach_flag = 0;
 722 }
 723
 724 #endif /* ATTACH_DETACH */
 725 \f
 726 /* Default the type of the ptrace transfer to int.  */
 727 #ifndef PTRACE_XFER_TYPE
 728 #define PTRACE_XFER_TYPE int
 729 #endif
 730 \f
 731
 732 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
 733    in the NEW_SUN_PTRACE case.
 734    It ought to be straightforward.  But it appears that writing did
 735    not write the data that I specified.  I cannot understand where
 736    it got the data that it actually did write.  */
 737
 738 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
 739    to debugger memory starting at MYADDR.   Copy to inferior if
 740    WRITE is nonzero.
 741
 742    Returns the length copied, which is either the LEN argument or zero.
 743    This xfer function does not do partial moves, since child_ops
 744    doesn't allow memory operations to cross below us in the target stack
 745    anyway.  */
 746
 747 int
 748 child_xfer_memory (memaddr, myaddr, len, write, target)
 749      CORE_ADDR memaddr;
 750      char *myaddr;
 751      int len;
 752      int write;
 753      struct target_ops *target; /* ignored */
 754 {
 755   register int i;
 756   /* Round starting address down to longword boundary.  */
 757   register CORE_ADDR addr = memaddr & -sizeof (PTRACE_XFER_TYPE);
 758   /* Round ending address up; get number of longwords that makes.  */
 759   register int count
 760   = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
 761   / sizeof (PTRACE_XFER_TYPE);
 762   /* Allocate buffer of that many longwords.  */
 763   register PTRACE_XFER_TYPE *buffer
 764   = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
 765
 766   if (write)
 767     {
 768       /* Fill start and end extra bytes of buffer with existing memory data.  */
 769
 770       if (addr != memaddr || len < (int) sizeof (PTRACE_XFER_TYPE))
 771         {
 772           /* Need part of initial word -- fetch it.  */
 773           buffer[0] = ptrace (PT_RTEXT, inferior_pid, (PTRACE_ARG3_TYPE) addr,
 774                               0);
 775         }
 776
 777       if (count > 1)            /* FIXME, avoid if even boundary */
 778         {
 779           buffer[count - 1]
 780             = ptrace (PT_RTEXT, inferior_pid,
 781                       ((PTRACE_ARG3_TYPE)
 782                        (addr + (count - 1) * sizeof (PTRACE_XFER_TYPE))),
 783                       0);
 784         }
 785
 786       /* Copy data to be written over corresponding part of buffer */
 787
 788       memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
 789               myaddr,
 790               len);
 791
 792       /* Write the entire buffer.  */
 793
 794       for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
 795         {
 796           errno = 0;
 797           ptrace (PT_WDATA, inferior_pid, (PTRACE_ARG3_TYPE) addr,
 798                   buffer[i]);
 799           if (errno)
 800             {
 801               /* Using the appropriate one (I or D) is necessary for
 802                  Gould NP1, at least.  */
 803               errno = 0;
 804               ptrace (PT_WTEXT, inferior_pid, (PTRACE_ARG3_TYPE) addr,
 805                       buffer[i]);
 806             }
 807           if (errno)
 808             return 0;
 809         }
 810     }
 811   else
 812     {
 813       /* Read all the longwords */
 814       for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
 815         {
 816           errno = 0;
 817           buffer[i] = ptrace (PT_RTEXT, inferior_pid,
 818                               (PTRACE_ARG3_TYPE) addr, 0);
 819           if (errno)
 820             return 0;
 821           QUIT;
 822         }
 823
 824       /* Copy appropriate bytes out of the buffer.  */
 825       memcpy (myaddr,
 826               (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
 827               len);
 828     }
 829   return len;
 830 }
 831
 832
 833 void
 834 _initialize_symm_nat (void)
 835 {
 836 #ifdef ATTACH_DETACH
 837 /*
 838  * the MPDEBUGGER is necessary for process tree debugging and attach
 839  * to work, but it alters the behavior of debugged processes, so other
 840  * things (at least child_wait()) will have to change to accomodate
 841  * that.
 842  *
 843  * Note that attach is not implemented in dynix 3, and not in ptx
 844  * until version 2.1 of the OS.
 845  */
 846   int rv;
 847   sigset_t set;
 848   struct sigaction sact;
 849
 850   rv = mptrace (XPT_MPDEBUGGER, 0, 0, 0);
 851   if (-1 == rv)
 852     {
 853       internal_error ("_initialize_symm_nat(): mptrace(XPT_MPDEBUGGER): %s",
 854                       safe_strerror (errno));
 855     }
 856
 857   /*
 858    * Under MPDEBUGGER, we get SIGCLHD when a traced process does
 859    * anything of interest.
 860    */
 861
 862   /*
 863    * Block SIGCHLD.  We leave it blocked all the time, and then
 864    * call sigsuspend() in child_wait() to wait for the child
 865    * to do something.  None of these ought to fail, but check anyway.
 866    */
 867   sigemptyset (&set);
 868   rv = sigaddset (&set, SIGCHLD);
 869   if (-1 == rv)
 870     {
 871       internal_error ("_initialize_symm_nat(): sigaddset(SIGCHLD): %s",
 872                       safe_strerror (errno));
 873     }
 874   rv = sigprocmask (SIG_BLOCK, &set, (sigset_t *) NULL);
 875   if (-1 == rv)
 876     {
 877       internal_error ("_initialize_symm_nat(): sigprocmask(SIG_BLOCK): %s",
 878                       safe_strerror (errno));
 879     }
 880
 881   sact.sa_handler = sigchld_handler;
 882   sigemptyset (&sact.sa_mask);
 883   sact.sa_flags = SA_NOCLDWAIT; /* keep the zombies away */
 884   rv = sigaction (SIGCHLD, &sact, (struct sigaction *) NULL);
 885   if (-1 == rv)
 886     {
 887       internal_error ("_initialize_symm_nat(): sigaction(SIGCHLD): %s",
 888                       safe_strerror (errno));
 889     }
 890 #endif
 891 }