1 /* Sequent Symmetry host interface, for GDB when running under Unix.
2 Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1999, 2000,
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* FIXME, some 387-specific items of use taken from i387-tdep.c -- ought to be
33 /* FIXME: What is the _INKERNEL define for? */
38 #include <sys/param.h>
42 #include <sys/ioctl.h>
45 #include <sys/ptrace.h>
47 /* Dynix has only machine/ptrace.h, which is already included by sys/user.h */
48 /* Dynix has no mptrace call */
49 #define mptrace ptrace
54 #define TERMINAL struct sgttyb
59 store_inferior_registers (int regno
)
61 struct pt_regset regs
;
64 /* FIXME: Fetching the registers is a kludge to initialize all elements
65 in the fpu and fpa status. This works for normal debugging, but
66 might cause problems when calling functions in the inferior.
67 At least fpu_control and fpa_pcr (probably more) should be added
68 to the registers array to solve this properly. */
69 mptrace (XPT_RREGS
, inferior_pid
, (PTRACE_ARG3_TYPE
) & regs
, 0);
71 regs
.pr_eax
= *(int *) ®isters
[REGISTER_BYTE (0)];
72 regs
.pr_ebx
= *(int *) ®isters
[REGISTER_BYTE (5)];
73 regs
.pr_ecx
= *(int *) ®isters
[REGISTER_BYTE (2)];
74 regs
.pr_edx
= *(int *) ®isters
[REGISTER_BYTE (1)];
75 regs
.pr_esi
= *(int *) ®isters
[REGISTER_BYTE (6)];
76 regs
.pr_edi
= *(int *) ®isters
[REGISTER_BYTE (7)];
77 regs
.pr_esp
= *(int *) ®isters
[REGISTER_BYTE (14)];
78 regs
.pr_ebp
= *(int *) ®isters
[REGISTER_BYTE (15)];
79 regs
.pr_eip
= *(int *) ®isters
[REGISTER_BYTE (16)];
80 regs
.pr_flags
= *(int *) ®isters
[REGISTER_BYTE (17)];
81 for (i
= 0; i
< 31; i
++)
83 regs
.pr_fpa
.fpa_regs
[i
] =
84 *(int *) ®isters
[REGISTER_BYTE (FP1_REGNUM
+ i
)];
86 memcpy (regs
.pr_fpu
.fpu_stack
[0], ®isters
[REGISTER_BYTE (ST0_REGNUM
)], 10);
87 memcpy (regs
.pr_fpu
.fpu_stack
[1], ®isters
[REGISTER_BYTE (ST1_REGNUM
)], 10);
88 memcpy (regs
.pr_fpu
.fpu_stack
[2], ®isters
[REGISTER_BYTE (ST2_REGNUM
)], 10);
89 memcpy (regs
.pr_fpu
.fpu_stack
[3], ®isters
[REGISTER_BYTE (ST3_REGNUM
)], 10);
90 memcpy (regs
.pr_fpu
.fpu_stack
[4], ®isters
[REGISTER_BYTE (ST4_REGNUM
)], 10);
91 memcpy (regs
.pr_fpu
.fpu_stack
[5], ®isters
[REGISTER_BYTE (ST5_REGNUM
)], 10);
92 memcpy (regs
.pr_fpu
.fpu_stack
[6], ®isters
[REGISTER_BYTE (ST6_REGNUM
)], 10);
93 memcpy (regs
.pr_fpu
.fpu_stack
[7], ®isters
[REGISTER_BYTE (ST7_REGNUM
)], 10);
94 mptrace (XPT_WREGS
, inferior_pid
, (PTRACE_ARG3_TYPE
) & regs
, 0);
98 fetch_inferior_registers (int regno
)
101 struct pt_regset regs
;
103 registers_fetched ();
105 mptrace (XPT_RREGS
, inferior_pid
, (PTRACE_ARG3_TYPE
) & regs
, 0);
106 *(int *) ®isters
[REGISTER_BYTE (EAX_REGNUM
)] = regs
.pr_eax
;
107 *(int *) ®isters
[REGISTER_BYTE (EBX_REGNUM
)] = regs
.pr_ebx
;
108 *(int *) ®isters
[REGISTER_BYTE (ECX_REGNUM
)] = regs
.pr_ecx
;
109 *(int *) ®isters
[REGISTER_BYTE (EDX_REGNUM
)] = regs
.pr_edx
;
110 *(int *) ®isters
[REGISTER_BYTE (ESI_REGNUM
)] = regs
.pr_esi
;
111 *(int *) ®isters
[REGISTER_BYTE (EDI_REGNUM
)] = regs
.pr_edi
;
112 *(int *) ®isters
[REGISTER_BYTE (EBP_REGNUM
)] = regs
.pr_ebp
;
113 *(int *) ®isters
[REGISTER_BYTE (ESP_REGNUM
)] = regs
.pr_esp
;
114 *(int *) ®isters
[REGISTER_BYTE (EIP_REGNUM
)] = regs
.pr_eip
;
115 *(int *) ®isters
[REGISTER_BYTE (EFLAGS_REGNUM
)] = regs
.pr_flags
;
116 for (i
= 0; i
< FPA_NREGS
; i
++)
118 *(int *) ®isters
[REGISTER_BYTE (FP1_REGNUM
+ i
)] =
119 regs
.pr_fpa
.fpa_regs
[i
];
121 memcpy (®isters
[REGISTER_BYTE (ST0_REGNUM
)], regs
.pr_fpu
.fpu_stack
[0], 10);
122 memcpy (®isters
[REGISTER_BYTE (ST1_REGNUM
)], regs
.pr_fpu
.fpu_stack
[1], 10);
123 memcpy (®isters
[REGISTER_BYTE (ST2_REGNUM
)], regs
.pr_fpu
.fpu_stack
[2], 10);
124 memcpy (®isters
[REGISTER_BYTE (ST3_REGNUM
)], regs
.pr_fpu
.fpu_stack
[3], 10);
125 memcpy (®isters
[REGISTER_BYTE (ST4_REGNUM
)], regs
.pr_fpu
.fpu_stack
[4], 10);
126 memcpy (®isters
[REGISTER_BYTE (ST5_REGNUM
)], regs
.pr_fpu
.fpu_stack
[5], 10);
127 memcpy (®isters
[REGISTER_BYTE (ST6_REGNUM
)], regs
.pr_fpu
.fpu_stack
[6], 10);
128 memcpy (®isters
[REGISTER_BYTE (ST7_REGNUM
)], regs
.pr_fpu
.fpu_stack
[7], 10);
131 /* FIXME: This should be merged with i387-tdep.c as well. */
133 print_fpu_status (struct pt_regset ep
)
141 printf_unfiltered ("80387:");
142 if (ep
.pr_fpu
.fpu_ip
== 0)
144 printf_unfiltered (" not in use.\n");
149 printf_unfiltered ("\n");
151 if (ep
.pr_fpu
.fpu_status
!= 0)
153 print_387_status_word (ep
.pr_fpu
.fpu_status
);
155 print_387_control_word (ep
.pr_fpu
.fpu_control
);
156 printf_unfiltered ("last exception: ");
157 printf_unfiltered ("opcode 0x%x; ", ep
.pr_fpu
.fpu_rsvd4
);
158 printf_unfiltered ("pc 0x%x:0x%x; ", ep
.pr_fpu
.fpu_cs
, ep
.pr_fpu
.fpu_ip
);
159 printf_unfiltered ("operand 0x%x:0x%x\n", ep
.pr_fpu
.fpu_data_offset
, ep
.pr_fpu
.fpu_op_sel
);
161 top
= (ep
.pr_fpu
.fpu_status
>> 11) & 7;
163 printf_unfiltered ("regno tag msb lsb value\n");
164 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
168 printf_unfiltered ("%s %d: ", fpreg
== top
? "=>" : " ", fpreg
);
170 switch ((ep
.pr_fpu
.fpu_tag
>> (fpreg
* 2)) & 3)
173 printf_unfiltered ("valid ");
176 printf_unfiltered ("zero ");
179 printf_unfiltered ("trap ");
182 printf_unfiltered ("empty ");
185 for (i
= 9; i
>= 0; i
--)
186 printf_unfiltered ("%02x", ep
.pr_fpu
.fpu_stack
[fpreg
][i
]);
188 i387_to_double ((char *) ep
.pr_fpu
.fpu_stack
[fpreg
], (char *) &val
);
189 printf_unfiltered (" %g\n", val
);
191 if (ep
.pr_fpu
.fpu_rsvd1
)
192 warning ("rsvd1 is 0x%x\n", ep
.pr_fpu
.fpu_rsvd1
);
193 if (ep
.pr_fpu
.fpu_rsvd2
)
194 warning ("rsvd2 is 0x%x\n", ep
.pr_fpu
.fpu_rsvd2
);
195 if (ep
.pr_fpu
.fpu_rsvd3
)
196 warning ("rsvd3 is 0x%x\n", ep
.pr_fpu
.fpu_rsvd3
);
197 if (ep
.pr_fpu
.fpu_rsvd5
)
198 warning ("rsvd5 is 0x%x\n", ep
.pr_fpu
.fpu_rsvd5
);
202 print_1167_control_word (unsigned int pcr
)
206 pcr_tmp
= pcr
& FPA_PCR_MODE
;
207 printf_unfiltered ("\tMODE= %#x; RND= %#x ", pcr_tmp
, pcr_tmp
& 12);
208 switch (pcr_tmp
& 12)
211 printf_unfiltered ("RN (Nearest Value)");
214 printf_unfiltered ("RZ (Zero)");
217 printf_unfiltered ("RP (Positive Infinity)");
220 printf_unfiltered ("RM (Negative Infinity)");
223 printf_unfiltered ("; IRND= %d ", pcr_tmp
& 2);
224 if (0 == pcr_tmp
& 2)
226 printf_unfiltered ("(same as RND)\n");
230 printf_unfiltered ("(toward zero)\n");
232 pcr_tmp
= pcr
& FPA_PCR_EM
;
233 printf_unfiltered ("\tEM= %#x", pcr_tmp
);
234 if (pcr_tmp
& FPA_PCR_EM_DM
)
235 printf_unfiltered (" DM");
236 if (pcr_tmp
& FPA_PCR_EM_UOM
)
237 printf_unfiltered (" UOM");
238 if (pcr_tmp
& FPA_PCR_EM_PM
)
239 printf_unfiltered (" PM");
240 if (pcr_tmp
& FPA_PCR_EM_UM
)
241 printf_unfiltered (" UM");
242 if (pcr_tmp
& FPA_PCR_EM_OM
)
243 printf_unfiltered (" OM");
244 if (pcr_tmp
& FPA_PCR_EM_ZM
)
245 printf_unfiltered (" ZM");
246 if (pcr_tmp
& FPA_PCR_EM_IM
)
247 printf_unfiltered (" IM");
248 printf_unfiltered ("\n");
249 pcr_tmp
= FPA_PCR_CC
;
250 printf_unfiltered ("\tCC= %#x", pcr_tmp
);
251 if (pcr_tmp
& FPA_PCR_20MHZ
)
252 printf_unfiltered (" 20MHZ");
253 if (pcr_tmp
& FPA_PCR_CC_Z
)
254 printf_unfiltered (" Z");
255 if (pcr_tmp
& FPA_PCR_CC_C2
)
256 printf_unfiltered (" C2");
258 /* Dynix defines FPA_PCR_CC_C0 to 0x100 and ptx defines
259 FPA_PCR_CC_C1 to 0x100. Use whichever is defined and assume
260 the OS knows what it is doing. */
262 if (pcr_tmp
& FPA_PCR_CC_C1
)
263 printf_unfiltered (" C1");
265 if (pcr_tmp
& FPA_PCR_CC_C0
)
266 printf_unfiltered (" C0");
272 printf_unfiltered (" (Equal)");
279 printf_unfiltered (" (Less than)");
282 printf_unfiltered (" (Greater than)");
291 printf_unfiltered (" (Unordered)");
294 printf_unfiltered (" (Undefined)");
297 printf_unfiltered ("\n");
298 pcr_tmp
= pcr
& FPA_PCR_AE
;
299 printf_unfiltered ("\tAE= %#x", pcr_tmp
);
300 if (pcr_tmp
& FPA_PCR_AE_DE
)
301 printf_unfiltered (" DE");
302 if (pcr_tmp
& FPA_PCR_AE_UOE
)
303 printf_unfiltered (" UOE");
304 if (pcr_tmp
& FPA_PCR_AE_PE
)
305 printf_unfiltered (" PE");
306 if (pcr_tmp
& FPA_PCR_AE_UE
)
307 printf_unfiltered (" UE");
308 if (pcr_tmp
& FPA_PCR_AE_OE
)
309 printf_unfiltered (" OE");
310 if (pcr_tmp
& FPA_PCR_AE_ZE
)
311 printf_unfiltered (" ZE");
312 if (pcr_tmp
& FPA_PCR_AE_EE
)
313 printf_unfiltered (" EE");
314 if (pcr_tmp
& FPA_PCR_AE_IE
)
315 printf_unfiltered (" IE");
316 printf_unfiltered ("\n");
319 print_1167_regs (long regs
[FPA_NREGS
])
337 for (i
= 0; i
< FPA_NREGS
; i
++)
340 printf_unfiltered ("%%fp%d: raw= %#x, single= %f", i
+ 1, regs
[i
], xf
.f
);
343 printf_unfiltered ("\n");
348 xd
.l
[0] = regs
[i
+ 1];
349 printf_unfiltered (", double= %f\n", xd
.d
);
354 print_fpa_status (struct pt_regset ep
)
357 printf_unfiltered ("WTL 1167:");
358 if (ep
.pr_fpa
.fpa_pcr
!= 0)
360 printf_unfiltered ("\n");
361 print_1167_control_word (ep
.pr_fpa
.fpa_pcr
);
362 print_1167_regs (ep
.pr_fpa
.fpa_regs
);
366 printf_unfiltered (" not in use.\n");
370 #if 0 /* disabled because it doesn't go through the target vector. */
371 i386_float_info (void)
373 char ubuf
[UPAGES
* NBPG
];
374 struct pt_regset regset
;
376 if (have_inferior_p ())
378 PTRACE_READ_REGS (inferior_pid
, (PTRACE_ARG3_TYPE
) & regset
);
382 int corechan
= bfd_cache_lookup (core_bfd
);
383 if (lseek (corechan
, 0, 0) < 0)
385 perror ("seek on core file");
387 if (myread (corechan
, ubuf
, UPAGES
* NBPG
) < 0)
389 perror ("read on core file");
391 /* only interested in the floating point registers */
392 regset
.pr_fpu
= ((struct user
*) ubuf
)->u_fpusave
;
393 regset
.pr_fpa
= ((struct user
*) ubuf
)->u_fpasave
;
395 print_fpu_status (regset
);
396 print_fpa_status (regset
);
400 static volatile int got_sigchld
;
403 /* This will eventually be more interesting. */
405 sigchld_handler (int signo
)
411 * Signals for which the default action does not cause the process
412 * to die. See <sys/signal.h> for where this came from (alas, we
413 * can't use those macros directly)
416 #define sigmask(s) (1 << ((s) - 1))
418 #define SIGNALS_DFL_SAFE sigmask(SIGSTOP) | sigmask(SIGTSTP) | \
419 sigmask(SIGTTIN) | sigmask(SIGTTOU) | sigmask(SIGCHLD) | \
420 sigmask(SIGCONT) | sigmask(SIGWINCH) | sigmask(SIGPWR) | \
421 sigmask(SIGURG) | sigmask(SIGPOLL)
425 * Thanks to XPT_MPDEBUGGER, we have to mange child_wait().
428 child_wait (int pid
, struct target_waitstatus
*status
)
430 int save_errno
, rv
, xvaloff
, saoff
, sa_hand
;
434 /* Host signal number for a signal which the inferior terminates with, or
435 0 if it hasn't terminated due to a signal. */
436 static int death_by_signal
= 0;
437 #ifdef SVR4_SHARED_LIBS /* use this to distinguish ptx 2 vs ptx 4 */
443 set_sigint_trap (); /* Causes SIGINT to be passed on to the
451 while (got_sigchld
== 0)
456 clear_sigint_trap ();
458 rv
= mptrace (XPT_STOPSTAT
, 0, (char *) &pt
, 0);
461 printf ("XPT_STOPSTAT: errno %d\n", errno
); /* DEBUG */
467 if (pid
!= inferior_pid
)
469 /* NOTE: the mystery fork in csh/tcsh needs to be ignored.
470 * We should not return new children for the initial run
471 * of a process until it has done the exec.
473 /* inferior probably forked; send it on its way */
474 rv
= mptrace (XPT_UNDEBUG
, pid
, 0, 0);
477 printf ("child_wait: XPT_UNDEBUG: pid %d: %s\n", pid
,
478 safe_strerror (errno
));
482 /* FIXME: Do we deal with fork notification correctly? */
483 switch (pt
.ps_reason
)
486 /* multi proc: treat like PTS_EXEC */
488 * Pretend this didn't happen, since gdb isn't set up
489 * to deal with stops on fork.
491 rv
= ptrace (PT_CONTSIG
, pid
, 1, 0);
494 printf ("PTS_FORK: PT_CONTSIG: error %d\n", errno
);
499 * Pretend this is a SIGTRAP.
501 status
->kind
= TARGET_WAITKIND_STOPPED
;
502 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
506 * Note: we stop before the exit actually occurs. Extract
507 * the exit code from the uarea. If we're stopped in the
508 * exit() system call, the exit code will be in
509 * u.u_ap[0]. An exit due to an uncaught signal will have
510 * something else in here, see the comment in the default:
511 * case, below. Finally,let the process exit.
515 status
->kind
= TARGET_WAITKIND_SIGNALED
;
516 status
->value
.sig
= target_signal_from_host (death_by_signal
);
520 xvaloff
= (unsigned long) &u
.u_ap
[0] - (unsigned long) &u
;
522 rv
= ptrace (PT_RUSER
, pid
, (char *) xvaloff
, 0);
523 status
->kind
= TARGET_WAITKIND_EXITED
;
524 status
->value
.integer
= rv
;
526 * addr & data to mptrace() don't matter here, since
527 * the process is already dead.
529 rv
= mptrace (XPT_UNDEBUG
, pid
, 0, 0);
532 printf ("child_wait: PTS_EXIT: XPT_UNDEBUG: pid %d error %d\n", pid
,
536 case PTS_WATCHPT_HIT
:
537 internal_error (__FILE__
, __LINE__
,
538 "PTS_WATCHPT_HIT\n");
541 /* stopped by signal */
542 status
->kind
= TARGET_WAITKIND_STOPPED
;
543 status
->value
.sig
= target_signal_from_host (pt
.ps_reason
);
546 if (0 == (SIGNALS_DFL_SAFE
& sigmask (pt
.ps_reason
)))
550 /* else default action of signal is to die */
551 #ifdef SVR4_SHARED_LIBS
552 rv
= ptrace (PT_GET_PRSTATUS
, pid
, (char *) &pstatus
, 0);
554 error ("child_wait: signal %d PT_GET_PRSTATUS: %s\n",
555 pt
.ps_reason
, safe_strerror (errno
));
556 if (pstatus
.pr_cursig
!= pt
.ps_reason
)
558 printf ("pstatus signal %d, pt signal %d\n",
559 pstatus
.pr_cursig
, pt
.ps_reason
);
561 sa_hand
= (int) pstatus
.pr_action
.sa_handler
;
563 saoff
= (unsigned long) &u
.u_sa
[0] - (unsigned long) &u
;
564 saoff
+= sizeof (struct sigaction
) * (pt
.ps_reason
- 1);
566 sa_hand
= ptrace (PT_RUSER
, pid
, (char *) saoff
, 0);
568 error ("child_wait: signal %d: RUSER: %s\n",
569 pt
.ps_reason
, safe_strerror (errno
));
571 if ((int) SIG_DFL
== sa_hand
)
573 /* we will be dying */
574 death_by_signal
= pt
.ps_reason
;
580 while (pid
!= inferior_pid
); /* Some other child died or stopped */
584 #else /* !ATTACH_DETACH */
586 * Simple child_wait() based on inftarg.c child_wait() for use until
587 * the MPDEBUGGER child_wait() works properly. This will go away when
590 child_wait (int pid
, struct target_waitstatus
*ourstatus
)
597 pid
= wait (&status
);
602 if (save_errno
== EINTR
)
604 fprintf (stderr
, "Child process unexpectedly missing: %s.\n",
605 safe_strerror (save_errno
));
606 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
607 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
611 while (pid
!= inferior_pid
); /* Some other child died or stopped */
612 store_waitstatus (ourstatus
, status
);
615 #endif /* ATTACH_DETACH */
619 /* This function simply calls ptrace with the given arguments.
620 It exists so that all calls to ptrace are isolated in this
621 machine-dependent file. */
623 call_ptrace (int request
, int pid
, PTRACE_ARG3_TYPE addr
, int data
)
625 return ptrace (request
, pid
, addr
, data
);
629 call_mptrace (int request
, int pid
, PTRACE_ARG3_TYPE addr
, int data
)
631 return mptrace (request
, pid
, addr
, data
);
634 #if defined (DEBUG_PTRACE)
635 /* For the rest of the file, use an extra level of indirection */
636 /* This lets us breakpoint usefully on call_ptrace. */
637 #define ptrace call_ptrace
638 #define mptrace call_mptrace
644 if (inferior_pid
== 0)
647 /* For MPDEBUGGER, don't use PT_KILL, since the child will stop
648 again with a PTS_EXIT. Just hit him with SIGKILL (so he stops)
651 kill (inferior_pid
, SIGKILL
);
654 #else /* ATTACH_DETACH */
655 ptrace (PT_KILL
, inferior_pid
, 0, 0);
657 #endif /* ATTACH_DETACH */
658 target_mourn_inferior ();
661 /* Resume execution of the inferior process.
662 If STEP is nonzero, single-step it.
663 If SIGNAL is nonzero, give it that signal. */
666 child_resume (int pid
, int step
, enum target_signal signal
)
673 /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where
674 it was. (If GDB wanted it to start some other way, we have already
675 written a new PC value to the child.)
677 If this system does not support PT_SSTEP, a higher level function will
678 have called single_step() to transmute the step request into a
679 continue request (by setting breakpoints on all possible successor
680 instructions), so we don't have to worry about that here. */
683 ptrace (PT_SSTEP
, pid
, (PTRACE_ARG3_TYPE
) 1, signal
);
685 ptrace (PT_CONTSIG
, pid
, (PTRACE_ARG3_TYPE
) 1, signal
);
688 perror_with_name ("ptrace");
692 /* Start debugging the process whose number is PID. */
699 rv
= mptrace (XPT_DEBUG
, pid
, 0, 0);
702 error ("mptrace(XPT_DEBUG): %s", safe_strerror (errno
));
704 rv
= mptrace (XPT_SIGNAL
, pid
, 0, SIGSTOP
);
707 error ("mptrace(XPT_SIGNAL): %s", safe_strerror (errno
));
718 rv
= mptrace (XPT_UNDEBUG
, inferior_pid
, 1, signo
);
721 error ("mptrace(XPT_UNDEBUG): %s", safe_strerror (errno
));
726 #endif /* ATTACH_DETACH */
728 /* Default the type of the ptrace transfer to int. */
729 #ifndef PTRACE_XFER_TYPE
730 #define PTRACE_XFER_TYPE int
734 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
735 in the NEW_SUN_PTRACE case.
736 It ought to be straightforward. But it appears that writing did
737 not write the data that I specified. I cannot understand where
738 it got the data that it actually did write. */
740 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
741 to debugger memory starting at MYADDR. Copy to inferior if
742 WRITE is nonzero. TARGET is ignored.
744 Returns the length copied, which is either the LEN argument or zero.
745 This xfer function does not do partial moves, since child_ops
746 doesn't allow memory operations to cross below us in the target stack
750 child_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
751 struct mem_attrib
*attrib
,
752 struct target_ops
*target
)
755 /* Round starting address down to longword boundary. */
756 register CORE_ADDR addr
= memaddr
& -sizeof (PTRACE_XFER_TYPE
);
757 /* Round ending address up; get number of longwords that makes. */
759 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
760 / sizeof (PTRACE_XFER_TYPE
);
761 /* Allocate buffer of that many longwords. */
762 register PTRACE_XFER_TYPE
*buffer
763 = (PTRACE_XFER_TYPE
*) alloca (count
* sizeof (PTRACE_XFER_TYPE
));
767 /* Fill start and end extra bytes of buffer with existing memory data. */
769 if (addr
!= memaddr
|| len
< (int) sizeof (PTRACE_XFER_TYPE
))
771 /* Need part of initial word -- fetch it. */
772 buffer
[0] = ptrace (PT_RTEXT
, inferior_pid
, (PTRACE_ARG3_TYPE
) addr
,
776 if (count
> 1) /* FIXME, avoid if even boundary */
779 = ptrace (PT_RTEXT
, inferior_pid
,
781 (addr
+ (count
- 1) * sizeof (PTRACE_XFER_TYPE
))),
785 /* Copy data to be written over corresponding part of buffer */
787 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
791 /* Write the entire buffer. */
793 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
796 ptrace (PT_WDATA
, inferior_pid
, (PTRACE_ARG3_TYPE
) addr
,
800 /* Using the appropriate one (I or D) is necessary for
801 Gould NP1, at least. */
803 ptrace (PT_WTEXT
, inferior_pid
, (PTRACE_ARG3_TYPE
) addr
,
812 /* Read all the longwords */
813 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
816 buffer
[i
] = ptrace (PT_RTEXT
, inferior_pid
,
817 (PTRACE_ARG3_TYPE
) addr
, 0);
823 /* Copy appropriate bytes out of the buffer. */
825 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
833 _initialize_symm_nat (void)
837 * the MPDEBUGGER is necessary for process tree debugging and attach
838 * to work, but it alters the behavior of debugged processes, so other
839 * things (at least child_wait()) will have to change to accomodate
842 * Note that attach is not implemented in dynix 3, and not in ptx
843 * until version 2.1 of the OS.
847 struct sigaction sact
;
849 rv
= mptrace (XPT_MPDEBUGGER
, 0, 0, 0);
852 internal_error (__FILE__
, __LINE__
,
853 "_initialize_symm_nat(): mptrace(XPT_MPDEBUGGER): %s",
854 safe_strerror (errno
));
858 * Under MPDEBUGGER, we get SIGCLHD when a traced process does
859 * anything of interest.
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.
868 rv
= sigaddset (&set
, SIGCHLD
);
871 internal_error (__FILE__
, __LINE__
,
872 "_initialize_symm_nat(): sigaddset(SIGCHLD): %s",
873 safe_strerror (errno
));
875 rv
= sigprocmask (SIG_BLOCK
, &set
, (sigset_t
*) NULL
);
878 internal_error (__FILE__
, __LINE__
,
879 "_initialize_symm_nat(): sigprocmask(SIG_BLOCK): %s",
880 safe_strerror (errno
));
883 sact
.sa_handler
= sigchld_handler
;
884 sigemptyset (&sact
.sa_mask
);
885 sact
.sa_flags
= SA_NOCLDWAIT
; /* keep the zombies away */
886 rv
= sigaction (SIGCHLD
, &sact
, (struct sigaction
*) NULL
);
889 internal_error (__FILE__
, __LINE__
,
890 "_initialize_symm_nat(): sigaction(SIGCHLD): %s",
891 safe_strerror (errno
));