1 /* Native support code for HPUX PA-RISC.
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1998
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, Boston, MA 02111-1307, USA. */
28 #include <sys/ptrace.h>
33 extern CORE_ADDR text_end
;
35 static void fetch_register
PARAMS ((int));
38 fetch_inferior_registers (regno
)
42 for (regno
= 0; regno
< NUM_REGS
; regno
++)
43 fetch_register (regno
);
45 fetch_register (regno
);
48 /* Store our register values back into the inferior.
49 If REGNO is -1, do this for all registers.
50 Otherwise, REGNO specifies which register (so we can save time). */
53 store_inferior_registers (regno
)
56 register unsigned int regaddr
;
58 extern char registers
[];
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.
134 char *err
= safe_strerror (errno
);
135 char *msg
= alloca (strlen (err
) + 128);
136 sprintf (msg
, "reading register %s: %s", REGISTER_NAME (regno
), err
);
141 if (regno
== PCOQ_HEAD_REGNUM
|| regno
== PCOQ_TAIL_REGNUM
)
143 supply_register (regno
, buf
);
147 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
148 to debugger memory starting at MYADDR. Copy to inferior if
151 Returns the length copied, which is either the LEN argument or zero.
152 This xfer function does not do partial moves, since child_ops
153 doesn't allow memory operations to cross below us in the target stack
157 child_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
162 struct target_ops
*target
; /* ignored */
165 /* Round starting address down to longword boundary. */
166 register CORE_ADDR addr
= memaddr
& - sizeof (int);
167 /* Round ending address up; get number of longwords that makes. */
169 = (((memaddr
+ len
) - addr
) + sizeof (int) - 1) / sizeof (int);
171 /* Allocate buffer of that many longwords. */
172 /* Note (RT) - This code formerly used alloca, which I have
173 * replaced with xmalloc and a matching free() at the end.
174 * The problem with alloca() is that there is no guarantee of
175 * when it'll be freed, and we were seeing cases of memory
179 * where the piled-up alloca's for the child_xfer_memory buffers
180 * were not getting freed.
182 register int *buffer
= (int *) xmalloc (count
* sizeof (int));
186 /* Fill start and end extra bytes of buffer with existing memory data. */
188 if (addr
!= memaddr
|| len
< (int)sizeof (int)) {
189 /* Need part of initial word -- fetch it. */
190 buffer
[0] = call_ptrace (addr
< text_end
? PT_RIUSER
: PT_RDUSER
,
191 inferior_pid
, (PTRACE_ARG3_TYPE
) addr
, 0);
194 if (count
> 1) /* FIXME, avoid if even boundary */
197 = call_ptrace (addr
< text_end
? PT_RIUSER
: PT_RDUSER
, inferior_pid
,
198 (PTRACE_ARG3_TYPE
) (addr
+ (count
- 1) * sizeof (int)),
202 /* Copy data to be written over corresponding part of buffer */
204 memcpy ((char *) buffer
+ (memaddr
& (sizeof (int) - 1)), myaddr
, len
);
206 /* Write the entire buffer. */
208 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
212 /* The HP-UX kernel crashes if you use PT_WDUSER to write into the text
213 segment. FIXME -- does it work to write into the data segment using
214 WIUSER, or do these idiots really expect us to figure out which segment
215 the address is in, so we can use a separate system call for it??! */
217 pt_request
= (addr
< text_end
) ? PT_WIUSER
: PT_WDUSER
;
218 pt_status
= call_ptrace (pt_request
,
220 (PTRACE_ARG3_TYPE
) addr
,
223 /* Did we fail? Might we've guessed wrong about which
224 segment this address resides in? Try the other request,
225 and see if that works...
227 if ((pt_status
== -1) && errno
) {
229 pt_request
= (pt_request
== PT_WIUSER
) ? PT_WDUSER
: PT_WIUSER
;
230 pt_status
= call_ptrace (pt_request
,
232 (PTRACE_ARG3_TYPE
) addr
,
235 /* No, we still fail. Okay, time to punt. */
236 if ((pt_status
== -1) && errno
)
246 /* Read all the longwords */
247 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
250 buffer
[i
] = call_ptrace (addr
< text_end
? PT_RIUSER
: PT_RDUSER
,
251 inferior_pid
, (PTRACE_ARG3_TYPE
) addr
, 0);
259 /* Copy appropriate bytes out of the buffer. */
260 memcpy (myaddr
, (char *) buffer
+ (memaddr
& (sizeof (int) - 1)), len
);
268 child_post_follow_inferior_by_clone ()
272 /* This function is used when following both the parent and child
273 of a fork. In this case, the debugger clones itself. The original
274 debugger follows the parent, the clone follows the child. The
275 original detaches from the child, delivering a SIGSTOP to it to
276 keep it from running away until the clone can attach itself.
278 At this point, the clone has attached to the child. Because of
279 the SIGSTOP, we must now deliver a SIGCONT to the child, or it
280 won't behave properly. */
281 status
= kill (inferior_pid
, SIGCONT
);
286 child_post_follow_vfork (parent_pid
, followed_parent
, child_pid
, followed_child
)
293 /* Are we a debugger that followed the parent of a vfork? If so,
294 then recall that the child's vfork event was delivered to us
295 first. And, that the parent was suspended by the OS until the
296 child's exec or exit events were received.
298 Upon receiving that child vfork, then, we were forced to remove
299 all breakpoints in the child and continue it so that it could
300 reach the exec or exit point.
302 But also recall that the parent and child of a vfork share the
303 same address space. Thus, removing bp's in the child also
304 removed them from the parent.
306 Now that the child has safely exec'd or exited, we must restore
307 the parent's breakpoints before we continue it. Else, we may
308 cause it run past expected stopping points. */
311 reattach_breakpoints (parent_pid
);
314 /* Are we a debugger that followed the child of a vfork? If so,
315 then recall that we don't actually acquire control of the child
316 until after it has exec'd or exited.
320 /* If the child has exited, then there's nothing for us to do.
321 In the case of an exec event, we'll let that be handled by
322 the normal mechanism that notices and handles exec events, in
328 /* Format a process id, given a pid. Be sure to terminate
329 * this with a null--it's going to be printed via a "%s".
332 hppa_pid_to_str( pid
)
335 static char buf
[30]; /* Static because address returned */
337 sprintf( buf
, "process %d\0\0\0\0", pid
);
338 /* Extra NULLs for paranoia's sake */
343 /* Format a thread id, given a tid. Be sure to terminate
344 * this with a null--it's going to be printed via a "%s".
346 * Note: This is a core-gdb tid, not the actual system tid.
347 * See infttrace.c for details.
350 hppa_tid_to_str( tid
)
353 static char buf
[30]; /* Static because address returned */
355 sprintf( buf
, "system thread %d\0\0\0\0", tid
);
356 /* Extra NULLs for paranoia's sake */
361 #if !defined (GDB_NATIVE_HPUX_11)
363 /* The following code is a substitute for the infttrace.c versions used
364 with ttrace() in HPUX 11. */
366 /* This value is an arbitrary integer. */
367 #define PT_VERSION 123456
369 /* This semaphore is used to coordinate the child and parent processes
370 after a fork(), and before an exec() by the child. See
371 parent_attach_all for details. */
374 int parent_channel
[2]; /* Parent "talks" to [1], child "listens" to [0] */
375 int child_channel
[2]; /* Child "talks" to [1], parent "listens" to [0] */
376 } startup_semaphore_t
;
379 #define SEM_LISTEN (0)
381 static startup_semaphore_t startup_semaphore
;
383 extern int parent_attach_all
PARAMS ((int, PTRACE_ARG3_TYPE
, int));
386 /* This function causes the caller's process to be traced by its
387 parent. This is intended to be called after GDB forks itself,
388 and before the child execs the target.
390 Note that HP-UX ptrace is rather funky in how this is done.
391 If the parent wants to get the initial exec event of a child,
392 it must set the ptrace event mask of the child to include execs.
393 (The child cannot do this itself.) This must be done after the
394 child is forked, but before it execs.
396 To coordinate the parent and child, we implement a semaphore using
397 pipes. After SETTRC'ing itself, the child tells the parent that
398 it is now traceable by the parent, and waits for the parent's
399 acknowledgement. The parent can then set the child's event mask,
400 and notify the child that it can now exec.
402 (The acknowledgement by parent happens as a result of a call to
403 child_acknowledge_created_inferior.) */
406 parent_attach_all (pid
, addr
, data
)
408 PTRACE_ARG3_TYPE addr
;
413 /* We need a memory home for a constant. */
414 int tc_magic_child
= PT_VERSION
;
415 int tc_magic_parent
= 0;
417 /* The remainder of this function is only useful for HPUX 10.0 and
418 later, as it depends upon the ability to request notification
419 of specific kinds of events by the kernel. */
420 #if defined(PT_SET_EVENT_MASK)
422 /* Notify the parent that we're potentially ready to exec(). */
423 write (startup_semaphore
.child_channel
[SEM_TALK
],
425 sizeof (tc_magic_child
));
427 /* Wait for acknowledgement from the parent. */
428 read (startup_semaphore
.parent_channel
[SEM_LISTEN
],
430 sizeof (tc_magic_parent
));
431 if (tc_magic_child
!= tc_magic_parent
)
432 warning ("mismatched semaphore magic");
434 /* Discard our copy of the semaphore. */
435 (void) close (startup_semaphore
.parent_channel
[SEM_LISTEN
]);
436 (void) close (startup_semaphore
.parent_channel
[SEM_TALK
]);
437 (void) close (startup_semaphore
.child_channel
[SEM_LISTEN
]);
438 (void) close (startup_semaphore
.child_channel
[SEM_TALK
]);
446 hppa_require_attach (pid
)
452 unsigned int regs_offset
;
454 /* Are we already attached? There appears to be no explicit way to
455 answer this via ptrace, so we try something which should be
456 innocuous if we are attached. If that fails, then we assume
457 we're not attached, and so attempt to make it so. */
460 regs_offset
= U_REGS_OFFSET
;
461 pc_addr
= register_addr (PC_REGNUM
, regs_offset
);
462 pc
= call_ptrace (PT_READ_U
, pid
, (PTRACE_ARG3_TYPE
) pc_addr
, 0);
467 pt_status
= call_ptrace (PT_ATTACH
, pid
, (PTRACE_ARG3_TYPE
) 0, 0);
472 /* Now we really are attached. */
480 hppa_require_detach (pid
, signal
)
485 call_ptrace (PT_DETACH
, pid
, (PTRACE_ARG3_TYPE
) 1, signal
);
486 errno
= 0; /* Ignore any errors. */
490 /* Since ptrace doesn't support memory page-protection events, which
491 are used to implement "hardware" watchpoints on HP-UX, these are
492 dummy versions, which perform no useful work. */
495 hppa_enable_page_protection_events (pid
)
501 hppa_disable_page_protection_events (pid
)
507 hppa_insert_hw_watchpoint (pid
, start
, len
, type
)
513 error ("Hardware watchpoints not implemented on this platform.");
517 hppa_remove_hw_watchpoint (pid
, start
, len
, type
)
523 error ("Hardware watchpoints not implemented on this platform.");
527 hppa_can_use_hw_watchpoint (type
, cnt
, ot
)
536 hppa_range_profitable_for_hw_watchpoint (pid
, start
, len
)
541 error ("Hardware watchpoints not implemented on this platform.");
545 hppa_pid_or_tid_to_str (id
)
548 /* In the ptrace world, there are only processes. */
549 return hppa_pid_to_str (id
);
552 /* This function has no meaning in a non-threaded world. Thus, we
553 return 0 (FALSE). See the use of "hppa_prepare_to_proceed" in
557 hppa_switched_threads (pid
)
564 hppa_ensure_vforking_parent_remains_stopped (pid
)
567 /* This assumes that the vforked parent is presently stopped, and
568 that the vforked child has just delivered its first exec event.
569 Calling kill() this way will cause the SIGTRAP to be delivered as
570 soon as the parent is resumed, which happens as soon as the
571 vforked child is resumed. See wait_for_inferior for the use of
577 hppa_resume_execd_vforking_child_to_get_parent_vfork ()
579 return 1; /* Yes, the child must be resumed. */
583 require_notification_of_events (pid
)
586 #if defined(PT_SET_EVENT_MASK)
588 ptrace_event_t ptrace_events
;
590 /* Instruct the kernel as to the set of events we wish to be
591 informed of. (This support does not exist before HPUX 10.0.
592 We'll assume if PT_SET_EVENT_MASK has not been defined by
593 <sys/ptrace.h>, then we're being built on pre-10.0.)
595 memset (&ptrace_events
, 0, sizeof (ptrace_events
));
597 /* Note: By default, all signals are visible to us. If we wish
598 the kernel to keep certain signals hidden from us, we do it
599 by calling sigdelset (ptrace_events.pe_signals, signal) for
600 each such signal here, before doing PT_SET_EVENT_MASK.
602 sigemptyset (&ptrace_events
.pe_signals
);
604 ptrace_events
.pe_set_event
= 0;
606 ptrace_events
.pe_set_event
|= PTRACE_SIGNAL
;
607 ptrace_events
.pe_set_event
|= PTRACE_EXEC
;
608 ptrace_events
.pe_set_event
|= PTRACE_FORK
;
609 ptrace_events
.pe_set_event
|= PTRACE_VFORK
;
610 /* ??rehrauer: Add this one when we're prepared to catch it...
611 ptrace_events.pe_set_event |= PTRACE_EXIT;
615 pt_status
= call_ptrace (PT_SET_EVENT_MASK
,
617 (PTRACE_ARG3_TYPE
) &ptrace_events
,
618 sizeof (ptrace_events
));
620 perror_with_name ("ptrace");
627 require_notification_of_exec_events (pid
)
630 #if defined(PT_SET_EVENT_MASK)
632 ptrace_event_t ptrace_events
;
634 /* Instruct the kernel as to the set of events we wish to be
635 informed of. (This support does not exist before HPUX 10.0.
636 We'll assume if PT_SET_EVENT_MASK has not been defined by
637 <sys/ptrace.h>, then we're being built on pre-10.0.)
639 memset (&ptrace_events
, 0, sizeof (ptrace_events
));
641 /* Note: By default, all signals are visible to us. If we wish
642 the kernel to keep certain signals hidden from us, we do it
643 by calling sigdelset (ptrace_events.pe_signals, signal) for
644 each such signal here, before doing PT_SET_EVENT_MASK.
646 sigemptyset (&ptrace_events
.pe_signals
);
648 ptrace_events
.pe_set_event
= 0;
650 ptrace_events
.pe_set_event
|= PTRACE_EXEC
;
651 /* ??rehrauer: Add this one when we're prepared to catch it...
652 ptrace_events.pe_set_event |= PTRACE_EXIT;
656 pt_status
= call_ptrace (PT_SET_EVENT_MASK
,
658 (PTRACE_ARG3_TYPE
) &ptrace_events
,
659 sizeof (ptrace_events
));
661 perror_with_name ("ptrace");
667 /* This function is called by the parent process, with pid being the
668 ID of the child process, after the debugger has forked. */
671 child_acknowledge_created_inferior (pid
)
674 /* We need a memory home for a constant. */
675 int tc_magic_parent
= PT_VERSION
;
676 int tc_magic_child
= 0;
678 /* Wait for the child to tell us that it has forked. */
679 read (startup_semaphore
.child_channel
[SEM_LISTEN
],
681 sizeof(tc_magic_child
));
683 /* Notify the child that it can exec.
685 In the infttrace.c variant of this function, we set the child's
686 event mask after the fork but before the exec. In the ptrace
687 world, it seems we can't set the event mask until after the exec. */
689 write (startup_semaphore
.parent_channel
[SEM_TALK
],
691 sizeof (tc_magic_parent
));
693 /* We'd better pause a bit before trying to set the event mask,
694 though, to ensure that the exec has happened. We don't want to
695 wait() on the child, because that'll screw up the upper layers
696 of gdb's execution control that expect to see the exec event.
698 After an exec, the child is no longer executing gdb code. Hence,
699 we can't have yet another synchronization via the pipes. We'll
700 just sleep for a second, and hope that's enough delay... */
704 /* Instruct the kernel as to the set of events we wish to be
707 require_notification_of_exec_events (pid
);
709 /* Discard our copy of the semaphore. */
710 (void) close (startup_semaphore
.parent_channel
[SEM_LISTEN
]);
711 (void) close (startup_semaphore
.parent_channel
[SEM_TALK
]);
712 (void) close (startup_semaphore
.child_channel
[SEM_LISTEN
]);
713 (void) close (startup_semaphore
.child_channel
[SEM_TALK
]);
717 child_post_startup_inferior (pid
)
721 require_notification_of_events (pid
);
725 child_post_attach (pid
)
728 require_notification_of_events (pid
);
732 child_insert_fork_catchpoint (pid
)
735 /* This request is only available on HPUX 10.0 and later. */
736 #if !defined(PT_SET_EVENT_MASK)
737 error ("Unable to catch forks prior to HPUX 10.0");
739 /* Enable reporting of fork events from the kernel. */
740 /* ??rehrauer: For the moment, we're always enabling these events,
741 and just ignoring them if there's no catchpoint to catch them.
748 child_remove_fork_catchpoint (pid
)
751 /* This request is only available on HPUX 10.0 and later. */
752 #if !defined(PT_SET_EVENT_MASK)
753 error ("Unable to catch forks prior to HPUX 10.0");
755 /* Disable reporting of fork events from the kernel. */
756 /* ??rehrauer: For the moment, we're always enabling these events,
757 and just ignoring them if there's no catchpoint to catch them. */
763 child_insert_vfork_catchpoint (pid
)
766 /* This request is only available on HPUX 10.0 and later. */
767 #if !defined(PT_SET_EVENT_MASK)
768 error ("Unable to catch vforks prior to HPUX 10.0");
770 /* Enable reporting of vfork events from the kernel. */
771 /* ??rehrauer: For the moment, we're always enabling these events,
772 and just ignoring them if there's no catchpoint to catch them. */
778 child_remove_vfork_catchpoint (pid
)
781 /* This request is only available on HPUX 10.0 and later. */
782 #if !defined(PT_SET_EVENT_MASK)
783 error ("Unable to catch vforks prior to HPUX 10.0");
785 /* Disable reporting of vfork events from the kernel. */
786 /* ??rehrauer: For the moment, we're always enabling these events,
787 and just ignoring them if there's no catchpoint to catch them. */
793 child_has_forked (pid
, childpid
)
797 /* This request is only available on HPUX 10.0 and later. */
798 #if !defined(PT_GET_PROCESS_STATE)
803 ptrace_state_t ptrace_state
;
806 pt_status
= call_ptrace (PT_GET_PROCESS_STATE
,
808 (PTRACE_ARG3_TYPE
) &ptrace_state
,
809 sizeof (ptrace_state
));
811 perror_with_name ("ptrace");
815 if (ptrace_state
.pe_report_event
& PTRACE_FORK
)
817 *childpid
= ptrace_state
.pe_other_pid
;
826 child_has_vforked (pid
, childpid
)
830 /* This request is only available on HPUX 10.0 and later. */
831 #if !defined(PT_GET_PROCESS_STATE)
837 ptrace_state_t ptrace_state
;
840 pt_status
= call_ptrace (PT_GET_PROCESS_STATE
,
842 (PTRACE_ARG3_TYPE
) &ptrace_state
,
843 sizeof (ptrace_state
));
845 perror_with_name ("ptrace");
849 if (ptrace_state
.pe_report_event
& PTRACE_VFORK
)
851 *childpid
= ptrace_state
.pe_other_pid
;
860 child_can_follow_vfork_prior_to_exec ()
862 /* ptrace doesn't allow this. */
867 child_insert_exec_catchpoint (pid
)
870 /* This request is only available on HPUX 10.0 and later.
872 #if !defined(PT_SET_EVENT_MASK)
873 error ("Unable to catch execs prior to HPUX 10.0");
876 /* Enable reporting of exec events from the kernel. */
877 /* ??rehrauer: For the moment, we're always enabling these events,
878 and just ignoring them if there's no catchpoint to catch them.
885 child_remove_exec_catchpoint (pid
)
888 /* This request is only available on HPUX 10.0 and later.
890 #if !defined(PT_SET_EVENT_MASK)
891 error ("Unable to catch execs prior to HPUX 10.0");
894 /* Disable reporting of exec events from the kernel. */
895 /* ??rehrauer: For the moment, we're always enabling these events,
896 and just ignoring them if there's no catchpoint to catch them.
903 child_has_execd (pid
, execd_pathname
)
905 char ** execd_pathname
;
908 /* This request is only available on HPUX 10.0 and later.
910 #if !defined(PT_GET_PROCESS_STATE)
911 *execd_pathname
= NULL
;
916 ptrace_state_t ptrace_state
;
919 pt_status
= call_ptrace (PT_GET_PROCESS_STATE
,
921 (PTRACE_ARG3_TYPE
) &ptrace_state
,
922 sizeof (ptrace_state
));
924 perror_with_name ("ptrace");
928 if (ptrace_state
.pe_report_event
& PTRACE_EXEC
)
930 char * exec_file
= target_pid_to_exec_file (pid
);
931 *execd_pathname
= savestring (exec_file
, strlen (exec_file
));
940 child_reported_exec_events_per_exec_call ()
942 return 2; /* ptrace reports the event twice per call. */
946 child_has_syscall_event (pid
, kind
, syscall_id
)
948 enum target_waitkind
*kind
;
951 /* This request is only available on HPUX 10.30 and later, via
952 the ttrace interface. */
954 *kind
= TARGET_WAITKIND_SPURIOUS
;
960 child_pid_to_exec_file (pid
)
963 static char exec_file_buffer
[1024];
965 CORE_ADDR top_of_stack
;
969 int saved_inferior_pid
;
972 #ifdef PT_GET_PROCESS_PATHNAME
973 /* As of 10.x HP-UX, there's an explicit request to get the pathname. */
974 pt_status
= call_ptrace (PT_GET_PROCESS_PATHNAME
,
976 (PTRACE_ARG3_TYPE
) exec_file_buffer
,
977 sizeof (exec_file_buffer
) - 1);
979 return exec_file_buffer
;
982 /* It appears that this request is broken prior to 10.30.
983 If it fails, try a really, truly amazingly gross hack
984 that DDE uses, of pawing through the process' data
985 segment to find the pathname. */
987 top_of_stack
= 0x7b03a000;
991 /* On the chance that pid != inferior_pid, set inferior_pid
992 to pid, so that (grrrr!) implicit uses of inferior_pid get
995 saved_inferior_pid
= inferior_pid
;
998 /* Try to grab a null-terminated string. */
1001 if (target_read_memory (top_of_stack
, four_chars
, 4) != 0)
1003 inferior_pid
= saved_inferior_pid
;
1006 for (i
= 0; i
< 4; i
++)
1008 exec_file_buffer
[name_index
++] = four_chars
[i
];
1009 done
= (four_chars
[i
] == '\0');
1016 if (exec_file_buffer
[0] == '\0')
1018 inferior_pid
= saved_inferior_pid
;
1022 inferior_pid
= saved_inferior_pid
;
1023 return exec_file_buffer
;
1027 pre_fork_inferior ()
1031 status
= pipe (startup_semaphore
.parent_channel
);
1034 warning ("error getting parent pipe for startup semaphore");
1038 status
= pipe (startup_semaphore
.child_channel
);
1041 warning ("error getting child pipe for startup semaphore");
1047 /* Check to see if the given thread is alive.
1049 This is a no-op, as ptrace doesn't support threads, so we just
1053 child_thread_alive (pid
)
1059 #endif /* ! GDB_NATIVE_HPUX_11 */