1 /* Native support code for HPUX PA-RISC.
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1998, 1999
3 Free Software Foundation, Inc.
5 Contributed by the Center for Software Science at the
6 University of Utah (pa-gdb-bugs@cs.utah.edu).
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
29 #include <sys/ptrace.h>
34 extern CORE_ADDR text_end
;
36 static void fetch_register
PARAMS ((int));
39 fetch_inferior_registers (regno
)
43 for (regno
= 0; regno
< NUM_REGS
; regno
++)
44 fetch_register (regno
);
46 fetch_register (regno
);
49 /* Store our register values back into the inferior.
50 If REGNO is -1, do this for all registers.
51 Otherwise, REGNO specifies which register (so we can save time). */
54 store_inferior_registers (regno
)
57 register unsigned int regaddr
;
60 unsigned int offset
= U_REGS_OFFSET
;
65 if (CANNOT_STORE_REGISTER (regno
))
67 regaddr
= register_addr (regno
, offset
);
69 if (regno
== PCOQ_HEAD_REGNUM
|| regno
== PCOQ_TAIL_REGNUM
)
71 scratch
= *(int *) ®isters
[REGISTER_BYTE (regno
)] | 0x3;
72 call_ptrace (PT_WUREGS
, inferior_pid
, (PTRACE_ARG3_TYPE
) regaddr
,
76 /* Error, even if attached. Failing to write these two
77 registers is pretty serious. */
78 sprintf (buf
, "writing register number %d", regno
);
79 perror_with_name (buf
);
83 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (int))
86 call_ptrace (PT_WUREGS
, inferior_pid
, (PTRACE_ARG3_TYPE
) regaddr
,
87 *(int *) ®isters
[REGISTER_BYTE (regno
) + i
]);
90 /* Warning, not error, in case we are attached; sometimes the
91 kernel doesn't let us at the registers. */
92 char *err
= safe_strerror (errno
);
93 char *msg
= alloca (strlen (err
) + 128);
94 sprintf (msg
, "writing register %s: %s",
95 REGISTER_NAME (regno
), err
);
99 regaddr
+= sizeof (int);
103 for (regno
= 0; regno
< NUM_REGS
; regno
++)
104 store_inferior_registers (regno
);
107 /* Fetch one register. */
110 fetch_register (regno
)
113 register unsigned int regaddr
;
114 char buf
[MAX_REGISTER_RAW_SIZE
];
117 /* Offset of registers within the u area. */
120 offset
= U_REGS_OFFSET
;
122 regaddr
= register_addr (regno
, offset
);
123 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
+= sizeof (int))
126 *(int *) &buf
[i
] = call_ptrace (PT_RUREGS
, inferior_pid
,
127 (PTRACE_ARG3_TYPE
) regaddr
, 0);
128 regaddr
+= sizeof (int);
131 /* Warning, not error, in case we are attached; sometimes the
132 kernel doesn't let us at the registers. */
133 char *err
= safe_strerror (errno
);
134 char *msg
= alloca (strlen (err
) + 128);
135 sprintf (msg
, "reading register %s: %s", REGISTER_NAME (regno
), err
);
140 if (regno
== PCOQ_HEAD_REGNUM
|| regno
== PCOQ_TAIL_REGNUM
)
142 supply_register (regno
, buf
);
146 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
147 to debugger memory starting at MYADDR. Copy to inferior if
150 Returns the length copied, which is either the LEN argument or zero.
151 This xfer function does not do partial moves, since child_ops
152 doesn't allow memory operations to cross below us in the target stack
156 child_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
161 struct target_ops
*target
; /* ignored */
164 /* Round starting address down to longword boundary. */
165 register CORE_ADDR addr
= memaddr
& -sizeof (int);
166 /* Round ending address up; get number of longwords that makes. */
168 = (((memaddr
+ len
) - addr
) + sizeof (int) - 1) / sizeof (int);
170 /* Allocate buffer of that many longwords.
171 Note -- do not use alloca to allocate this buffer since there is no
172 guarantee of when the buffer will actually be deallocated.
174 This routine can be called over and over with the same call chain;
175 this (in effect) would pile up all those alloca requests until a call
176 to alloca was made from a point higher than this routine in the
178 register int *buffer
= (int *) xmalloc (count
* sizeof (int));
182 /* Fill start and end extra bytes of buffer with existing memory data. */
183 if (addr
!= memaddr
|| len
< (int) sizeof (int))
185 /* Need part of initial word -- fetch it. */
186 buffer
[0] = call_ptrace (addr
< text_end
? PT_RIUSER
: PT_RDUSER
,
187 inferior_pid
, (PTRACE_ARG3_TYPE
) addr
, 0);
190 if (count
> 1) /* FIXME, avoid if even boundary */
193 = call_ptrace (addr
< text_end
? PT_RIUSER
: PT_RDUSER
,
195 (PTRACE_ARG3_TYPE
) (addr
196 + (count
- 1) * sizeof (int)),
200 /* Copy data to be written over corresponding part of buffer */
201 memcpy ((char *) buffer
+ (memaddr
& (sizeof (int) - 1)), myaddr
, len
);
203 /* Write the entire buffer. */
204 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
208 /* The HP-UX kernel crashes if you use PT_WDUSER to write into the
209 text segment. FIXME -- does it work to write into the data
210 segment using WIUSER, or do these idiots really expect us to
211 figure out which segment the address is in, so we can use a
212 separate system call for it??! */
214 pt_request
= (addr
< text_end
) ? PT_WIUSER
: PT_WDUSER
;
215 pt_status
= call_ptrace (pt_request
,
217 (PTRACE_ARG3_TYPE
) addr
,
220 /* Did we fail? Might we've guessed wrong about which
221 segment this address resides in? Try the other request,
222 and see if that works... */
223 if ((pt_status
== -1) && errno
)
226 pt_request
= (pt_request
== PT_WIUSER
) ? PT_WDUSER
: PT_WIUSER
;
227 pt_status
= call_ptrace (pt_request
,
229 (PTRACE_ARG3_TYPE
) addr
,
232 /* No, we still fail. Okay, time to punt. */
233 if ((pt_status
== -1) && errno
)
243 /* Read all the longwords */
244 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
247 buffer
[i
] = call_ptrace (addr
< text_end
? PT_RIUSER
: PT_RDUSER
,
248 inferior_pid
, (PTRACE_ARG3_TYPE
) addr
, 0);
257 /* Copy appropriate bytes out of the buffer. */
258 memcpy (myaddr
, (char *) buffer
+ (memaddr
& (sizeof (int) - 1)), len
);
266 child_post_follow_inferior_by_clone ()
270 /* This function is used when following both the parent and child
271 of a fork. In this case, the debugger clones itself. The original
272 debugger follows the parent, the clone follows the child. The
273 original detaches from the child, delivering a SIGSTOP to it to
274 keep it from running away until the clone can attach itself.
276 At this point, the clone has attached to the child. Because of
277 the SIGSTOP, we must now deliver a SIGCONT to the child, or it
278 won't behave properly. */
279 status
= kill (inferior_pid
, SIGCONT
);
284 child_post_follow_vfork (parent_pid
, followed_parent
, child_pid
, followed_child
)
290 /* Are we a debugger that followed the parent of a vfork? If so,
291 then recall that the child's vfork event was delivered to us
292 first. And, that the parent was suspended by the OS until the
293 child's exec or exit events were received.
295 Upon receiving that child vfork, then, we were forced to remove
296 all breakpoints in the child and continue it so that it could
297 reach the exec or exit point.
299 But also recall that the parent and child of a vfork share the
300 same address space. Thus, removing bp's in the child also
301 removed them from the parent.
303 Now that the child has safely exec'd or exited, we must restore
304 the parent's breakpoints before we continue it. Else, we may
305 cause it run past expected stopping points. */
308 reattach_breakpoints (parent_pid
);
311 /* Are we a debugger that followed the child of a vfork? If so,
312 then recall that we don't actually acquire control of the child
313 until after it has exec'd or exited. */
316 /* If the child has exited, then there's nothing for us to do.
317 In the case of an exec event, we'll let that be handled by
318 the normal mechanism that notices and handles exec events, in
323 /* Format a process id, given PID. Be sure to terminate
324 this with a null--it's going to be printed via a "%s". */
326 hppa_pid_to_str (pid
)
329 /* Static because address returned */
332 /* Extra NULLs for paranoia's sake */
333 sprintf (buf
, "process %d\0\0\0\0", pid
);
338 /* Format a thread id, given TID. Be sure to terminate
339 this with a null--it's going to be printed via a "%s".
341 Note: This is a core-gdb tid, not the actual system tid.
342 See infttrace.c for details. */
344 hppa_tid_to_str (tid
)
347 /* Static because address returned */
350 /* Extra NULLs for paranoia's sake */
351 sprintf (buf
, "system thread %d\0\0\0\0", tid
);
356 #if !defined (GDB_NATIVE_HPUX_11)
358 /* The following code is a substitute for the infttrace.c versions used
359 with ttrace() in HPUX 11. */
361 /* This value is an arbitrary integer. */
362 #define PT_VERSION 123456
364 /* This semaphore is used to coordinate the child and parent processes
365 after a fork(), and before an exec() by the child. See
366 parent_attach_all for details. */
370 int parent_channel
[2]; /* Parent "talks" to [1], child "listens" to [0] */
371 int child_channel
[2]; /* Child "talks" to [1], parent "listens" to [0] */
376 #define SEM_LISTEN (0)
378 static startup_semaphore_t startup_semaphore
;
380 extern int parent_attach_all
PARAMS ((int, PTRACE_ARG3_TYPE
, int));
383 /* This function causes the caller's process to be traced by its
384 parent. This is intended to be called after GDB forks itself,
385 and before the child execs the target.
387 Note that HP-UX ptrace is rather funky in how this is done.
388 If the parent wants to get the initial exec event of a child,
389 it must set the ptrace event mask of the child to include execs.
390 (The child cannot do this itself.) This must be done after the
391 child is forked, but before it execs.
393 To coordinate the parent and child, we implement a semaphore using
394 pipes. After SETTRC'ing itself, the child tells the parent that
395 it is now traceable by the parent, and waits for the parent's
396 acknowledgement. The parent can then set the child's event mask,
397 and notify the child that it can now exec.
399 (The acknowledgement by parent happens as a result of a call to
400 child_acknowledge_created_inferior.) */
403 parent_attach_all (pid
, addr
, data
)
405 PTRACE_ARG3_TYPE addr
;
410 /* We need a memory home for a constant. */
411 int tc_magic_child
= PT_VERSION
;
412 int tc_magic_parent
= 0;
414 /* The remainder of this function is only useful for HPUX 10.0 and
415 later, as it depends upon the ability to request notification
416 of specific kinds of events by the kernel. */
417 #if defined(PT_SET_EVENT_MASK)
419 /* Notify the parent that we're potentially ready to exec(). */
420 write (startup_semaphore
.child_channel
[SEM_TALK
],
422 sizeof (tc_magic_child
));
424 /* Wait for acknowledgement from the parent. */
425 read (startup_semaphore
.parent_channel
[SEM_LISTEN
],
427 sizeof (tc_magic_parent
));
428 if (tc_magic_child
!= tc_magic_parent
)
429 warning ("mismatched semaphore magic");
431 /* Discard our copy of the semaphore. */
432 (void) close (startup_semaphore
.parent_channel
[SEM_LISTEN
]);
433 (void) close (startup_semaphore
.parent_channel
[SEM_TALK
]);
434 (void) close (startup_semaphore
.child_channel
[SEM_LISTEN
]);
435 (void) close (startup_semaphore
.child_channel
[SEM_TALK
]);
443 hppa_require_attach (pid
)
449 unsigned int regs_offset
;
451 /* Are we already attached? There appears to be no explicit way to
452 answer this via ptrace, so we try something which should be
453 innocuous if we are attached. If that fails, then we assume
454 we're not attached, and so attempt to make it so. */
457 regs_offset
= U_REGS_OFFSET
;
458 pc_addr
= register_addr (PC_REGNUM
, regs_offset
);
459 pc
= call_ptrace (PT_READ_U
, pid
, (PTRACE_ARG3_TYPE
) pc_addr
, 0);
464 pt_status
= call_ptrace (PT_ATTACH
, pid
, (PTRACE_ARG3_TYPE
) 0, 0);
469 /* Now we really are attached. */
477 hppa_require_detach (pid
, signal
)
482 call_ptrace (PT_DETACH
, pid
, (PTRACE_ARG3_TYPE
) 1, signal
);
483 errno
= 0; /* Ignore any errors. */
487 /* Since ptrace doesn't support memory page-protection events, which
488 are used to implement "hardware" watchpoints on HP-UX, these are
489 dummy versions, which perform no useful work. */
492 hppa_enable_page_protection_events (pid
)
498 hppa_disable_page_protection_events (pid
)
504 hppa_insert_hw_watchpoint (pid
, start
, len
, type
)
510 error ("Hardware watchpoints not implemented on this platform.");
514 hppa_remove_hw_watchpoint (pid
, start
, len
, type
)
520 error ("Hardware watchpoints not implemented on this platform.");
524 hppa_can_use_hw_watchpoint (type
, cnt
, ot
)
533 hppa_range_profitable_for_hw_watchpoint (pid
, start
, len
)
538 error ("Hardware watchpoints not implemented on this platform.");
542 hppa_pid_or_tid_to_str (id
)
545 /* In the ptrace world, there are only processes. */
546 return hppa_pid_to_str (id
);
549 /* This function has no meaning in a non-threaded world. Thus, we
550 return 0 (FALSE). See the use of "hppa_prepare_to_proceed" in
554 hppa_switched_threads (pid
)
561 hppa_ensure_vforking_parent_remains_stopped (pid
)
564 /* This assumes that the vforked parent is presently stopped, and
565 that the vforked child has just delivered its first exec event.
566 Calling kill() this way will cause the SIGTRAP to be delivered as
567 soon as the parent is resumed, which happens as soon as the
568 vforked child is resumed. See wait_for_inferior for the use of
574 hppa_resume_execd_vforking_child_to_get_parent_vfork ()
576 return 1; /* Yes, the child must be resumed. */
580 require_notification_of_events (pid
)
583 #if defined(PT_SET_EVENT_MASK)
585 ptrace_event_t ptrace_events
;
587 /* Instruct the kernel as to the set of events we wish to be
588 informed of. (This support does not exist before HPUX 10.0.
589 We'll assume if PT_SET_EVENT_MASK has not been defined by
590 <sys/ptrace.h>, then we're being built on pre-10.0.) */
591 memset (&ptrace_events
, 0, sizeof (ptrace_events
));
593 /* Note: By default, all signals are visible to us. If we wish
594 the kernel to keep certain signals hidden from us, we do it
595 by calling sigdelset (ptrace_events.pe_signals, signal) for
596 each such signal here, before doing PT_SET_EVENT_MASK. */
597 sigemptyset (&ptrace_events
.pe_signals
);
599 ptrace_events
.pe_set_event
= 0;
601 ptrace_events
.pe_set_event
|= PTRACE_SIGNAL
;
602 ptrace_events
.pe_set_event
|= PTRACE_EXEC
;
603 ptrace_events
.pe_set_event
|= PTRACE_FORK
;
604 ptrace_events
.pe_set_event
|= PTRACE_VFORK
;
605 /* ??rehrauer: Add this one when we're prepared to catch it...
606 ptrace_events.pe_set_event |= PTRACE_EXIT;
610 pt_status
= call_ptrace (PT_SET_EVENT_MASK
,
612 (PTRACE_ARG3_TYPE
) & ptrace_events
,
613 sizeof (ptrace_events
));
615 perror_with_name ("ptrace");
622 require_notification_of_exec_events (pid
)
625 #if defined(PT_SET_EVENT_MASK)
627 ptrace_event_t ptrace_events
;
629 /* Instruct the kernel as to the set of events we wish to be
630 informed of. (This support does not exist before HPUX 10.0.
631 We'll assume if PT_SET_EVENT_MASK has not been defined by
632 <sys/ptrace.h>, then we're being built on pre-10.0.) */
633 memset (&ptrace_events
, 0, sizeof (ptrace_events
));
635 /* Note: By default, all signals are visible to us. If we wish
636 the kernel to keep certain signals hidden from us, we do it
637 by calling sigdelset (ptrace_events.pe_signals, signal) for
638 each such signal here, before doing PT_SET_EVENT_MASK. */
639 sigemptyset (&ptrace_events
.pe_signals
);
641 ptrace_events
.pe_set_event
= 0;
643 ptrace_events
.pe_set_event
|= PTRACE_EXEC
;
644 /* ??rehrauer: Add this one when we're prepared to catch it...
645 ptrace_events.pe_set_event |= PTRACE_EXIT;
649 pt_status
= call_ptrace (PT_SET_EVENT_MASK
,
651 (PTRACE_ARG3_TYPE
) & ptrace_events
,
652 sizeof (ptrace_events
));
654 perror_with_name ("ptrace");
660 /* This function is called by the parent process, with pid being the
661 ID of the child process, after the debugger has forked. */
664 child_acknowledge_created_inferior (pid
)
667 /* We need a memory home for a constant. */
668 int tc_magic_parent
= PT_VERSION
;
669 int tc_magic_child
= 0;
671 /* The remainder of this function is only useful for HPUX 10.0 and
672 later, as it depends upon the ability to request notification
673 of specific kinds of events by the kernel. */
674 #if defined(PT_SET_EVENT_MASK)
675 /* Wait for the child to tell us that it has forked. */
676 read (startup_semaphore
.child_channel
[SEM_LISTEN
],
678 sizeof (tc_magic_child
));
680 /* Notify the child that it can exec.
682 In the infttrace.c variant of this function, we set the child's
683 event mask after the fork but before the exec. In the ptrace
684 world, it seems we can't set the event mask until after the exec. */
685 write (startup_semaphore
.parent_channel
[SEM_TALK
],
687 sizeof (tc_magic_parent
));
689 /* We'd better pause a bit before trying to set the event mask,
690 though, to ensure that the exec has happened. We don't want to
691 wait() on the child, because that'll screw up the upper layers
692 of gdb's execution control that expect to see the exec event.
694 After an exec, the child is no longer executing gdb code. Hence,
695 we can't have yet another synchronization via the pipes. We'll
696 just sleep for a second, and hope that's enough delay... */
699 /* Instruct the kernel as to the set of events we wish to be
701 require_notification_of_exec_events (pid
);
703 /* Discard our copy of the semaphore. */
704 (void) close (startup_semaphore
.parent_channel
[SEM_LISTEN
]);
705 (void) close (startup_semaphore
.parent_channel
[SEM_TALK
]);
706 (void) close (startup_semaphore
.child_channel
[SEM_LISTEN
]);
707 (void) close (startup_semaphore
.child_channel
[SEM_TALK
]);
712 child_post_startup_inferior (pid
)
715 require_notification_of_events (pid
);
719 child_post_attach (pid
)
722 require_notification_of_events (pid
);
726 child_insert_fork_catchpoint (pid
)
729 /* This request is only available on HPUX 10.0 and later. */
730 #if !defined(PT_SET_EVENT_MASK)
731 error ("Unable to catch forks prior to HPUX 10.0");
733 /* Enable reporting of fork events from the kernel. */
734 /* ??rehrauer: For the moment, we're always enabling these events,
735 and just ignoring them if there's no catchpoint to catch them. */
741 child_remove_fork_catchpoint (pid
)
744 /* This request is only available on HPUX 10.0 and later. */
745 #if !defined(PT_SET_EVENT_MASK)
746 error ("Unable to catch forks prior to HPUX 10.0");
748 /* Disable reporting of fork events from the kernel. */
749 /* ??rehrauer: For the moment, we're always enabling these events,
750 and just ignoring them if there's no catchpoint to catch them. */
756 child_insert_vfork_catchpoint (pid
)
759 /* This request is only available on HPUX 10.0 and later. */
760 #if !defined(PT_SET_EVENT_MASK)
761 error ("Unable to catch vforks prior to HPUX 10.0");
763 /* Enable reporting of vfork events from the kernel. */
764 /* ??rehrauer: For the moment, we're always enabling these events,
765 and just ignoring them if there's no catchpoint to catch them. */
771 child_remove_vfork_catchpoint (pid
)
774 /* This request is only available on HPUX 10.0 and later. */
775 #if !defined(PT_SET_EVENT_MASK)
776 error ("Unable to catch vforks prior to HPUX 10.0");
778 /* Disable reporting of vfork events from the kernel. */
779 /* ??rehrauer: For the moment, we're always enabling these events,
780 and just ignoring them if there's no catchpoint to catch them. */
786 child_has_forked (pid
, childpid
)
790 /* This request is only available on HPUX 10.0 and later. */
791 #if !defined(PT_GET_PROCESS_STATE)
796 ptrace_state_t ptrace_state
;
799 pt_status
= call_ptrace (PT_GET_PROCESS_STATE
,
801 (PTRACE_ARG3_TYPE
) & ptrace_state
,
802 sizeof (ptrace_state
));
804 perror_with_name ("ptrace");
808 if (ptrace_state
.pe_report_event
& PTRACE_FORK
)
810 *childpid
= ptrace_state
.pe_other_pid
;
819 child_has_vforked (pid
, childpid
)
823 /* This request is only available on HPUX 10.0 and later. */
824 #if !defined(PT_GET_PROCESS_STATE)
830 ptrace_state_t ptrace_state
;
833 pt_status
= call_ptrace (PT_GET_PROCESS_STATE
,
835 (PTRACE_ARG3_TYPE
) & ptrace_state
,
836 sizeof (ptrace_state
));
838 perror_with_name ("ptrace");
842 if (ptrace_state
.pe_report_event
& PTRACE_VFORK
)
844 *childpid
= ptrace_state
.pe_other_pid
;
853 child_can_follow_vfork_prior_to_exec ()
855 /* ptrace doesn't allow this. */
860 child_insert_exec_catchpoint (pid
)
863 /* This request is only available on HPUX 10.0 and later. */
864 #if !defined(PT_SET_EVENT_MASK)
865 error ("Unable to catch execs prior to HPUX 10.0");
868 /* Enable reporting of exec events from the kernel. */
869 /* ??rehrauer: For the moment, we're always enabling these events,
870 and just ignoring them if there's no catchpoint to catch them. */
876 child_remove_exec_catchpoint (pid
)
879 /* This request is only available on HPUX 10.0 and later. */
880 #if !defined(PT_SET_EVENT_MASK)
881 error ("Unable to catch execs prior to HPUX 10.0");
884 /* Disable reporting of exec events from the kernel. */
885 /* ??rehrauer: For the moment, we're always enabling these events,
886 and just ignoring them if there's no catchpoint to catch them. */
892 child_has_execd (pid
, execd_pathname
)
894 char **execd_pathname
;
896 /* This request is only available on HPUX 10.0 and later. */
897 #if !defined(PT_GET_PROCESS_STATE)
898 *execd_pathname
= NULL
;
903 ptrace_state_t ptrace_state
;
906 pt_status
= call_ptrace (PT_GET_PROCESS_STATE
,
908 (PTRACE_ARG3_TYPE
) & ptrace_state
,
909 sizeof (ptrace_state
));
911 perror_with_name ("ptrace");
915 if (ptrace_state
.pe_report_event
& PTRACE_EXEC
)
917 char *exec_file
= target_pid_to_exec_file (pid
);
918 *execd_pathname
= savestring (exec_file
, strlen (exec_file
));
927 child_reported_exec_events_per_exec_call ()
929 return 2; /* ptrace reports the event twice per call. */
933 child_has_syscall_event (pid
, kind
, syscall_id
)
935 enum target_waitkind
*kind
;
938 /* This request is only available on HPUX 10.30 and later, via
939 the ttrace interface. */
941 *kind
= TARGET_WAITKIND_SPURIOUS
;
947 child_pid_to_exec_file (pid
)
950 static char exec_file_buffer
[1024];
952 CORE_ADDR top_of_stack
;
956 int saved_inferior_pid
;
959 #ifdef PT_GET_PROCESS_PATHNAME
960 /* As of 10.x HP-UX, there's an explicit request to get the pathname. */
961 pt_status
= call_ptrace (PT_GET_PROCESS_PATHNAME
,
963 (PTRACE_ARG3_TYPE
) exec_file_buffer
,
964 sizeof (exec_file_buffer
) - 1);
966 return exec_file_buffer
;
969 /* It appears that this request is broken prior to 10.30.
970 If it fails, try a really, truly amazingly gross hack
971 that DDE uses, of pawing through the process' data
972 segment to find the pathname. */
974 top_of_stack
= 0x7b03a000;
978 /* On the chance that pid != inferior_pid, set inferior_pid
979 to pid, so that (grrrr!) implicit uses of inferior_pid get
982 saved_inferior_pid
= inferior_pid
;
985 /* Try to grab a null-terminated string. */
988 if (target_read_memory (top_of_stack
, four_chars
, 4) != 0)
990 inferior_pid
= saved_inferior_pid
;
993 for (i
= 0; i
< 4; i
++)
995 exec_file_buffer
[name_index
++] = four_chars
[i
];
996 done
= (four_chars
[i
] == '\0');
1003 if (exec_file_buffer
[0] == '\0')
1005 inferior_pid
= saved_inferior_pid
;
1009 inferior_pid
= saved_inferior_pid
;
1010 return exec_file_buffer
;
1014 pre_fork_inferior ()
1018 status
= pipe (startup_semaphore
.parent_channel
);
1021 warning ("error getting parent pipe for startup semaphore");
1025 status
= pipe (startup_semaphore
.child_channel
);
1028 warning ("error getting child pipe for startup semaphore");
1034 /* Check to see if the given thread is alive.
1036 This is a no-op, as ptrace doesn't support threads, so we just
1040 child_thread_alive (pid
)
1046 #endif /* ! GDB_NATIVE_HPUX_11 */