1 /* Native support code for HPUX PA-RISC, for GDB the GNU debugger.
3 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1998, 1999, 2000, 2001, 2004 Free Software Foundation, Inc.
6 Contributed by the Center for Software Science at the
7 University of Utah (pa-gdb-bugs@cs.utah.edu).
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 59 Temple Place - Suite 330,
24 Boston, MA 02111-1307, USA. */
30 #include <sys/ptrace.h>
34 #include "gdb_string.h"
35 #include "infttrace.h"
38 #include "hppa-tdep.h"
40 static CORE_ADDR text_end
;
43 deprecated_hpux_text_end (struct target_ops
*exec_ops
)
45 struct section_table
*p
;
47 /* Set text_end to the highest address of the end of any readonly
49 /* FIXME: The comment above does not match the code. The code
50 checks for sections with are either code *or* readonly. */
51 text_end
= (CORE_ADDR
) 0;
52 for (p
= exec_ops
->to_sections
; p
< exec_ops
->to_sections_end
; p
++)
53 if (bfd_get_section_flags (p
->bfd
, p
->the_bfd_section
)
54 & (SEC_CODE
| SEC_READONLY
))
56 if (text_end
< p
->endaddr
)
57 text_end
= p
->endaddr
;
62 static void fetch_register (int);
65 fetch_inferior_registers (int regno
)
68 for (regno
= 0; regno
< NUM_REGS
; regno
++)
69 fetch_register (regno
);
71 fetch_register (regno
);
74 /* Our own version of the offsetof macro, since we can't assume ANSI C. */
75 #define HPPAH_OFFSETOF(type, member) ((int) (&((type *) 0)->member))
77 /* Store our register values back into the inferior.
78 If REGNO is -1, do this for all registers.
79 Otherwise, REGNO specifies which register (so we can save time). */
82 store_inferior_registers (int regno
)
87 unsigned int offset
= U_REGS_OFFSET
;
92 unsigned int addr
, len
, offset
;
94 if (CANNOT_STORE_REGISTER (regno
))
98 len
= register_size (current_gdbarch
, regno
);
100 /* Requests for register zero actually want the save_state's
101 ss_flags member. As RM says: "Oh, what a hack!" */
105 addr
= HPPAH_OFFSETOF (save_state_t
, ss_flags
);
106 len
= sizeof (ss
.ss_flags
);
108 /* Note that ss_flags is always an int, no matter what
109 register_size (0) says. Assuming all HP-UX PA machines
110 are big-endian, put it at the least significant end of
111 the value, and zap the rest of the buffer. */
112 offset
= register_size (current_gdbarch
, 0) - len
;
115 /* Floating-point registers come from the ss_fpblock area. */
116 else if (regno
>= HPPA_FP0_REGNUM
)
117 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_fpblock
)
118 + (DEPRECATED_REGISTER_BYTE (regno
) - DEPRECATED_REGISTER_BYTE (HPPA_FP0_REGNUM
)));
120 /* Wide registers come from the ss_wide area.
121 I think it's more PC to test (ss_flags & SS_WIDEREGS) to select
122 between ss_wide and ss_narrow than to use the raw register size.
123 But checking ss_flags would require an extra ptrace call for
124 every register reference. Bleah. */
126 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_wide
)
127 + DEPRECATED_REGISTER_BYTE (regno
));
129 /* Narrow registers come from the ss_narrow area. Note that
130 ss_narrow starts with gr1, not gr0. */
132 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_narrow
)
133 + (DEPRECATED_REGISTER_BYTE (regno
) - DEPRECATED_REGISTER_BYTE (1)));
135 internal_error (__FILE__
, __LINE__
,
136 "hppah-nat.c (write_register): unexpected register size");
138 #ifdef GDB_TARGET_IS_HPPA_20W
139 /* Unbelieveable. The PC head and tail must be written in 64bit hunks
140 or we will get an error. Worse yet, the oddball ptrace/ttrace
141 layering will not allow us to perform a 64bit register store.
144 if ((regno
== HPPA_PCOQ_HEAD_REGNUM
|| regno
== HPPA_PCOQ_TAIL_REGNUM
) && len
== 8)
148 regcache_raw_read (current_regcache
, regno
, &temp
);
150 /* Set the priv level (stored in the low two bits of the PC. */
153 ttrace_write_reg_64 (PIDGET (inferior_ptid
), (CORE_ADDR
)addr
,
156 /* If we fail to write the PC, give a true error instead of
160 char *err
= safe_strerror (errno
);
161 char *msg
= alloca (strlen (err
) + 128);
162 sprintf (msg
, "writing `%s' register: %s",
163 REGISTER_NAME (regno
), err
);
164 perror_with_name (msg
);
169 /* Another crock. HPUX complains if you write a nonzero value to
170 the high part of IPSW. What will it take for HP to catch a
171 clue about building sensible interfaces? */
172 if (regno
== HPPA_IPSW_REGNUM
&& len
== 8)
176 regcache_raw_write_part (current_regcache
, regno
, 0,
177 sizeof (int), &temp
);
181 for (i
= 0; i
< len
; i
+= sizeof (int))
186 regcache_raw_read_part (current_regcache
, regno
, i
,
187 sizeof (int), &temp
);
188 call_ptrace (PT_WUREGS
, PIDGET (inferior_ptid
),
189 (PTRACE_ARG3_TYPE
) addr
+ i
,
193 /* Warning, not error, in case we are attached; sometimes
194 the kernel doesn't let us at the registers. */
195 char *err
= safe_strerror (errno
);
196 char *msg
= alloca (strlen (err
) + 128);
197 sprintf (msg
, "writing `%s' register: %s",
198 REGISTER_NAME (regno
), err
);
199 /* If we fail to write the PC, give a true error instead of
201 if (regno
== HPPA_PCOQ_HEAD_REGNUM
|| regno
== HPPA_PCOQ_TAIL_REGNUM
)
202 perror_with_name (msg
);
210 for (regno
= 0; regno
< NUM_REGS
; regno
++)
211 store_inferior_registers (regno
);
215 /* Fetch a register's value from the process's U area. */
217 fetch_register (int regno
)
219 char buf
[MAX_REGISTER_SIZE
];
220 unsigned int addr
, len
, offset
;
224 len
= register_size (current_gdbarch
, regno
);
226 /* Requests for register zero actually want the save_state's
227 ss_flags member. As RM says: "Oh, what a hack!" */
231 addr
= HPPAH_OFFSETOF (save_state_t
, ss_flags
);
232 len
= sizeof (ss
.ss_flags
);
234 /* Note that ss_flags is always an int, no matter what
235 register_size (0) says. Assuming all HP-UX PA machines are
236 big-endian, put it at the least significant end of the value,
237 and zap the rest of the buffer. */
238 offset
= register_size (current_gdbarch
, 0) - len
;
239 memset (buf
, 0, sizeof (buf
));
242 /* Floating-point registers come from the ss_fpblock area. */
243 else if (regno
>= HPPA_FP0_REGNUM
)
244 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_fpblock
)
245 + (DEPRECATED_REGISTER_BYTE (regno
) - DEPRECATED_REGISTER_BYTE (HPPA_FP0_REGNUM
)));
247 /* Wide registers come from the ss_wide area.
248 I think it's more PC to test (ss_flags & SS_WIDEREGS) to select
249 between ss_wide and ss_narrow than to use the raw register size.
250 But checking ss_flags would require an extra ptrace call for
251 every register reference. Bleah. */
253 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_wide
)
254 + DEPRECATED_REGISTER_BYTE (regno
));
256 /* Narrow registers come from the ss_narrow area. Note that
257 ss_narrow starts with gr1, not gr0. */
259 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_narrow
)
260 + (DEPRECATED_REGISTER_BYTE (regno
) - DEPRECATED_REGISTER_BYTE (1)));
263 internal_error (__FILE__
, __LINE__
,
264 "hppa-nat.c (fetch_register): unexpected register size");
266 for (i
= 0; i
< len
; i
+= sizeof (int))
269 /* Copy an int from the U area to buf. Fill the least
270 significant end if len != raw_size. */
271 * (int *) &buf
[offset
+ i
] =
272 call_ptrace (PT_RUREGS
, PIDGET (inferior_ptid
),
273 (PTRACE_ARG3_TYPE
) addr
+ i
, 0);
276 /* Warning, not error, in case we are attached; sometimes
277 the kernel doesn't let us at the registers. */
278 char *err
= safe_strerror (errno
);
279 char *msg
= alloca (strlen (err
) + 128);
280 sprintf (msg
, "reading `%s' register: %s",
281 REGISTER_NAME (regno
), err
);
287 /* If we're reading an address from the instruction address queue,
288 mask out the bottom two bits --- they contain the privilege
290 if (regno
== HPPA_PCOQ_HEAD_REGNUM
|| regno
== HPPA_PCOQ_TAIL_REGNUM
)
291 buf
[len
- 1] &= ~0x3;
293 regcache_raw_supply (current_regcache
, regno
, buf
);
297 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
298 to debugger memory starting at MYADDR. Copy to inferior if
301 Returns the length copied, which is either the LEN argument or
302 zero. This xfer function does not do partial moves, since
303 deprecated_child_ops doesn't allow memory operations to cross below
304 us in the target stack anyway. TARGET is ignored. */
307 child_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
308 struct mem_attrib
*mem
,
309 struct target_ops
*target
)
312 /* Round starting address down to longword boundary. */
313 CORE_ADDR addr
= memaddr
& - (CORE_ADDR
)(sizeof (int));
314 /* Round ending address up; get number of longwords that makes. */
316 = (((memaddr
+ len
) - addr
) + sizeof (int) - 1) / sizeof (int);
318 /* Allocate buffer of that many longwords.
319 Note -- do not use alloca to allocate this buffer since there is no
320 guarantee of when the buffer will actually be deallocated.
322 This routine can be called over and over with the same call chain;
323 this (in effect) would pile up all those alloca requests until a call
324 to alloca was made from a point higher than this routine in the
326 int *buffer
= (int *) xmalloc (count
* sizeof (int));
330 /* Fill start and end extra bytes of buffer with existing memory data. */
331 if (addr
!= memaddr
|| len
< (int) sizeof (int))
333 /* Need part of initial word -- fetch it. */
334 buffer
[0] = call_ptrace (addr
< text_end
? PT_RIUSER
: PT_RDUSER
,
335 PIDGET (inferior_ptid
),
336 (PTRACE_ARG3_TYPE
) addr
, 0);
339 if (count
> 1) /* FIXME, avoid if even boundary */
342 = call_ptrace (addr
< text_end
? PT_RIUSER
: PT_RDUSER
,
343 PIDGET (inferior_ptid
),
344 (PTRACE_ARG3_TYPE
) (addr
345 + (count
- 1) * sizeof (int)),
349 /* Copy data to be written over corresponding part of buffer */
350 memcpy ((char *) buffer
+ (memaddr
& (sizeof (int) - 1)), myaddr
, len
);
352 /* Write the entire buffer. */
353 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
357 /* The HP-UX kernel crashes if you use PT_WDUSER to write into the
358 text segment. FIXME -- does it work to write into the data
359 segment using WIUSER, or do these idiots really expect us to
360 figure out which segment the address is in, so we can use a
361 separate system call for it??! */
363 pt_request
= (addr
< text_end
) ? PT_WIUSER
: PT_WDUSER
;
364 pt_status
= call_ptrace (pt_request
,
365 PIDGET (inferior_ptid
),
366 (PTRACE_ARG3_TYPE
) addr
,
369 /* Did we fail? Might we've guessed wrong about which
370 segment this address resides in? Try the other request,
371 and see if that works... */
372 if ((pt_status
== -1) && errno
)
375 pt_request
= (pt_request
== PT_WIUSER
) ? PT_WDUSER
: PT_WIUSER
;
376 pt_status
= call_ptrace (pt_request
,
377 PIDGET (inferior_ptid
),
378 (PTRACE_ARG3_TYPE
) addr
,
381 /* No, we still fail. Okay, time to punt. */
382 if ((pt_status
== -1) && errno
)
392 /* Read all the longwords */
393 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
396 buffer
[i
] = call_ptrace (addr
< text_end
? PT_RIUSER
: PT_RDUSER
,
397 PIDGET (inferior_ptid
),
398 (PTRACE_ARG3_TYPE
) addr
, 0);
407 /* Copy appropriate bytes out of the buffer. */
408 memcpy (myaddr
, (char *) buffer
+ (memaddr
& (sizeof (int) - 1)), len
);
414 char *saved_child_execd_pathname
= NULL
;
422 } saved_vfork_state
= STATE_NONE
;
425 child_follow_fork (int follow_child
)
428 struct target_waitstatus last_status
;
430 int parent_pid
, child_pid
;
432 get_last_target_status (&last_ptid
, &last_status
);
433 has_vforked
= (last_status
.kind
== TARGET_WAITKIND_VFORKED
);
434 parent_pid
= ptid_get_pid (last_ptid
);
435 child_pid
= last_status
.value
.related_pid
;
437 /* At this point, if we are vforking, breakpoints were already
438 detached from the child in child_wait; and the child has already
439 called execve(). If we are forking, both the parent and child
440 have breakpoints inserted. */
446 detach_breakpoints (child_pid
);
447 #ifdef SOLIB_REMOVE_INFERIOR_HOOK
448 SOLIB_REMOVE_INFERIOR_HOOK (child_pid
);
452 /* Detach from the child. */
453 printf_unfiltered ("Detaching after fork from %s\n",
454 target_pid_to_str (pid_to_ptid (child_pid
)));
455 hppa_require_detach (child_pid
, 0);
457 /* The parent and child of a vfork share the same address space.
458 Also, on some targets the order in which vfork and exec events
459 are received for parent in child requires some delicate handling
462 For instance, on ptrace-based HPUX we receive the child's vfork
463 event first, at which time the parent has been suspended by the
464 OS and is essentially untouchable until the child's exit or second
465 exec event arrives. At that time, the parent's vfork event is
466 delivered to us, and that's when we see and decide how to follow
467 the vfork. But to get to that point, we must continue the child
468 until it execs or exits. To do that smoothly, all breakpoints
469 must be removed from the child, in case there are any set between
470 the vfork() and exec() calls. But removing them from the child
471 also removes them from the parent, due to the shared-address-space
472 nature of a vfork'd parent and child. On HPUX, therefore, we must
473 take care to restore the bp's to the parent before we continue it.
474 Else, it's likely that we may not stop in the expected place. (The
475 worst scenario is when the user tries to step over a vfork() call;
476 the step-resume bp must be restored for the step to properly stop
477 in the parent after the call completes!)
479 Sequence of events, as reported to gdb from HPUX:
481 Parent Child Action for gdb to take
482 -------------------------------------------------------
483 1 VFORK Continue child
488 Now that the child has safely exec'd or exited, we must restore
489 the parent's breakpoints before we continue it. Else, we may
490 cause it run past expected stopping points. */
493 reattach_breakpoints (parent_pid
);
497 /* Needed to keep the breakpoint lists in sync. */
499 detach_breakpoints (child_pid
);
501 /* Before detaching from the parent, remove all breakpoints from it. */
502 remove_breakpoints ();
504 /* Also reset the solib inferior hook from the parent. */
505 #ifdef SOLIB_REMOVE_INFERIOR_HOOK
506 SOLIB_REMOVE_INFERIOR_HOOK (PIDGET (inferior_ptid
));
509 /* Detach from the parent. */
510 target_detach (NULL
, 1);
512 /* Attach to the child. */
513 printf_unfiltered ("Attaching after fork to %s\n",
514 target_pid_to_str (pid_to_ptid (child_pid
)));
515 hppa_require_attach (child_pid
);
516 inferior_ptid
= pid_to_ptid (child_pid
);
518 /* If we vforked, then we've also execed by now. The exec will be
519 reported momentarily. follow_exec () will handle breakpoints, so
520 we don't have to.. */
522 follow_inferior_reset_breakpoints ();
527 /* If we followed the parent, don't try to follow the child's exec. */
528 if (saved_vfork_state
!= STATE_GOT_PARENT
529 && saved_vfork_state
!= STATE_FAKE_EXEC
)
530 fprintf_unfiltered (gdb_stdout
,
531 "hppa: post follow vfork: confused state\n");
533 if (! follow_child
|| saved_vfork_state
== STATE_GOT_PARENT
)
534 saved_vfork_state
= STATE_NONE
;
541 /* Format a process id, given PID. Be sure to terminate
542 this with a null--it's going to be printed via a "%s". */
544 child_pid_to_str (ptid_t ptid
)
546 /* Static because address returned */
548 pid_t pid
= PIDGET (ptid
);
550 /* Extra NUL for paranoia's sake */
551 sprintf (buf
, "process %d%c", pid
, '\0');
556 /* Format a thread id, given TID. Be sure to terminate
557 this with a null--it's going to be printed via a "%s".
559 Note: This is a core-gdb tid, not the actual system tid.
560 See infttrace.c for details. */
562 hppa_tid_to_str (ptid_t ptid
)
564 /* Static because address returned */
566 /* This seems strange, but when I did the ptid conversion, it looked
567 as though a pid was always being passed. - Kevin Buettner */
568 pid_t tid
= PIDGET (ptid
);
570 /* Extra NULLs for paranoia's sake */
571 sprintf (buf
, "system thread %d%c", tid
, '\0');
577 /* Enable HACK for ttrace work. In
578 * infttrace.c/require_notification_of_events,
579 * this is set to 0 so that the loop in child_wait
582 int not_same_real_pid
= 1;
585 /* Wait for child to do something. Return pid of child, or -1 in case
586 of error; store status through argument pointer OURSTATUS. */
589 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
593 char *execd_pathname
= NULL
;
597 enum target_waitkind kind
;
600 if (saved_vfork_state
== STATE_FAKE_EXEC
)
602 saved_vfork_state
= STATE_NONE
;
603 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
604 ourstatus
->value
.execd_pathname
= saved_child_execd_pathname
;
605 return inferior_ptid
;
610 set_sigint_trap (); /* Causes SIGINT to be passed on to the
614 pid
= ptrace_wait (inferior_ptid
, &status
);
620 clear_sigint_trap ();
624 if (save_errno
== EINTR
)
627 fprintf_unfiltered (gdb_stderr
, "Child process unexpectedly missing: %s.\n",
628 safe_strerror (save_errno
));
630 /* Claim it exited with unknown signal. */
631 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
632 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
633 return pid_to_ptid (-1);
638 if (target_has_exited (pid
, status
, &exit_status
))
640 /* ??rehrauer: For now, ignore this. */
644 if (!target_thread_alive (pid_to_ptid (pid
)))
646 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
647 return pid_to_ptid (pid
);
650 if (hpux_has_forked (pid
, &related_pid
))
652 /* Ignore the parent's fork event. */
653 if (pid
== PIDGET (inferior_ptid
))
655 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
656 return inferior_ptid
;
659 /* If this is the child's fork event, report that the
660 process has forked. */
661 if (related_pid
== PIDGET (inferior_ptid
))
663 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
664 ourstatus
->value
.related_pid
= pid
;
665 return inferior_ptid
;
669 if (hpux_has_vforked (pid
, &related_pid
))
671 if (pid
== PIDGET (inferior_ptid
))
673 if (saved_vfork_state
== STATE_GOT_CHILD
)
674 saved_vfork_state
= STATE_GOT_PARENT
;
675 else if (saved_vfork_state
== STATE_GOT_EXEC
)
676 saved_vfork_state
= STATE_FAKE_EXEC
;
678 fprintf_unfiltered (gdb_stdout
,
679 "hppah: parent vfork: confused\n");
681 else if (related_pid
== PIDGET (inferior_ptid
))
683 if (saved_vfork_state
== STATE_NONE
)
684 saved_vfork_state
= STATE_GOT_CHILD
;
686 fprintf_unfiltered (gdb_stdout
,
687 "hppah: child vfork: confused\n");
690 fprintf_unfiltered (gdb_stdout
,
691 "hppah: unknown vfork: confused\n");
693 if (saved_vfork_state
== STATE_GOT_CHILD
)
695 child_post_startup_inferior (pid_to_ptid (pid
));
696 detach_breakpoints (pid
);
697 #ifdef SOLIB_REMOVE_INFERIOR_HOOK
698 SOLIB_REMOVE_INFERIOR_HOOK (pid
);
700 child_resume (pid_to_ptid (pid
), 0, TARGET_SIGNAL_0
);
701 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
702 return pid_to_ptid (related_pid
);
704 else if (saved_vfork_state
== STATE_FAKE_EXEC
)
706 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
707 ourstatus
->value
.related_pid
= related_pid
;
708 return pid_to_ptid (pid
);
712 /* We saw the parent's vfork, but we haven't seen the exec yet.
713 Wait for it, for simplicity's sake. It should be pending. */
714 saved_vfork_pid
= related_pid
;
715 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
716 return pid_to_ptid (pid
);
720 if (hpux_has_execd (pid
, &execd_pathname
))
722 /* On HP-UX, events associated with a vforking inferior come in
723 threes: a vfork event for the child (always first), followed
724 a vfork event for the parent and an exec event for the child.
725 The latter two can come in either order. Make sure we get
727 if (saved_vfork_state
!= STATE_NONE
)
729 if (saved_vfork_state
== STATE_GOT_CHILD
)
731 saved_vfork_state
= STATE_GOT_EXEC
;
732 /* On HP/UX with ptrace, the child must be resumed before
733 the parent vfork event is delivered. A single-step
735 if (RESUME_EXECD_VFORKING_CHILD_TO_GET_PARENT_VFORK ())
736 target_resume (pid_to_ptid (pid
), 1, TARGET_SIGNAL_0
);
737 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
739 else if (saved_vfork_state
== STATE_GOT_PARENT
)
741 saved_vfork_state
= STATE_FAKE_EXEC
;
742 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
743 ourstatus
->value
.related_pid
= saved_vfork_pid
;
746 fprintf_unfiltered (gdb_stdout
,
747 "hppa: exec: unexpected state\n");
749 saved_child_execd_pathname
= execd_pathname
;
751 return inferior_ptid
;
754 /* Are we ignoring initial exec events? (This is likely because
755 we're in the process of starting up the inferior, and another
756 (older) mechanism handles those.) If so, we'll report this
757 as a regular stop, not an exec.
759 if (inferior_ignoring_startup_exec_events
)
761 inferior_ignoring_startup_exec_events
--;
765 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
766 ourstatus
->value
.execd_pathname
= execd_pathname
;
767 return pid_to_ptid (pid
);
771 /* All we must do with these is communicate their occurrence
772 to wait_for_inferior...
774 if (hpux_has_syscall_event (pid
, &kind
, &syscall_id
))
776 ourstatus
->kind
= kind
;
777 ourstatus
->value
.syscall_id
= syscall_id
;
778 return pid_to_ptid (pid
);
781 /*## } while (pid != PIDGET (inferior_ptid)); ## *//* Some other child died or stopped */
782 /* hack for thread testing */
784 while ((pid
!= PIDGET (inferior_ptid
)) && not_same_real_pid
);
787 store_waitstatus (ourstatus
, status
);
788 return pid_to_ptid (pid
);
791 #if !defined (GDB_NATIVE_HPUX_11)
793 /* The following code is a substitute for the infttrace.c versions used
794 with ttrace() in HPUX 11. */
796 /* This value is an arbitrary integer. */
797 #define PT_VERSION 123456
799 /* This semaphore is used to coordinate the child and parent processes
800 after a fork(), and before an exec() by the child. See
801 parent_attach_all for details. */
805 int parent_channel
[2]; /* Parent "talks" to [1], child "listens" to [0] */
806 int child_channel
[2]; /* Child "talks" to [1], parent "listens" to [0] */
811 #define SEM_LISTEN (0)
813 static startup_semaphore_t startup_semaphore
;
816 /* This function causes the caller's process to be traced by its
817 parent. This is intended to be called after GDB forks itself,
818 and before the child execs the target.
820 Note that HP-UX ptrace is rather funky in how this is done.
821 If the parent wants to get the initial exec event of a child,
822 it must set the ptrace event mask of the child to include execs.
823 (The child cannot do this itself.) This must be done after the
824 child is forked, but before it execs.
826 To coordinate the parent and child, we implement a semaphore using
827 pipes. After SETTRC'ing itself, the child tells the parent that
828 it is now traceable by the parent, and waits for the parent's
829 acknowledgement. The parent can then set the child's event mask,
830 and notify the child that it can now exec.
832 (The acknowledgement by parent happens as a result of a call to
833 child_acknowledge_created_inferior.) */
836 parent_attach_all (int pid
, PTRACE_ARG3_TYPE addr
, int data
)
840 /* We need a memory home for a constant. */
841 int tc_magic_child
= PT_VERSION
;
842 int tc_magic_parent
= 0;
844 /* The remainder of this function is only useful for HPUX 10.0 and
845 later, as it depends upon the ability to request notification
846 of specific kinds of events by the kernel. */
847 #if defined(PT_SET_EVENT_MASK)
849 /* Notify the parent that we're potentially ready to exec(). */
850 write (startup_semaphore
.child_channel
[SEM_TALK
],
852 sizeof (tc_magic_child
));
854 /* Wait for acknowledgement from the parent. */
855 read (startup_semaphore
.parent_channel
[SEM_LISTEN
],
857 sizeof (tc_magic_parent
));
858 if (tc_magic_child
!= tc_magic_parent
)
859 warning ("mismatched semaphore magic");
861 /* Discard our copy of the semaphore. */
862 (void) close (startup_semaphore
.parent_channel
[SEM_LISTEN
]);
863 (void) close (startup_semaphore
.parent_channel
[SEM_TALK
]);
864 (void) close (startup_semaphore
.child_channel
[SEM_LISTEN
]);
865 (void) close (startup_semaphore
.child_channel
[SEM_TALK
]);
873 hppa_require_attach (int pid
)
878 unsigned int regs_offset
;
880 /* Are we already attached? There appears to be no explicit way to
881 answer this via ptrace, so we try something which should be
882 innocuous if we are attached. If that fails, then we assume
883 we're not attached, and so attempt to make it so. */
886 regs_offset
= U_REGS_OFFSET
;
887 pc_addr
= register_addr (PC_REGNUM
, regs_offset
);
888 pc
= call_ptrace (PT_READ_U
, pid
, (PTRACE_ARG3_TYPE
) pc_addr
, 0);
893 pt_status
= call_ptrace (PT_ATTACH
, pid
, (PTRACE_ARG3_TYPE
) 0, 0);
898 /* Now we really are attached. */
906 hppa_require_detach (int pid
, int signal
)
909 call_ptrace (PT_DETACH
, pid
, (PTRACE_ARG3_TYPE
) 1, signal
);
910 errno
= 0; /* Ignore any errors. */
914 /* Since ptrace doesn't support memory page-protection events, which
915 are used to implement "hardware" watchpoints on HP-UX, these are
916 dummy versions, which perform no useful work. */
919 hppa_enable_page_protection_events (int pid
)
924 hppa_disable_page_protection_events (int pid
)
929 hppa_insert_hw_watchpoint (int pid
, CORE_ADDR start
, LONGEST len
, int type
)
931 error ("Hardware watchpoints not implemented on this platform.");
935 hppa_remove_hw_watchpoint (int pid
, CORE_ADDR start
, LONGEST len
, int type
)
937 error ("Hardware watchpoints not implemented on this platform.");
941 hppa_can_use_hw_watchpoint (int type
, int cnt
, int ot
)
947 hppa_range_profitable_for_hw_watchpoint (int pid
, CORE_ADDR start
, LONGEST len
)
949 error ("Hardware watchpoints not implemented on this platform.");
953 hppa_pid_or_tid_to_str (ptid_t id
)
955 /* In the ptrace world, there are only processes. */
956 return child_pid_to_str (id
);
960 hppa_ensure_vforking_parent_remains_stopped (int pid
)
962 /* This assumes that the vforked parent is presently stopped, and
963 that the vforked child has just delivered its first exec event.
964 Calling kill() this way will cause the SIGTRAP to be delivered as
965 soon as the parent is resumed, which happens as soon as the
966 vforked child is resumed. See wait_for_inferior for the use of
972 hppa_resume_execd_vforking_child_to_get_parent_vfork (void)
974 return 1; /* Yes, the child must be resumed. */
978 require_notification_of_events (int pid
)
980 #if defined(PT_SET_EVENT_MASK)
982 ptrace_event_t ptrace_events
;
986 /* Instruct the kernel as to the set of events we wish to be
987 informed of. (This support does not exist before HPUX 10.0.
988 We'll assume if PT_SET_EVENT_MASK has not been defined by
989 <sys/ptrace.h>, then we're being built on pre-10.0.) */
990 memset (&ptrace_events
, 0, sizeof (ptrace_events
));
992 /* Note: By default, all signals are visible to us. If we wish
993 the kernel to keep certain signals hidden from us, we do it
994 by calling sigdelset (ptrace_events.pe_signals, signal) for
995 each such signal here, before doing PT_SET_EVENT_MASK. */
996 /* RM: The above comment is no longer true. We start with ignoring
997 all signals, and then add the ones we are interested in. We could
998 do it the other way: start by looking at all signals and then
999 deleting the ones that we aren't interested in, except that
1000 multiple gdb signals may be mapped to the same host signal
1001 (eg. TARGET_SIGNAL_IO and TARGET_SIGNAL_POLL both get mapped to
1002 signal 22 on HPUX 10.20) We want to be notified if we are
1003 interested in either signal. */
1004 sigfillset (&ptrace_events
.pe_signals
);
1006 /* RM: Let's not bother with signals we don't care about */
1007 nsigs
= (int) TARGET_SIGNAL_LAST
;
1008 for (signum
= nsigs
; signum
> 0; signum
--)
1010 if ((signal_stop_state (signum
)) ||
1011 (signal_print_state (signum
)) ||
1012 (!signal_pass_state (signum
)))
1014 if (target_signal_to_host_p (signum
))
1015 sigdelset (&ptrace_events
.pe_signals
,
1016 target_signal_to_host (signum
));
1020 ptrace_events
.pe_set_event
= 0;
1022 ptrace_events
.pe_set_event
|= PTRACE_SIGNAL
;
1023 ptrace_events
.pe_set_event
|= PTRACE_EXEC
;
1024 ptrace_events
.pe_set_event
|= PTRACE_FORK
;
1025 ptrace_events
.pe_set_event
|= PTRACE_VFORK
;
1026 /* ??rehrauer: Add this one when we're prepared to catch it...
1027 ptrace_events.pe_set_event |= PTRACE_EXIT;
1031 pt_status
= call_ptrace (PT_SET_EVENT_MASK
,
1033 (PTRACE_ARG3_TYPE
) & ptrace_events
,
1034 sizeof (ptrace_events
));
1036 perror_with_name ("ptrace");
1043 require_notification_of_exec_events (int pid
)
1045 #if defined(PT_SET_EVENT_MASK)
1047 ptrace_event_t ptrace_events
;
1049 /* Instruct the kernel as to the set of events we wish to be
1050 informed of. (This support does not exist before HPUX 10.0.
1051 We'll assume if PT_SET_EVENT_MASK has not been defined by
1052 <sys/ptrace.h>, then we're being built on pre-10.0.) */
1053 memset (&ptrace_events
, 0, sizeof (ptrace_events
));
1055 /* Note: By default, all signals are visible to us. If we wish
1056 the kernel to keep certain signals hidden from us, we do it
1057 by calling sigdelset (ptrace_events.pe_signals, signal) for
1058 each such signal here, before doing PT_SET_EVENT_MASK. */
1059 sigemptyset (&ptrace_events
.pe_signals
);
1061 ptrace_events
.pe_set_event
= 0;
1063 ptrace_events
.pe_set_event
|= PTRACE_EXEC
;
1064 /* ??rehrauer: Add this one when we're prepared to catch it...
1065 ptrace_events.pe_set_event |= PTRACE_EXIT;
1069 pt_status
= call_ptrace (PT_SET_EVENT_MASK
,
1071 (PTRACE_ARG3_TYPE
) & ptrace_events
,
1072 sizeof (ptrace_events
));
1074 perror_with_name ("ptrace");
1080 /* This function is called by the parent process, with pid being the
1081 ID of the child process, after the debugger has forked. */
1084 child_acknowledge_created_inferior (int pid
)
1086 /* We need a memory home for a constant. */
1087 int tc_magic_parent
= PT_VERSION
;
1088 int tc_magic_child
= 0;
1090 /* The remainder of this function is only useful for HPUX 10.0 and
1091 later, as it depends upon the ability to request notification
1092 of specific kinds of events by the kernel. */
1093 #if defined(PT_SET_EVENT_MASK)
1094 /* Wait for the child to tell us that it has forked. */
1095 read (startup_semaphore
.child_channel
[SEM_LISTEN
],
1097 sizeof (tc_magic_child
));
1099 /* Notify the child that it can exec.
1101 In the infttrace.c variant of this function, we set the child's
1102 event mask after the fork but before the exec. In the ptrace
1103 world, it seems we can't set the event mask until after the exec. */
1104 write (startup_semaphore
.parent_channel
[SEM_TALK
],
1106 sizeof (tc_magic_parent
));
1108 /* We'd better pause a bit before trying to set the event mask,
1109 though, to ensure that the exec has happened. We don't want to
1110 wait() on the child, because that'll screw up the upper layers
1111 of gdb's execution control that expect to see the exec event.
1113 After an exec, the child is no longer executing gdb code. Hence,
1114 we can't have yet another synchronization via the pipes. We'll
1115 just sleep for a second, and hope that's enough delay... */
1118 /* Instruct the kernel as to the set of events we wish to be
1120 require_notification_of_exec_events (pid
);
1122 /* Discard our copy of the semaphore. */
1123 (void) close (startup_semaphore
.parent_channel
[SEM_LISTEN
]);
1124 (void) close (startup_semaphore
.parent_channel
[SEM_TALK
]);
1125 (void) close (startup_semaphore
.child_channel
[SEM_LISTEN
]);
1126 (void) close (startup_semaphore
.child_channel
[SEM_TALK
]);
1131 child_post_startup_inferior (ptid_t ptid
)
1133 require_notification_of_events (PIDGET (ptid
));
1137 child_post_attach (int pid
)
1139 require_notification_of_events (pid
);
1143 child_insert_fork_catchpoint (int pid
)
1145 /* This request is only available on HPUX 10.0 and later. */
1146 #if !defined(PT_SET_EVENT_MASK)
1147 error ("Unable to catch forks prior to HPUX 10.0");
1149 /* Enable reporting of fork events from the kernel. */
1150 /* ??rehrauer: For the moment, we're always enabling these events,
1151 and just ignoring them if there's no catchpoint to catch them. */
1157 child_remove_fork_catchpoint (int pid
)
1159 /* This request is only available on HPUX 10.0 and later. */
1160 #if !defined(PT_SET_EVENT_MASK)
1161 error ("Unable to catch forks prior to HPUX 10.0");
1163 /* Disable reporting of fork events from the kernel. */
1164 /* ??rehrauer: For the moment, we're always enabling these events,
1165 and just ignoring them if there's no catchpoint to catch them. */
1171 child_insert_vfork_catchpoint (int pid
)
1173 /* This request is only available on HPUX 10.0 and later. */
1174 #if !defined(PT_SET_EVENT_MASK)
1175 error ("Unable to catch vforks prior to HPUX 10.0");
1177 /* Enable reporting of vfork events from the kernel. */
1178 /* ??rehrauer: For the moment, we're always enabling these events,
1179 and just ignoring them if there's no catchpoint to catch them. */
1185 child_remove_vfork_catchpoint (int pid
)
1187 /* This request is only available on HPUX 10.0 and later. */
1188 #if !defined(PT_SET_EVENT_MASK)
1189 error ("Unable to catch vforks prior to HPUX 10.0");
1191 /* Disable reporting of vfork events from the kernel. */
1192 /* ??rehrauer: For the moment, we're always enabling these events,
1193 and just ignoring them if there's no catchpoint to catch them. */
1199 hpux_has_forked (int pid
, int *childpid
)
1201 /* This request is only available on HPUX 10.0 and later. */
1202 #if !defined(PT_GET_PROCESS_STATE)
1207 ptrace_state_t ptrace_state
;
1210 pt_status
= call_ptrace (PT_GET_PROCESS_STATE
,
1212 (PTRACE_ARG3_TYPE
) & ptrace_state
,
1213 sizeof (ptrace_state
));
1215 perror_with_name ("ptrace");
1219 if (ptrace_state
.pe_report_event
& PTRACE_FORK
)
1221 *childpid
= ptrace_state
.pe_other_pid
;
1230 hpux_has_vforked (int pid
, int *childpid
)
1232 /* This request is only available on HPUX 10.0 and later. */
1233 #if !defined(PT_GET_PROCESS_STATE)
1239 ptrace_state_t ptrace_state
;
1242 pt_status
= call_ptrace (PT_GET_PROCESS_STATE
,
1244 (PTRACE_ARG3_TYPE
) & ptrace_state
,
1245 sizeof (ptrace_state
));
1247 perror_with_name ("ptrace");
1251 if (ptrace_state
.pe_report_event
& PTRACE_VFORK
)
1253 *childpid
= ptrace_state
.pe_other_pid
;
1262 child_insert_exec_catchpoint (int pid
)
1264 /* This request is only available on HPUX 10.0 and later. */
1265 #if !defined(PT_SET_EVENT_MASK)
1266 error ("Unable to catch execs prior to HPUX 10.0");
1269 /* Enable reporting of exec events from the kernel. */
1270 /* ??rehrauer: For the moment, we're always enabling these events,
1271 and just ignoring them if there's no catchpoint to catch them. */
1277 child_remove_exec_catchpoint (int pid
)
1279 /* This request is only available on HPUX 10.0 and later. */
1280 #if !defined(PT_SET_EVENT_MASK)
1281 error ("Unable to catch execs prior to HPUX 10.0");
1284 /* Disable reporting of exec events from the kernel. */
1285 /* ??rehrauer: For the moment, we're always enabling these events,
1286 and just ignoring them if there's no catchpoint to catch them. */
1292 hpux_has_execd (int pid
, char **execd_pathname
)
1294 /* This request is only available on HPUX 10.0 and later. */
1295 #if !defined(PT_GET_PROCESS_STATE)
1296 *execd_pathname
= NULL
;
1301 ptrace_state_t ptrace_state
;
1304 pt_status
= call_ptrace (PT_GET_PROCESS_STATE
,
1306 (PTRACE_ARG3_TYPE
) & ptrace_state
,
1307 sizeof (ptrace_state
));
1309 perror_with_name ("ptrace");
1313 if (ptrace_state
.pe_report_event
& PTRACE_EXEC
)
1315 char *exec_file
= target_pid_to_exec_file (pid
);
1316 *execd_pathname
= savestring (exec_file
, strlen (exec_file
));
1325 child_reported_exec_events_per_exec_call (void)
1327 return 2; /* ptrace reports the event twice per call. */
1331 hpux_has_syscall_event (int pid
, enum target_waitkind
*kind
, int *syscall_id
)
1333 /* This request is only available on HPUX 10.30 and later, via
1334 the ttrace interface. */
1336 *kind
= TARGET_WAITKIND_SPURIOUS
;
1342 child_pid_to_exec_file (int pid
)
1344 static char exec_file_buffer
[1024];
1346 CORE_ADDR top_of_stack
;
1350 ptid_t saved_inferior_ptid
;
1353 #ifdef PT_GET_PROCESS_PATHNAME
1354 /* As of 10.x HP-UX, there's an explicit request to get the pathname. */
1355 pt_status
= call_ptrace (PT_GET_PROCESS_PATHNAME
,
1357 (PTRACE_ARG3_TYPE
) exec_file_buffer
,
1358 sizeof (exec_file_buffer
) - 1);
1360 return exec_file_buffer
;
1363 /* It appears that this request is broken prior to 10.30.
1364 If it fails, try a really, truly amazingly gross hack
1365 that DDE uses, of pawing through the process' data
1366 segment to find the pathname. */
1368 top_of_stack
= 0x7b03a000;
1372 /* On the chance that pid != inferior_ptid, set inferior_ptid
1373 to pid, so that (grrrr!) implicit uses of inferior_ptid get
1376 saved_inferior_ptid
= inferior_ptid
;
1377 inferior_ptid
= pid_to_ptid (pid
);
1379 /* Try to grab a null-terminated string. */
1382 if (target_read_memory (top_of_stack
, four_chars
, 4) != 0)
1384 inferior_ptid
= saved_inferior_ptid
;
1387 for (i
= 0; i
< 4; i
++)
1389 exec_file_buffer
[name_index
++] = four_chars
[i
];
1390 done
= (four_chars
[i
] == '\0');
1397 if (exec_file_buffer
[0] == '\0')
1399 inferior_ptid
= saved_inferior_ptid
;
1403 inferior_ptid
= saved_inferior_ptid
;
1404 return exec_file_buffer
;
1408 pre_fork_inferior (void)
1412 status
= pipe (startup_semaphore
.parent_channel
);
1415 warning ("error getting parent pipe for startup semaphore");
1419 status
= pipe (startup_semaphore
.child_channel
);
1422 warning ("error getting child pipe for startup semaphore");
1428 /* Check to see if the given thread is alive.
1430 This is a no-op, as ptrace doesn't support threads, so we just
1434 child_thread_alive (ptid_t ptid
)
1439 #endif /* ! GDB_NATIVE_HPUX_11 */