1 /* Sequent Symmetry host interface, for GDB when running under Unix.
2 Copyright 1986, 1987, 1989, 1991, 1992, 1994, 2001
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* FIXME, some 387-specific items of use taken from i387-tdep.c -- ought to be
32 /* FIXME: What is the _INKERNEL define for? */
37 #include <sys/param.h>
41 #include <sys/ioctl.h>
44 #include <sys/ptrace.h>
46 /* Dynix has only machine/ptrace.h, which is already included by sys/user.h */
47 /* Dynix has no mptrace call */
48 #define mptrace ptrace
53 #define TERMINAL struct sgttyb
58 store_inferior_registers (int regno
)
60 struct pt_regset regs
;
63 /* FIXME: Fetching the registers is a kludge to initialize all elements
64 in the fpu and fpa status. This works for normal debugging, but
65 might cause problems when calling functions in the inferior.
66 At least fpu_control and fpa_pcr (probably more) should be added
67 to the registers array to solve this properly. */
68 mptrace (XPT_RREGS
, inferior_pid
, (PTRACE_ARG3_TYPE
) & regs
, 0);
70 regs
.pr_eax
= *(int *) ®isters
[REGISTER_BYTE (0)];
71 regs
.pr_ebx
= *(int *) ®isters
[REGISTER_BYTE (5)];
72 regs
.pr_ecx
= *(int *) ®isters
[REGISTER_BYTE (2)];
73 regs
.pr_edx
= *(int *) ®isters
[REGISTER_BYTE (1)];
74 regs
.pr_esi
= *(int *) ®isters
[REGISTER_BYTE (6)];
75 regs
.pr_edi
= *(int *) ®isters
[REGISTER_BYTE (7)];
76 regs
.pr_esp
= *(int *) ®isters
[REGISTER_BYTE (14)];
77 regs
.pr_ebp
= *(int *) ®isters
[REGISTER_BYTE (15)];
78 regs
.pr_eip
= *(int *) ®isters
[REGISTER_BYTE (16)];
79 regs
.pr_flags
= *(int *) ®isters
[REGISTER_BYTE (17)];
80 for (i
= 0; i
< 31; i
++)
82 regs
.pr_fpa
.fpa_regs
[i
] =
83 *(int *) ®isters
[REGISTER_BYTE (FP1_REGNUM
+ i
)];
85 memcpy (regs
.pr_fpu
.fpu_stack
[0], ®isters
[REGISTER_BYTE (ST0_REGNUM
)], 10);
86 memcpy (regs
.pr_fpu
.fpu_stack
[1], ®isters
[REGISTER_BYTE (ST1_REGNUM
)], 10);
87 memcpy (regs
.pr_fpu
.fpu_stack
[2], ®isters
[REGISTER_BYTE (ST2_REGNUM
)], 10);
88 memcpy (regs
.pr_fpu
.fpu_stack
[3], ®isters
[REGISTER_BYTE (ST3_REGNUM
)], 10);
89 memcpy (regs
.pr_fpu
.fpu_stack
[4], ®isters
[REGISTER_BYTE (ST4_REGNUM
)], 10);
90 memcpy (regs
.pr_fpu
.fpu_stack
[5], ®isters
[REGISTER_BYTE (ST5_REGNUM
)], 10);
91 memcpy (regs
.pr_fpu
.fpu_stack
[6], ®isters
[REGISTER_BYTE (ST6_REGNUM
)], 10);
92 memcpy (regs
.pr_fpu
.fpu_stack
[7], ®isters
[REGISTER_BYTE (ST7_REGNUM
)], 10);
93 mptrace (XPT_WREGS
, inferior_pid
, (PTRACE_ARG3_TYPE
) & regs
, 0);
97 fetch_inferior_registers (int regno
)
100 struct pt_regset regs
;
102 registers_fetched ();
104 mptrace (XPT_RREGS
, inferior_pid
, (PTRACE_ARG3_TYPE
) & regs
, 0);
105 *(int *) ®isters
[REGISTER_BYTE (EAX_REGNUM
)] = regs
.pr_eax
;
106 *(int *) ®isters
[REGISTER_BYTE (EBX_REGNUM
)] = regs
.pr_ebx
;
107 *(int *) ®isters
[REGISTER_BYTE (ECX_REGNUM
)] = regs
.pr_ecx
;
108 *(int *) ®isters
[REGISTER_BYTE (EDX_REGNUM
)] = regs
.pr_edx
;
109 *(int *) ®isters
[REGISTER_BYTE (ESI_REGNUM
)] = regs
.pr_esi
;
110 *(int *) ®isters
[REGISTER_BYTE (EDI_REGNUM
)] = regs
.pr_edi
;
111 *(int *) ®isters
[REGISTER_BYTE (EBP_REGNUM
)] = regs
.pr_ebp
;
112 *(int *) ®isters
[REGISTER_BYTE (ESP_REGNUM
)] = regs
.pr_esp
;
113 *(int *) ®isters
[REGISTER_BYTE (EIP_REGNUM
)] = regs
.pr_eip
;
114 *(int *) ®isters
[REGISTER_BYTE (EFLAGS_REGNUM
)] = regs
.pr_flags
;
115 for (i
= 0; i
< FPA_NREGS
; i
++)
117 *(int *) ®isters
[REGISTER_BYTE (FP1_REGNUM
+ i
)] =
118 regs
.pr_fpa
.fpa_regs
[i
];
120 memcpy (®isters
[REGISTER_BYTE (ST0_REGNUM
)], regs
.pr_fpu
.fpu_stack
[0], 10);
121 memcpy (®isters
[REGISTER_BYTE (ST1_REGNUM
)], regs
.pr_fpu
.fpu_stack
[1], 10);
122 memcpy (®isters
[REGISTER_BYTE (ST2_REGNUM
)], regs
.pr_fpu
.fpu_stack
[2], 10);
123 memcpy (®isters
[REGISTER_BYTE (ST3_REGNUM
)], regs
.pr_fpu
.fpu_stack
[3], 10);
124 memcpy (®isters
[REGISTER_BYTE (ST4_REGNUM
)], regs
.pr_fpu
.fpu_stack
[4], 10);
125 memcpy (®isters
[REGISTER_BYTE (ST5_REGNUM
)], regs
.pr_fpu
.fpu_stack
[5], 10);
126 memcpy (®isters
[REGISTER_BYTE (ST6_REGNUM
)], regs
.pr_fpu
.fpu_stack
[6], 10);
127 memcpy (®isters
[REGISTER_BYTE (ST7_REGNUM
)], regs
.pr_fpu
.fpu_stack
[7], 10);
130 /* FIXME: This should be merged with i387-tdep.c as well. */
132 print_fpu_status (struct pt_regset ep
)
140 printf_unfiltered ("80387:");
141 if (ep
.pr_fpu
.fpu_ip
== 0)
143 printf_unfiltered (" not in use.\n");
148 printf_unfiltered ("\n");
150 if (ep
.pr_fpu
.fpu_status
!= 0)
152 print_387_status_word (ep
.pr_fpu
.fpu_status
);
154 print_387_control_word (ep
.pr_fpu
.fpu_control
);
155 printf_unfiltered ("last exception: ");
156 printf_unfiltered ("opcode 0x%x; ", ep
.pr_fpu
.fpu_rsvd4
);
157 printf_unfiltered ("pc 0x%x:0x%x; ", ep
.pr_fpu
.fpu_cs
, ep
.pr_fpu
.fpu_ip
);
158 printf_unfiltered ("operand 0x%x:0x%x\n", ep
.pr_fpu
.fpu_data_offset
, ep
.pr_fpu
.fpu_op_sel
);
160 top
= (ep
.pr_fpu
.fpu_status
>> 11) & 7;
162 printf_unfiltered ("regno tag msb lsb value\n");
163 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
167 printf_unfiltered ("%s %d: ", fpreg
== top
? "=>" : " ", fpreg
);
169 switch ((ep
.pr_fpu
.fpu_tag
>> (fpreg
* 2)) & 3)
172 printf_unfiltered ("valid ");
175 printf_unfiltered ("zero ");
178 printf_unfiltered ("trap ");
181 printf_unfiltered ("empty ");
184 for (i
= 9; i
>= 0; i
--)
185 printf_unfiltered ("%02x", ep
.pr_fpu
.fpu_stack
[fpreg
][i
]);
187 i387_to_double ((char *) ep
.pr_fpu
.fpu_stack
[fpreg
], (char *) &val
);
188 printf_unfiltered (" %g\n", val
);
190 if (ep
.pr_fpu
.fpu_rsvd1
)
191 warning ("rsvd1 is 0x%x\n", ep
.pr_fpu
.fpu_rsvd1
);
192 if (ep
.pr_fpu
.fpu_rsvd2
)
193 warning ("rsvd2 is 0x%x\n", ep
.pr_fpu
.fpu_rsvd2
);
194 if (ep
.pr_fpu
.fpu_rsvd3
)
195 warning ("rsvd3 is 0x%x\n", ep
.pr_fpu
.fpu_rsvd3
);
196 if (ep
.pr_fpu
.fpu_rsvd5
)
197 warning ("rsvd5 is 0x%x\n", ep
.pr_fpu
.fpu_rsvd5
);
201 print_1167_control_word (unsigned int pcr
)
205 pcr_tmp
= pcr
& FPA_PCR_MODE
;
206 printf_unfiltered ("\tMODE= %#x; RND= %#x ", pcr_tmp
, pcr_tmp
& 12);
207 switch (pcr_tmp
& 12)
210 printf_unfiltered ("RN (Nearest Value)");
213 printf_unfiltered ("RZ (Zero)");
216 printf_unfiltered ("RP (Positive Infinity)");
219 printf_unfiltered ("RM (Negative Infinity)");
222 printf_unfiltered ("; IRND= %d ", pcr_tmp
& 2);
223 if (0 == pcr_tmp
& 2)
225 printf_unfiltered ("(same as RND)\n");
229 printf_unfiltered ("(toward zero)\n");
231 pcr_tmp
= pcr
& FPA_PCR_EM
;
232 printf_unfiltered ("\tEM= %#x", pcr_tmp
);
233 if (pcr_tmp
& FPA_PCR_EM_DM
)
234 printf_unfiltered (" DM");
235 if (pcr_tmp
& FPA_PCR_EM_UOM
)
236 printf_unfiltered (" UOM");
237 if (pcr_tmp
& FPA_PCR_EM_PM
)
238 printf_unfiltered (" PM");
239 if (pcr_tmp
& FPA_PCR_EM_UM
)
240 printf_unfiltered (" UM");
241 if (pcr_tmp
& FPA_PCR_EM_OM
)
242 printf_unfiltered (" OM");
243 if (pcr_tmp
& FPA_PCR_EM_ZM
)
244 printf_unfiltered (" ZM");
245 if (pcr_tmp
& FPA_PCR_EM_IM
)
246 printf_unfiltered (" IM");
247 printf_unfiltered ("\n");
248 pcr_tmp
= FPA_PCR_CC
;
249 printf_unfiltered ("\tCC= %#x", pcr_tmp
);
250 if (pcr_tmp
& FPA_PCR_20MHZ
)
251 printf_unfiltered (" 20MHZ");
252 if (pcr_tmp
& FPA_PCR_CC_Z
)
253 printf_unfiltered (" Z");
254 if (pcr_tmp
& FPA_PCR_CC_C2
)
255 printf_unfiltered (" C2");
257 /* Dynix defines FPA_PCR_CC_C0 to 0x100 and ptx defines
258 FPA_PCR_CC_C1 to 0x100. Use whichever is defined and assume
259 the OS knows what it is doing. */
261 if (pcr_tmp
& FPA_PCR_CC_C1
)
262 printf_unfiltered (" C1");
264 if (pcr_tmp
& FPA_PCR_CC_C0
)
265 printf_unfiltered (" C0");
271 printf_unfiltered (" (Equal)");
278 printf_unfiltered (" (Less than)");
281 printf_unfiltered (" (Greater than)");
290 printf_unfiltered (" (Unordered)");
293 printf_unfiltered (" (Undefined)");
296 printf_unfiltered ("\n");
297 pcr_tmp
= pcr
& FPA_PCR_AE
;
298 printf_unfiltered ("\tAE= %#x", pcr_tmp
);
299 if (pcr_tmp
& FPA_PCR_AE_DE
)
300 printf_unfiltered (" DE");
301 if (pcr_tmp
& FPA_PCR_AE_UOE
)
302 printf_unfiltered (" UOE");
303 if (pcr_tmp
& FPA_PCR_AE_PE
)
304 printf_unfiltered (" PE");
305 if (pcr_tmp
& FPA_PCR_AE_UE
)
306 printf_unfiltered (" UE");
307 if (pcr_tmp
& FPA_PCR_AE_OE
)
308 printf_unfiltered (" OE");
309 if (pcr_tmp
& FPA_PCR_AE_ZE
)
310 printf_unfiltered (" ZE");
311 if (pcr_tmp
& FPA_PCR_AE_EE
)
312 printf_unfiltered (" EE");
313 if (pcr_tmp
& FPA_PCR_AE_IE
)
314 printf_unfiltered (" IE");
315 printf_unfiltered ("\n");
318 print_1167_regs (long regs
[FPA_NREGS
])
336 for (i
= 0; i
< FPA_NREGS
; i
++)
339 printf_unfiltered ("%%fp%d: raw= %#x, single= %f", i
+ 1, regs
[i
], xf
.f
);
342 printf_unfiltered ("\n");
347 xd
.l
[0] = regs
[i
+ 1];
348 printf_unfiltered (", double= %f\n", xd
.d
);
353 print_fpa_status (struct pt_regset ep
)
356 printf_unfiltered ("WTL 1167:");
357 if (ep
.pr_fpa
.fpa_pcr
!= 0)
359 printf_unfiltered ("\n");
360 print_1167_control_word (ep
.pr_fpa
.fpa_pcr
);
361 print_1167_regs (ep
.pr_fpa
.fpa_regs
);
365 printf_unfiltered (" not in use.\n");
369 #if 0 /* disabled because it doesn't go through the target vector. */
370 i386_float_info (void)
372 char ubuf
[UPAGES
* NBPG
];
373 struct pt_regset regset
;
375 if (have_inferior_p ())
377 PTRACE_READ_REGS (inferior_pid
, (PTRACE_ARG3_TYPE
) & regset
);
381 int corechan
= bfd_cache_lookup (core_bfd
);
382 if (lseek (corechan
, 0, 0) < 0)
384 perror ("seek on core file");
386 if (myread (corechan
, ubuf
, UPAGES
* NBPG
) < 0)
388 perror ("read on core file");
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
;
394 print_fpu_status (regset
);
395 print_fpa_status (regset
);
399 static volatile int got_sigchld
;
402 /* This will eventually be more interesting. */
404 sigchld_handler (int signo
)
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)
415 #define sigmask(s) (1 << ((s) - 1))
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)
424 * Thanks to XPT_MPDEBUGGER, we have to mange child_wait().
427 child_wait (int pid
, struct target_waitstatus
*status
)
429 int save_errno
, rv
, xvaloff
, saoff
, sa_hand
;
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 */
442 set_sigint_trap (); /* Causes SIGINT to be passed on to the
450 while (got_sigchld
== 0)
455 clear_sigint_trap ();
457 rv
= mptrace (XPT_STOPSTAT
, 0, (char *) &pt
, 0);
460 printf ("XPT_STOPSTAT: errno %d\n", errno
); /* DEBUG */
466 if (pid
!= inferior_pid
)
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.
472 /* inferior probably forked; send it on its way */
473 rv
= mptrace (XPT_UNDEBUG
, pid
, 0, 0);
476 printf ("child_wait: XPT_UNDEBUG: pid %d: %s\n", pid
,
477 safe_strerror (errno
));
481 /* FIXME: Do we deal with fork notification correctly? */
482 switch (pt
.ps_reason
)
485 /* multi proc: treat like PTS_EXEC */
487 * Pretend this didn't happen, since gdb isn't set up
488 * to deal with stops on fork.
490 rv
= ptrace (PT_CONTSIG
, pid
, 1, 0);
493 printf ("PTS_FORK: PT_CONTSIG: error %d\n", errno
);
498 * Pretend this is a SIGTRAP.
500 status
->kind
= TARGET_WAITKIND_STOPPED
;
501 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
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.
514 status
->kind
= TARGET_WAITKIND_SIGNALED
;
515 status
->value
.sig
= target_signal_from_host (death_by_signal
);
519 xvaloff
= (unsigned long) &u
.u_ap
[0] - (unsigned long) &u
;
521 rv
= ptrace (PT_RUSER
, pid
, (char *) xvaloff
, 0);
522 status
->kind
= TARGET_WAITKIND_EXITED
;
523 status
->value
.integer
= rv
;
525 * addr & data to mptrace() don't matter here, since
526 * the process is already dead.
528 rv
= mptrace (XPT_UNDEBUG
, pid
, 0, 0);
531 printf ("child_wait: PTS_EXIT: XPT_UNDEBUG: pid %d error %d\n", pid
,
535 case PTS_WATCHPT_HIT
:
536 internal_error (__FILE__
, __LINE__
,
537 "PTS_WATCHPT_HIT\n");
540 /* stopped by signal */
541 status
->kind
= TARGET_WAITKIND_STOPPED
;
542 status
->value
.sig
= target_signal_from_host (pt
.ps_reason
);
545 if (0 == (SIGNALS_DFL_SAFE
& sigmask (pt
.ps_reason
)))
549 /* else default action of signal is to die */
550 #ifdef SVR4_SHARED_LIBS
551 rv
= ptrace (PT_GET_PRSTATUS
, pid
, (char *) &pstatus
, 0);
553 error ("child_wait: signal %d PT_GET_PRSTATUS: %s\n",
554 pt
.ps_reason
, safe_strerror (errno
));
555 if (pstatus
.pr_cursig
!= pt
.ps_reason
)
557 printf ("pstatus signal %d, pt signal %d\n",
558 pstatus
.pr_cursig
, pt
.ps_reason
);
560 sa_hand
= (int) pstatus
.pr_action
.sa_handler
;
562 saoff
= (unsigned long) &u
.u_sa
[0] - (unsigned long) &u
;
563 saoff
+= sizeof (struct sigaction
) * (pt
.ps_reason
- 1);
565 sa_hand
= ptrace (PT_RUSER
, pid
, (char *) saoff
, 0);
567 error ("child_wait: signal %d: RUSER: %s\n",
568 pt
.ps_reason
, safe_strerror (errno
));
570 if ((int) SIG_DFL
== sa_hand
)
572 /* we will be dying */
573 death_by_signal
= pt
.ps_reason
;
579 while (pid
!= inferior_pid
); /* Some other child died or stopped */
583 #else /* !ATTACH_DETACH */
585 * Simple child_wait() based on inftarg.c child_wait() for use until
586 * the MPDEBUGGER child_wait() works properly. This will go away when
589 child_wait (int pid
, struct target_waitstatus
*ourstatus
)
596 pid
= wait (&status
);
601 if (save_errno
== EINTR
)
603 fprintf (stderr
, "Child process unexpectedly missing: %s.\n",
604 safe_strerror (save_errno
));
605 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
606 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
610 while (pid
!= inferior_pid
); /* Some other child died or stopped */
611 store_waitstatus (ourstatus
, status
);
614 #endif /* ATTACH_DETACH */
618 /* This function simply calls ptrace with the given arguments.
619 It exists so that all calls to ptrace are isolated in this
620 machine-dependent file. */
622 call_ptrace (int request
, int pid
, PTRACE_ARG3_TYPE addr
, int data
)
624 return ptrace (request
, pid
, addr
, data
);
628 call_mptrace (int request
, int pid
, PTRACE_ARG3_TYPE addr
, int data
)
630 return mptrace (request
, pid
, addr
, data
);
633 #if defined (DEBUG_PTRACE)
634 /* For the rest of the file, use an extra level of indirection */
635 /* This lets us breakpoint usefully on call_ptrace. */
636 #define ptrace call_ptrace
637 #define mptrace call_mptrace
643 if (inferior_pid
== 0)
646 /* For MPDEBUGGER, don't use PT_KILL, since the child will stop
647 again with a PTS_EXIT. Just hit him with SIGKILL (so he stops)
650 kill (inferior_pid
, SIGKILL
);
653 #else /* ATTACH_DETACH */
654 ptrace (PT_KILL
, inferior_pid
, 0, 0);
656 #endif /* ATTACH_DETACH */
657 target_mourn_inferior ();
660 /* Resume execution of the inferior process.
661 If STEP is nonzero, single-step it.
662 If SIGNAL is nonzero, give it that signal. */
665 child_resume (int pid
, int step
, enum target_signal signal
)
672 /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where
673 it was. (If GDB wanted it to start some other way, we have already
674 written a new PC value to the child.)
676 If this system does not support PT_SSTEP, a higher level function will
677 have called single_step() to transmute the step request into a
678 continue request (by setting breakpoints on all possible successor
679 instructions), so we don't have to worry about that here. */
682 ptrace (PT_SSTEP
, pid
, (PTRACE_ARG3_TYPE
) 1, signal
);
684 ptrace (PT_CONTSIG
, pid
, (PTRACE_ARG3_TYPE
) 1, signal
);
687 perror_with_name ("ptrace");
691 /* Start debugging the process whose number is PID. */
698 rv
= mptrace (XPT_DEBUG
, pid
, 0, 0);
701 error ("mptrace(XPT_DEBUG): %s", safe_strerror (errno
));
703 rv
= mptrace (XPT_SIGNAL
, pid
, 0, SIGSTOP
);
706 error ("mptrace(XPT_SIGNAL): %s", safe_strerror (errno
));
717 rv
= mptrace (XPT_UNDEBUG
, inferior_pid
, 1, signo
);
720 error ("mptrace(XPT_UNDEBUG): %s", safe_strerror (errno
));
725 #endif /* ATTACH_DETACH */
727 /* Default the type of the ptrace transfer to int. */
728 #ifndef PTRACE_XFER_TYPE
729 #define PTRACE_XFER_TYPE int
733 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
734 in the NEW_SUN_PTRACE case.
735 It ought to be straightforward. But it appears that writing did
736 not write the data that I specified. I cannot understand where
737 it got the data that it actually did write. */
739 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
740 to debugger memory starting at MYADDR. Copy to inferior if
741 WRITE is nonzero. TARGET is ignored.
743 Returns the length copied, which is either the LEN argument or zero.
744 This xfer function does not do partial moves, since child_ops
745 doesn't allow memory operations to cross below us in the target stack
749 child_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
750 struct target_ops
*target
)
753 /* Round starting address down to longword boundary. */
754 register CORE_ADDR addr
= memaddr
& -sizeof (PTRACE_XFER_TYPE
);
755 /* Round ending address up; get number of longwords that makes. */
757 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
758 / sizeof (PTRACE_XFER_TYPE
);
759 /* Allocate buffer of that many longwords. */
760 register PTRACE_XFER_TYPE
*buffer
761 = (PTRACE_XFER_TYPE
*) alloca (count
* sizeof (PTRACE_XFER_TYPE
));
765 /* Fill start and end extra bytes of buffer with existing memory data. */
767 if (addr
!= memaddr
|| len
< (int) sizeof (PTRACE_XFER_TYPE
))
769 /* Need part of initial word -- fetch it. */
770 buffer
[0] = ptrace (PT_RTEXT
, inferior_pid
, (PTRACE_ARG3_TYPE
) addr
,
774 if (count
> 1) /* FIXME, avoid if even boundary */
777 = ptrace (PT_RTEXT
, inferior_pid
,
779 (addr
+ (count
- 1) * sizeof (PTRACE_XFER_TYPE
))),
783 /* Copy data to be written over corresponding part of buffer */
785 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
789 /* Write the entire buffer. */
791 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
794 ptrace (PT_WDATA
, inferior_pid
, (PTRACE_ARG3_TYPE
) addr
,
798 /* Using the appropriate one (I or D) is necessary for
799 Gould NP1, at least. */
801 ptrace (PT_WTEXT
, inferior_pid
, (PTRACE_ARG3_TYPE
) addr
,
810 /* Read all the longwords */
811 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
814 buffer
[i
] = ptrace (PT_RTEXT
, inferior_pid
,
815 (PTRACE_ARG3_TYPE
) addr
, 0);
821 /* Copy appropriate bytes out of the buffer. */
823 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
831 _initialize_symm_nat (void)
835 * the MPDEBUGGER is necessary for process tree debugging and attach
836 * to work, but it alters the behavior of debugged processes, so other
837 * things (at least child_wait()) will have to change to accomodate
840 * Note that attach is not implemented in dynix 3, and not in ptx
841 * until version 2.1 of the OS.
845 struct sigaction sact
;
847 rv
= mptrace (XPT_MPDEBUGGER
, 0, 0, 0);
850 internal_error (__FILE__
, __LINE__
,
851 "_initialize_symm_nat(): mptrace(XPT_MPDEBUGGER): %s",
852 safe_strerror (errno
));
856 * Under MPDEBUGGER, we get SIGCLHD when a traced process does
857 * anything of interest.
861 * Block SIGCHLD. We leave it blocked all the time, and then
862 * call sigsuspend() in child_wait() to wait for the child
863 * to do something. None of these ought to fail, but check anyway.
866 rv
= sigaddset (&set
, SIGCHLD
);
869 internal_error (__FILE__
, __LINE__
,
870 "_initialize_symm_nat(): sigaddset(SIGCHLD): %s",
871 safe_strerror (errno
));
873 rv
= sigprocmask (SIG_BLOCK
, &set
, (sigset_t
*) NULL
);
876 internal_error (__FILE__
, __LINE__
,
877 "_initialize_symm_nat(): sigprocmask(SIG_BLOCK): %s",
878 safe_strerror (errno
));
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
);
887 internal_error (__FILE__
, __LINE__
,
888 "_initialize_symm_nat(): sigaction(SIGCHLD): %s",
889 safe_strerror (errno
));