1 /* Native support code for HPUX PA-RISC.
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 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>
36 extern CORE_ADDR text_end
;
38 static void fetch_register (int);
41 fetch_inferior_registers (int regno
)
44 for (regno
= 0; regno
< NUM_REGS
; regno
++)
45 fetch_register (regno
);
47 fetch_register (regno
);
50 /* Our own version of the offsetof macro, since we can't assume ANSI C. */
51 #define HPPAH_OFFSETOF(type, member) ((int) (&((type *) 0)->member))
53 /* Store our register values back into the inferior.
54 If REGNO is -1, do this for all registers.
55 Otherwise, REGNO specifies which register (so we can save time). */
58 store_inferior_registers (int regno
)
60 register unsigned int regaddr
;
63 unsigned int offset
= U_REGS_OFFSET
;
68 unsigned int addr
, len
, offset
;
70 if (CANNOT_STORE_REGISTER (regno
))
74 len
= REGISTER_RAW_SIZE (regno
);
76 /* Requests for register zero actually want the save_state's
77 ss_flags member. As RM says: "Oh, what a hack!" */
81 addr
= HPPAH_OFFSETOF (save_state_t
, ss_flags
);
82 len
= sizeof (ss
.ss_flags
);
84 /* Note that ss_flags is always an int, no matter what
85 REGISTER_RAW_SIZE(0) says. Assuming all HP-UX PA machines
86 are big-endian, put it at the least significant end of the
87 value, and zap the rest of the buffer. */
88 offset
= REGISTER_RAW_SIZE (0) - len
;
91 /* Floating-point registers come from the ss_fpblock area. */
92 else if (regno
>= FP0_REGNUM
)
93 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_fpblock
)
94 + (REGISTER_BYTE (regno
) - REGISTER_BYTE (FP0_REGNUM
)));
96 /* Wide registers come from the ss_wide area.
97 I think it's more PC to test (ss_flags & SS_WIDEREGS) to select
98 between ss_wide and ss_narrow than to use the raw register size.
99 But checking ss_flags would require an extra ptrace call for
100 every register reference. Bleah. */
102 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_wide
)
103 + REGISTER_BYTE (regno
));
105 /* Narrow registers come from the ss_narrow area. Note that
106 ss_narrow starts with gr1, not gr0. */
108 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_narrow
)
109 + (REGISTER_BYTE (regno
) - REGISTER_BYTE (1)));
111 internal_error (__FILE__
, __LINE__
,
112 "hppah-nat.c (write_register): unexpected register size");
114 #ifdef GDB_TARGET_IS_HPPA_20W
115 /* Unbelieveable. The PC head and tail must be written in 64bit hunks
116 or we will get an error. Worse yet, the oddball ptrace/ttrace
117 layering will not allow us to perform a 64bit register store.
120 if (regno
== PCOQ_HEAD_REGNUM
|| regno
== PCOQ_TAIL_REGNUM
&& len
== 8)
124 temp
= *(CORE_ADDR
*)®isters
[REGISTER_BYTE (regno
)];
126 /* Set the priv level (stored in the low two bits of the PC. */
129 ttrace_write_reg_64 (inferior_pid
, (CORE_ADDR
)addr
, (CORE_ADDR
)&temp
);
131 /* If we fail to write the PC, give a true error instead of
135 char *err
= safe_strerror (errno
);
136 char *msg
= alloca (strlen (err
) + 128);
137 sprintf (msg
, "writing `%s' register: %s",
138 REGISTER_NAME (regno
), err
);
139 perror_with_name (msg
);
144 /* Another crock. HPUX complains if you write a nonzero value to
145 the high part of IPSW. What will it take for HP to catch a
146 clue about building sensible interfaces? */
147 if (regno
== IPSW_REGNUM
&& len
== 8)
148 *(int *)®isters
[REGISTER_BYTE (regno
)] = 0;
151 for (i
= 0; i
< len
; i
+= sizeof (int))
154 call_ptrace (PT_WUREGS
, inferior_pid
, (PTRACE_ARG3_TYPE
) addr
+ i
,
155 *(int *) ®isters
[REGISTER_BYTE (regno
) + i
]);
158 /* Warning, not error, in case we are attached; sometimes
159 the kernel doesn't let us at the registers. */
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 /* If we fail to write the PC, give a true error instead of
166 if (regno
== PCOQ_HEAD_REGNUM
|| regno
== PCOQ_TAIL_REGNUM
)
167 perror_with_name (msg
);
175 for (regno
= 0; regno
< NUM_REGS
; regno
++)
176 store_inferior_registers (regno
);
180 /* Fetch a register's value from the process's U area. */
182 fetch_register (int regno
)
184 char buf
[MAX_REGISTER_RAW_SIZE
];
185 unsigned int addr
, len
, offset
;
189 len
= REGISTER_RAW_SIZE (regno
);
191 /* Requests for register zero actually want the save_state's
192 ss_flags member. As RM says: "Oh, what a hack!" */
196 addr
= HPPAH_OFFSETOF (save_state_t
, ss_flags
);
197 len
= sizeof (ss
.ss_flags
);
199 /* Note that ss_flags is always an int, no matter what
200 REGISTER_RAW_SIZE(0) says. Assuming all HP-UX PA machines
201 are big-endian, put it at the least significant end of the
202 value, and zap the rest of the buffer. */
203 offset
= REGISTER_RAW_SIZE (0) - len
;
204 memset (buf
, 0, sizeof (buf
));
207 /* Floating-point registers come from the ss_fpblock area. */
208 else if (regno
>= FP0_REGNUM
)
209 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_fpblock
)
210 + (REGISTER_BYTE (regno
) - REGISTER_BYTE (FP0_REGNUM
)));
212 /* Wide registers come from the ss_wide area.
213 I think it's more PC to test (ss_flags & SS_WIDEREGS) to select
214 between ss_wide and ss_narrow than to use the raw register size.
215 But checking ss_flags would require an extra ptrace call for
216 every register reference. Bleah. */
218 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_wide
)
219 + REGISTER_BYTE (regno
));
221 /* Narrow registers come from the ss_narrow area. Note that
222 ss_narrow starts with gr1, not gr0. */
224 addr
= (HPPAH_OFFSETOF (save_state_t
, ss_narrow
)
225 + (REGISTER_BYTE (regno
) - REGISTER_BYTE (1)));
228 internal_error (__FILE__
, __LINE__
,
229 "hppa-nat.c (fetch_register): unexpected register size");
231 for (i
= 0; i
< len
; i
+= sizeof (int))
234 /* Copy an int from the U area to buf. Fill the least
235 significant end if len != raw_size. */
236 * (int *) &buf
[offset
+ i
] =
237 call_ptrace (PT_RUREGS
, inferior_pid
,
238 (PTRACE_ARG3_TYPE
) addr
+ i
, 0);
241 /* Warning, not error, in case we are attached; sometimes
242 the kernel doesn't let us at the registers. */
243 char *err
= safe_strerror (errno
);
244 char *msg
= alloca (strlen (err
) + 128);
245 sprintf (msg
, "reading `%s' register: %s",
246 REGISTER_NAME (regno
), err
);
252 /* If we're reading an address from the instruction address queue,
253 mask out the bottom two bits --- they contain the privilege
255 if (regno
== PCOQ_HEAD_REGNUM
|| regno
== PCOQ_TAIL_REGNUM
)
256 buf
[len
- 1] &= ~0x3;
258 supply_register (regno
, buf
);
262 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
263 to debugger memory starting at MYADDR. Copy to inferior if
266 Returns the length copied, which is either the LEN argument or zero.
267 This xfer function does not do partial moves, since child_ops
268 doesn't allow memory operations to cross below us in the target stack
269 anyway. TARGET is ignored. */
272 child_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
273 struct mem_attrib
*mem
,
274 struct target_ops
*target
)
277 /* Round starting address down to longword boundary. */
278 register CORE_ADDR addr
= memaddr
& - (CORE_ADDR
)(sizeof (int));
279 /* Round ending address up; get number of longwords that makes. */
281 = (((memaddr
+ len
) - addr
) + sizeof (int) - 1) / sizeof (int);
283 /* Allocate buffer of that many longwords.
284 Note -- do not use alloca to allocate this buffer since there is no
285 guarantee of when the buffer will actually be deallocated.
287 This routine can be called over and over with the same call chain;
288 this (in effect) would pile up all those alloca requests until a call
289 to alloca was made from a point higher than this routine in the
291 register int *buffer
= (int *) xmalloc (count
* sizeof (int));
295 /* Fill start and end extra bytes of buffer with existing memory data. */
296 if (addr
!= memaddr
|| len
< (int) sizeof (int))
298 /* Need part of initial word -- fetch it. */
299 buffer
[0] = call_ptrace (addr
< text_end
? PT_RIUSER
: PT_RDUSER
,
300 inferior_pid
, (PTRACE_ARG3_TYPE
) addr
, 0);
303 if (count
> 1) /* FIXME, avoid if even boundary */
306 = call_ptrace (addr
< text_end
? PT_RIUSER
: PT_RDUSER
,
308 (PTRACE_ARG3_TYPE
) (addr
309 + (count
- 1) * sizeof (int)),
313 /* Copy data to be written over corresponding part of buffer */
314 memcpy ((char *) buffer
+ (memaddr
& (sizeof (int) - 1)), myaddr
, len
);
316 /* Write the entire buffer. */
317 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
321 /* The HP-UX kernel crashes if you use PT_WDUSER to write into the
322 text segment. FIXME -- does it work to write into the data
323 segment using WIUSER, or do these idiots really expect us to
324 figure out which segment the address is in, so we can use a
325 separate system call for it??! */
327 pt_request
= (addr
< text_end
) ? PT_WIUSER
: PT_WDUSER
;
328 pt_status
= call_ptrace (pt_request
,
330 (PTRACE_ARG3_TYPE
) addr
,
333 /* Did we fail? Might we've guessed wrong about which
334 segment this address resides in? Try the other request,
335 and see if that works... */
336 if ((pt_status
== -1) && errno
)
339 pt_request
= (pt_request
== PT_WIUSER
) ? PT_WDUSER
: PT_WIUSER
;
340 pt_status
= call_ptrace (pt_request
,
342 (PTRACE_ARG3_TYPE
) addr
,
345 /* No, we still fail. Okay, time to punt. */
346 if ((pt_status
== -1) && errno
)
356 /* Read all the longwords */
357 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
360 buffer
[i
] = call_ptrace (addr
< text_end
? PT_RIUSER
: PT_RDUSER
,
361 inferior_pid
, (PTRACE_ARG3_TYPE
) addr
, 0);
370 /* Copy appropriate bytes out of the buffer. */
371 memcpy (myaddr
, (char *) buffer
+ (memaddr
& (sizeof (int) - 1)), len
);
379 child_post_follow_inferior_by_clone (void)
383 /* This function is used when following both the parent and child
384 of a fork. In this case, the debugger clones itself. The original
385 debugger follows the parent, the clone follows the child. The
386 original detaches from the child, delivering a SIGSTOP to it to
387 keep it from running away until the clone can attach itself.
389 At this point, the clone has attached to the child. Because of
390 the SIGSTOP, we must now deliver a SIGCONT to the child, or it
391 won't behave properly. */
392 status
= kill (inferior_pid
, SIGCONT
);
397 child_post_follow_vfork (int parent_pid
, int followed_parent
, int child_pid
,
400 /* Are we a debugger that followed the parent of a vfork? If so,
401 then recall that the child's vfork event was delivered to us
402 first. And, that the parent was suspended by the OS until the
403 child's exec or exit events were received.
405 Upon receiving that child vfork, then, we were forced to remove
406 all breakpoints in the child and continue it so that it could
407 reach the exec or exit point.
409 But also recall that the parent and child of a vfork share the
410 same address space. Thus, removing bp's in the child also
411 removed them from the parent.
413 Now that the child has safely exec'd or exited, we must restore
414 the parent's breakpoints before we continue it. Else, we may
415 cause it run past expected stopping points. */
418 reattach_breakpoints (parent_pid
);
421 /* Are we a debugger that followed the child of a vfork? If so,
422 then recall that we don't actually acquire control of the child
423 until after it has exec'd or exited. */
426 /* If the child has exited, then there's nothing for us to do.
427 In the case of an exec event, we'll let that be handled by
428 the normal mechanism that notices and handles exec events, in
433 /* Format a process id, given PID. Be sure to terminate
434 this with a null--it's going to be printed via a "%s". */
436 child_pid_to_str (pid_t pid
)
438 /* Static because address returned */
441 /* Extra NULLs for paranoia's sake */
442 sprintf (buf
, "process %d\0\0\0\0", pid
);
447 /* Format a thread id, given TID. Be sure to terminate
448 this with a null--it's going to be printed via a "%s".
450 Note: This is a core-gdb tid, not the actual system tid.
451 See infttrace.c for details. */
453 hppa_tid_to_str (pid_t tid
)
455 /* Static because address returned */
458 /* Extra NULLs for paranoia's sake */
459 sprintf (buf
, "system thread %d\0\0\0\0", tid
);
464 #if !defined (GDB_NATIVE_HPUX_11)
466 /* The following code is a substitute for the infttrace.c versions used
467 with ttrace() in HPUX 11. */
469 /* This value is an arbitrary integer. */
470 #define PT_VERSION 123456
472 /* This semaphore is used to coordinate the child and parent processes
473 after a fork(), and before an exec() by the child. See
474 parent_attach_all for details. */
478 int parent_channel
[2]; /* Parent "talks" to [1], child "listens" to [0] */
479 int child_channel
[2]; /* Child "talks" to [1], parent "listens" to [0] */
484 #define SEM_LISTEN (0)
486 static startup_semaphore_t startup_semaphore
;
488 extern int parent_attach_all (int, PTRACE_ARG3_TYPE
, int);
491 /* This function causes the caller's process to be traced by its
492 parent. This is intended to be called after GDB forks itself,
493 and before the child execs the target.
495 Note that HP-UX ptrace is rather funky in how this is done.
496 If the parent wants to get the initial exec event of a child,
497 it must set the ptrace event mask of the child to include execs.
498 (The child cannot do this itself.) This must be done after the
499 child is forked, but before it execs.
501 To coordinate the parent and child, we implement a semaphore using
502 pipes. After SETTRC'ing itself, the child tells the parent that
503 it is now traceable by the parent, and waits for the parent's
504 acknowledgement. The parent can then set the child's event mask,
505 and notify the child that it can now exec.
507 (The acknowledgement by parent happens as a result of a call to
508 child_acknowledge_created_inferior.) */
511 parent_attach_all (int pid
, PTRACE_ARG3_TYPE addr
, int data
)
515 /* We need a memory home for a constant. */
516 int tc_magic_child
= PT_VERSION
;
517 int tc_magic_parent
= 0;
519 /* The remainder of this function is only useful for HPUX 10.0 and
520 later, as it depends upon the ability to request notification
521 of specific kinds of events by the kernel. */
522 #if defined(PT_SET_EVENT_MASK)
524 /* Notify the parent that we're potentially ready to exec(). */
525 write (startup_semaphore
.child_channel
[SEM_TALK
],
527 sizeof (tc_magic_child
));
529 /* Wait for acknowledgement from the parent. */
530 read (startup_semaphore
.parent_channel
[SEM_LISTEN
],
532 sizeof (tc_magic_parent
));
533 if (tc_magic_child
!= tc_magic_parent
)
534 warning ("mismatched semaphore magic");
536 /* Discard our copy of the semaphore. */
537 (void) close (startup_semaphore
.parent_channel
[SEM_LISTEN
]);
538 (void) close (startup_semaphore
.parent_channel
[SEM_TALK
]);
539 (void) close (startup_semaphore
.child_channel
[SEM_LISTEN
]);
540 (void) close (startup_semaphore
.child_channel
[SEM_TALK
]);
548 hppa_require_attach (int pid
)
553 unsigned int regs_offset
;
555 /* Are we already attached? There appears to be no explicit way to
556 answer this via ptrace, so we try something which should be
557 innocuous if we are attached. If that fails, then we assume
558 we're not attached, and so attempt to make it so. */
561 regs_offset
= U_REGS_OFFSET
;
562 pc_addr
= register_addr (PC_REGNUM
, regs_offset
);
563 pc
= call_ptrace (PT_READ_U
, pid
, (PTRACE_ARG3_TYPE
) pc_addr
, 0);
568 pt_status
= call_ptrace (PT_ATTACH
, pid
, (PTRACE_ARG3_TYPE
) 0, 0);
573 /* Now we really are attached. */
581 hppa_require_detach (int pid
, int signal
)
584 call_ptrace (PT_DETACH
, pid
, (PTRACE_ARG3_TYPE
) 1, signal
);
585 errno
= 0; /* Ignore any errors. */
589 /* Since ptrace doesn't support memory page-protection events, which
590 are used to implement "hardware" watchpoints on HP-UX, these are
591 dummy versions, which perform no useful work. */
594 hppa_enable_page_protection_events (int pid
)
599 hppa_disable_page_protection_events (int pid
)
604 hppa_insert_hw_watchpoint (int pid
, CORE_ADDR start
, LONGEST len
, int type
)
606 error ("Hardware watchpoints not implemented on this platform.");
610 hppa_remove_hw_watchpoint (int pid
, CORE_ADDR start
, LONGEST len
,
613 error ("Hardware watchpoints not implemented on this platform.");
617 hppa_can_use_hw_watchpoint (enum bptype type
, int cnt
, enum bptype ot
)
623 hppa_range_profitable_for_hw_watchpoint (int pid
, CORE_ADDR start
, LONGEST len
)
625 error ("Hardware watchpoints not implemented on this platform.");
629 hppa_pid_or_tid_to_str (pid_t id
)
631 /* In the ptrace world, there are only processes. */
632 return child_pid_to_str (id
);
635 /* This function has no meaning in a non-threaded world. Thus, we
636 return 0 (FALSE). See the use of "hppa_prepare_to_proceed" in
640 hppa_switched_threads (pid_t pid
)
646 hppa_ensure_vforking_parent_remains_stopped (int pid
)
648 /* This assumes that the vforked parent is presently stopped, and
649 that the vforked child has just delivered its first exec event.
650 Calling kill() this way will cause the SIGTRAP to be delivered as
651 soon as the parent is resumed, which happens as soon as the
652 vforked child is resumed. See wait_for_inferior for the use of
658 hppa_resume_execd_vforking_child_to_get_parent_vfork (void)
660 return 1; /* Yes, the child must be resumed. */
664 require_notification_of_events (int pid
)
666 #if defined(PT_SET_EVENT_MASK)
668 ptrace_event_t ptrace_events
;
672 /* Instruct the kernel as to the set of events we wish to be
673 informed of. (This support does not exist before HPUX 10.0.
674 We'll assume if PT_SET_EVENT_MASK has not been defined by
675 <sys/ptrace.h>, then we're being built on pre-10.0.) */
676 memset (&ptrace_events
, 0, sizeof (ptrace_events
));
678 /* Note: By default, all signals are visible to us. If we wish
679 the kernel to keep certain signals hidden from us, we do it
680 by calling sigdelset (ptrace_events.pe_signals, signal) for
681 each such signal here, before doing PT_SET_EVENT_MASK. */
682 /* RM: The above comment is no longer true. We start with ignoring
683 all signals, and then add the ones we are interested in. We could
684 do it the other way: start by looking at all signals and then
685 deleting the ones that we aren't interested in, except that
686 multiple gdb signals may be mapped to the same host signal
687 (eg. TARGET_SIGNAL_IO and TARGET_SIGNAL_POLL both get mapped to
688 signal 22 on HPUX 10.20) We want to be notified if we are
689 interested in either signal. */
690 sigfillset (&ptrace_events
.pe_signals
);
692 /* RM: Let's not bother with signals we don't care about */
693 nsigs
= (int) TARGET_SIGNAL_LAST
;
694 for (signum
= nsigs
; signum
> 0; signum
--)
696 if ((signal_stop_state (signum
)) ||
697 (signal_print_state (signum
)) ||
698 (!signal_pass_state (signum
)))
700 if (target_signal_to_host_p (signum
))
701 sigdelset (&ptrace_events
.pe_signals
,
702 target_signal_to_host (signum
));
706 ptrace_events
.pe_set_event
= 0;
708 ptrace_events
.pe_set_event
|= PTRACE_SIGNAL
;
709 ptrace_events
.pe_set_event
|= PTRACE_EXEC
;
710 ptrace_events
.pe_set_event
|= PTRACE_FORK
;
711 ptrace_events
.pe_set_event
|= PTRACE_VFORK
;
712 /* ??rehrauer: Add this one when we're prepared to catch it...
713 ptrace_events.pe_set_event |= PTRACE_EXIT;
717 pt_status
= call_ptrace (PT_SET_EVENT_MASK
,
719 (PTRACE_ARG3_TYPE
) & ptrace_events
,
720 sizeof (ptrace_events
));
722 perror_with_name ("ptrace");
729 require_notification_of_exec_events (int pid
)
731 #if defined(PT_SET_EVENT_MASK)
733 ptrace_event_t ptrace_events
;
735 /* Instruct the kernel as to the set of events we wish to be
736 informed of. (This support does not exist before HPUX 10.0.
737 We'll assume if PT_SET_EVENT_MASK has not been defined by
738 <sys/ptrace.h>, then we're being built on pre-10.0.) */
739 memset (&ptrace_events
, 0, sizeof (ptrace_events
));
741 /* Note: By default, all signals are visible to us. If we wish
742 the kernel to keep certain signals hidden from us, we do it
743 by calling sigdelset (ptrace_events.pe_signals, signal) for
744 each such signal here, before doing PT_SET_EVENT_MASK. */
745 sigemptyset (&ptrace_events
.pe_signals
);
747 ptrace_events
.pe_set_event
= 0;
749 ptrace_events
.pe_set_event
|= PTRACE_EXEC
;
750 /* ??rehrauer: Add this one when we're prepared to catch it...
751 ptrace_events.pe_set_event |= PTRACE_EXIT;
755 pt_status
= call_ptrace (PT_SET_EVENT_MASK
,
757 (PTRACE_ARG3_TYPE
) & ptrace_events
,
758 sizeof (ptrace_events
));
760 perror_with_name ("ptrace");
766 /* This function is called by the parent process, with pid being the
767 ID of the child process, after the debugger has forked. */
770 child_acknowledge_created_inferior (int pid
)
772 /* We need a memory home for a constant. */
773 int tc_magic_parent
= PT_VERSION
;
774 int tc_magic_child
= 0;
776 /* The remainder of this function is only useful for HPUX 10.0 and
777 later, as it depends upon the ability to request notification
778 of specific kinds of events by the kernel. */
779 #if defined(PT_SET_EVENT_MASK)
780 /* Wait for the child to tell us that it has forked. */
781 read (startup_semaphore
.child_channel
[SEM_LISTEN
],
783 sizeof (tc_magic_child
));
785 /* Notify the child that it can exec.
787 In the infttrace.c variant of this function, we set the child's
788 event mask after the fork but before the exec. In the ptrace
789 world, it seems we can't set the event mask until after the exec. */
790 write (startup_semaphore
.parent_channel
[SEM_TALK
],
792 sizeof (tc_magic_parent
));
794 /* We'd better pause a bit before trying to set the event mask,
795 though, to ensure that the exec has happened. We don't want to
796 wait() on the child, because that'll screw up the upper layers
797 of gdb's execution control that expect to see the exec event.
799 After an exec, the child is no longer executing gdb code. Hence,
800 we can't have yet another synchronization via the pipes. We'll
801 just sleep for a second, and hope that's enough delay... */
804 /* Instruct the kernel as to the set of events we wish to be
806 require_notification_of_exec_events (pid
);
808 /* Discard our copy of the semaphore. */
809 (void) close (startup_semaphore
.parent_channel
[SEM_LISTEN
]);
810 (void) close (startup_semaphore
.parent_channel
[SEM_TALK
]);
811 (void) close (startup_semaphore
.child_channel
[SEM_LISTEN
]);
812 (void) close (startup_semaphore
.child_channel
[SEM_TALK
]);
817 child_post_startup_inferior (int pid
)
819 require_notification_of_events (pid
);
823 child_post_attach (int pid
)
825 require_notification_of_events (pid
);
829 child_insert_fork_catchpoint (int pid
)
831 /* This request is only available on HPUX 10.0 and later. */
832 #if !defined(PT_SET_EVENT_MASK)
833 error ("Unable to catch forks prior to HPUX 10.0");
835 /* Enable reporting of fork events from the kernel. */
836 /* ??rehrauer: For the moment, we're always enabling these events,
837 and just ignoring them if there's no catchpoint to catch them. */
843 child_remove_fork_catchpoint (int pid
)
845 /* This request is only available on HPUX 10.0 and later. */
846 #if !defined(PT_SET_EVENT_MASK)
847 error ("Unable to catch forks prior to HPUX 10.0");
849 /* Disable reporting of fork events from the kernel. */
850 /* ??rehrauer: For the moment, we're always enabling these events,
851 and just ignoring them if there's no catchpoint to catch them. */
857 child_insert_vfork_catchpoint (int pid
)
859 /* This request is only available on HPUX 10.0 and later. */
860 #if !defined(PT_SET_EVENT_MASK)
861 error ("Unable to catch vforks prior to HPUX 10.0");
863 /* Enable reporting of vfork events from the kernel. */
864 /* ??rehrauer: For the moment, we're always enabling these events,
865 and just ignoring them if there's no catchpoint to catch them. */
871 child_remove_vfork_catchpoint (int pid
)
873 /* This request is only available on HPUX 10.0 and later. */
874 #if !defined(PT_SET_EVENT_MASK)
875 error ("Unable to catch vforks prior to HPUX 10.0");
877 /* Disable reporting of vfork events from the kernel. */
878 /* ??rehrauer: For the moment, we're always enabling these events,
879 and just ignoring them if there's no catchpoint to catch them. */
885 child_has_forked (int pid
, int *childpid
)
887 /* This request is only available on HPUX 10.0 and later. */
888 #if !defined(PT_GET_PROCESS_STATE)
893 ptrace_state_t ptrace_state
;
896 pt_status
= call_ptrace (PT_GET_PROCESS_STATE
,
898 (PTRACE_ARG3_TYPE
) & ptrace_state
,
899 sizeof (ptrace_state
));
901 perror_with_name ("ptrace");
905 if (ptrace_state
.pe_report_event
& PTRACE_FORK
)
907 *childpid
= ptrace_state
.pe_other_pid
;
916 child_has_vforked (int pid
, int *childpid
)
918 /* This request is only available on HPUX 10.0 and later. */
919 #if !defined(PT_GET_PROCESS_STATE)
925 ptrace_state_t ptrace_state
;
928 pt_status
= call_ptrace (PT_GET_PROCESS_STATE
,
930 (PTRACE_ARG3_TYPE
) & ptrace_state
,
931 sizeof (ptrace_state
));
933 perror_with_name ("ptrace");
937 if (ptrace_state
.pe_report_event
& PTRACE_VFORK
)
939 *childpid
= ptrace_state
.pe_other_pid
;
948 child_can_follow_vfork_prior_to_exec (void)
950 /* ptrace doesn't allow this. */
955 child_insert_exec_catchpoint (int pid
)
957 /* This request is only available on HPUX 10.0 and later. */
958 #if !defined(PT_SET_EVENT_MASK)
959 error ("Unable to catch execs prior to HPUX 10.0");
962 /* Enable reporting of exec events from the kernel. */
963 /* ??rehrauer: For the moment, we're always enabling these events,
964 and just ignoring them if there's no catchpoint to catch them. */
970 child_remove_exec_catchpoint (int pid
)
972 /* This request is only available on HPUX 10.0 and later. */
973 #if !defined(PT_SET_EVENT_MASK)
974 error ("Unable to catch execs prior to HPUX 10.0");
977 /* Disable reporting of exec events from the kernel. */
978 /* ??rehrauer: For the moment, we're always enabling these events,
979 and just ignoring them if there's no catchpoint to catch them. */
985 child_has_execd (int pid
, char **execd_pathname
)
987 /* This request is only available on HPUX 10.0 and later. */
988 #if !defined(PT_GET_PROCESS_STATE)
989 *execd_pathname
= NULL
;
994 ptrace_state_t ptrace_state
;
997 pt_status
= call_ptrace (PT_GET_PROCESS_STATE
,
999 (PTRACE_ARG3_TYPE
) & ptrace_state
,
1000 sizeof (ptrace_state
));
1002 perror_with_name ("ptrace");
1006 if (ptrace_state
.pe_report_event
& PTRACE_EXEC
)
1008 char *exec_file
= target_pid_to_exec_file (pid
);
1009 *execd_pathname
= savestring (exec_file
, strlen (exec_file
));
1018 child_reported_exec_events_per_exec_call (void)
1020 return 2; /* ptrace reports the event twice per call. */
1024 child_has_syscall_event (int pid
, enum target_waitkind
*kind
, int *syscall_id
)
1026 /* This request is only available on HPUX 10.30 and later, via
1027 the ttrace interface. */
1029 *kind
= TARGET_WAITKIND_SPURIOUS
;
1035 child_pid_to_exec_file (int pid
)
1037 static char exec_file_buffer
[1024];
1039 CORE_ADDR top_of_stack
;
1043 int saved_inferior_pid
;
1046 #ifdef PT_GET_PROCESS_PATHNAME
1047 /* As of 10.x HP-UX, there's an explicit request to get the pathname. */
1048 pt_status
= call_ptrace (PT_GET_PROCESS_PATHNAME
,
1050 (PTRACE_ARG3_TYPE
) exec_file_buffer
,
1051 sizeof (exec_file_buffer
) - 1);
1053 return exec_file_buffer
;
1056 /* It appears that this request is broken prior to 10.30.
1057 If it fails, try a really, truly amazingly gross hack
1058 that DDE uses, of pawing through the process' data
1059 segment to find the pathname. */
1061 top_of_stack
= 0x7b03a000;
1065 /* On the chance that pid != inferior_pid, set inferior_pid
1066 to pid, so that (grrrr!) implicit uses of inferior_pid get
1069 saved_inferior_pid
= inferior_pid
;
1072 /* Try to grab a null-terminated string. */
1075 if (target_read_memory (top_of_stack
, four_chars
, 4) != 0)
1077 inferior_pid
= saved_inferior_pid
;
1080 for (i
= 0; i
< 4; i
++)
1082 exec_file_buffer
[name_index
++] = four_chars
[i
];
1083 done
= (four_chars
[i
] == '\0');
1090 if (exec_file_buffer
[0] == '\0')
1092 inferior_pid
= saved_inferior_pid
;
1096 inferior_pid
= saved_inferior_pid
;
1097 return exec_file_buffer
;
1101 pre_fork_inferior (void)
1105 status
= pipe (startup_semaphore
.parent_channel
);
1108 warning ("error getting parent pipe for startup semaphore");
1112 status
= pipe (startup_semaphore
.child_channel
);
1115 warning ("error getting child pipe for startup semaphore");
1121 /* Check to see if the given thread is alive.
1123 This is a no-op, as ptrace doesn't support threads, so we just
1127 child_thread_alive (int pid
)
1132 #endif /* ! GDB_NATIVE_HPUX_11 */