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 + ((regno
- HPPA_FP0_REGNUM
)
119 * register_size (current_gdbarch
, regno
));
121 /* Wide registers come from the ss_wide area.
122 I think it's more PC to test (ss_flags & SS_WIDEREGS) to select
123 between ss_wide and ss_narrow than to use the raw register size.
124 But checking ss_flags would require an extra ptrace call for
125 every register reference. Bleah. */
127 addr
= HPPAH_OFFSETOF (save_state_t
, ss_wide
)
130 /* Narrow registers come from the ss_narrow area. Note that
131 ss_narrow starts with gr1, not gr0. */
133 addr
= HPPAH_OFFSETOF (save_state_t
, ss_narrow
)
136 internal_error (__FILE__
, __LINE__
,
137 "hppah-nat.c (write_register): unexpected register size");
139 #ifdef GDB_TARGET_IS_HPPA_20W
140 /* Unbelieveable. The PC head and tail must be written in 64bit hunks
141 or we will get an error. Worse yet, the oddball ptrace/ttrace
142 layering will not allow us to perform a 64bit register store.
145 if ((regno
== HPPA_PCOQ_HEAD_REGNUM
|| regno
== HPPA_PCOQ_TAIL_REGNUM
) && len
== 8)
149 regcache_raw_read (current_regcache
, regno
, &temp
);
151 /* Set the priv level (stored in the low two bits of the PC. */
154 ttrace_write_reg_64 (PIDGET (inferior_ptid
), (CORE_ADDR
)addr
,
157 /* If we fail to write the PC, give a true error instead of
161 char *err
= safe_strerror (errno
);
162 char *msg
= alloca (strlen (err
) + 128);
163 sprintf (msg
, "writing `%s' register: %s",
164 REGISTER_NAME (regno
), err
);
165 perror_with_name (msg
);
170 /* Another crock. HPUX complains if you write a nonzero value to
171 the high part of IPSW. What will it take for HP to catch a
172 clue about building sensible interfaces? */
173 if (regno
== HPPA_IPSW_REGNUM
&& len
== 8)
177 regcache_raw_write_part (current_regcache
, regno
, 0,
178 sizeof (int), &temp
);
182 for (i
= 0; i
< len
; i
+= sizeof (int))
187 regcache_raw_read_part (current_regcache
, regno
, i
,
188 sizeof (int), &temp
);
189 call_ptrace (PT_WUREGS
, PIDGET (inferior_ptid
),
190 (PTRACE_ARG3_TYPE
) addr
+ i
,
194 /* Warning, not error, in case we are attached; sometimes
195 the kernel doesn't let us at the registers. */
196 char *err
= safe_strerror (errno
);
197 char *msg
= alloca (strlen (err
) + 128);
198 sprintf (msg
, "writing `%s' register: %s",
199 REGISTER_NAME (regno
), err
);
200 /* If we fail to write the PC, give a true error instead of
202 if (regno
== HPPA_PCOQ_HEAD_REGNUM
|| regno
== HPPA_PCOQ_TAIL_REGNUM
)
203 perror_with_name (msg
);
211 for (regno
= 0; regno
< NUM_REGS
; regno
++)
212 store_inferior_registers (regno
);
216 /* Fetch a register's value from the process's U area. */
218 fetch_register (int regno
)
220 char buf
[MAX_REGISTER_SIZE
];
221 unsigned int addr
, len
, offset
;
225 len
= register_size (current_gdbarch
, regno
);
227 /* Requests for register zero actually want the save_state's
228 ss_flags member. As RM says: "Oh, what a hack!" */
232 addr
= HPPAH_OFFSETOF (save_state_t
, ss_flags
);
233 len
= sizeof (ss
.ss_flags
);
235 /* Note that ss_flags is always an int, no matter what
236 register_size (0) says. Assuming all HP-UX PA machines are
237 big-endian, put it at the least significant end of the value,
238 and zap the rest of the buffer. */
239 offset
= register_size (current_gdbarch
, 0) - len
;
240 memset (buf
, 0, sizeof (buf
));
243 /* Floating-point registers come from the ss_fpblock area. */
244 else if (regno
>= HPPA_FP0_REGNUM
)
245 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_fpblock
)
246 + (DEPRECATED_REGISTER_BYTE (regno
) - DEPRECATED_REGISTER_BYTE (HPPA_FP0_REGNUM
)));
248 /* Wide registers come from the ss_wide area.
249 I think it's more PC to test (ss_flags & SS_WIDEREGS) to select
250 between ss_wide and ss_narrow than to use the raw register size.
251 But checking ss_flags would require an extra ptrace call for
252 every register reference. Bleah. */
254 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_wide
)
255 + DEPRECATED_REGISTER_BYTE (regno
));
257 /* Narrow registers come from the ss_narrow area. Note that
258 ss_narrow starts with gr1, not gr0. */
260 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_narrow
)
261 + (DEPRECATED_REGISTER_BYTE (regno
) - DEPRECATED_REGISTER_BYTE (1)));
264 internal_error (__FILE__
, __LINE__
,
265 "hppa-nat.c (fetch_register): unexpected register size");
267 for (i
= 0; i
< len
; i
+= sizeof (int))
270 /* Copy an int from the U area to buf. Fill the least
271 significant end if len != raw_size. */
272 * (int *) &buf
[offset
+ i
] =
273 call_ptrace (PT_RUREGS
, PIDGET (inferior_ptid
),
274 (PTRACE_ARG3_TYPE
) addr
+ i
, 0);
277 /* Warning, not error, in case we are attached; sometimes
278 the kernel doesn't let us at the registers. */
279 char *err
= safe_strerror (errno
);
280 char *msg
= alloca (strlen (err
) + 128);
281 sprintf (msg
, "reading `%s' register: %s",
282 REGISTER_NAME (regno
), err
);
288 /* If we're reading an address from the instruction address queue,
289 mask out the bottom two bits --- they contain the privilege
291 if (regno
== HPPA_PCOQ_HEAD_REGNUM
|| regno
== HPPA_PCOQ_TAIL_REGNUM
)
292 buf
[len
- 1] &= ~0x3;
294 regcache_raw_supply (current_regcache
, regno
, buf
);
298 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
299 to debugger memory starting at MYADDR. Copy to inferior if
302 Returns the length copied, which is either the LEN argument or
303 zero. This xfer function does not do partial moves, since
304 deprecated_child_ops doesn't allow memory operations to cross below
305 us in the target stack anyway. TARGET is ignored. */
308 child_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
309 struct mem_attrib
*mem
,
310 struct target_ops
*target
)
313 /* Round starting address down to longword boundary. */
314 CORE_ADDR addr
= memaddr
& - (CORE_ADDR
)(sizeof (int));
315 /* Round ending address up; get number of longwords that makes. */
317 = (((memaddr
+ len
) - addr
) + sizeof (int) - 1) / sizeof (int);
319 /* Allocate buffer of that many longwords.
320 Note -- do not use alloca to allocate this buffer since there is no
321 guarantee of when the buffer will actually be deallocated.
323 This routine can be called over and over with the same call chain;
324 this (in effect) would pile up all those alloca requests until a call
325 to alloca was made from a point higher than this routine in the
327 int *buffer
= (int *) xmalloc (count
* sizeof (int));
331 /* Fill start and end extra bytes of buffer with existing memory data. */
332 if (addr
!= memaddr
|| len
< (int) sizeof (int))
334 /* Need part of initial word -- fetch it. */
335 buffer
[0] = call_ptrace (addr
< text_end
? PT_RIUSER
: PT_RDUSER
,
336 PIDGET (inferior_ptid
),
337 (PTRACE_ARG3_TYPE
) addr
, 0);
340 if (count
> 1) /* FIXME, avoid if even boundary */
343 = call_ptrace (addr
< text_end
? PT_RIUSER
: PT_RDUSER
,
344 PIDGET (inferior_ptid
),
345 (PTRACE_ARG3_TYPE
) (addr
346 + (count
- 1) * sizeof (int)),
350 /* Copy data to be written over corresponding part of buffer */
351 memcpy ((char *) buffer
+ (memaddr
& (sizeof (int) - 1)), myaddr
, len
);
353 /* Write the entire buffer. */
354 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
358 /* The HP-UX kernel crashes if you use PT_WDUSER to write into the
359 text segment. FIXME -- does it work to write into the data
360 segment using WIUSER, or do these idiots really expect us to
361 figure out which segment the address is in, so we can use a
362 separate system call for it??! */
364 pt_request
= (addr
< text_end
) ? PT_WIUSER
: PT_WDUSER
;
365 pt_status
= call_ptrace (pt_request
,
366 PIDGET (inferior_ptid
),
367 (PTRACE_ARG3_TYPE
) addr
,
370 /* Did we fail? Might we've guessed wrong about which
371 segment this address resides in? Try the other request,
372 and see if that works... */
373 if ((pt_status
== -1) && errno
)
376 pt_request
= (pt_request
== PT_WIUSER
) ? PT_WDUSER
: PT_WIUSER
;
377 pt_status
= call_ptrace (pt_request
,
378 PIDGET (inferior_ptid
),
379 (PTRACE_ARG3_TYPE
) addr
,
382 /* No, we still fail. Okay, time to punt. */
383 if ((pt_status
== -1) && errno
)
393 /* Read all the longwords */
394 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
397 buffer
[i
] = call_ptrace (addr
< text_end
? PT_RIUSER
: PT_RDUSER
,
398 PIDGET (inferior_ptid
),
399 (PTRACE_ARG3_TYPE
) addr
, 0);
408 /* Copy appropriate bytes out of the buffer. */
409 memcpy (myaddr
, (char *) buffer
+ (memaddr
& (sizeof (int) - 1)), len
);
415 char *saved_child_execd_pathname
= NULL
;
423 } saved_vfork_state
= STATE_NONE
;
426 child_follow_fork (int follow_child
)
429 struct target_waitstatus last_status
;
431 int parent_pid
, child_pid
;
433 get_last_target_status (&last_ptid
, &last_status
);
434 has_vforked
= (last_status
.kind
== TARGET_WAITKIND_VFORKED
);
435 parent_pid
= ptid_get_pid (last_ptid
);
436 child_pid
= last_status
.value
.related_pid
;
438 /* At this point, if we are vforking, breakpoints were already
439 detached from the child in child_wait; and the child has already
440 called execve(). If we are forking, both the parent and child
441 have breakpoints inserted. */
447 detach_breakpoints (child_pid
);
448 #ifdef SOLIB_REMOVE_INFERIOR_HOOK
449 SOLIB_REMOVE_INFERIOR_HOOK (child_pid
);
453 /* Detach from the child. */
454 printf_unfiltered ("Detaching after fork from %s\n",
455 target_pid_to_str (pid_to_ptid (child_pid
)));
456 hppa_require_detach (child_pid
, 0);
458 /* The parent and child of a vfork share the same address space.
459 Also, on some targets the order in which vfork and exec events
460 are received for parent in child requires some delicate handling
463 For instance, on ptrace-based HPUX we receive the child's vfork
464 event first, at which time the parent has been suspended by the
465 OS and is essentially untouchable until the child's exit or second
466 exec event arrives. At that time, the parent's vfork event is
467 delivered to us, and that's when we see and decide how to follow
468 the vfork. But to get to that point, we must continue the child
469 until it execs or exits. To do that smoothly, all breakpoints
470 must be removed from the child, in case there are any set between
471 the vfork() and exec() calls. But removing them from the child
472 also removes them from the parent, due to the shared-address-space
473 nature of a vfork'd parent and child. On HPUX, therefore, we must
474 take care to restore the bp's to the parent before we continue it.
475 Else, it's likely that we may not stop in the expected place. (The
476 worst scenario is when the user tries to step over a vfork() call;
477 the step-resume bp must be restored for the step to properly stop
478 in the parent after the call completes!)
480 Sequence of events, as reported to gdb from HPUX:
482 Parent Child Action for gdb to take
483 -------------------------------------------------------
484 1 VFORK Continue child
489 Now that the child has safely exec'd or exited, we must restore
490 the parent's breakpoints before we continue it. Else, we may
491 cause it run past expected stopping points. */
494 reattach_breakpoints (parent_pid
);
498 /* Needed to keep the breakpoint lists in sync. */
500 detach_breakpoints (child_pid
);
502 /* Before detaching from the parent, remove all breakpoints from it. */
503 remove_breakpoints ();
505 /* Also reset the solib inferior hook from the parent. */
506 #ifdef SOLIB_REMOVE_INFERIOR_HOOK
507 SOLIB_REMOVE_INFERIOR_HOOK (PIDGET (inferior_ptid
));
510 /* Detach from the parent. */
511 target_detach (NULL
, 1);
513 /* Attach to the child. */
514 printf_unfiltered ("Attaching after fork to %s\n",
515 target_pid_to_str (pid_to_ptid (child_pid
)));
516 hppa_require_attach (child_pid
);
517 inferior_ptid
= pid_to_ptid (child_pid
);
519 /* If we vforked, then we've also execed by now. The exec will be
520 reported momentarily. follow_exec () will handle breakpoints, so
521 we don't have to.. */
523 follow_inferior_reset_breakpoints ();
528 /* If we followed the parent, don't try to follow the child's exec. */
529 if (saved_vfork_state
!= STATE_GOT_PARENT
530 && saved_vfork_state
!= STATE_FAKE_EXEC
)
531 fprintf_unfiltered (gdb_stdout
,
532 "hppa: post follow vfork: confused state\n");
534 if (! follow_child
|| saved_vfork_state
== STATE_GOT_PARENT
)
535 saved_vfork_state
= STATE_NONE
;
542 /* Format a process id, given PID. Be sure to terminate
543 this with a null--it's going to be printed via a "%s". */
545 child_pid_to_str (ptid_t ptid
)
547 /* Static because address returned */
549 pid_t pid
= PIDGET (ptid
);
551 /* Extra NUL for paranoia's sake */
552 sprintf (buf
, "process %d%c", pid
, '\0');
557 /* Format a thread id, given TID. Be sure to terminate
558 this with a null--it's going to be printed via a "%s".
560 Note: This is a core-gdb tid, not the actual system tid.
561 See infttrace.c for details. */
563 hppa_tid_to_str (ptid_t ptid
)
565 /* Static because address returned */
567 /* This seems strange, but when I did the ptid conversion, it looked
568 as though a pid was always being passed. - Kevin Buettner */
569 pid_t tid
= PIDGET (ptid
);
571 /* Extra NULLs for paranoia's sake */
572 sprintf (buf
, "system thread %d%c", tid
, '\0');
578 /* Enable HACK for ttrace work. In
579 * infttrace.c/require_notification_of_events,
580 * this is set to 0 so that the loop in child_wait
583 int not_same_real_pid
= 1;
586 /* Wait for child to do something. Return pid of child, or -1 in case
587 of error; store status through argument pointer OURSTATUS. */
590 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
594 char *execd_pathname
= NULL
;
598 enum target_waitkind kind
;
601 if (saved_vfork_state
== STATE_FAKE_EXEC
)
603 saved_vfork_state
= STATE_NONE
;
604 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
605 ourstatus
->value
.execd_pathname
= saved_child_execd_pathname
;
606 return inferior_ptid
;
611 set_sigint_trap (); /* Causes SIGINT to be passed on to the
615 pid
= ptrace_wait (inferior_ptid
, &status
);
621 clear_sigint_trap ();
625 if (save_errno
== EINTR
)
628 fprintf_unfiltered (gdb_stderr
, "Child process unexpectedly missing: %s.\n",
629 safe_strerror (save_errno
));
631 /* Claim it exited with unknown signal. */
632 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
633 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
634 return pid_to_ptid (-1);
639 if (target_has_exited (pid
, status
, &exit_status
))
641 /* ??rehrauer: For now, ignore this. */
645 if (!target_thread_alive (pid_to_ptid (pid
)))
647 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
648 return pid_to_ptid (pid
);
651 if (hpux_has_forked (pid
, &related_pid
))
653 /* Ignore the parent's fork event. */
654 if (pid
== PIDGET (inferior_ptid
))
656 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
657 return inferior_ptid
;
660 /* If this is the child's fork event, report that the
661 process has forked. */
662 if (related_pid
== PIDGET (inferior_ptid
))
664 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
665 ourstatus
->value
.related_pid
= pid
;
666 return inferior_ptid
;
670 if (hpux_has_vforked (pid
, &related_pid
))
672 if (pid
== PIDGET (inferior_ptid
))
674 if (saved_vfork_state
== STATE_GOT_CHILD
)
675 saved_vfork_state
= STATE_GOT_PARENT
;
676 else if (saved_vfork_state
== STATE_GOT_EXEC
)
677 saved_vfork_state
= STATE_FAKE_EXEC
;
679 fprintf_unfiltered (gdb_stdout
,
680 "hppah: parent vfork: confused\n");
682 else if (related_pid
== PIDGET (inferior_ptid
))
684 if (saved_vfork_state
== STATE_NONE
)
685 saved_vfork_state
= STATE_GOT_CHILD
;
687 fprintf_unfiltered (gdb_stdout
,
688 "hppah: child vfork: confused\n");
691 fprintf_unfiltered (gdb_stdout
,
692 "hppah: unknown vfork: confused\n");
694 if (saved_vfork_state
== STATE_GOT_CHILD
)
696 child_post_startup_inferior (pid_to_ptid (pid
));
697 detach_breakpoints (pid
);
698 #ifdef SOLIB_REMOVE_INFERIOR_HOOK
699 SOLIB_REMOVE_INFERIOR_HOOK (pid
);
701 child_resume (pid_to_ptid (pid
), 0, TARGET_SIGNAL_0
);
702 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
703 return pid_to_ptid (related_pid
);
705 else if (saved_vfork_state
== STATE_FAKE_EXEC
)
707 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
708 ourstatus
->value
.related_pid
= related_pid
;
709 return pid_to_ptid (pid
);
713 /* We saw the parent's vfork, but we haven't seen the exec yet.
714 Wait for it, for simplicity's sake. It should be pending. */
715 saved_vfork_pid
= related_pid
;
716 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
717 return pid_to_ptid (pid
);
721 if (hpux_has_execd (pid
, &execd_pathname
))
723 /* On HP-UX, events associated with a vforking inferior come in
724 threes: a vfork event for the child (always first), followed
725 a vfork event for the parent and an exec event for the child.
726 The latter two can come in either order. Make sure we get
728 if (saved_vfork_state
!= STATE_NONE
)
730 if (saved_vfork_state
== STATE_GOT_CHILD
)
732 saved_vfork_state
= STATE_GOT_EXEC
;
733 /* On HP/UX with ptrace, the child must be resumed before
734 the parent vfork event is delivered. A single-step
736 if (RESUME_EXECD_VFORKING_CHILD_TO_GET_PARENT_VFORK ())
737 target_resume (pid_to_ptid (pid
), 1, TARGET_SIGNAL_0
);
738 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
740 else if (saved_vfork_state
== STATE_GOT_PARENT
)
742 saved_vfork_state
= STATE_FAKE_EXEC
;
743 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
744 ourstatus
->value
.related_pid
= saved_vfork_pid
;
747 fprintf_unfiltered (gdb_stdout
,
748 "hppa: exec: unexpected state\n");
750 saved_child_execd_pathname
= execd_pathname
;
752 return inferior_ptid
;
755 /* Are we ignoring initial exec events? (This is likely because
756 we're in the process of starting up the inferior, and another
757 (older) mechanism handles those.) If so, we'll report this
758 as a regular stop, not an exec.
760 if (inferior_ignoring_startup_exec_events
)
762 inferior_ignoring_startup_exec_events
--;
766 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
767 ourstatus
->value
.execd_pathname
= execd_pathname
;
768 return pid_to_ptid (pid
);
772 /* All we must do with these is communicate their occurrence
773 to wait_for_inferior...
775 if (hpux_has_syscall_event (pid
, &kind
, &syscall_id
))
777 ourstatus
->kind
= kind
;
778 ourstatus
->value
.syscall_id
= syscall_id
;
779 return pid_to_ptid (pid
);
782 /*## } while (pid != PIDGET (inferior_ptid)); ## *//* Some other child died or stopped */
783 /* hack for thread testing */
785 while ((pid
!= PIDGET (inferior_ptid
)) && not_same_real_pid
);
788 store_waitstatus (ourstatus
, status
);
789 return pid_to_ptid (pid
);
792 #if !defined (GDB_NATIVE_HPUX_11)
794 /* The following code is a substitute for the infttrace.c versions used
795 with ttrace() in HPUX 11. */
797 /* This value is an arbitrary integer. */
798 #define PT_VERSION 123456
800 /* This semaphore is used to coordinate the child and parent processes
801 after a fork(), and before an exec() by the child. See
802 parent_attach_all for details. */
806 int parent_channel
[2]; /* Parent "talks" to [1], child "listens" to [0] */
807 int child_channel
[2]; /* Child "talks" to [1], parent "listens" to [0] */
812 #define SEM_LISTEN (0)
814 static startup_semaphore_t startup_semaphore
;
817 /* This function causes the caller's process to be traced by its
818 parent. This is intended to be called after GDB forks itself,
819 and before the child execs the target.
821 Note that HP-UX ptrace is rather funky in how this is done.
822 If the parent wants to get the initial exec event of a child,
823 it must set the ptrace event mask of the child to include execs.
824 (The child cannot do this itself.) This must be done after the
825 child is forked, but before it execs.
827 To coordinate the parent and child, we implement a semaphore using
828 pipes. After SETTRC'ing itself, the child tells the parent that
829 it is now traceable by the parent, and waits for the parent's
830 acknowledgement. The parent can then set the child's event mask,
831 and notify the child that it can now exec.
833 (The acknowledgement by parent happens as a result of a call to
834 child_acknowledge_created_inferior.) */
837 parent_attach_all (int pid
, PTRACE_ARG3_TYPE addr
, int data
)
841 /* We need a memory home for a constant. */
842 int tc_magic_child
= PT_VERSION
;
843 int tc_magic_parent
= 0;
845 /* The remainder of this function is only useful for HPUX 10.0 and
846 later, as it depends upon the ability to request notification
847 of specific kinds of events by the kernel. */
848 #if defined(PT_SET_EVENT_MASK)
850 /* Notify the parent that we're potentially ready to exec(). */
851 write (startup_semaphore
.child_channel
[SEM_TALK
],
853 sizeof (tc_magic_child
));
855 /* Wait for acknowledgement from the parent. */
856 read (startup_semaphore
.parent_channel
[SEM_LISTEN
],
858 sizeof (tc_magic_parent
));
859 if (tc_magic_child
!= tc_magic_parent
)
860 warning ("mismatched semaphore magic");
862 /* Discard our copy of the semaphore. */
863 (void) close (startup_semaphore
.parent_channel
[SEM_LISTEN
]);
864 (void) close (startup_semaphore
.parent_channel
[SEM_TALK
]);
865 (void) close (startup_semaphore
.child_channel
[SEM_LISTEN
]);
866 (void) close (startup_semaphore
.child_channel
[SEM_TALK
]);
874 hppa_require_attach (int pid
)
879 unsigned int regs_offset
;
881 /* Are we already attached? There appears to be no explicit way to
882 answer this via ptrace, so we try something which should be
883 innocuous if we are attached. If that fails, then we assume
884 we're not attached, and so attempt to make it so. */
887 regs_offset
= U_REGS_OFFSET
;
888 pc_addr
= register_addr (PC_REGNUM
, regs_offset
);
889 pc
= call_ptrace (PT_READ_U
, pid
, (PTRACE_ARG3_TYPE
) pc_addr
, 0);
894 pt_status
= call_ptrace (PT_ATTACH
, pid
, (PTRACE_ARG3_TYPE
) 0, 0);
899 /* Now we really are attached. */
907 hppa_require_detach (int pid
, int signal
)
910 call_ptrace (PT_DETACH
, pid
, (PTRACE_ARG3_TYPE
) 1, signal
);
911 errno
= 0; /* Ignore any errors. */
915 /* Since ptrace doesn't support memory page-protection events, which
916 are used to implement "hardware" watchpoints on HP-UX, these are
917 dummy versions, which perform no useful work. */
920 hppa_enable_page_protection_events (int pid
)
925 hppa_disable_page_protection_events (int pid
)
930 hppa_insert_hw_watchpoint (int pid
, CORE_ADDR start
, LONGEST len
, int type
)
932 error ("Hardware watchpoints not implemented on this platform.");
936 hppa_remove_hw_watchpoint (int pid
, CORE_ADDR start
, LONGEST len
, int type
)
938 error ("Hardware watchpoints not implemented on this platform.");
942 hppa_can_use_hw_watchpoint (int type
, int cnt
, int ot
)
948 hppa_range_profitable_for_hw_watchpoint (int pid
, CORE_ADDR start
, LONGEST len
)
950 error ("Hardware watchpoints not implemented on this platform.");
954 hppa_pid_or_tid_to_str (ptid_t id
)
956 /* In the ptrace world, there are only processes. */
957 return child_pid_to_str (id
);
961 hppa_ensure_vforking_parent_remains_stopped (int pid
)
963 /* This assumes that the vforked parent is presently stopped, and
964 that the vforked child has just delivered its first exec event.
965 Calling kill() this way will cause the SIGTRAP to be delivered as
966 soon as the parent is resumed, which happens as soon as the
967 vforked child is resumed. See wait_for_inferior for the use of
973 hppa_resume_execd_vforking_child_to_get_parent_vfork (void)
975 return 1; /* Yes, the child must be resumed. */
979 require_notification_of_events (int pid
)
981 #if defined(PT_SET_EVENT_MASK)
983 ptrace_event_t ptrace_events
;
987 /* Instruct the kernel as to the set of events we wish to be
988 informed of. (This support does not exist before HPUX 10.0.
989 We'll assume if PT_SET_EVENT_MASK has not been defined by
990 <sys/ptrace.h>, then we're being built on pre-10.0.) */
991 memset (&ptrace_events
, 0, sizeof (ptrace_events
));
993 /* Note: By default, all signals are visible to us. If we wish
994 the kernel to keep certain signals hidden from us, we do it
995 by calling sigdelset (ptrace_events.pe_signals, signal) for
996 each such signal here, before doing PT_SET_EVENT_MASK. */
997 /* RM: The above comment is no longer true. We start with ignoring
998 all signals, and then add the ones we are interested in. We could
999 do it the other way: start by looking at all signals and then
1000 deleting the ones that we aren't interested in, except that
1001 multiple gdb signals may be mapped to the same host signal
1002 (eg. TARGET_SIGNAL_IO and TARGET_SIGNAL_POLL both get mapped to
1003 signal 22 on HPUX 10.20) We want to be notified if we are
1004 interested in either signal. */
1005 sigfillset (&ptrace_events
.pe_signals
);
1007 /* RM: Let's not bother with signals we don't care about */
1008 nsigs
= (int) TARGET_SIGNAL_LAST
;
1009 for (signum
= nsigs
; signum
> 0; signum
--)
1011 if ((signal_stop_state (signum
)) ||
1012 (signal_print_state (signum
)) ||
1013 (!signal_pass_state (signum
)))
1015 if (target_signal_to_host_p (signum
))
1016 sigdelset (&ptrace_events
.pe_signals
,
1017 target_signal_to_host (signum
));
1021 ptrace_events
.pe_set_event
= 0;
1023 ptrace_events
.pe_set_event
|= PTRACE_SIGNAL
;
1024 ptrace_events
.pe_set_event
|= PTRACE_EXEC
;
1025 ptrace_events
.pe_set_event
|= PTRACE_FORK
;
1026 ptrace_events
.pe_set_event
|= PTRACE_VFORK
;
1027 /* ??rehrauer: Add this one when we're prepared to catch it...
1028 ptrace_events.pe_set_event |= PTRACE_EXIT;
1032 pt_status
= call_ptrace (PT_SET_EVENT_MASK
,
1034 (PTRACE_ARG3_TYPE
) & ptrace_events
,
1035 sizeof (ptrace_events
));
1037 perror_with_name ("ptrace");
1044 require_notification_of_exec_events (int pid
)
1046 #if defined(PT_SET_EVENT_MASK)
1048 ptrace_event_t ptrace_events
;
1050 /* Instruct the kernel as to the set of events we wish to be
1051 informed of. (This support does not exist before HPUX 10.0.
1052 We'll assume if PT_SET_EVENT_MASK has not been defined by
1053 <sys/ptrace.h>, then we're being built on pre-10.0.) */
1054 memset (&ptrace_events
, 0, sizeof (ptrace_events
));
1056 /* Note: By default, all signals are visible to us. If we wish
1057 the kernel to keep certain signals hidden from us, we do it
1058 by calling sigdelset (ptrace_events.pe_signals, signal) for
1059 each such signal here, before doing PT_SET_EVENT_MASK. */
1060 sigemptyset (&ptrace_events
.pe_signals
);
1062 ptrace_events
.pe_set_event
= 0;
1064 ptrace_events
.pe_set_event
|= PTRACE_EXEC
;
1065 /* ??rehrauer: Add this one when we're prepared to catch it...
1066 ptrace_events.pe_set_event |= PTRACE_EXIT;
1070 pt_status
= call_ptrace (PT_SET_EVENT_MASK
,
1072 (PTRACE_ARG3_TYPE
) & ptrace_events
,
1073 sizeof (ptrace_events
));
1075 perror_with_name ("ptrace");
1081 /* This function is called by the parent process, with pid being the
1082 ID of the child process, after the debugger has forked. */
1085 child_acknowledge_created_inferior (int pid
)
1087 /* We need a memory home for a constant. */
1088 int tc_magic_parent
= PT_VERSION
;
1089 int tc_magic_child
= 0;
1091 /* The remainder of this function is only useful for HPUX 10.0 and
1092 later, as it depends upon the ability to request notification
1093 of specific kinds of events by the kernel. */
1094 #if defined(PT_SET_EVENT_MASK)
1095 /* Wait for the child to tell us that it has forked. */
1096 read (startup_semaphore
.child_channel
[SEM_LISTEN
],
1098 sizeof (tc_magic_child
));
1100 /* Notify the child that it can exec.
1102 In the infttrace.c variant of this function, we set the child's
1103 event mask after the fork but before the exec. In the ptrace
1104 world, it seems we can't set the event mask until after the exec. */
1105 write (startup_semaphore
.parent_channel
[SEM_TALK
],
1107 sizeof (tc_magic_parent
));
1109 /* We'd better pause a bit before trying to set the event mask,
1110 though, to ensure that the exec has happened. We don't want to
1111 wait() on the child, because that'll screw up the upper layers
1112 of gdb's execution control that expect to see the exec event.
1114 After an exec, the child is no longer executing gdb code. Hence,
1115 we can't have yet another synchronization via the pipes. We'll
1116 just sleep for a second, and hope that's enough delay... */
1119 /* Instruct the kernel as to the set of events we wish to be
1121 require_notification_of_exec_events (pid
);
1123 /* Discard our copy of the semaphore. */
1124 (void) close (startup_semaphore
.parent_channel
[SEM_LISTEN
]);
1125 (void) close (startup_semaphore
.parent_channel
[SEM_TALK
]);
1126 (void) close (startup_semaphore
.child_channel
[SEM_LISTEN
]);
1127 (void) close (startup_semaphore
.child_channel
[SEM_TALK
]);
1132 child_post_startup_inferior (ptid_t ptid
)
1134 require_notification_of_events (PIDGET (ptid
));
1138 child_post_attach (int pid
)
1140 require_notification_of_events (pid
);
1144 child_insert_fork_catchpoint (int pid
)
1146 /* This request is only available on HPUX 10.0 and later. */
1147 #if !defined(PT_SET_EVENT_MASK)
1148 error ("Unable to catch forks prior to HPUX 10.0");
1150 /* Enable reporting of fork events from the kernel. */
1151 /* ??rehrauer: For the moment, we're always enabling these events,
1152 and just ignoring them if there's no catchpoint to catch them. */
1158 child_remove_fork_catchpoint (int pid
)
1160 /* This request is only available on HPUX 10.0 and later. */
1161 #if !defined(PT_SET_EVENT_MASK)
1162 error ("Unable to catch forks prior to HPUX 10.0");
1164 /* Disable reporting of fork events from the kernel. */
1165 /* ??rehrauer: For the moment, we're always enabling these events,
1166 and just ignoring them if there's no catchpoint to catch them. */
1172 child_insert_vfork_catchpoint (int pid
)
1174 /* This request is only available on HPUX 10.0 and later. */
1175 #if !defined(PT_SET_EVENT_MASK)
1176 error ("Unable to catch vforks prior to HPUX 10.0");
1178 /* Enable reporting of vfork events from the kernel. */
1179 /* ??rehrauer: For the moment, we're always enabling these events,
1180 and just ignoring them if there's no catchpoint to catch them. */
1186 child_remove_vfork_catchpoint (int pid
)
1188 /* This request is only available on HPUX 10.0 and later. */
1189 #if !defined(PT_SET_EVENT_MASK)
1190 error ("Unable to catch vforks prior to HPUX 10.0");
1192 /* Disable reporting of vfork events from the kernel. */
1193 /* ??rehrauer: For the moment, we're always enabling these events,
1194 and just ignoring them if there's no catchpoint to catch them. */
1200 hpux_has_forked (int pid
, int *childpid
)
1202 /* This request is only available on HPUX 10.0 and later. */
1203 #if !defined(PT_GET_PROCESS_STATE)
1208 ptrace_state_t ptrace_state
;
1211 pt_status
= call_ptrace (PT_GET_PROCESS_STATE
,
1213 (PTRACE_ARG3_TYPE
) & ptrace_state
,
1214 sizeof (ptrace_state
));
1216 perror_with_name ("ptrace");
1220 if (ptrace_state
.pe_report_event
& PTRACE_FORK
)
1222 *childpid
= ptrace_state
.pe_other_pid
;
1231 hpux_has_vforked (int pid
, int *childpid
)
1233 /* This request is only available on HPUX 10.0 and later. */
1234 #if !defined(PT_GET_PROCESS_STATE)
1240 ptrace_state_t ptrace_state
;
1243 pt_status
= call_ptrace (PT_GET_PROCESS_STATE
,
1245 (PTRACE_ARG3_TYPE
) & ptrace_state
,
1246 sizeof (ptrace_state
));
1248 perror_with_name ("ptrace");
1252 if (ptrace_state
.pe_report_event
& PTRACE_VFORK
)
1254 *childpid
= ptrace_state
.pe_other_pid
;
1263 child_insert_exec_catchpoint (int pid
)
1265 /* This request is only available on HPUX 10.0 and later. */
1266 #if !defined(PT_SET_EVENT_MASK)
1267 error ("Unable to catch execs prior to HPUX 10.0");
1270 /* Enable reporting of exec events from the kernel. */
1271 /* ??rehrauer: For the moment, we're always enabling these events,
1272 and just ignoring them if there's no catchpoint to catch them. */
1278 child_remove_exec_catchpoint (int pid
)
1280 /* This request is only available on HPUX 10.0 and later. */
1281 #if !defined(PT_SET_EVENT_MASK)
1282 error ("Unable to catch execs prior to HPUX 10.0");
1285 /* Disable reporting of exec events from the kernel. */
1286 /* ??rehrauer: For the moment, we're always enabling these events,
1287 and just ignoring them if there's no catchpoint to catch them. */
1293 hpux_has_execd (int pid
, char **execd_pathname
)
1295 /* This request is only available on HPUX 10.0 and later. */
1296 #if !defined(PT_GET_PROCESS_STATE)
1297 *execd_pathname
= NULL
;
1302 ptrace_state_t ptrace_state
;
1305 pt_status
= call_ptrace (PT_GET_PROCESS_STATE
,
1307 (PTRACE_ARG3_TYPE
) & ptrace_state
,
1308 sizeof (ptrace_state
));
1310 perror_with_name ("ptrace");
1314 if (ptrace_state
.pe_report_event
& PTRACE_EXEC
)
1316 char *exec_file
= target_pid_to_exec_file (pid
);
1317 *execd_pathname
= savestring (exec_file
, strlen (exec_file
));
1326 child_reported_exec_events_per_exec_call (void)
1328 return 2; /* ptrace reports the event twice per call. */
1332 hpux_has_syscall_event (int pid
, enum target_waitkind
*kind
, int *syscall_id
)
1334 /* This request is only available on HPUX 10.30 and later, via
1335 the ttrace interface. */
1337 *kind
= TARGET_WAITKIND_SPURIOUS
;
1343 child_pid_to_exec_file (int pid
)
1345 static char exec_file_buffer
[1024];
1347 CORE_ADDR top_of_stack
;
1351 ptid_t saved_inferior_ptid
;
1354 #ifdef PT_GET_PROCESS_PATHNAME
1355 /* As of 10.x HP-UX, there's an explicit request to get the pathname. */
1356 pt_status
= call_ptrace (PT_GET_PROCESS_PATHNAME
,
1358 (PTRACE_ARG3_TYPE
) exec_file_buffer
,
1359 sizeof (exec_file_buffer
) - 1);
1361 return exec_file_buffer
;
1364 /* It appears that this request is broken prior to 10.30.
1365 If it fails, try a really, truly amazingly gross hack
1366 that DDE uses, of pawing through the process' data
1367 segment to find the pathname. */
1369 top_of_stack
= 0x7b03a000;
1373 /* On the chance that pid != inferior_ptid, set inferior_ptid
1374 to pid, so that (grrrr!) implicit uses of inferior_ptid get
1377 saved_inferior_ptid
= inferior_ptid
;
1378 inferior_ptid
= pid_to_ptid (pid
);
1380 /* Try to grab a null-terminated string. */
1383 if (target_read_memory (top_of_stack
, four_chars
, 4) != 0)
1385 inferior_ptid
= saved_inferior_ptid
;
1388 for (i
= 0; i
< 4; i
++)
1390 exec_file_buffer
[name_index
++] = four_chars
[i
];
1391 done
= (four_chars
[i
] == '\0');
1398 if (exec_file_buffer
[0] == '\0')
1400 inferior_ptid
= saved_inferior_ptid
;
1404 inferior_ptid
= saved_inferior_ptid
;
1405 return exec_file_buffer
;
1409 pre_fork_inferior (void)
1413 status
= pipe (startup_semaphore
.parent_channel
);
1416 warning ("error getting parent pipe for startup semaphore");
1420 status
= pipe (startup_semaphore
.child_channel
);
1423 warning ("error getting child pipe for startup semaphore");
1429 /* Check to see if the given thread is alive.
1431 This is a no-op, as ptrace doesn't support threads, so we just
1435 child_thread_alive (ptid_t ptid
)
1440 #endif /* ! GDB_NATIVE_HPUX_11 */