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