Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996
Free Software Foundation, Inc.
-This file is part of GDB.
+ This file is part of GDB.
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
#include "defs.h"
#include "frame.h"
/* This semaphore is used to coordinate the child and parent processes
after a fork(), and before an exec() by the child. See parent_attach_all
for details.
- */
-typedef struct {
- int parent_channel[2]; /* Parent "talks" to [1], child "listens" to [0] */
- int child_channel[2]; /* Child "talks" to [1], parent "listens" to [0] */
-} startup_semaphore_t;
+ */
+typedef struct
+ {
+ int parent_channel[2]; /* Parent "talks" to [1], child "listens" to [0] */
+ int child_channel[2]; /* Child "talks" to [1], parent "listens" to [0] */
+ }
+startup_semaphore_t;
#define SEM_TALK (1)
#define SEM_LISTEN (0)
-static startup_semaphore_t startup_semaphore;
+static startup_semaphore_t startup_semaphore;
/* See can_touch_threads_of_process for details. */
-static int vforking_child_pid = 0;
-static int vfork_in_flight = 0;
+static int vforking_child_pid = 0;
+static int vfork_in_flight = 0;
/* To support PREPARE_TO_PROCEED (hppa_prepare_to_proceed).
*/
-static pid_t old_gdb_pid = 0;
+static pid_t old_gdb_pid = 0;
static pid_t reported_pid = 0;
static int reported_bpt = 0;
/* When supplied as the "addr" operand, ttrace interprets this
to mean, "from the current address".
- */
+ */
#define TT_USE_CURRENT_PC ((TTRACE_ARG_TYPE) TT_NOPC)
/* When supplied as the "addr", "data" or "addr2" operand for most
requests, ttrace interprets this to mean, "pay no heed to this
argument".
- */
+ */
#define TT_NIL ((TTRACE_ARG_TYPE) TT_NULLARG)
/* This is capable of holding the value of a 32-bit register. The
??rehrauer: Yes, this assumes that an int is 32-bits on HP-UX, and
that registers are 32-bits on HP-UX. The latter assumption changes
with PA2.0.
- */
-typedef int register_value_t;
+ */
+typedef int register_value_t;
/********************************************************************
/* Process state.
*/
-typedef enum process_state_enum {
+typedef enum process_state_enum
+ {
STOPPED,
FAKE_STEPPING,
- FAKE_CONTINUE, /* For later use */
+ FAKE_CONTINUE, /* For later use */
RUNNING,
FORKING,
VFORKING
-} process_state_t;
+ }
+process_state_t;
static process_state_t process_state = STOPPED;
/* User-specified stepping modality.
*/
-typedef enum stepping_mode_enum {
- DO_DEFAULT, /* ...which is a continue! */
+typedef enum stepping_mode_enum
+ {
+ DO_DEFAULT, /* ...which is a continue! */
DO_STEP,
DO_CONTINUE
-} stepping_mode_t;
-
+ }
+stepping_mode_t;
+
/* Action to take on an attach, depends on
* what kind (user command, fork, vfork).
*
*
* o leave stopped.
*/
-typedef enum attach_continue_enum {
- DO_ATTACH_CONTINUE,
- DONT_ATTACH_CONTINUE
-} attach_continue_t;
+typedef enum attach_continue_enum
+ {
+ DO_ATTACH_CONTINUE,
+ DONT_ATTACH_CONTINUE
+ }
+attach_continue_t;
/* This flag is true if we are doing a step-over-bpt
* with buffered events. We will have to be sure to
* code in "infrun.c/wait_for_inferior" will get
* confused.
*/
-static int doing_fake_step = 0;
-static lwpid_t fake_step_tid = 0;
-
+static int doing_fake_step = 0;
+static lwpid_t fake_step_tid = 0;
\f
+
/****************************************************
* Thread information structure routines and types. *
****************************************************
*/
-typedef
+typedef
struct thread_info_struct
-{
- int am_pseudo; /* This is a pseudo-thread for the process. */
- int pid; /* Process ID */
- lwpid_t tid; /* Thread ID */
- int handled; /* 1 if a buffered event was handled. */
- int seen; /* 1 if this thread was seen on a traverse. */
- int terminated; /* 1 if thread has terminated. */
- int have_signal; /* 1 if signal to be sent */
- enum target_signal signal_value; /* Signal to send */
- int have_start; /* 1 if alternate starting address */
- stepping_mode_t stepping_mode; /* Whether to step or continue */
- CORE_ADDR start; /* Where to start */
- int have_state; /* 1 if the event state has been set */
- ttstate_t last_stop_state;/* The most recently-waited event for this thread. */
+ {
+ int am_pseudo; /* This is a pseudo-thread for the process. */
+ int pid; /* Process ID */
+ lwpid_t tid; /* Thread ID */
+ int handled; /* 1 if a buffered event was handled. */
+ int seen; /* 1 if this thread was seen on a traverse. */
+ int terminated; /* 1 if thread has terminated. */
+ int have_signal; /* 1 if signal to be sent */
+ enum target_signal signal_value; /* Signal to send */
+ int have_start; /* 1 if alternate starting address */
+ stepping_mode_t stepping_mode; /* Whether to step or continue */
+ CORE_ADDR start; /* Where to start */
+ int have_state; /* 1 if the event state has been set */
+ ttstate_t last_stop_state; /* The most recently-waited event for this thread. */
struct thread_info_struct
- *next; /* All threads are linked via this field. */
+ *next; /* All threads are linked via this field. */
struct thread_info_struct
- *next_pseudo; /* All pseudo-threads are linked via this field. */
-} thread_info;
+ *next_pseudo; /* All pseudo-threads are linked via this field. */
+ }
+thread_info;
typedef
struct thread_info_header_struct
-{
- int count;
+ {
+ int count;
thread_info *head;
thread_info *head_pseudo;
-
-} thread_info_header;
-static thread_info_header thread_head = { 0, NULL, NULL };
-static thread_info_header deleted_threads = { 0, NULL, NULL };
+ }
+thread_info_header;
-static saved_real_pid = 0;
+static thread_info_header thread_head =
+{0, NULL, NULL};
+static thread_info_header deleted_threads =
+{0, NULL, NULL};
+static saved_real_pid = 0;
\f
+
/*************************************************
* Debugging support functions *
*************************************************
*/
CORE_ADDR
-get_raw_pc( ttid )
- lwpid_t ttid;
+get_raw_pc (ttid)
+ lwpid_t ttid;
{
- unsigned long pc_val;
- int offset;
- int res;
-
- offset = register_addr( PC_REGNUM, U_REGS_OFFSET );
- res = read_from_register_save_state(
- ttid,
- (TTRACE_ARG_TYPE) offset,
- (char *) &pc_val,
- sizeof( pc_val ));
- if( res <= 0 ) {
- return (CORE_ADDR) pc_val;
- }
- else {
- return (CORE_ADDR) 0;
- }
-}
+ unsigned long pc_val;
+ int offset;
+ int res;
+
+ offset = register_addr (PC_REGNUM, U_REGS_OFFSET);
+ res = read_from_register_save_state (
+ ttid,
+ (TTRACE_ARG_TYPE) offset,
+ (char *) &pc_val,
+ sizeof (pc_val));
+ if (res <= 0)
+ {
+ return (CORE_ADDR) pc_val;
+ }
+ else
+ {
+ return (CORE_ADDR) 0;
+ }
+}
static char *
-get_printable_name_of_stepping_mode( mode )
- stepping_mode_t mode;
+get_printable_name_of_stepping_mode (mode)
+ stepping_mode_t mode;
{
- switch( mode ) {
- case DO_DEFAULT: return "DO_DEFAULT";
- case DO_STEP: return "DO_STEP";
- case DO_CONTINUE: return "DO_CONTINUE";
- default: return "?unknown mode?";
- }
+ switch (mode)
+ {
+ case DO_DEFAULT:
+ return "DO_DEFAULT";
+ case DO_STEP:
+ return "DO_STEP";
+ case DO_CONTINUE:
+ return "DO_CONTINUE";
+ default:
+ return "?unknown mode?";
+ }
}
/* This function returns a pointer to a string describing the
*/
char *
get_printable_name_of_ttrace_event (event)
- ttevents_t event;
+ ttevents_t event;
{
/* This enumeration is "gappy", so don't use a table. */
- switch (event) {
+ switch (event)
+ {
case TTEVT_NONE:
- return "TTEVT_NONE";
+ return "TTEVT_NONE";
case TTEVT_SIGNAL:
- return "TTEVT_SIGNAL";
+ return "TTEVT_SIGNAL";
case TTEVT_FORK:
- return "TTEVT_FORK";
+ return "TTEVT_FORK";
case TTEVT_EXEC:
- return "TTEVT_EXEC";
+ return "TTEVT_EXEC";
case TTEVT_EXIT:
- return "TTEVT_EXIT";
+ return "TTEVT_EXIT";
case TTEVT_VFORK:
- return "TTEVT_VFORK";
+ return "TTEVT_VFORK";
case TTEVT_SYSCALL_RETURN:
- return "TTEVT_SYSCALL_RETURN";
+ return "TTEVT_SYSCALL_RETURN";
case TTEVT_LWP_CREATE:
- return "TTEVT_LWP_CREATE";
+ return "TTEVT_LWP_CREATE";
case TTEVT_LWP_TERMINATE:
- return "TTEVT_LWP_TERMINATE";
+ return "TTEVT_LWP_TERMINATE";
case TTEVT_LWP_EXIT:
- return "TTEVT_LWP_EXIT";
+ return "TTEVT_LWP_EXIT";
case TTEVT_LWP_ABORT_SYSCALL:
- return "TTEVT_LWP_ABORT_SYSCALL";
+ return "TTEVT_LWP_ABORT_SYSCALL";
case TTEVT_SYSCALL_ENTRY:
- return "TTEVT_SYSCALL_ENTRY";
- case TTEVT_SYSCALL_RESTART:
- return "TTEVT_SYSCALL_RESTART";
- default :
+ return "TTEVT_SYSCALL_ENTRY";
+ case TTEVT_SYSCALL_RESTART:
+ return "TTEVT_SYSCALL_RESTART";
+ default:
return "?new event?";
- }
+ }
}
-
\f
+
/* This function translates the ttrace request enumeration into
* a character string that is its printable (aka "human readable")
* name.
*/
char *
get_printable_name_of_ttrace_request (request)
- ttreq_t request;
+ ttreq_t request;
{
if (!IS_TTRACE_REQ (request))
return "?bad req?";
/* This enumeration is "gappy", so don't use a table. */
- switch (request) {
- case TT_PROC_SETTRC :
+ switch (request)
+ {
+ case TT_PROC_SETTRC:
return "TT_PROC_SETTRC";
- case TT_PROC_ATTACH :
+ case TT_PROC_ATTACH:
return "TT_PROC_ATTACH";
- case TT_PROC_DETACH :
+ case TT_PROC_DETACH:
return "TT_PROC_DETACH";
- case TT_PROC_RDTEXT :
+ case TT_PROC_RDTEXT:
return "TT_PROC_RDTEXT";
- case TT_PROC_WRTEXT :
+ case TT_PROC_WRTEXT:
return "TT_PROC_WRTEXT";
- case TT_PROC_RDDATA :
+ case TT_PROC_RDDATA:
return "TT_PROC_RDDATA";
- case TT_PROC_WRDATA :
+ case TT_PROC_WRDATA:
return "TT_PROC_WRDATA";
- case TT_PROC_STOP :
+ case TT_PROC_STOP:
return "TT_PROC_STOP";
- case TT_PROC_CONTINUE :
+ case TT_PROC_CONTINUE:
return "TT_PROC_CONTINUE";
- case TT_PROC_GET_PATHNAME :
+ case TT_PROC_GET_PATHNAME:
return "TT_PROC_GET_PATHNAME";
- case TT_PROC_GET_EVENT_MASK :
+ case TT_PROC_GET_EVENT_MASK:
return "TT_PROC_GET_EVENT_MASK";
- case TT_PROC_SET_EVENT_MASK :
+ case TT_PROC_SET_EVENT_MASK:
return "TT_PROC_SET_EVENT_MASK";
- case TT_PROC_GET_FIRST_LWP_STATE :
+ case TT_PROC_GET_FIRST_LWP_STATE:
return "TT_PROC_GET_FIRST_LWP_STATE";
- case TT_PROC_GET_NEXT_LWP_STATE :
+ case TT_PROC_GET_NEXT_LWP_STATE:
return "TT_PROC_GET_NEXT_LWP_STATE";
- case TT_PROC_EXIT :
+ case TT_PROC_EXIT:
return "TT_PROC_EXIT";
- case TT_PROC_GET_MPROTECT :
+ case TT_PROC_GET_MPROTECT:
return "TT_PROC_GET_MPROTECT";
- case TT_PROC_SET_MPROTECT :
+ case TT_PROC_SET_MPROTECT:
return "TT_PROC_SET_MPROTECT";
- case TT_PROC_SET_SCBM :
+ case TT_PROC_SET_SCBM:
return "TT_PROC_SET_SCBM";
- case TT_LWP_STOP :
+ case TT_LWP_STOP:
return "TT_LWP_STOP";
- case TT_LWP_CONTINUE :
+ case TT_LWP_CONTINUE:
return "TT_LWP_CONTINUE";
- case TT_LWP_SINGLE :
+ case TT_LWP_SINGLE:
return "TT_LWP_SINGLE";
- case TT_LWP_RUREGS :
+ case TT_LWP_RUREGS:
return "TT_LWP_RUREGS";
- case TT_LWP_WUREGS :
+ case TT_LWP_WUREGS:
return "TT_LWP_WUREGS";
- case TT_LWP_GET_EVENT_MASK :
+ case TT_LWP_GET_EVENT_MASK:
return "TT_LWP_GET_EVENT_MASK";
- case TT_LWP_SET_EVENT_MASK :
+ case TT_LWP_SET_EVENT_MASK:
return "TT_LWP_SET_EVENT_MASK";
- case TT_LWP_GET_STATE :
+ case TT_LWP_GET_STATE:
return "TT_LWP_GET_STATE";
- default :
+ default:
return "?new req?";
- }
+ }
}
-
\f
+
/* This function translates the process state enumeration into
* a character string that is its printable (aka "human readable")
* name.
*/
static char *
get_printable_name_of_process_state (process_state)
- process_state_t process_state;
+ process_state_t process_state;
{
- switch (process_state) {
+ switch (process_state)
+ {
case STOPPED:
return "STOPPED";
case FAKE_STEPPING:
return "VFORKING";
default:
return "?some unknown state?";
- }
+ }
}
/* Set a ttrace thread state to a safe, initial state.
*/
static void
clear_ttstate_t (tts)
- ttstate_t * tts;
+ ttstate_t *tts;
{
- tts->tts_pid = 0;
- tts->tts_lwpid = 0;
- tts->tts_user_tid = 0;
- tts->tts_event = TTEVT_NONE;
+ tts->tts_pid = 0;
+ tts->tts_lwpid = 0;
+ tts->tts_user_tid = 0;
+ tts->tts_event = TTEVT_NONE;
}
/* Copy ttrace thread state TTS_FROM into TTS_TO.
*/
static void
copy_ttstate_t (tts_to, tts_from)
- ttstate_t * tts_to;
- ttstate_t * tts_from;
+ ttstate_t *tts_to;
+ ttstate_t *tts_from;
{
- memcpy ((char *) tts_to, (char *) tts_from, sizeof (*tts_to));
+ memcpy ((char *) tts_to, (char *) tts_from, sizeof (*tts_to));
}
/* Are there any live threads we know about?
*/
-static int
-any_thread_records()
+static int
+any_thread_records ()
{
- return( thread_head.count > 0 );
+ return (thread_head.count > 0);
}
/* Create, fill in and link in a thread descriptor.
*/
static thread_info *
create_thread_info (pid, tid)
- int pid;
- lwpid_t tid;
+ int pid;
+ lwpid_t tid;
{
- thread_info * new_p;
- thread_info * p;
- int thread_count_of_pid;
-
- new_p = malloc( sizeof( thread_info ));
- new_p->pid = pid;
- new_p->tid = tid;
- new_p->have_signal = 0;
- new_p->have_start = 0;
- new_p->have_state = 0;
- clear_ttstate_t( &new_p->last_stop_state );
- new_p->am_pseudo = 0;
- new_p->handled = 0;
- new_p->seen = 0;
- new_p->terminated = 0;
- new_p->next = NULL;
- new_p->next_pseudo = NULL;
- new_p->stepping_mode = DO_DEFAULT;
-
- if( 0 == thread_head.count ) {
+ thread_info *new_p;
+ thread_info *p;
+ int thread_count_of_pid;
+
+ new_p = malloc (sizeof (thread_info));
+ new_p->pid = pid;
+ new_p->tid = tid;
+ new_p->have_signal = 0;
+ new_p->have_start = 0;
+ new_p->have_state = 0;
+ clear_ttstate_t (&new_p->last_stop_state);
+ new_p->am_pseudo = 0;
+ new_p->handled = 0;
+ new_p->seen = 0;
+ new_p->terminated = 0;
+ new_p->next = NULL;
+ new_p->next_pseudo = NULL;
+ new_p->stepping_mode = DO_DEFAULT;
+
+ if (0 == thread_head.count)
+ {
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "First thread, pid %d tid %d!\n", pid, tid );
+ if (debug_on)
+ printf ("First thread, pid %d tid %d!\n", pid, tid);
#endif
- saved_real_pid = inferior_pid;
+ saved_real_pid = inferior_pid;
}
- else {
+ else
+ {
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Subsequent thread, pid %d tid %d\n", pid, tid );
+ if (debug_on)
+ printf ("Subsequent thread, pid %d tid %d\n", pid, tid);
#endif
}
- /* Another day, another thread...
- */
- thread_head.count++;
+ /* Another day, another thread...
+ */
+ thread_head.count++;
- /* The new thread always goes at the head of the list.
- */
- new_p->next = thread_head.head;
- thread_head.head = new_p;
+ /* The new thread always goes at the head of the list.
+ */
+ new_p->next = thread_head.head;
+ thread_head.head = new_p;
- /* Is this the "pseudo" thread of a process? It is if there's
- * no other thread for this process on the list. (Note that this
- * accomodates multiple processes, such as we see even for simple
- * cases like forking "non-threaded" programs.)
- */
- p = thread_head.head;
- thread_count_of_pid = 0;
- while (p)
- {
- if (p->pid == new_p->pid)
- thread_count_of_pid++;
- p = p->next;
- }
-
- /* Did we see any other threads for this pid? (Recall that we just
- * added this thread to the list...)
- */
- if (thread_count_of_pid == 1)
- {
- new_p->am_pseudo = 1;
- new_p->next_pseudo = thread_head.head_pseudo;
- thread_head.head_pseudo = new_p;
- }
-
- return new_p;
+ /* Is this the "pseudo" thread of a process? It is if there's
+ * no other thread for this process on the list. (Note that this
+ * accomodates multiple processes, such as we see even for simple
+ * cases like forking "non-threaded" programs.)
+ */
+ p = thread_head.head;
+ thread_count_of_pid = 0;
+ while (p)
+ {
+ if (p->pid == new_p->pid)
+ thread_count_of_pid++;
+ p = p->next;
+ }
+
+ /* Did we see any other threads for this pid? (Recall that we just
+ * added this thread to the list...)
+ */
+ if (thread_count_of_pid == 1)
+ {
+ new_p->am_pseudo = 1;
+ new_p->next_pseudo = thread_head.head_pseudo;
+ thread_head.head_pseudo = new_p;
+ }
+
+ return new_p;
}
/* Get rid of our thread info.
static void
clear_thread_info ()
{
- thread_info *p;
- thread_info *q;
+ thread_info *p;
+ thread_info *q;
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Clearing all thread info\n" );
+ if (debug_on)
+ printf ("Clearing all thread info\n");
#endif
- p = thread_head.head;
- while( p ) {
- q = p;
- p = p->next;
- free( q );
+ p = thread_head.head;
+ while (p)
+ {
+ q = p;
+ p = p->next;
+ free (q);
}
- thread_head.head = NULL;
- thread_head.head_pseudo = NULL;
- thread_head.count = 0;
+ thread_head.head = NULL;
+ thread_head.head_pseudo = NULL;
+ thread_head.count = 0;
- p = deleted_threads.head;
- while( p ) {
- q = p;
- p = p->next;
- free( q );
+ p = deleted_threads.head;
+ while (p)
+ {
+ q = p;
+ p = p->next;
+ free (q);
}
- deleted_threads.head = NULL;
- deleted_threads.head_pseudo = NULL;
- deleted_threads.count = 0;
+ deleted_threads.head = NULL;
+ deleted_threads.head_pseudo = NULL;
+ deleted_threads.count = 0;
- /* No threads, so can't have pending events.
- */
- more_events_left = 0;
+ /* No threads, so can't have pending events.
+ */
+ more_events_left = 0;
}
/* Given a tid, find the thread block for it.
*/
static thread_info *
find_thread_info (tid)
- lwpid_t tid;
+ lwpid_t tid;
{
- thread_info *p;
+ thread_info *p;
- for( p = thread_head.head; p; p = p->next ) {
- if( p->tid == tid ) {
- return p;
- }
+ for (p = thread_head.head; p; p = p->next)
+ {
+ if (p->tid == tid)
+ {
+ return p;
+ }
}
- for( p = deleted_threads.head; p; p = p->next ) {
- if( p->tid == tid ) {
- return p;
- }
+ for (p = deleted_threads.head; p; p = p->next)
+ {
+ if (p->tid == tid)
+ {
+ return p;
+ }
}
-
- return NULL;
+
+ return NULL;
}
/* For any but the pseudo thread, this maps to the
* deleted threads. We do the map, but we don't like it.
*/
static lwpid_t
-map_from_gdb_tid( gdb_tid )
- lwpid_t gdb_tid;
+map_from_gdb_tid (gdb_tid)
+ lwpid_t gdb_tid;
{
- thread_info *p;
+ thread_info *p;
- /* First assume gdb_tid really is a tid, and try to find a
- * matching entry on the threads list.
- */
- for( p = thread_head.head; p; p = p->next ) {
- if( p->tid == gdb_tid )
- return gdb_tid;
+ /* First assume gdb_tid really is a tid, and try to find a
+ * matching entry on the threads list.
+ */
+ for (p = thread_head.head; p; p = p->next)
+ {
+ if (p->tid == gdb_tid)
+ return gdb_tid;
}
- /* It doesn't appear to be a tid; perhaps it's really a pid?
- * Try to find a "pseudo" thread entry on the threads list.
- */
- for (p = thread_head.head_pseudo; p != NULL; p = p->next_pseudo)
- {
- if (p->pid == gdb_tid)
- return p->tid;
- }
-
- /* Perhaps it's the tid of a deleted thread we may still
- * have some knowledge of?
- */
- for( p = deleted_threads.head; p; p = p-> next ) {
- if( p->tid == gdb_tid )
- return gdb_tid;
+ /* It doesn't appear to be a tid; perhaps it's really a pid?
+ * Try to find a "pseudo" thread entry on the threads list.
+ */
+ for (p = thread_head.head_pseudo; p != NULL; p = p->next_pseudo)
+ {
+ if (p->pid == gdb_tid)
+ return p->tid;
}
- /* Or perhaps it's the pid of a deleted process we may still
- * have knowledge of?
- */
- for (p = deleted_threads.head_pseudo; p != NULL; p = p->next_pseudo)
- {
- if (p->pid == gdb_tid)
- return p->tid;
- }
+ /* Perhaps it's the tid of a deleted thread we may still
+ * have some knowledge of?
+ */
+ for (p = deleted_threads.head; p; p = p->next)
+ {
+ if (p->tid == gdb_tid)
+ return gdb_tid;
+ }
- return 0; /* Error? */
+ /* Or perhaps it's the pid of a deleted process we may still
+ * have knowledge of?
+ */
+ for (p = deleted_threads.head_pseudo; p != NULL; p = p->next_pseudo)
+ {
+ if (p->pid == gdb_tid)
+ return p->tid;
+ }
+
+ return 0; /* Error? */
}
/* Map the other way: from a real tid to the
* also need to consider deleted threads.
*/
static lwpid_t
-map_to_gdb_tid( real_tid )
- lwpid_t real_tid;
+map_to_gdb_tid (real_tid)
+ lwpid_t real_tid;
{
- thread_info *p;
+ thread_info *p;
- for( p = thread_head.head; p; p = p->next ) {
- if( p->tid == real_tid ) {
- if( p->am_pseudo )
- return p->pid;
- else
- return real_tid;
- }
+ for (p = thread_head.head; p; p = p->next)
+ {
+ if (p->tid == real_tid)
+ {
+ if (p->am_pseudo)
+ return p->pid;
+ else
+ return real_tid;
+ }
}
- for( p = deleted_threads.head; p; p = p-> next ) {
- if( p->tid == real_tid )
- if( p->am_pseudo )
- return p->pid; /* Error? */
- else
- return real_tid;
+ for (p = deleted_threads.head; p; p = p->next)
+ {
+ if (p->tid == real_tid)
+ if (p->am_pseudo)
+ return p->pid; /* Error? */
+ else
+ return real_tid;
}
- return 0; /* Error? Never heard of this thread! */
+ return 0; /* Error? Never heard of this thread! */
}
/* Do any threads have saved signals?
*/
-static int
+static int
saved_signals_exist ()
{
- thread_info *p;
-
- for( p = thread_head.head; p; p = p->next ) {
- if( p->have_signal ) {
- return 1;
- }
+ thread_info *p;
+
+ for (p = thread_head.head; p; p = p->next)
+ {
+ if (p->have_signal)
+ {
+ return 1;
+ }
}
- return 0;
+ return 0;
}
/* Is this the tid for the zero-th thread?
*/
-static int
+static int
is_pseudo_thread (tid)
- lwpid_t tid;
+ lwpid_t tid;
{
- thread_info *p = find_thread_info( tid );
- if( NULL == p || p->terminated )
- return 0;
- else
- return p->am_pseudo;
+ thread_info *p = find_thread_info (tid);
+ if (NULL == p || p->terminated)
+ return 0;
+ else
+ return p->am_pseudo;
}
/* Is this thread terminated?
*/
-static int
+static int
is_terminated (tid)
- lwpid_t tid;
+ lwpid_t tid;
{
- thread_info *p = find_thread_info( tid );
+ thread_info *p = find_thread_info (tid);
- if( NULL != p )
- return p->terminated;
+ if (NULL != p)
+ return p->terminated;
- return 0;
+ return 0;
}
/* Is this pid a real PID or a TID?
*/
-static int
+static int
is_process_id (pid)
- int pid;
+ int pid;
{
- lwpid_t tid;
- thread_info * tinfo;
- pid_t this_pid;
- int this_pid_count;
+ lwpid_t tid;
+ thread_info *tinfo;
+ pid_t this_pid;
+ int this_pid_count;
/* What does PID really represent?
*/
tid = map_from_gdb_tid (pid);
if (tid <= 0)
- return 0; /* Actually, is probably an error... */
+ return 0; /* Actually, is probably an error... */
tinfo = find_thread_info (tid);
/* Does it appear to be a true thread?
*/
- if (! tinfo->am_pseudo)
+ if (!tinfo->am_pseudo)
return 0;
/* Else, it looks like it may be a process. See if there's any other
for (tinfo = thread_head.head; tinfo; tinfo = tinfo->next)
{
if (tinfo->pid == this_pid)
- this_pid_count++;
+ this_pid_count++;
}
return (this_pid_count == 1);
*/
static thread_info *
add_tthread (pid, tid)
- int pid;
- lwpid_t tid;
+ int pid;
+ lwpid_t tid;
{
- thread_info *p;
+ thread_info *p;
- p = find_thread_info( tid );
- if( NULL == p )
- p = create_thread_info( pid, tid );
+ p = find_thread_info (tid);
+ if (NULL == p)
+ p = create_thread_info (pid, tid);
- return p;
+ return p;
}
/* Notice that a thread was deleted.
*/
static void
del_tthread (tid)
- lwpid_t tid;
+ lwpid_t tid;
{
- thread_info *p;
- thread_info *chase;
+ thread_info *p;
+ thread_info *chase;
- if( thread_head.count <= 0 ) {
- error( "Internal error in thread database." );
- return;
+ if (thread_head.count <= 0)
+ {
+ error ("Internal error in thread database.");
+ return;
}
- chase = NULL;
- for( p = thread_head.head; p; p = p->next ) {
- if( p->tid == tid ) {
+ chase = NULL;
+ for (p = thread_head.head; p; p = p->next)
+ {
+ if (p->tid == tid)
+ {
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Delete here: %d \n", tid );
+ if (debug_on)
+ printf ("Delete here: %d \n", tid);
#endif
- if( p->am_pseudo ) {
- /*
- * Deleting a main thread is ok if we're doing
- * a parent-follow on a child; this is odd but
- * not wrong. It apparently _doesn't_ happen
- * on the child-follow, as we don't just delete
- * the pseudo while keeping the rest of the
- * threads around--instead, we clear out the whole
- * thread list at once.
- */
- thread_info *q;
- thread_info *q_chase;
-
- q_chase = NULL;
- for( q = thread_head.head_pseudo; q; q = q -> next ) {
- if( q == p ) {
- /* Remove from pseudo list.
- */
- if( q_chase == NULL )
- thread_head.head_pseudo = p->next_pseudo;
- else
- q_chase-> next = p->next_pseudo;
- }
- else
- q_chase = q;
- }
- }
-
- /* Remove from live list.
- */
- thread_head.count--;
-
- if( NULL == chase )
- thread_head.head = p->next;
- else
- chase->next = p->next;
-
- /* Add to deleted thread list.
- */
- p->next = deleted_threads.head;
- deleted_threads.head = p;
- deleted_threads.count++;
- if( p->am_pseudo ) {
- p->next_pseudo = deleted_threads.head_pseudo;
- deleted_threads.head_pseudo = p;
- }
- p->terminated = 1;
-
- return;
- }
-
- else
- chase = p;
+ if (p->am_pseudo)
+ {
+ /*
+ * Deleting a main thread is ok if we're doing
+ * a parent-follow on a child; this is odd but
+ * not wrong. It apparently _doesn't_ happen
+ * on the child-follow, as we don't just delete
+ * the pseudo while keeping the rest of the
+ * threads around--instead, we clear out the whole
+ * thread list at once.
+ */
+ thread_info *q;
+ thread_info *q_chase;
+
+ q_chase = NULL;
+ for (q = thread_head.head_pseudo; q; q = q->next)
+ {
+ if (q == p)
+ {
+ /* Remove from pseudo list.
+ */
+ if (q_chase == NULL)
+ thread_head.head_pseudo = p->next_pseudo;
+ else
+ q_chase->next = p->next_pseudo;
+ }
+ else
+ q_chase = q;
+ }
+ }
+
+ /* Remove from live list.
+ */
+ thread_head.count--;
+
+ if (NULL == chase)
+ thread_head.head = p->next;
+ else
+ chase->next = p->next;
+
+ /* Add to deleted thread list.
+ */
+ p->next = deleted_threads.head;
+ deleted_threads.head = p;
+ deleted_threads.count++;
+ if (p->am_pseudo)
+ {
+ p->next_pseudo = deleted_threads.head_pseudo;
+ deleted_threads.head_pseudo = p;
+ }
+ p->terminated = 1;
+
+ return;
+ }
+
+ else
+ chase = p;
}
}
*/
static int
get_pid_for (tid)
- lwpid_t tid;
+ lwpid_t tid;
{
- thread_info *p;
+ thread_info *p;
- for( p = thread_head.head; p; p = p->next ) {
- if( p->tid == tid ) {
- return p->pid;
- }
+ for (p = thread_head.head; p; p = p->next)
+ {
+ if (p->tid == tid)
+ {
+ return p->pid;
+ }
}
- for( p = deleted_threads.head; p; p = p->next ) {
- if( p->tid == tid ) {
- return p->pid;
- }
+ for (p = deleted_threads.head; p; p = p->next)
+ {
+ if (p->tid == tid)
+ {
+ return p->pid;
+ }
}
-
- return 0;
+
+ return 0;
}
/* Note that this thread's current event has been handled.
*/
static void
-set_handled( pid, tid )
- int pid;
- lwpid_t tid;
+set_handled (pid, tid)
+ int pid;
+ lwpid_t tid;
{
- thread_info *p;
-
- p = find_thread_info( tid );
- if( NULL == p )
- p = add_tthread( pid, tid );
+ thread_info *p;
+
+ p = find_thread_info (tid);
+ if (NULL == p)
+ p = add_tthread (pid, tid);
- p->handled = 1;
+ p->handled = 1;
}
/* Was this thread's current event handled?
*/
-static int
-was_handled( tid )
- lwpid_t tid;
+static int
+was_handled (tid)
+ lwpid_t tid;
{
- thread_info *p;
-
- p = find_thread_info( tid );
- if( NULL != p )
- return p->handled;
+ thread_info *p;
+
+ p = find_thread_info (tid);
+ if (NULL != p)
+ return p->handled;
- return 0; /* New threads have not been handled */
+ return 0; /* New threads have not been handled */
}
/* Set this thread to unhandled.
*/
static void
-clear_handled( tid )
- lwpid_t tid;
+clear_handled (tid)
+ lwpid_t tid;
{
- thread_info * p;
-
+ thread_info *p;
+
#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "clear_handled %d\n", (int) tid );
+ if (debug_on)
+ printf ("clear_handled %d\n", (int) tid);
#endif
p = find_thread_info (tid);
static void
clear_all_handled ()
{
- thread_info *p;
+ thread_info *p;
#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "clear_all_handled\n" );
+ if (debug_on)
+ printf ("clear_all_handled\n");
#endif
- for( p = thread_head.head; p; p = p->next ) {
- p->handled = 0;
+ for (p = thread_head.head; p; p = p->next)
+ {
+ p->handled = 0;
}
- for( p = deleted_threads.head; p; p = p->next ) {
- p->handled = 0;
+ for (p = deleted_threads.head; p; p = p->next)
+ {
+ p->handled = 0;
}
}
/* Set this thread to default stepping mode.
*/
static void
-clear_stepping_mode( tid )
- lwpid_t tid;
+clear_stepping_mode (tid)
+ lwpid_t tid;
{
- thread_info * p;
-
+ thread_info *p;
+
#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "clear_stepping_mode %d\n", (int) tid );
+ if (debug_on)
+ printf ("clear_stepping_mode %d\n", (int) tid);
#endif
p = find_thread_info (tid);
static void
clear_all_stepping_mode ()
{
- thread_info *p;
+ thread_info *p;
#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "clear_all_stepping_mode\n" );
+ if (debug_on)
+ printf ("clear_all_stepping_mode\n");
#endif
- for( p = thread_head.head; p; p = p->next ) {
- p->stepping_mode = DO_DEFAULT;
+ for (p = thread_head.head; p; p = p->next)
+ {
+ p->stepping_mode = DO_DEFAULT;
}
- for( p = deleted_threads.head; p; p = p->next ) {
- p->stepping_mode = DO_DEFAULT;
+ for (p = deleted_threads.head; p; p = p->next)
+ {
+ p->stepping_mode = DO_DEFAULT;
}
}
/* Set all threads to unseen on this pass.
- */
+ */
static void
set_all_unseen ()
{
- thread_info *p;
+ thread_info *p;
- for( p = thread_head.head; p; p = p->next ) {
- p->seen = 0;
+ for (p = thread_head.head; p; p = p->next)
+ {
+ p->seen = 0;
}
}
*/
static void
print_tthread (p)
- thread_info * p;
+ thread_info *p;
{
- printf( " Thread pid %d, tid %d", p->pid, p->tid );
- if( p->have_state )
- printf( ", event is %s",
- get_printable_name_of_ttrace_event( p->last_stop_state.tts_event ));
-
- if( p->am_pseudo )
- printf( ", pseudo thread" );
-
- if( p->have_signal )
- printf( ", have signal 0x%x", p->signal_value );
-
- if( p->have_start )
- printf( ", have start at 0x%x", p->start );
-
- printf( ", step is %s", get_printable_name_of_stepping_mode( p->stepping_mode ));
-
- if( p->handled )
- printf( ", handled" );
- else
- printf( ", not handled" );
-
- if( p->seen )
- printf( ", seen" );
- else
- printf( ", not seen" );
-
- printf( "\n" );
+ printf (" Thread pid %d, tid %d", p->pid, p->tid);
+ if (p->have_state)
+ printf (", event is %s",
+ get_printable_name_of_ttrace_event (p->last_stop_state.tts_event));
+
+ if (p->am_pseudo)
+ printf (", pseudo thread");
+
+ if (p->have_signal)
+ printf (", have signal 0x%x", p->signal_value);
+
+ if (p->have_start)
+ printf (", have start at 0x%x", p->start);
+
+ printf (", step is %s", get_printable_name_of_stepping_mode (p->stepping_mode));
+
+ if (p->handled)
+ printf (", handled");
+ else
+ printf (", not handled");
+
+ if (p->seen)
+ printf (", seen");
+ else
+ printf (", not seen");
+
+ printf ("\n");
}
static void
print_tthreads ()
{
- thread_info *p;
-
- if( thread_head.count == 0 )
- printf( "Thread list is empty\n" );
- else {
- printf( "Thread list has " );
- if( thread_head.count == 1 )
- printf( "1 entry:\n" );
- else
- printf( "%d entries:\n", thread_head.count );
- for( p = thread_head.head; p; p = p->next ) {
- print_tthread (p);
- }
- }
-
- if( deleted_threads.count == 0 )
- printf( "Deleted thread list is empty\n" );
- else {
- printf( "Deleted thread list has " );
- if( deleted_threads.count == 1 )
- printf( "1 entry:\n" );
- else
- printf( "%d entries:\n", deleted_threads.count );
-
- for( p = deleted_threads.head; p; p = p->next ) {
- print_tthread (p);
- }
+ thread_info *p;
+
+ if (thread_head.count == 0)
+ printf ("Thread list is empty\n");
+ else
+ {
+ printf ("Thread list has ");
+ if (thread_head.count == 1)
+ printf ("1 entry:\n");
+ else
+ printf ("%d entries:\n", thread_head.count);
+ for (p = thread_head.head; p; p = p->next)
+ {
+ print_tthread (p);
+ }
+ }
+
+ if (deleted_threads.count == 0)
+ printf ("Deleted thread list is empty\n");
+ else
+ {
+ printf ("Deleted thread list has ");
+ if (deleted_threads.count == 1)
+ printf ("1 entry:\n");
+ else
+ printf ("%d entries:\n", deleted_threads.count);
+
+ for (p = deleted_threads.head; p; p = p->next)
+ {
+ print_tthread (p);
+ }
}
}
#endif
static void
update_thread_list ()
{
- thread_info *p;
- thread_info *chase;
+ thread_info *p;
+ thread_info *chase;
- chase = NULL;
- for( p = thread_head.head; p; p = p->next ) {
+ chase = NULL;
+ for (p = thread_head.head; p; p = p->next)
+ {
/* Is this an "unseen" thread which really happens to be a process?
If so, is it inferior_pid and is a vfork in flight? If yes to
all, then DON'T REMOVE IT! We're in the midst of moving a vfork
can touch the parent again. We've most likely stopped to examine
the child at a late stage in the vfork, and if we're not following
the child, we'd best not treat the parent as a dead "thread"...
- */
- if( (!p->seen) && p->am_pseudo && vfork_in_flight
- && (p->pid != vforking_child_pid))
- p->seen = 1;
+ */
+ if ((!p->seen) && p->am_pseudo && vfork_in_flight
+ && (p->pid != vforking_child_pid))
+ p->seen = 1;
- if( !p->seen ) {
- /* Remove this one
- */
+ if (!p->seen)
+ {
+ /* Remove this one
+ */
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Delete unseen thread: %d \n", p->tid );
+ if (debug_on)
+ printf ("Delete unseen thread: %d \n", p->tid);
#endif
- del_tthread( p->tid );
- }
+ del_tthread (p->tid);
+ }
}
}
-
-
\f
+
+
/************************************************
* O/S call wrappers *
************************************************
* No other "raw" calls to ttrace should exist in this module.
*/
static int
-call_real_ttrace( request, pid, tid, addr, data, addr2 )
- ttreq_t request;
- pid_t pid;
- lwpid_t tid;
- TTRACE_ARG_TYPE addr, data, addr2;
+call_real_ttrace (request, pid, tid, addr, data, addr2)
+ ttreq_t request;
+ pid_t pid;
+ lwpid_t tid;
+ TTRACE_ARG_TYPE addr, data, addr2;
{
- int tt_status;
+ int tt_status;
errno = 0;
- tt_status = ttrace( request, pid, tid, addr, data, addr2 );
+ tt_status = ttrace (request, pid, tid, addr, data, addr2);
#ifdef THREAD_DEBUG
- if (errno) {
- /* Don't bother for a known benign error: if you ask for the
- * first thread state, but there is only one thread and it's
- * not stopped, ttrace complains.
- *
- * We have this inside the #ifdef because our caller will do
- * this check for real.
- */
- if( request != TT_PROC_GET_FIRST_LWP_STATE
- || errno != EPROTO ) {
- if( debug_on )
- printf( "TT fail for %s, with pid %d, tid %d, status %d \n",
- get_printable_name_of_ttrace_request (request),
- pid, tid, tt_status );
+ if (errno)
+ {
+ /* Don't bother for a known benign error: if you ask for the
+ * first thread state, but there is only one thread and it's
+ * not stopped, ttrace complains.
+ *
+ * We have this inside the #ifdef because our caller will do
+ * this check for real.
+ */
+ if (request != TT_PROC_GET_FIRST_LWP_STATE
+ || errno != EPROTO)
+ {
+ if (debug_on)
+ printf ("TT fail for %s, with pid %d, tid %d, status %d \n",
+ get_printable_name_of_ttrace_request (request),
+ pid, tid, tt_status);
+ }
}
- }
#endif
#if 0
* failed requests here. However, some clients of this interface
* seem to expect to catch & deal with them, so we'd best not.
*/
- if (errno) {
- strcpy (reason_for_failure, "ttrace (");
- strcat (reason_for_failure, get_printable_name_of_ttrace_request (request));
- strcat (reason_for_failure, ")");
- printf( "ttrace error, errno = %d\n", errno );
- perror_with_name (reason_for_failure);
- }
+ if (errno)
+ {
+ strcpy (reason_for_failure, "ttrace (");
+ strcat (reason_for_failure, get_printable_name_of_ttrace_request (request));
+ strcat (reason_for_failure, ")");
+ printf ("ttrace error, errno = %d\n", errno);
+ perror_with_name (reason_for_failure);
+ }
#endif
return tt_status;
}
-
\f
+
/* This function simply calls ttrace_wait with the given arguments.
* It exists so that all calls to ttrace_wait are isolated.
*
* No "raw" calls to ttrace_wait should exist elsewhere.
*/
static int
-call_real_ttrace_wait( pid, tid, option, tsp, tsp_size )
- int pid;
- lwpid_t tid;
- ttwopt_t option;
- ttstate_t *tsp;
- size_t tsp_size;
+call_real_ttrace_wait (pid, tid, option, tsp, tsp_size)
+ int pid;
+ lwpid_t tid;
+ ttwopt_t option;
+ ttstate_t *tsp;
+ size_t tsp_size;
{
- int ttw_status;
- thread_info * tinfo = NULL;
+ int ttw_status;
+ thread_info *tinfo = NULL;
errno = 0;
ttw_status = ttrace_wait (pid, tid, option, tsp, tsp_size);
-
- if (errno) {
+
+ if (errno)
+ {
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "TW fail with pid %d, tid %d \n", pid, tid );
+ if (debug_on)
+ printf ("TW fail with pid %d, tid %d \n", pid, tid);
#endif
perror_with_name ("ttrace wait");
- }
+ }
return ttw_status;
}
-
\f
+
/* A process may have one or more kernel threads, of which all or
none may be stopped. This function returns the ID of the first
kernel thread in a stopped state, or 0 if none are stopped.
*/
static lwpid_t
get_process_first_stopped_thread_id (pid, thread_state)
- int pid;
- ttstate_t * thread_state;
+ int pid;
+ ttstate_t *thread_state;
{
- int tt_status;
+ int tt_status;
tt_status = call_real_ttrace (
- TT_PROC_GET_FIRST_LWP_STATE,
- (pid_t) pid,
- (lwpid_t) TT_NIL,
- (TTRACE_ARG_TYPE) thread_state,
- (TTRACE_ARG_TYPE) sizeof (*thread_state),
- TT_NIL);
-
- if (errno) {
- if( errno == EPROTO) {
- /* This is an error we can handle: there isn't any stopped
- * thread. This happens when we're re-starting the application
- * and it has only one thread. GET_NEXT handles the case of
- * no more stopped threads well; GET_FIRST doesn't. (A ttrace
- * "feature".)
- */
- tt_status = 1;
- errno = 0;
- return 0;
- }
- else
- perror_with_name ("ttrace");
- }
-
- if( tt_status < 0 )
+ TT_PROC_GET_FIRST_LWP_STATE,
+ (pid_t) pid,
+ (lwpid_t) TT_NIL,
+ (TTRACE_ARG_TYPE) thread_state,
+ (TTRACE_ARG_TYPE) sizeof (*thread_state),
+ TT_NIL);
+
+ if (errno)
+ {
+ if (errno == EPROTO)
+ {
+ /* This is an error we can handle: there isn't any stopped
+ * thread. This happens when we're re-starting the application
+ * and it has only one thread. GET_NEXT handles the case of
+ * no more stopped threads well; GET_FIRST doesn't. (A ttrace
+ * "feature".)
+ */
+ tt_status = 1;
+ errno = 0;
+ return 0;
+ }
+ else
+ perror_with_name ("ttrace");
+ }
+
+ if (tt_status < 0)
/* Failed somehow.
*/
return 0;
return thread_state->tts_lwpid;
}
-
\f
+
/* This function returns the ID of the "next" kernel thread in a
stopped state, or 0 if there are none. "Next" refers to the
thread following that of the last successful call to this
*/
static lwpid_t
get_process_next_stopped_thread_id (pid, thread_state)
- int pid;
- ttstate_t * thread_state;
+ int pid;
+ ttstate_t *thread_state;
{
- int tt_status;
+ int tt_status;
tt_status = call_real_ttrace (
- TT_PROC_GET_NEXT_LWP_STATE,
- (pid_t) pid,
- (lwpid_t) TT_NIL,
- (TTRACE_ARG_TYPE) thread_state,
- (TTRACE_ARG_TYPE) sizeof (*thread_state),
- TT_NIL);
+ TT_PROC_GET_NEXT_LWP_STATE,
+ (pid_t) pid,
+ (lwpid_t) TT_NIL,
+ (TTRACE_ARG_TYPE) thread_state,
+ (TTRACE_ARG_TYPE) sizeof (*thread_state),
+ TT_NIL);
if (errno)
perror_with_name ("ttrace");
*/
return 0;
- else if( tt_status == 0 ) {
- /* End of list, no next state. Don't return the
- * tts_lwpid, as it's a meaningless "240".
- *
- * This is an HPUX "feature".
- */
- return 0;
- }
-
+ else if (tt_status == 0)
+ {
+ /* End of list, no next state. Don't return the
+ * tts_lwpid, as it's a meaningless "240".
+ *
+ * This is an HPUX "feature".
+ */
+ return 0;
+ }
+
return thread_state->tts_lwpid;
}
*/
static lwpid_t
get_active_tid_of_pid (pid)
- int pid;
+ int pid;
{
- ttstate_t thread_state;
+ ttstate_t thread_state;
return get_process_first_stopped_thread_id (pid, &thread_state);
}
*/
int
is_process_ttrace_request (tt_request)
- ttreq_t tt_request;
+ ttreq_t tt_request;
{
return IS_TTRACE_PROCREQ (tt_request);
}
-
\f
+
/* This function translates a thread ttrace request into
* the equivalent process request for a one-thread process.
*/
static ttreq_t
-make_process_version( request )
- ttreq_t request;
+make_process_version (request)
+ ttreq_t request;
{
- if (!IS_TTRACE_REQ (request)) {
- error( "Internal error, bad ttrace request made\n" );
- return -1;
- }
+ if (!IS_TTRACE_REQ (request))
+ {
+ error ("Internal error, bad ttrace request made\n");
+ return -1;
+ }
- switch (request) {
- case TT_LWP_STOP :
+ switch (request)
+ {
+ case TT_LWP_STOP:
return TT_PROC_STOP;
- case TT_LWP_CONTINUE :
+ case TT_LWP_CONTINUE:
return TT_PROC_CONTINUE;
- case TT_LWP_GET_EVENT_MASK :
+ case TT_LWP_GET_EVENT_MASK:
return TT_PROC_GET_EVENT_MASK;
- case TT_LWP_SET_EVENT_MASK :
+ case TT_LWP_SET_EVENT_MASK:
return TT_PROC_SET_EVENT_MASK;
- case TT_LWP_SINGLE :
- case TT_LWP_RUREGS :
- case TT_LWP_WUREGS :
- case TT_LWP_GET_STATE :
- return -1; /* No equivalent */
+ case TT_LWP_SINGLE:
+ case TT_LWP_RUREGS:
+ case TT_LWP_WUREGS:
+ case TT_LWP_GET_STATE:
+ return -1; /* No equivalent */
- default :
+ default:
return request;
- }
+ }
}
-
\f
+
/* This function translates the "pid" used by the rest of
* gdb to a real pid and a tid. It then calls "call_real_ttrace"
* with the given arguments.
* reasons).
*/
static int
-call_ttrace( request, gdb_tid, addr, data, addr2 )
- ttreq_t request;
- int gdb_tid;
- TTRACE_ARG_TYPE addr, data, addr2;
+call_ttrace (request, gdb_tid, addr, data, addr2)
+ ttreq_t request;
+ int gdb_tid;
+ TTRACE_ARG_TYPE addr, data, addr2;
{
- lwpid_t real_tid;
- int real_pid;
- ttreq_t new_request;
- int tt_status;
- char reason_for_failure [100]; /* Arbitrary size, should be big enough. */
-
+ lwpid_t real_tid;
+ int real_pid;
+ ttreq_t new_request;
+ int tt_status;
+ char reason_for_failure[100]; /* Arbitrary size, should be big enough. */
+
#ifdef THREAD_DEBUG
- int is_interesting = 0;
+ int is_interesting = 0;
- if( TT_LWP_RUREGS == request ) {
- is_interesting = 1; /* Adjust code here as desired */
- }
-
- if( is_interesting && 0 && debug_on ) {
- if( !is_process_ttrace_request( request )) {
- printf( "TT: Thread request, tid is %d", gdb_tid );
- printf( "== SINGLE at %x", addr );
- }
- else {
- printf( "TT: Process request, tid is %d\n", gdb_tid );
- printf( "==! SINGLE at %x", addr );
- }
- }
+ if (TT_LWP_RUREGS == request)
+ {
+ is_interesting = 1; /* Adjust code here as desired */
+ }
+
+ if (is_interesting && 0 && debug_on)
+ {
+ if (!is_process_ttrace_request (request))
+ {
+ printf ("TT: Thread request, tid is %d", gdb_tid);
+ printf ("== SINGLE at %x", addr);
+ }
+ else
+ {
+ printf ("TT: Process request, tid is %d\n", gdb_tid);
+ printf ("==! SINGLE at %x", addr);
+ }
+ }
#endif
/* The initial SETTRC and SET_EVENT_MASK calls (and all others
* rule them out....
*/
#ifdef THREAD_DEBUG
- if( request == TT_PROC_SETTRC && debug_on )
- printf( "Unexpected call for TT_PROC_SETTRC\n" );
+ if (request == TT_PROC_SETTRC && debug_on)
+ printf ("Unexpected call for TT_PROC_SETTRC\n");
#endif
/* Sometimes we get called with a bogus tid (e.g., if a
* thread has terminated, we return 0; inftarg later asks
* whether the thread has exited/forked/vforked).
*/
- if( gdb_tid == 0 )
+ if (gdb_tid == 0)
{
- errno = ESRCH; /* ttrace's response would probably be "No such process". */
+ errno = ESRCH; /* ttrace's response would probably be "No such process". */
return -1;
}
/* All other cases should be able to expect that there are
* thread records.
*/
- if( !any_thread_records()) {
+ if (!any_thread_records ())
+ {
#ifdef THREAD_DEBUG
- if( debug_on )
- warning ("No thread records for ttrace call");
+ if (debug_on)
+ warning ("No thread records for ttrace call");
#endif
- errno = ESRCH; /* ttrace's response would be "No such process". */
+ errno = ESRCH; /* ttrace's response would be "No such process". */
return -1;
- }
+ }
/* OK, now the task is to translate the incoming tid into
* a pid/tid pair.
*/
- real_tid = map_from_gdb_tid( gdb_tid );
- real_pid = get_pid_for( real_tid );
+ real_tid = map_from_gdb_tid (gdb_tid);
+ real_pid = get_pid_for (real_tid);
/* Now check the result. "Real_pid" is NULL if our list
* didn't find it. We have some tricks we can play to fix
* this, however.
*/
- if( 0 == real_pid ) {
- ttstate_t thread_state;
+ if (0 == real_pid)
+ {
+ ttstate_t thread_state;
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "No saved pid for tid %d\n", gdb_tid );
+ if (debug_on)
+ printf ("No saved pid for tid %d\n", gdb_tid);
#endif
- if( is_process_ttrace_request( request )) {
-
- /* Ok, we couldn't get a tid. Try to translate to
- * the equivalent process operation. We expect this
- * NOT to happen, so this is a desparation-type
- * move. It can happen if there is an internal
- * error and so no "wait()" call is ever done.
- */
- new_request = make_process_version( request );
- if( new_request == -1 ) {
-
+ if (is_process_ttrace_request (request))
+ {
+
+ /* Ok, we couldn't get a tid. Try to translate to
+ * the equivalent process operation. We expect this
+ * NOT to happen, so this is a desparation-type
+ * move. It can happen if there is an internal
+ * error and so no "wait()" call is ever done.
+ */
+ new_request = make_process_version (request);
+ if (new_request == -1)
+ {
+
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "...and couldn't make process version of thread operation\n" );
+ if (debug_on)
+ printf ("...and couldn't make process version of thread operation\n");
#endif
- /* Use hacky saved pid, which won't always be correct
- * in the multi-process future. Use tid as thread,
- * probably dooming this to failure. FIX!
- */
- if( saved_real_pid != 0 ) {
+ /* Use hacky saved pid, which won't always be correct
+ * in the multi-process future. Use tid as thread,
+ * probably dooming this to failure. FIX!
+ */
+ if (saved_real_pid != 0)
+ {
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "...using saved pid %d\n", saved_real_pid );
+ if (debug_on)
+ printf ("...using saved pid %d\n", saved_real_pid);
#endif
- real_pid = saved_real_pid;
- real_tid = gdb_tid;
- }
+ real_pid = saved_real_pid;
+ real_tid = gdb_tid;
+ }
- else
- error( "Unable to perform thread operation" );
- }
+ else
+ error ("Unable to perform thread operation");
+ }
- else {
- /* Sucessfully translated this to a process request,
- * which needs no thread value.
- */
- real_pid = gdb_tid;
- real_tid = 0;
- request = new_request;
+ else
+ {
+ /* Sucessfully translated this to a process request,
+ * which needs no thread value.
+ */
+ real_pid = gdb_tid;
+ real_tid = 0;
+ request = new_request;
#ifdef THREAD_DEBUG
- if( debug_on ) {
- printf( "Translated thread request to process request\n" );
- if( saved_real_pid == 0 )
- printf( "...but there's no saved pid\n" );
-
- else {
- if( gdb_tid != saved_real_pid )
- printf( "...but have the wrong pid (%d rather than %d)\n",
- gdb_tid, saved_real_pid );
- }
- }
+ if (debug_on)
+ {
+ printf ("Translated thread request to process request\n");
+ if (saved_real_pid == 0)
+ printf ("...but there's no saved pid\n");
+
+ else
+ {
+ if (gdb_tid != saved_real_pid)
+ printf ("...but have the wrong pid (%d rather than %d)\n",
+ gdb_tid, saved_real_pid);
+ }
+ }
#endif
- } /* Translated to a process request */
- } /* Is a process request */
+ } /* Translated to a process request */
+ } /* Is a process request */
- else {
- /* We have to have a thread. Ooops.
- */
- error( "Thread request with no threads (%s)",
- get_printable_name_of_ttrace_request( request ));
+ else
+ {
+ /* We have to have a thread. Ooops.
+ */
+ error ("Thread request with no threads (%s)",
+ get_printable_name_of_ttrace_request (request));
+ }
}
- }
/* Ttrace doesn't like to see tid values on process requests,
* even if we have the right one.
*/
- if (is_process_ttrace_request (request)) {
+ if (is_process_ttrace_request (request))
+ {
real_tid = 0;
- }
-
+ }
+
#ifdef THREAD_DEBUG
- if( is_interesting && 0 && debug_on ) {
- printf( " now tid %d, pid %d\n", real_tid, real_pid );
- printf( " request is %s\n", get_printable_name_of_ttrace_request (request));
- }
+ if (is_interesting && 0 && debug_on)
+ {
+ printf (" now tid %d, pid %d\n", real_tid, real_pid);
+ printf (" request is %s\n", get_printable_name_of_ttrace_request (request));
+ }
#endif
/* Finally, the (almost) real call.
tt_status = call_real_ttrace (request, real_pid, real_tid, addr, data, addr2);
#ifdef THREAD_DEBUG
- if(is_interesting && debug_on ) {
- if( !TT_OK( tt_status, errno )
- && !(tt_status == 0 & errno == 0))
- printf( " got error (errno==%d, status==%d)\n", errno, tt_status );
- }
+ if (is_interesting && debug_on)
+ {
+ if (!TT_OK (tt_status, errno)
+ && !(tt_status == 0 & errno == 0))
+ printf (" got error (errno==%d, status==%d)\n", errno, tt_status);
+ }
#endif
return tt_status;
/* Stop all the threads of a process.
- *
+
* NOTE: use of TT_PROC_STOP can cause a thread with a real event
* to get a TTEVT_NONE event, discarding the old event. Be
* very careful, and only call TT_PROC_STOP when you mean it!
*/
static void
-stop_all_threads_of_process( real_pid )
- pid_t real_pid;
+stop_all_threads_of_process (real_pid)
+ pid_t real_pid;
{
- int ttw_status;
+ int ttw_status;
ttw_status = call_real_ttrace (TT_PROC_STOP,
- (pid_t) real_pid,
- (lwpid_t) TT_NIL,
- (TTRACE_ARG_TYPE) TT_NIL,
- (TTRACE_ARG_TYPE) TT_NIL,
- TT_NIL );
+ (pid_t) real_pid,
+ (lwpid_t) TT_NIL,
+ (TTRACE_ARG_TYPE) TT_NIL,
+ (TTRACE_ARG_TYPE) TT_NIL,
+ TT_NIL);
if (errno)
perror_with_name ("ttrace stop of other threads");
}
This function returns 1 if this stopped process, and the event that
we're told was responsible for its current stopped state, cannot safely
have its threads examined.
- */
+ */
#define CHILD_VFORKED(evt,pid) \
(((evt) == TTEVT_VFORK) && ((pid) != inferior_pid))
#define CHILD_URPED(evt,pid) \
static int
can_touch_threads_of_process (pid, stopping_event)
- int pid;
- ttevents_t stopping_event;
+ int pid;
+ ttevents_t stopping_event;
{
if (CHILD_VFORKED (stopping_event, pid))
{
}
else if (vfork_in_flight &&
- (PARENT_VFORKED (stopping_event, pid) ||
- CHILD_URPED (stopping_event, pid)))
+ (PARENT_VFORKED (stopping_event, pid) ||
+ CHILD_URPED (stopping_event, pid)))
{
vfork_in_flight = 0;
vforking_child_pid = 0;
}
- return ! vfork_in_flight;
+ return !vfork_in_flight;
}
* If this function is used when the threads of PIS haven't
* been stopped, undefined behaviour is guaranteed!
*/
-static int
+static int
select_stopped_thread_of_process (pid, tsp)
- int pid;
- ttstate_t * tsp;
+ int pid;
+ ttstate_t *tsp;
{
- lwpid_t candidate_tid, tid;
- ttstate_t candidate_tstate, tstate;
+ lwpid_t candidate_tid, tid;
+ ttstate_t candidate_tstate, tstate;
/* If we're not allowed to touch the process now, then just
* return the current value of *TSP.
* This supports "vfork". It's ok, really, to double the
* current event (the child EXEC, we hope!).
*/
- if (! can_touch_threads_of_process (pid, tsp->tts_event))
+ if (!can_touch_threads_of_process (pid, tsp->tts_event))
return 1;
/* Decide which of (possibly more than one) events to
* an artifact of our "stop the world" model--the thread is
* stopped because we stopped it.
*/
- if (tstate.tts_event == TTEVT_NONE) {
- set_handled( pid, tstate.tts_lwpid );
- }
+ if (tstate.tts_event == TTEVT_NONE)
+ {
+ set_handled (pid, tstate.tts_lwpid);
+ }
/* Did we just single-step a single thread, without letting any
* of the others run? Is this an event for that thread?
* checking for what all threads are doing.)
*/
else if (doing_fake_step && (tstate.tts_lwpid == fake_step_tid))
- {
+ {
#ifdef WAIT_BUFFER_DEBUG
- /* It's possible here to see either a SIGTRAP (due to
- * successful completion of a step) or a SYSCALL_ENTRY
- * (due to a step completion with active hardware
- * watchpoints).
- */
- if( debug_on )
- printf( "Ending fake step with tid %d, state %s\n",
- tstate.tts_lwpid,
- get_printable_name_of_ttrace_event( tstate.tts_event ));
-#endif
-
- /* Remember this one, and throw away any previous
- * candidate.
- */
- candidate_tid = tstate.tts_lwpid;
- candidate_tstate = tstate;
- }
+ /* It's possible here to see either a SIGTRAP (due to
+ * successful completion of a step) or a SYSCALL_ENTRY
+ * (due to a step completion with active hardware
+ * watchpoints).
+ */
+ if (debug_on)
+ printf ("Ending fake step with tid %d, state %s\n",
+ tstate.tts_lwpid,
+ get_printable_name_of_ttrace_event (tstate.tts_event));
+#endif
+
+ /* Remember this one, and throw away any previous
+ * candidate.
+ */
+ candidate_tid = tstate.tts_lwpid;
+ candidate_tstate = tstate;
+ }
#ifdef FORGET_DELETED_BPTS
* But it has to go in the buffering code, not in the
* real go/wait code.
*/
- else if( (TTEVT_SIGNAL == tstate.tts_event)
- && (5 == tstate.tts_u.tts_signal.tts_signo)
- && (0 != get_raw_pc( tstate.tts_lwpid ))
- && ! breakpoint_here_p( get_raw_pc( tstate.tts_lwpid )) ) {
- /*
- * If the user deleted a breakpoint while this
- * breakpoint-hit event was buffered, we can forget
- * it now.
- */
+ else if ((TTEVT_SIGNAL == tstate.tts_event)
+ && (5 == tstate.tts_u.tts_signal.tts_signo)
+ && (0 != get_raw_pc (tstate.tts_lwpid))
+ && !breakpoint_here_p (get_raw_pc (tstate.tts_lwpid)))
+ {
+ /*
+ * If the user deleted a breakpoint while this
+ * breakpoint-hit event was buffered, we can forget
+ * it now.
+ */
#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "Forgetting deleted bp hit for thread %d\n",
- tstate.tts_lwpid );
-#endif
+ if (debug_on)
+ printf ("Forgetting deleted bp hit for thread %d\n",
+ tstate.tts_lwpid);
+#endif
- set_handled( pid, tstate.tts_lwpid );
- }
+ set_handled (pid, tstate.tts_lwpid);
+ }
#endif
/* Else, is this the first "unhandled" event? If so,
* we believe our client wants to see it (if we don't
* see a fake-step later on in the scan).
*/
- else if( !was_handled( tstate.tts_lwpid ) && candidate_tid == 0 ) {
- candidate_tid = tstate.tts_lwpid;
- candidate_tstate = tstate;
- }
+ else if (!was_handled (tstate.tts_lwpid) && candidate_tid == 0)
+ {
+ candidate_tid = tstate.tts_lwpid;
+ candidate_tstate = tstate;
+ }
/* This is either an event that has already been "handled",
* and thus we believe is uninteresting to our client, or we
/* What do we report?
*/
- if( doing_fake_step ) {
- if( candidate_tid == fake_step_tid ) {
- /* Fake step.
- */
- tstate = candidate_tstate;
- }
- else {
- warning( "Internal error: fake-step failed to complete." );
- return 0;
- }
- }
- else if( candidate_tid != 0 ) {
+ if (doing_fake_step)
+ {
+ if (candidate_tid == fake_step_tid)
+ {
+ /* Fake step.
+ */
+ tstate = candidate_tstate;
+ }
+ else
+ {
+ warning ("Internal error: fake-step failed to complete.");
+ return 0;
+ }
+ }
+ else if (candidate_tid != 0)
+ {
/* Found a candidate unhandled event.
*/
tstate = candidate_tstate;
- }
- else if( tid != 0 ) {
- warning( "Internal error in call of ttrace_wait." );
+ }
+ else if (tid != 0)
+ {
+ warning ("Internal error in call of ttrace_wait.");
return 0;
- }
- else {
+ }
+ else
+ {
warning ("Internal error: no unhandled thread event to select");
return 0;
- }
+ }
copy_ttstate_t (tsp, &tstate);
return 1;
-} /* End of select_stopped_thread_of_process */
+} /* End of select_stopped_thread_of_process */
#ifdef PARANOIA
/* Check our internal thread data against the real thing.
*/
static void
-check_thread_consistency( real_pid )
- pid_t real_pid;
+check_thread_consistency (real_pid)
+ pid_t real_pid;
{
- int tid; /* really lwpid_t */
- ttstate_t tstate;
- thread_info *p;
+ int tid; /* really lwpid_t */
+ ttstate_t tstate;
+ thread_info *p;
- /* Spin down the O/S list of threads, checking that they
- * match what we've got.
- */
- for (tid = get_process_first_stopped_thread_id( real_pid, &tstate );
- tid != 0;
- tid = get_process_next_stopped_thread_id( real_pid, &tstate )) {
-
- p = find_thread_info( tid );
-
- if( NULL == p ) {
- warning( "No internal thread data for thread %d.", tid );
- continue;
- }
+ /* Spin down the O/S list of threads, checking that they
+ * match what we've got.
+ */
+ for (tid = get_process_first_stopped_thread_id (real_pid, &tstate);
+ tid != 0;
+ tid = get_process_next_stopped_thread_id (real_pid, &tstate))
+ {
- if( !p->seen ) {
- warning( "Inconsistent internal thread data for thread %d.", tid );
- }
+ p = find_thread_info (tid);
- if( p->terminated ) {
- warning( "Thread %d is not terminated, internal error.", tid );
- continue;
- }
+ if (NULL == p)
+ {
+ warning ("No internal thread data for thread %d.", tid);
+ continue;
+ }
+
+ if (!p->seen)
+ {
+ warning ("Inconsistent internal thread data for thread %d.", tid);
+ }
+
+ if (p->terminated)
+ {
+ warning ("Thread %d is not terminated, internal error.", tid);
+ continue;
+ }
#define TT_COMPARE( fld ) \
tstate.fld != p->last_stop_state.fld
-
- if( p->have_state ) {
- if( TT_COMPARE( tts_pid )
- || TT_COMPARE( tts_lwpid )
- || TT_COMPARE( tts_user_tid )
- || TT_COMPARE( tts_event )
- || TT_COMPARE( tts_flags )
- || TT_COMPARE( tts_scno )
- || TT_COMPARE( tts_scnargs )) {
- warning( "Internal thread data for thread %d is wrong.", tid );
- continue;
- }
- }
+
+ if (p->have_state)
+ {
+ if (TT_COMPARE (tts_pid)
+ || TT_COMPARE (tts_lwpid)
+ || TT_COMPARE (tts_user_tid)
+ || TT_COMPARE (tts_event)
+ || TT_COMPARE (tts_flags)
+ || TT_COMPARE (tts_scno)
+ || TT_COMPARE (tts_scnargs))
+ {
+ warning ("Internal thread data for thread %d is wrong.", tid);
+ continue;
+ }
+ }
}
}
-#endif /* PARANOIA */
-
+#endif /* PARANOIA */
\f
+
/* This function wraps calls to "call_real_ttrace_wait" so
* that a actual wait is only done when all pending events
* have been reported.
* Return value is the status of the pseudo wait.
*/
static int
-call_ttrace_wait( pid, option, tsp, tsp_size )
- int pid;
- ttwopt_t option;
- ttstate_t *tsp;
- size_t tsp_size;
+call_ttrace_wait (pid, option, tsp, tsp_size)
+ int pid;
+ ttwopt_t option;
+ ttstate_t *tsp;
+ size_t tsp_size;
{
/* This holds the actual, for-real, true process ID.
*/
* means "Any process", and zero tid means
* "Any thread of the specified process".
*/
- int wait_pid = 0;
- lwpid_t wait_tid = 0;
- lwpid_t real_tid;
+ int wait_pid = 0;
+ lwpid_t wait_tid = 0;
+ lwpid_t real_tid;
- int ttw_status = 0; /* To be returned */
+ int ttw_status = 0; /* To be returned */
- thread_info * tinfo = NULL;
+ thread_info *tinfo = NULL;
- if( pid != 0 ) {
+ if (pid != 0)
+ {
/* Unexpected case.
*/
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "TW: Pid to wait on is %d\n", pid );
+ if (debug_on)
+ printf ("TW: Pid to wait on is %d\n", pid);
#endif
- if( !any_thread_records())
- error( "No thread records for ttrace call w. specific pid" );
+ if (!any_thread_records ())
+ error ("No thread records for ttrace call w. specific pid");
/* OK, now the task is to translate the incoming tid into
* a pid/tid pair.
*/
- real_tid = map_from_gdb_tid( pid );
- real_pid = get_pid_for( real_tid );
+ real_tid = map_from_gdb_tid (pid);
+ real_pid = get_pid_for (real_tid);
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "==TW: real pid %d, real tid %d\n", real_pid, real_tid );
+ if (debug_on)
+ printf ("==TW: real pid %d, real tid %d\n", real_pid, real_tid);
#endif
- }
+ }
/* Sanity checks and set-up.
* Buffered events | debuffer error wait debuffer (?)
*
*/
- if( more_events_left == 0 ) {
-
- if( process_state == RUNNING ) {
- /* OK--normal call of ttrace_wait with no buffered events.
- */
- ;
- }
- else if( process_state == FAKE_STEPPING ) {
- /* Ok--call of ttrace_wait to support
- * fake stepping with no buffered events.
- *
- * But we better be fake-stepping!
- */
- if( !doing_fake_step ) {
- warning( "Inconsistent thread state." );
- }
- }
- else if( (process_state == FORKING)
- || (process_state == VFORKING)) {
- /* Ok--there are two processes, so waiting
- * for the second while the first is stopped
- * is ok. Handled bits stay as they were.
- */
- ;
- }
- else if( process_state == STOPPED ) {
- warning( "Process not running at wait call." );
- }
+ if (more_events_left == 0)
+ {
+
+ if (process_state == RUNNING)
+ {
+ /* OK--normal call of ttrace_wait with no buffered events.
+ */
+ ;
+ }
+ else if (process_state == FAKE_STEPPING)
+ {
+ /* Ok--call of ttrace_wait to support
+ * fake stepping with no buffered events.
+ *
+ * But we better be fake-stepping!
+ */
+ if (!doing_fake_step)
+ {
+ warning ("Inconsistent thread state.");
+ }
+ }
+ else if ((process_state == FORKING)
+ || (process_state == VFORKING))
+ {
+ /* Ok--there are two processes, so waiting
+ * for the second while the first is stopped
+ * is ok. Handled bits stay as they were.
+ */
+ ;
+ }
+ else if (process_state == STOPPED)
+ {
+ warning ("Process not running at wait call.");
+ }
else
- /* No known state.
- */
- warning( "Inconsistent process state." );
- }
-
- else {
+ /* No known state.
+ */
+ warning ("Inconsistent process state.");
+ }
+
+ else
+ {
/* More events left
*/
- if( process_state == STOPPED ) {
- /* OK--buffered events being unbuffered.
- */
- ;
- }
- else if( process_state == RUNNING ) {
- /* An error--shouldn't have buffered events
- * when running.
- */
- warning( "Trying to continue with buffered events:" );
- }
- else if( process_state == FAKE_STEPPING ) {
- /*
- * Better be fake-stepping!
- */
- if( !doing_fake_step ) {
- warning( "Losing buffered thread events!\n" );
- }
- }
- else if( (process_state == FORKING)
- || (process_state == VFORKING)) {
- /* Ok--there are two processes, so waiting
- * for the second while the first is stopped
- * is ok. Handled bits stay as they were.
- */
- ;
- }
+ if (process_state == STOPPED)
+ {
+ /* OK--buffered events being unbuffered.
+ */
+ ;
+ }
+ else if (process_state == RUNNING)
+ {
+ /* An error--shouldn't have buffered events
+ * when running.
+ */
+ warning ("Trying to continue with buffered events:");
+ }
+ else if (process_state == FAKE_STEPPING)
+ {
+ /*
+ * Better be fake-stepping!
+ */
+ if (!doing_fake_step)
+ {
+ warning ("Losing buffered thread events!\n");
+ }
+ }
+ else if ((process_state == FORKING)
+ || (process_state == VFORKING))
+ {
+ /* Ok--there are two processes, so waiting
+ * for the second while the first is stopped
+ * is ok. Handled bits stay as they were.
+ */
+ ;
+ }
else
- warning( "Process in unknown state with buffered events." );
- }
+ warning ("Process in unknown state with buffered events.");
+ }
/* Sometimes we have to wait for a particular thread
* (if we're stepping over a bpt). In that case, we
* certain very well-understood circumstances), so it
* can't block.
*/
- if( doing_fake_step ) {
+ if (doing_fake_step)
+ {
wait_tid = fake_step_tid;
- wait_pid = get_pid_for( fake_step_tid );
+ wait_pid = get_pid_for (fake_step_tid);
#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "Doing a wait after a fake-step for %d, pid %d\n",
- wait_tid, wait_pid );
+ if (debug_on)
+ printf ("Doing a wait after a fake-step for %d, pid %d\n",
+ wait_tid, wait_pid);
#endif
- }
+ }
- if( more_events_left == 0 /* No buffered events, need real ones. */
- || process_state != STOPPED ) {
+ if (more_events_left == 0 /* No buffered events, need real ones. */
+ || process_state != STOPPED)
+ {
/* If there are no buffered events, and so we need
* real ones, or if we are FORKING, VFORKING,
* FAKE_STEPPING or RUNNING, and thus have to do
#ifdef WAIT_BUFFER_DEBUG
/* Normal case... */
- if( debug_on )
- printf( "TW: do it for real; pid %d, tid %d\n", wait_pid, wait_tid );
+ if (debug_on)
+ printf ("TW: do it for real; pid %d, tid %d\n", wait_pid, wait_tid);
#endif
/* The actual wait call.
*/
- ttw_status = call_real_ttrace_wait( wait_pid, wait_tid, option, tsp, tsp_size);
+ ttw_status = call_real_ttrace_wait (wait_pid, wait_tid, option, tsp, tsp_size);
/* Note that the routines we'll call will be using "call_real_ttrace",
* not "call_ttrace", and thus need the real pid rather than the pseudo-tid
real_pid = tsp->tts_pid;
/* For most events: Stop the world!
- *
+
* It's sometimes not safe to stop all threads of a process.
* Sometimes it's not even safe to ask for the thread state
* of a process!
*/
if (can_touch_threads_of_process (real_pid, tsp->tts_event))
- {
- /* If we're really only stepping a single thread, then don't
- * try to stop all the others -- we only do this single-stepping
- * business when all others were already stopped...and the stop
- * would mess up other threads' events.
- *
- * Similiarly, if there are other threads with events,
- * don't do the stop.
- */
- if( !doing_fake_step ) {
- if( more_events_left > 0 )
- warning( "Internal error in stopping process" );
-
- stop_all_threads_of_process (real_pid);
-
- /* At this point, we could scan and update_thread_list(),
- * and only use the local list for the rest of the
- * module! We'd get rid of the scans in the various
- * continue routines (adding one in attach). It'd
- * be great--UPGRADE ME!
- */
- }
- }
-
+ {
+ /* If we're really only stepping a single thread, then don't
+ * try to stop all the others -- we only do this single-stepping
+ * business when all others were already stopped...and the stop
+ * would mess up other threads' events.
+ *
+ * Similiarly, if there are other threads with events,
+ * don't do the stop.
+ */
+ if (!doing_fake_step)
+ {
+ if (more_events_left > 0)
+ warning ("Internal error in stopping process");
+
+ stop_all_threads_of_process (real_pid);
+
+ /* At this point, we could scan and update_thread_list(),
+ * and only use the local list for the rest of the
+ * module! We'd get rid of the scans in the various
+ * continue routines (adding one in attach). It'd
+ * be great--UPGRADE ME!
+ */
+ }
+ }
+
#ifdef PARANOIA
- else if( debug_on ) {
- if( more_events_left > 0 )
- printf( "== Can't stop process; more events!\n" );
- else
- printf( "== Can't stop process!\n" );
- }
+ else if (debug_on)
+ {
+ if (more_events_left > 0)
+ printf ("== Can't stop process; more events!\n");
+ else
+ printf ("== Can't stop process!\n");
+ }
#endif
- process_state = STOPPED;
+ process_state = STOPPED;
#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "Process set to STOPPED\n" );
+ if (debug_on)
+ printf ("Process set to STOPPED\n");
#endif
- }
-
- else {
+ }
+
+ else
+ {
/* Fake a call to ttrace_wait. The process must be
* STOPPED, as we aren't going to do any wait.
*/
#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "TW: fake it\n" );
+ if (debug_on)
+ printf ("TW: fake it\n");
#endif
- if( process_state != STOPPED ) {
- warning( "Process not stopped at wait call, in state '%s'.\n",
- get_printable_name_of_process_state( process_state ));
- }
-
- if( doing_fake_step )
- error( "Internal error in stepping over breakpoint" );
+ if (process_state != STOPPED)
+ {
+ warning ("Process not stopped at wait call, in state '%s'.\n",
+ get_printable_name_of_process_state (process_state));
+ }
+
+ if (doing_fake_step)
+ error ("Internal error in stepping over breakpoint");
- ttw_status = 0; /* Faking it is always successful! */
- } /* End of fake or not? if */
+ ttw_status = 0; /* Faking it is always successful! */
+ } /* End of fake or not? if */
/* Pick an event to pass to our caller. Be paranoid.
*/
- if( !select_stopped_thread_of_process( real_pid, tsp ))
- warning( "Can't find event, using previous event." );
+ if (!select_stopped_thread_of_process (real_pid, tsp))
+ warning ("Can't find event, using previous event.");
+
+ else if (tsp->tts_event == TTEVT_NONE)
+ warning ("Internal error: no thread has a real event.");
- else if( tsp->tts_event == TTEVT_NONE )
- warning( "Internal error: no thread has a real event." );
+ else if (doing_fake_step)
+ {
+ if (fake_step_tid != tsp->tts_lwpid)
+ warning ("Internal error in stepping over breakpoint.");
- else if( doing_fake_step ) {
- if( fake_step_tid != tsp->tts_lwpid )
- warning( "Internal error in stepping over breakpoint." );
-
/* This wait clears the (current) fake-step if there was one.
*/
doing_fake_step = 0;
- fake_step_tid = 0;
- }
+ fake_step_tid = 0;
+ }
/* We now have a correct tsp and ttw_status for the thread
* which we want to report. So it's "handled"! This call
* will add it to our list if it's not there already.
*/
- set_handled( real_pid, tsp->tts_lwpid );
+ set_handled (real_pid, tsp->tts_lwpid);
/* Save a copy of the ttrace state of this thread, in our local
thread descriptor.
it into our list of threads.)
*/
tinfo = find_thread_info (tsp->tts_lwpid);
- if (tinfo != NULL) {
- copy_ttstate_t (&tinfo->last_stop_state, tsp);
- tinfo->have_state = 1;
- }
-
+ if (tinfo != NULL)
+ {
+ copy_ttstate_t (&tinfo->last_stop_state, tsp);
+ tinfo->have_state = 1;
+ }
+
return ttw_status;
-} /* call_ttrace_wait */
+} /* call_ttrace_wait */
#if defined(CHILD_REPORTED_EXEC_EVENTS_PER_EXEC_CALL)
int
child_reported_exec_events_per_exec_call ()
{
- return 1; /* ttrace reports the event once per call. */
+ return 1; /* ttrace reports the event once per call. */
}
#endif
+\f
-\f
/* Our implementation of hardware watchpoints involves making memory
pages write-protected. We must remember a page's original permissions,
and we must also know when it is appropriate to restore a page's
page X, its reference count is decremented. If a page's reference
count drops to 0, it's permissions are restored and the page's entry
is thrown out of the dictionary.
- */
-typedef struct memory_page {
- CORE_ADDR page_start;
- int reference_count;
- int original_permissions;
- struct memory_page * next;
- struct memory_page * previous;
-} memory_page_t;
+ */
+typedef struct memory_page
+{
+ CORE_ADDR page_start;
+ int reference_count;
+ int original_permissions;
+ struct memory_page *next;
+ struct memory_page *previous;
+}
+memory_page_t;
#define MEMORY_PAGE_DICTIONARY_BUCKET_COUNT 128
-static struct {
- LONGEST page_count;
- int page_size;
- int page_protections_allowed;
- /* These are just the heads of chains of actual page descriptors. */
- memory_page_t buckets [MEMORY_PAGE_DICTIONARY_BUCKET_COUNT];
-} memory_page_dictionary;
+static struct
+ {
+ LONGEST page_count;
+ int page_size;
+ int page_protections_allowed;
+ /* These are just the heads of chains of actual page descriptors. */
+ memory_page_t buckets[MEMORY_PAGE_DICTIONARY_BUCKET_COUNT];
+ }
+memory_page_dictionary;
static void
require_memory_page_dictionary ()
{
- int i;
+ int i;
/* Is the memory page dictionary ready for use? If so, we're done. */
if (memory_page_dictionary.page_count >= (LONGEST) 0)
/* Else, initialize it. */
memory_page_dictionary.page_count = (LONGEST) 0;
- for (i=0; i<MEMORY_PAGE_DICTIONARY_BUCKET_COUNT; i++)
+ for (i = 0; i < MEMORY_PAGE_DICTIONARY_BUCKET_COUNT; i++)
{
memory_page_dictionary.buckets[i].page_start = (CORE_ADDR) 0;
memory_page_dictionary.buckets[i].reference_count = 0;
static void
retire_memory_page_dictionary ()
{
- memory_page_dictionary.page_count = (LONGEST) -1;
+ memory_page_dictionary.page_count = (LONGEST) - 1;
}
*/
static int
write_protect_page (pid, page_start)
- int pid;
- CORE_ADDR page_start;
+ int pid;
+ CORE_ADDR page_start;
{
- int tt_status;
- int original_permissions;
- int new_permissions;
+ int tt_status;
+ int original_permissions;
+ int new_permissions;
tt_status = call_ttrace (TT_PROC_GET_MPROTECT,
- pid,
- (TTRACE_ARG_TYPE) page_start,
- TT_NIL,
- (TTRACE_ARG_TYPE) &original_permissions);
+ pid,
+ (TTRACE_ARG_TYPE) page_start,
+ TT_NIL,
+ (TTRACE_ARG_TYPE) & original_permissions);
if (errno || (tt_status < 0))
{
- return 0; /* What else can we do? */
+ return 0; /* What else can we do? */
}
/* We'll also write-protect the page now, if that's allowed. */
{
new_permissions = original_permissions & ~PROT_WRITE;
tt_status = call_ttrace (TT_PROC_SET_MPROTECT,
- pid,
- (TTRACE_ARG_TYPE) page_start,
- (TTRACE_ARG_TYPE) memory_page_dictionary.page_size,
- (TTRACE_ARG_TYPE) new_permissions);
+ pid,
+ (TTRACE_ARG_TYPE) page_start,
+ (TTRACE_ARG_TYPE) memory_page_dictionary.page_size,
+ (TTRACE_ARG_TYPE) new_permissions);
if (errno || (tt_status < 0))
- {
- return 0; /* What else can we do? */
- }
+ {
+ return 0; /* What else can we do? */
+ }
}
return original_permissions;
/* Unwrite-protect the memory page that starts at this address, restoring
(what we must assume are) its original permissions.
- */
+ */
static void
unwrite_protect_page (pid, page_start, original_permissions)
- int pid;
- CORE_ADDR page_start;
- int original_permissions;
+ int pid;
+ CORE_ADDR page_start;
+ int original_permissions;
{
- int tt_status;
+ int tt_status;
tt_status = call_ttrace (TT_PROC_SET_MPROTECT,
- pid,
- (TTRACE_ARG_TYPE) page_start,
- (TTRACE_ARG_TYPE) memory_page_dictionary.page_size,
- (TTRACE_ARG_TYPE) original_permissions);
+ pid,
+ (TTRACE_ARG_TYPE) page_start,
+ (TTRACE_ARG_TYPE) memory_page_dictionary.page_size,
+ (TTRACE_ARG_TYPE) original_permissions);
if (errno || (tt_status < 0))
{
- return; /* What else can we do? */
+ return; /* What else can we do? */
}
}
For every memory page that is currently being watched (i.e., that
presently should be write-protected), write-protect it.
- */
+ */
void
hppa_enable_page_protection_events (pid)
- int pid;
+ int pid;
{
- int bucket;
+ int bucket;
memory_page_dictionary.page_protections_allowed = 1;
- for (bucket=0; bucket<MEMORY_PAGE_DICTIONARY_BUCKET_COUNT; bucket++)
+ for (bucket = 0; bucket < MEMORY_PAGE_DICTIONARY_BUCKET_COUNT; bucket++)
{
- memory_page_t * page;
+ memory_page_t *page;
page = memory_page_dictionary.buckets[bucket].next;
while (page != NULL)
- {
- page->original_permissions = write_protect_page (pid, page->page_start);
- page = page->next;
- }
+ {
+ page->original_permissions = write_protect_page (pid, page->page_start);
+ page = page->next;
+ }
}
}
For every memory page that is currently being watched (i.e., that
presently is or should be write-protected), un-write-protect it.
- */
+ */
void
hppa_disable_page_protection_events (pid)
- int pid;
+ int pid;
{
- int bucket;
+ int bucket;
- for (bucket=0; bucket<MEMORY_PAGE_DICTIONARY_BUCKET_COUNT; bucket++)
+ for (bucket = 0; bucket < MEMORY_PAGE_DICTIONARY_BUCKET_COUNT; bucket++)
{
- memory_page_t * page;
+ memory_page_t *page;
page = memory_page_dictionary.buckets[bucket].next;
while (page != NULL)
- {
- unwrite_protect_page (pid, page->page_start, page->original_permissions);
- page = page->next;
- }
+ {
+ unwrite_protect_page (pid, page->page_start, page->original_permissions);
+ page = page->next;
+ }
}
memory_page_dictionary.page_protections_allowed = 0;
* Note: we could just scan our own thread list. FIXME!
*/
static int
-count_unhandled_events( real_pid, real_tid )
- int real_pid;
- lwpid_t real_tid;
+count_unhandled_events (real_pid, real_tid)
+ int real_pid;
+ lwpid_t real_tid;
{
- ttstate_t tstate;
- lwpid_t ttid;
- int events_left;
-
+ ttstate_t tstate;
+ lwpid_t ttid;
+ int events_left;
+
/* Ok, find out how many threads have real events to report.
*/
events_left = 0;
- ttid = get_process_first_stopped_thread_id( real_pid, &tstate );
+ ttid = get_process_first_stopped_thread_id (real_pid, &tstate);
#ifdef THREAD_DEBUG
- if( debug_on ) {
- if( ttid == 0 )
- printf( "Process %d has no threads\n", real_pid );
+ if (debug_on)
+ {
+ if (ttid == 0)
+ printf ("Process %d has no threads\n", real_pid);
else
- printf( "Process %d has these threads:\n", real_pid );
- }
+ printf ("Process %d has these threads:\n", real_pid);
+ }
#endif
- while (ttid > 0 ) {
- if( tstate.tts_event != TTEVT_NONE
- && !was_handled( ttid )) {
- /* TTEVT_NONE implies we just stopped it ourselves
- * because we're the stop-the-world guys, so it's
- * not an event from our point of view.
- *
- * If "was_handled" is true, this is an event we
- * already handled, so don't count it.
- *
- * Note that we don't count the thread with the
- * currently-reported event, as it's already marked
- * as handled.
- */
- events_left++;
- }
-
+ while (ttid > 0)
+ {
+ if (tstate.tts_event != TTEVT_NONE
+ && !was_handled (ttid))
+ {
+ /* TTEVT_NONE implies we just stopped it ourselves
+ * because we're the stop-the-world guys, so it's
+ * not an event from our point of view.
+ *
+ * If "was_handled" is true, this is an event we
+ * already handled, so don't count it.
+ *
+ * Note that we don't count the thread with the
+ * currently-reported event, as it's already marked
+ * as handled.
+ */
+ events_left++;
+ }
+
#if defined( THREAD_DEBUG ) || defined( WAIT_BUFFER_DEBUG )
- if( debug_on ) {
- if( ttid == real_tid )
- printf( "*" ); /* Thread we're reporting */
- else
- printf( " " );
-
- if( tstate.tts_event != TTEVT_NONE )
- printf( "+" ); /* Thread with a real event */
- else
- printf( " " );
+ if (debug_on)
+ {
+ if (ttid == real_tid)
+ printf ("*"); /* Thread we're reporting */
+ else
+ printf (" ");
+
+ if (tstate.tts_event != TTEVT_NONE)
+ printf ("+"); /* Thread with a real event */
+ else
+ printf (" ");
+
+ if (was_handled (ttid))
+ printf ("h"); /* Thread has been handled */
+ else
+ printf (" ");
+
+ printf (" %d, with event %s", ttid,
+ get_printable_name_of_ttrace_event (tstate.tts_event));
+
+ if (tstate.tts_event == TTEVT_SIGNAL
+ && 5 == tstate.tts_u.tts_signal.tts_signo)
+ {
+ CORE_ADDR pc_val;
- if( was_handled( ttid ))
- printf( "h" ); /* Thread has been handled */
- else
- printf( " " );
-
- printf( " %d, with event %s", ttid,
- get_printable_name_of_ttrace_event( tstate.tts_event ));
-
- if( tstate.tts_event == TTEVT_SIGNAL
- && 5 == tstate.tts_u.tts_signal.tts_signo ) {
- CORE_ADDR pc_val;
-
- pc_val = get_raw_pc( ttid );
-
- if( pc_val > 0 )
- printf( " breakpoint at 0x%x\n", pc_val );
- else
- printf( " bpt, can't fetch pc.\n" );
- }
- else
- printf( "\n" );
- }
+ pc_val = get_raw_pc (ttid);
+
+ if (pc_val > 0)
+ printf (" breakpoint at 0x%x\n", pc_val);
+ else
+ printf (" bpt, can't fetch pc.\n");
+ }
+ else
+ printf ("\n");
+ }
#endif
ttid = get_process_next_stopped_thread_id (real_pid, &tstate);
- }
+ }
#if defined( THREAD_DEBUG ) || defined( WAIT_BUFFER_DEBUG )
- if( debug_on )
- if( events_left > 0 )
- printf( "There are thus %d pending events\n", events_left );
+ if (debug_on)
+ if (events_left > 0)
+ printf ("There are thus %d pending events\n", events_left);
#endif
return events_left;
*/
int
ptrace_wait (pid, status)
- int pid;
- int *status;
+ int pid;
+ int *status;
{
- ttstate_t tsp;
- int ttwait_return;
- int real_pid;
- ttstate_t state;
- lwpid_t real_tid;
- int return_pid;
+ ttstate_t tsp;
+ int ttwait_return;
+ int real_pid;
+ ttstate_t state;
+ lwpid_t real_tid;
+ int return_pid;
/* The ptrace implementation of this also ignores pid.
*/
*status = 0;
- ttwait_return = call_ttrace_wait( 0, TTRACE_WAITOK, &tsp, sizeof (tsp) );
+ ttwait_return = call_ttrace_wait (0, TTRACE_WAITOK, &tsp, sizeof (tsp));
if (ttwait_return < 0)
{
/* ??rehrauer: It appears that if our inferior exits and we
haven't asked for exit events, that we're not getting any
indication save a negative return from ttrace_wait and an
errno set to ESRCH?
- */
+ */
if (errno == ESRCH)
- {
- *status = 0; /* WIFEXITED */
- return inferior_pid;
- }
+ {
+ *status = 0; /* WIFEXITED */
+ return inferior_pid;
+ }
- warning( "Call of ttrace_wait returned with errno %d.",
- errno );
+ warning ("Call of ttrace_wait returned with errno %d.",
+ errno);
*status = ttwait_return;
return inferior_pid;
}
* either have to force an order (as we do here), or handle
* more than one flag at a time.
*/
- if (tsp.tts_event & TTEVT_LWP_CREATE) {
-
- /* Unlike what you might expect, this event is reported in
- * the _creating_ thread, and the _created_ thread (whose tid
- * we have) is still running. So we have to stop it. This
- * has already been done in "call_ttrace_wait", but should we
- * ever abandon the "stop-the-world" model, here's the command
- * to use:
- *
- * call_ttrace( TT_LWP_STOP, real_tid, TT_NIL, TT_NIL, TT_NIL );
- *
- * Note that this would depend on being called _after_ "add_tthread"
- * below for the tid-to-pid translation to be done in "call_ttrace".
- */
+ if (tsp.tts_event & TTEVT_LWP_CREATE)
+ {
+
+ /* Unlike what you might expect, this event is reported in
+ * the _creating_ thread, and the _created_ thread (whose tid
+ * we have) is still running. So we have to stop it. This
+ * has already been done in "call_ttrace_wait", but should we
+ * ever abandon the "stop-the-world" model, here's the command
+ * to use:
+ *
+ * call_ttrace( TT_LWP_STOP, real_tid, TT_NIL, TT_NIL, TT_NIL );
+ *
+ * Note that this would depend on being called _after_ "add_tthread"
+ * below for the tid-to-pid translation to be done in "call_ttrace".
+ */
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "New thread: pid %d, tid %d, creator tid %d\n",
- real_pid, tsp.tts_u.tts_thread.tts_target_lwpid,
- real_tid );
+ if (debug_on)
+ printf ("New thread: pid %d, tid %d, creator tid %d\n",
+ real_pid, tsp.tts_u.tts_thread.tts_target_lwpid,
+ real_tid);
#endif
- /* Now we have to return the tid of the created thread, not
- * the creating thread, or "wait_for_inferior" won't know we
- * have a new "process" (thread). Plus we should record it
- * right, too.
- */
+ /* Now we have to return the tid of the created thread, not
+ * the creating thread, or "wait_for_inferior" won't know we
+ * have a new "process" (thread). Plus we should record it
+ * right, too.
+ */
real_tid = tsp.tts_u.tts_thread.tts_target_lwpid;
- add_tthread( real_pid, real_tid );
- }
+ add_tthread (real_pid, real_tid);
+ }
- else if( (tsp.tts_event & TTEVT_LWP_TERMINATE )
- || (tsp.tts_event & TTEVT_LWP_EXIT) ) {
+ else if ((tsp.tts_event & TTEVT_LWP_TERMINATE)
+ || (tsp.tts_event & TTEVT_LWP_EXIT))
+ {
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Thread dies: %d\n", real_tid );
+ if (debug_on)
+ printf ("Thread dies: %d\n", real_tid);
#endif
- del_tthread( real_tid );
- }
+ del_tthread (real_tid);
+ }
- else if (tsp.tts_event & TTEVT_EXEC) {
+ else if (tsp.tts_event & TTEVT_EXEC)
+ {
-#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Pid %d has zero'th thread %d; inferior pid is %d\n",
- real_pid, real_tid, inferior_pid );
+#ifdef THREAD_DEBUG
+ if (debug_on)
+ printf ("Pid %d has zero'th thread %d; inferior pid is %d\n",
+ real_pid, real_tid, inferior_pid);
#endif
- add_tthread( real_pid, real_tid );
- }
+ add_tthread (real_pid, real_tid);
+ }
#ifdef THREAD_DEBUG
- else if( debug_on ) {
- printf( "Process-level event %s, using tid %d\n",
- get_printable_name_of_ttrace_event( tsp.tts_event ),
- real_tid );
-
- /* OK to do this, as "add_tthread" won't add
- * duplicate entries. Also OK not to do it,
- * as this event isn't one which can change the
- * thread state.
- */
- add_tthread( real_pid, real_tid );
- }
+ else if (debug_on)
+ {
+ printf ("Process-level event %s, using tid %d\n",
+ get_printable_name_of_ttrace_event (tsp.tts_event),
+ real_tid);
+
+ /* OK to do this, as "add_tthread" won't add
+ * duplicate entries. Also OK not to do it,
+ * as this event isn't one which can change the
+ * thread state.
+ */
+ add_tthread (real_pid, real_tid);
+ }
#endif
* no other resort than to assume that no more events remain...)
*/
if (can_touch_threads_of_process (real_pid, tsp.tts_event))
- more_events_left = count_unhandled_events( real_pid, real_tid );
-
- else {
- if( more_events_left > 0 )
- warning( "Vfork or fork causing loss of %d buffered events.",
- more_events_left );
-
+ more_events_left = count_unhandled_events (real_pid, real_tid);
+
+ else
+ {
+ if (more_events_left > 0)
+ warning ("Vfork or fork causing loss of %d buffered events.",
+ more_events_left);
+
more_events_left = 0;
- }
+ }
/* Attempt to translate the ttrace_wait-returned status into the
ptrace equivalent.
??rehrauer: This is somewhat fragile. We really ought to rewrite
clients that expect to pick apart a ptrace wait status, to use
something a little more abstract.
- */
- if ( (tsp.tts_event & TTEVT_EXEC)
+ */
+ if ((tsp.tts_event & TTEVT_EXEC)
|| (tsp.tts_event & TTEVT_FORK)
|| (tsp.tts_event & TTEVT_VFORK))
{
* will do two waits. Be ready to notice this.
*/
if (tsp.tts_event & TTEVT_FORK)
- {
- process_state = FORKING;
-
+ {
+ process_state = FORKING;
+
#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "Process set to FORKING\n" );
+ if (debug_on)
+ printf ("Process set to FORKING\n");
#endif
- }
+ }
else if (tsp.tts_event & TTEVT_VFORK)
- {
- process_state = VFORKING;
-
+ {
+ process_state = VFORKING;
+
#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "Process set to VFORKING\n" );
+ if (debug_on)
+ printf ("Process set to VFORKING\n");
#endif
- }
+ }
/* Make an exec or fork look like a breakpoint. Definitely a hack,
but I don't think non HP-UX-specific clients really carefully
inspect the first events they get after inferior startup, so
it probably almost doesn't matter what we claim this is.
- */
+ */
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "..a process 'event'\n" );
+ if (debug_on)
+ printf ("..a process 'event'\n");
#endif
/* Also make fork and exec events look like bpts, so they can be caught.
- */
+ */
*status = 0177 | (_SIGTRAP << 8);
}
step out of one syscall only to immediately enter another...
*/
else if ((tsp.tts_event & TTEVT_SYSCALL_ENTRY)
- || (tsp.tts_event & TTEVT_SYSCALL_RETURN))
+ || (tsp.tts_event & TTEVT_SYSCALL_RETURN))
{
/* Make a syscall event look like a breakpoint. Same comments
as for exec & fork events.
- */
+ */
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "..a syscall 'event'\n" );
+ if (debug_on)
+ printf ("..a syscall 'event'\n");
#endif
/* Also make syscall events look like bpts, so they can be caught.
- */
+ */
*status = 0177 | (_SIGTRAP << 8);
}
else if ((tsp.tts_event & TTEVT_LWP_CREATE)
- || (tsp.tts_event & TTEVT_LWP_TERMINATE)
- || (tsp.tts_event & TTEVT_LWP_EXIT))
+ || (tsp.tts_event & TTEVT_LWP_TERMINATE)
+ || (tsp.tts_event & TTEVT_LWP_EXIT))
{
/* Make a thread event look like a breakpoint. Same comments
* as for exec & fork events.
*/
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "..a thread 'event'\n" );
+ if (debug_on)
+ printf ("..a thread 'event'\n");
#endif
/* Also make thread events look like bpts, so they can be caught.
- */
+ */
*status = 0177 | (_SIGTRAP << 8);
}
-
+
else if ((tsp.tts_event & TTEVT_EXIT))
- { /* WIFEXITED */
-
+ { /* WIFEXITED */
+
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "..an exit\n" );
+ if (debug_on)
+ printf ("..an exit\n");
#endif
/* Prevent rest of gdb from thinking this is
* a new thread if for some reason it's never
* seen the main thread before.
*/
- inferior_pid = map_to_gdb_tid( real_tid ); /* HACK, FIX */
-
+ inferior_pid = map_to_gdb_tid (real_tid); /* HACK, FIX */
+
*status = 0 | (tsp.tts_u.tts_exit.tts_exitcode);
}
-
+
else if (tsp.tts_event & TTEVT_SIGNAL)
- { /* WIFSTOPPED */
+ { /* WIFSTOPPED */
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "..a signal, %d\n", tsp.tts_u.tts_signal.tts_signo );
+ if (debug_on)
+ printf ("..a signal, %d\n", tsp.tts_u.tts_signal.tts_signo);
#endif
*status = 0177 | (tsp.tts_u.tts_signal.tts_signo << 8);
}
else
- { /* !WIFSTOPPED */
+ { /* !WIFSTOPPED */
/* This means the process or thread terminated. But we should've
caught an explicit exit/termination above. So warn (this is
warning ("process_wait: unknown process state");
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Process-level event %s, using tid %d\n",
- get_printable_name_of_ttrace_event( tsp.tts_event ),
- real_tid );
+ if (debug_on)
+ printf ("Process-level event %s, using tid %d\n",
+ get_printable_name_of_ttrace_event (tsp.tts_event),
+ real_tid);
#endif
*status = _SIGTRAP;
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Done waiting, pid is %d, tid %d\n", real_pid, real_tid );
+ if (debug_on)
+ printf ("Done waiting, pid is %d, tid %d\n", real_pid, real_tid);
#endif
/* All code external to this module uses the tid, but calls
* the first thread as having the same number as the starting
* pid.
*/
- return_pid = map_to_gdb_tid( real_tid );
+ return_pid = map_to_gdb_tid (real_tid);
/* Remember this for later use in "hppa_prepare_to_proceed".
*/
- old_gdb_pid = inferior_pid;
+ old_gdb_pid = inferior_pid;
reported_pid = return_pid;
reported_bpt = ((tsp.tts_event & TTEVT_SIGNAL) && (5 == tsp.tts_u.tts_signal.tts_signo));
- if( real_tid == 0 || return_pid == 0 ) {
- warning( "Internal error: process-wait failed." );
- }
-
+ if (real_tid == 0 || return_pid == 0)
+ {
+ warning ("Internal error: process-wait failed.");
+ }
+
return return_pid;
}
-
\f
+
/* This function causes the caller's process to be traced by its
parent. This is intended to be called after GDB forks itself,
and before the child execs the target. Despite the name, it
int
parent_attach_all ()
{
- int tt_status;
+ int tt_status;
/* We need a memory home for a constant, to pass it to ttrace.
The value of the constant is arbitrary, so long as both
parent and child use the same value. Might as well use the
"magic" constant provided by ttrace...
*/
- uint64_t tc_magic_child = TT_VERSION;
- uint64_t tc_magic_parent = 0;
+ uint64_t tc_magic_child = TT_VERSION;
+ uint64_t tc_magic_parent = 0;
tt_status = call_real_ttrace (
- TT_PROC_SETTRC,
- (int) TT_NIL,
- (lwpid_t) TT_NIL,
- TT_NIL,
- (TTRACE_ARG_TYPE) TT_VERSION,
- TT_NIL );
+ TT_PROC_SETTRC,
+ (int) TT_NIL,
+ (lwpid_t) TT_NIL,
+ TT_NIL,
+ (TTRACE_ARG_TYPE) TT_VERSION,
+ TT_NIL);
if (tt_status < 0)
return tt_status;
/* Notify the parent that we're potentially ready to exec(). */
write (startup_semaphore.child_channel[SEM_TALK],
- &tc_magic_child,
- sizeof (tc_magic_child));
+ &tc_magic_child,
+ sizeof (tc_magic_child));
/* Wait for acknowledgement from the parent. */
read (startup_semaphore.parent_channel[SEM_LISTEN],
- &tc_magic_parent,
- sizeof (tc_magic_parent));
-
+ &tc_magic_parent,
+ sizeof (tc_magic_parent));
+
if (tc_magic_child != tc_magic_parent)
warning ("mismatched semaphore magic");
(void) close (startup_semaphore.parent_channel[SEM_TALK]);
(void) close (startup_semaphore.child_channel[SEM_LISTEN]);
(void) close (startup_semaphore.child_channel[SEM_TALK]);
-
+
return tt_status;
}
* have to be the common part of both.
*/
static void
-require_notification_of_events ( real_pid )
- int real_pid;
+require_notification_of_events (real_pid)
+ int real_pid;
{
- int tt_status;
- ttevent_t notifiable_events;
+ int tt_status;
+ ttevent_t notifiable_events;
- lwpid_t tid;
- ttstate_t thread_state;
+ lwpid_t tid;
+ ttstate_t thread_state;
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Require notif, pid is %d\n", real_pid );
+ if (debug_on)
+ printf ("Require notif, pid is %d\n", real_pid);
#endif
/* Temporary HACK: tell inftarg.c/child_wait to not
*/
notifiable_events.tte_opts |= TTEO_PROC_INHERIT;
- notifiable_events.tte_events = TTEVT_DEFAULT;
+ notifiable_events.tte_events = TTEVT_DEFAULT;
notifiable_events.tte_events |= TTEVT_SIGNAL;
notifiable_events.tte_events |= TTEVT_EXEC;
notifiable_events.tte_events |= TTEVT_EXIT;
notifiable_events.tte_events |= TTEVT_LWP_TERMINATE;
tt_status = call_real_ttrace (
- TT_PROC_SET_EVENT_MASK,
- real_pid,
- (lwpid_t) TT_NIL,
- (TTRACE_ARG_TYPE) ¬ifiable_events,
- (TTRACE_ARG_TYPE) sizeof (notifiable_events),
- TT_NIL);
+ TT_PROC_SET_EVENT_MASK,
+ real_pid,
+ (lwpid_t) TT_NIL,
+ (TTRACE_ARG_TYPE) & notifiable_events,
+ (TTRACE_ARG_TYPE) sizeof (notifiable_events),
+ TT_NIL);
}
static void
-require_notification_of_exec_events ( real_pid )
- int real_pid;
+require_notification_of_exec_events (real_pid)
+ int real_pid;
{
- int tt_status;
- ttevent_t notifiable_events;
+ int tt_status;
+ ttevent_t notifiable_events;
- lwpid_t tid;
- ttstate_t thread_state;
+ lwpid_t tid;
+ ttstate_t thread_state;
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Require notif, pid is %d\n", real_pid );
+ if (debug_on)
+ printf ("Require notif, pid is %d\n", real_pid);
#endif
/* Temporary HACK: tell inftarg.c/child_wait to not
*/
notifiable_events.tte_opts &= ~TTEO_PROC_INHERIT;
- notifiable_events.tte_events = TTEVT_DEFAULT;
+ notifiable_events.tte_events = TTEVT_DEFAULT;
notifiable_events.tte_events |= TTEVT_EXEC;
notifiable_events.tte_events |= TTEVT_EXIT;
tt_status = call_real_ttrace (
- TT_PROC_SET_EVENT_MASK,
- real_pid,
- (lwpid_t) TT_NIL,
- (TTRACE_ARG_TYPE) ¬ifiable_events,
- (TTRACE_ARG_TYPE) sizeof (notifiable_events),
- TT_NIL);
+ TT_PROC_SET_EVENT_MASK,
+ real_pid,
+ (lwpid_t) TT_NIL,
+ (TTRACE_ARG_TYPE) & notifiable_events,
+ (TTRACE_ARG_TYPE) sizeof (notifiable_events),
+ TT_NIL);
}
-
\f
+
/* This function is called by the parent process, with pid being the
* ID of the child process, after the debugger has forked.
*/
void
child_acknowledge_created_inferior (pid)
- int pid;
+ int pid;
{
/* We need a memory home for a constant, to pass it to ttrace.
The value of the constant is arbitrary, so long as both
parent and child use the same value. Might as well use the
"magic" constant provided by ttrace...
- */
- uint64_t tc_magic_parent = TT_VERSION;
- uint64_t tc_magic_child = 0;
+ */
+ uint64_t tc_magic_parent = TT_VERSION;
+ uint64_t tc_magic_child = 0;
/* Wait for the child to tell us that it has forked. */
read (startup_semaphore.child_channel[SEM_LISTEN],
- &tc_magic_child,
- sizeof(tc_magic_child));
+ &tc_magic_child,
+ sizeof (tc_magic_child));
/* Clear thread info now. We'd like to do this in
* "require...", but that messes up attach.
*/
- clear_thread_info();
+ clear_thread_info ();
/* Tell the "rest of gdb" that the initial thread exists.
* This isn't really a hack. Other thread-based versions
* the process safely to ask what it is. Anyway, we'll
* add it when it gets the EXEC event.
*/
- add_thread( pid ); /* in thread.c */
+ add_thread (pid); /* in thread.c */
/* We can now set the child's ttrace event mask.
*/
/* Notify the child that it can exec. */
write (startup_semaphore.parent_channel[SEM_TALK],
- &tc_magic_parent,
- sizeof (tc_magic_parent));
+ &tc_magic_parent,
+ sizeof (tc_magic_parent));
/* Discard our copy of the semaphore. */
(void) close (startup_semaphore.parent_channel[SEM_LISTEN]);
* calling require_notification_of_events.
*/
void
-child_post_startup_inferior ( real_pid)
- int real_pid;
+child_post_startup_inferior (real_pid)
+ int real_pid;
{
require_notification_of_events (real_pid);
}
*/
static void
hppa_enable_catch_fork (tid)
- int tid;
+ int tid;
{
- int tt_status;
- ttevent_t ttrace_events;
+ int tt_status;
+ ttevent_t ttrace_events;
/* Get the set of events that are currently enabled.
*/
tt_status = call_ttrace (TT_PROC_GET_EVENT_MASK,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL );
+ tid,
+ (TTRACE_ARG_TYPE) & ttrace_events,
+ (TTRACE_ARG_TYPE) sizeof (ttrace_events),
+ TT_NIL);
if (errno)
perror_with_name ("ttrace");
ttrace_events.tte_events |= TTEVT_FORK;
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "enable fork, tid is %d\n", tid );
+ if (debug_on)
+ printf ("enable fork, tid is %d\n", tid);
#endif
tt_status = call_ttrace (TT_PROC_SET_EVENT_MASK,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
+ tid,
+ (TTRACE_ARG_TYPE) & ttrace_events,
+ (TTRACE_ARG_TYPE) sizeof (ttrace_events),
+ TT_NIL);
if (errno)
perror_with_name ("ttrace");
}
static void
hppa_disable_catch_fork (tid)
- int tid;
+ int tid;
{
- int tt_status;
- ttevent_t ttrace_events;
+ int tt_status;
+ ttevent_t ttrace_events;
/* Get the set of events that are currently enabled.
*/
tt_status = call_ttrace (TT_PROC_GET_EVENT_MASK,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
+ tid,
+ (TTRACE_ARG_TYPE) & ttrace_events,
+ (TTRACE_ARG_TYPE) sizeof (ttrace_events),
+ TT_NIL);
if (errno)
perror_with_name ("ttrace");
ttrace_events.tte_events &= ~TTEVT_FORK;
#ifdef THREAD_DEBUG
- if( debug_on )
- printf("disable fork, tid is %d\n", tid );
+ if (debug_on)
+ printf ("disable fork, tid is %d\n", tid);
#endif
tt_status = call_ttrace (TT_PROC_SET_EVENT_MASK,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
+ tid,
+ (TTRACE_ARG_TYPE) & ttrace_events,
+ (TTRACE_ARG_TYPE) sizeof (ttrace_events),
+ TT_NIL);
if (errno)
perror_with_name ("ttrace");
#if defined(CHILD_INSERT_FORK_CATCHPOINT)
int
child_insert_fork_catchpoint (tid)
- int tid;
+ int tid;
{
/* Enable reporting of fork events from the kernel. */
/* ??rehrauer: For the moment, we're always enabling these events,
and just ignoring them if there's no catchpoint to catch them.
- */
+ */
return 0;
}
#endif
#if defined(CHILD_REMOVE_FORK_CATCHPOINT)
int
child_remove_fork_catchpoint (tid)
- int tid;
+ int tid;
{
/* Disable reporting of fork events from the kernel. */
/* ??rehrauer: For the moment, we're always enabling these events,
and just ignoring them if there's no catchpoint to catch them.
- */
+ */
return 0;
}
#endif
static void
hppa_enable_catch_vfork (tid)
- int tid;
+ int tid;
{
- int tt_status;
- ttevent_t ttrace_events;
+ int tt_status;
+ ttevent_t ttrace_events;
/* Get the set of events that are currently enabled.
*/
tt_status = call_ttrace (TT_PROC_GET_EVENT_MASK,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
+ tid,
+ (TTRACE_ARG_TYPE) & ttrace_events,
+ (TTRACE_ARG_TYPE) sizeof (ttrace_events),
+ TT_NIL);
if (errno)
perror_with_name ("ttrace");
ttrace_events.tte_events |= TTEVT_VFORK;
#ifdef THREAD_DEBUG
- if( debug_on )
- printf("enable vfork, tid is %d\n", tid );
+ if (debug_on)
+ printf ("enable vfork, tid is %d\n", tid);
#endif
tt_status = call_ttrace (TT_PROC_SET_EVENT_MASK,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
+ tid,
+ (TTRACE_ARG_TYPE) & ttrace_events,
+ (TTRACE_ARG_TYPE) sizeof (ttrace_events),
+ TT_NIL);
if (errno)
perror_with_name ("ttrace");
static void
hppa_disable_catch_vfork (tid)
- int tid;
+ int tid;
{
- int tt_status;
- ttevent_t ttrace_events;
+ int tt_status;
+ ttevent_t ttrace_events;
/* Get the set of events that are currently enabled. */
tt_status = call_ttrace (TT_PROC_GET_EVENT_MASK,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
+ tid,
+ (TTRACE_ARG_TYPE) & ttrace_events,
+ (TTRACE_ARG_TYPE) sizeof (ttrace_events),
+ TT_NIL);
if (errno)
perror_with_name ("ttrace");
ttrace_events.tte_events &= ~TTEVT_VFORK;
#ifdef THREAD_DEBUG
- if( debug_on )
- printf("disable vfork, tid is %d\n", tid );
+ if (debug_on)
+ printf ("disable vfork, tid is %d\n", tid);
#endif
tt_status = call_ttrace (TT_PROC_SET_EVENT_MASK,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
+ tid,
+ (TTRACE_ARG_TYPE) & ttrace_events,
+ (TTRACE_ARG_TYPE) sizeof (ttrace_events),
+ TT_NIL);
if (errno)
perror_with_name ("ttrace");
#if defined(CHILD_INSERT_VFORK_CATCHPOINT)
int
child_insert_vfork_catchpoint (tid)
- int tid;
+ int tid;
{
/* Enable reporting of vfork events from the kernel. */
/* ??rehrauer: For the moment, we're always enabling these events,
and just ignoring them if there's no catchpoint to catch them.
- */
+ */
return 0;
}
#endif
#if defined(CHILD_REMOVE_VFORK_CATCHPOINT)
int
child_remove_vfork_catchpoint (tid)
- int tid;
+ int tid;
{
/* Disable reporting of vfork events from the kernel. */
/* ??rehrauer: For the moment, we're always enabling these events,
and just ignoring them if there's no catchpoint to catch them.
- */
+ */
return 0;
}
#endif
#if defined(CHILD_HAS_FORKED)
/* Q: Do we need to map the returned process ID to a thread ID?
- *
+
* A: I don't think so--here we want a _real_ pid. Any later
* operations will call "require_notification_of_events" and
* start the mapping.
*/
int
child_has_forked (tid, childpid)
- int tid;
- int *childpid;
+ int tid;
+ int *childpid;
{
- int tt_status;
- ttstate_t ttrace_state;
- thread_info * tinfo;
+ int tt_status;
+ ttstate_t ttrace_state;
+ thread_info *tinfo;
/* Do we have cached thread state that we can consult? If so, use it. */
tinfo = find_thread_info (map_from_gdb_tid (tid));
- if (tinfo != NULL) {
- copy_ttstate_t (&ttrace_state, &tinfo->last_stop_state);
- }
+ if (tinfo != NULL)
+ {
+ copy_ttstate_t (&ttrace_state, &tinfo->last_stop_state);
+ }
/* Nope, must read the thread's current state */
else
{
tt_status = call_ttrace (TT_LWP_GET_STATE,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_state,
- (TTRACE_ARG_TYPE) sizeof (ttrace_state),
- TT_NIL);
+ tid,
+ (TTRACE_ARG_TYPE) & ttrace_state,
+ (TTRACE_ARG_TYPE) sizeof (ttrace_state),
+ TT_NIL);
if (errno)
- perror_with_name ("ttrace");
-
+ perror_with_name ("ttrace");
+
if (tt_status < 0)
- return 0;
+ return 0;
}
if (ttrace_state.tts_event & TTEVT_FORK)
*/
int
child_has_vforked (tid, childpid)
- int tid;
- int * childpid;
+ int tid;
+ int *childpid;
{
- int tt_status;
- ttstate_t ttrace_state;
- thread_info * tinfo;
+ int tt_status;
+ ttstate_t ttrace_state;
+ thread_info *tinfo;
/* Do we have cached thread state that we can consult? If so, use it. */
tinfo = find_thread_info (map_from_gdb_tid (tid));
else
{
tt_status = call_ttrace (TT_LWP_GET_STATE,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_state,
- (TTRACE_ARG_TYPE) sizeof (ttrace_state),
- TT_NIL);
+ tid,
+ (TTRACE_ARG_TYPE) & ttrace_state,
+ (TTRACE_ARG_TYPE) sizeof (ttrace_state),
+ TT_NIL);
if (errno)
- perror_with_name ("ttrace");
-
+ perror_with_name ("ttrace");
+
if (tt_status < 0)
- return 0;
+ return 0;
}
if (ttrace_state.tts_event & TTEVT_VFORK)
??rehrauer: However, I had major-league problems trying to
convince wait_for_inferior to handle that case. Perhaps when
it is rewritten to grok multiple processes in an explicit way...
- */
+ */
return 0;
}
#endif
#if defined(CHILD_INSERT_EXEC_CATCHPOINT)
int
child_insert_exec_catchpoint (tid)
- int tid;
+ int tid;
{
/* Enable reporting of exec events from the kernel. */
/* ??rehrauer: For the moment, we're always enabling these events,
and just ignoring them if there's no catchpoint to catch them.
- */
+ */
return 0;
}
#endif
#if defined(CHILD_REMOVE_EXEC_CATCHPOINT)
int
child_remove_exec_catchpoint (tid)
- int tid;
+ int tid;
{
/* Disable reporting of execevents from the kernel. */
/* ??rehrauer: For the moment, we're always enabling these events,
and just ignoring them if there's no catchpoint to catch them.
- */
+ */
return 0;
}
#endif
#if defined(CHILD_HAS_EXECD)
int
child_has_execd (tid, execd_pathname)
- int tid;
- char ** execd_pathname;
+ int tid;
+ char **execd_pathname;
{
- int tt_status;
- ttstate_t ttrace_state;
- thread_info * tinfo;
+ int tt_status;
+ ttstate_t ttrace_state;
+ thread_info *tinfo;
/* Do we have cached thread state that we can consult? If so, use it. */
tinfo = find_thread_info (map_from_gdb_tid (tid));
else
{
tt_status = call_ttrace (TT_LWP_GET_STATE,
- tid,
- (TTRACE_ARG_TYPE) &ttrace_state,
- (TTRACE_ARG_TYPE) sizeof (ttrace_state),
- TT_NIL);
+ tid,
+ (TTRACE_ARG_TYPE) & ttrace_state,
+ (TTRACE_ARG_TYPE) sizeof (ttrace_state),
+ TT_NIL);
if (errno)
- perror_with_name ("ttrace");
-
+ perror_with_name ("ttrace");
+
if (tt_status < 0)
- return 0;
+ return 0;
}
if (ttrace_state.tts_event & TTEVT_EXEC)
{
/* See child_pid_to_exec_file in this file: this is a macro.
*/
- char * exec_file = target_pid_to_exec_file (tid);
-
+ char *exec_file = target_pid_to_exec_file (tid);
+
*execd_pathname = savestring (exec_file, strlen (exec_file));
return 1;
}
#if defined(CHILD_HAS_SYSCALL_EVENT)
int
child_has_syscall_event (pid, kind, syscall_id)
- int pid;
- enum target_waitkind * kind;
- int * syscall_id;
+ int pid;
+ enum target_waitkind *kind;
+ int *syscall_id;
{
- int tt_status;
- ttstate_t ttrace_state;
- thread_info * tinfo;
+ int tt_status;
+ ttstate_t ttrace_state;
+ thread_info *tinfo;
/* Do we have cached thread state that we can consult? If so, use it. */
tinfo = find_thread_info (map_from_gdb_tid (pid));
/* Nope, must read the thread's current state */
else
{
- tt_status = call_ttrace (TT_LWP_GET_STATE,
- pid,
- (TTRACE_ARG_TYPE) &ttrace_state,
- (TTRACE_ARG_TYPE) sizeof (ttrace_state),
- TT_NIL);
+ tt_status = call_ttrace (TT_LWP_GET_STATE,
+ pid,
+ (TTRACE_ARG_TYPE) & ttrace_state,
+ (TTRACE_ARG_TYPE) sizeof (ttrace_state),
+ TT_NIL);
if (errno)
- perror_with_name ("ttrace");
-
+ perror_with_name ("ttrace");
+
if (tt_status < 0)
- return 0;
+ return 0;
}
- *kind = TARGET_WAITKIND_SPURIOUS; /* Until proven otherwise... */
+ *kind = TARGET_WAITKIND_SPURIOUS; /* Until proven otherwise... */
*syscall_id = -1;
if (ttrace_state.tts_event & TTEVT_SYSCALL_ENTRY)
return 1;
}
#endif
+\f
-\f
#if defined(CHILD_THREAD_ALIVE)
/* Check to see if the given thread is alive.
- *
+
* We'll trust the thread list, as the more correct
* approach of stopping the process and spinning down
* the OS's thread list is _very_ expensive.
child_thread_alive (gdb_tid)
lwpid_t gdb_tid;
{
- lwpid_t tid;
+ lwpid_t tid;
- /* This spins down the lists twice.
- * Possible peformance improvement here!
- */
- tid = map_from_gdb_tid( gdb_tid );
- return !is_terminated( tid );
+ /* This spins down the lists twice.
+ * Possible peformance improvement here!
+ */
+ tid = map_from_gdb_tid (gdb_tid);
+ return !is_terminated (tid);
}
#endif
+\f
-\f
/* This function attempts to read the specified number of bytes from the
save_state_t that is our view into the hardware registers, starting at
ss_offset, and ending at ss_offset + sizeof_buf - 1
If it fails, it returns a negative result. The contents of buf are
undefined it this function fails.
- */
+ */
int
read_from_register_save_state (tid, ss_offset, buf, sizeof_buf)
- int tid;
- TTRACE_ARG_TYPE ss_offset;
- char * buf;
- int sizeof_buf;
+ int tid;
+ TTRACE_ARG_TYPE ss_offset;
+ char *buf;
+ int sizeof_buf;
{
- int tt_status;
- register_value_t register_value = 0;
+ int tt_status;
+ register_value_t register_value = 0;
tt_status = call_ttrace (TT_LWP_RUREGS,
- tid,
- ss_offset,
- (TTRACE_ARG_TYPE) sizeof_buf,
- (TTRACE_ARG_TYPE) buf);
-
- if( tt_status == 1 )
- /* Map ttrace's version of success to our version.
- * Sometime ttrace returns 0, but that's ok here.
- */
- return 0;
-
+ tid,
+ ss_offset,
+ (TTRACE_ARG_TYPE) sizeof_buf,
+ (TTRACE_ARG_TYPE) buf);
+
+ if (tt_status == 1)
+ /* Map ttrace's version of success to our version.
+ * Sometime ttrace returns 0, but that's ok here.
+ */
+ return 0;
+
return tt_status;
}
-
\f
+
/* This function attempts to write the specified number of bytes to the
save_state_t that is our view into the hardware registers, starting at
ss_offset, and ending at ss_offset + sizeof_buf - 1
If it fails, it returns a negative result. The contents of the save_state_t
are undefined it this function fails.
- */
+ */
int
write_to_register_save_state (tid, ss_offset, buf, sizeof_buf)
- int tid;
- TTRACE_ARG_TYPE ss_offset;
- char * buf;
- int sizeof_buf;
+ int tid;
+ TTRACE_ARG_TYPE ss_offset;
+ char *buf;
+ int sizeof_buf;
{
- int tt_status;
- register_value_t register_value = 0;
+ int tt_status;
+ register_value_t register_value = 0;
tt_status = call_ttrace (TT_LWP_WUREGS,
- tid,
- ss_offset,
- (TTRACE_ARG_TYPE) sizeof_buf,
- (TTRACE_ARG_TYPE) buf);
+ tid,
+ ss_offset,
+ (TTRACE_ARG_TYPE) sizeof_buf,
+ (TTRACE_ARG_TYPE) buf);
return tt_status;
}
-
\f
+
/* This function is a sop to the largeish number of direct calls
to call_ptrace that exist in other files. Rather than create
functions whose name abstracts away from ptrace, and change all
Note HP-UX explicitly disallows a mix of ptrace & ttrace on a traced
process. Thus, we must translate all ptrace requests into their
process-specific, ttrace equivalents.
- */
+ */
int
call_ptrace (pt_request, gdb_tid, addr, data)
- int pt_request;
- int gdb_tid;
- PTRACE_ARG3_TYPE addr;
- int data;
+ int pt_request;
+ int gdb_tid;
+ PTRACE_ARG3_TYPE addr;
+ int data;
{
- ttreq_t tt_request;
- TTRACE_ARG_TYPE tt_addr = (TTRACE_ARG_TYPE) addr;
- TTRACE_ARG_TYPE tt_data = (TTRACE_ARG_TYPE) data;
- TTRACE_ARG_TYPE tt_addr2 = TT_NIL;
- int tt_status;
- register_value_t register_value;
- int read_buf;
+ ttreq_t tt_request;
+ TTRACE_ARG_TYPE tt_addr = (TTRACE_ARG_TYPE) addr;
+ TTRACE_ARG_TYPE tt_data = (TTRACE_ARG_TYPE) data;
+ TTRACE_ARG_TYPE tt_addr2 = TT_NIL;
+ int tt_status;
+ register_value_t register_value;
+ int read_buf;
/* Perform the necessary argument translation. Note that some
cases are funky enough in the ttrace realm that we handle them
very specially.
*/
- switch (pt_request) {
+ switch (pt_request)
+ {
/* The following cases cannot conveniently be handled conveniently
by merely adjusting the ptrace arguments and feeding into the
generic call to ttrace at the bottom of this function.
Note that because all branches of this switch end in "return",
there's no need for any "break" statements.
- */
- case PT_SETTRC :
- return parent_attach_all ();
-
- case PT_RUREGS :
- tt_status = read_from_register_save_state (gdb_tid,
- tt_addr,
- ®ister_value,
- sizeof (register_value));
- if (tt_status < 0)
- return tt_status;
- return register_value;
-
- case PT_WUREGS :
- register_value = (int) tt_data;
- tt_status = write_to_register_save_state (gdb_tid,
- tt_addr,
- ®ister_value,
- sizeof (register_value));
- return tt_status;
- break;
-
- case PT_READ_I :
- tt_status = call_ttrace (TT_PROC_RDTEXT, /* Implicit 4-byte xfer becomes block-xfer. */
- gdb_tid,
- tt_addr,
- (TTRACE_ARG_TYPE) 4,
- (TTRACE_ARG_TYPE) &read_buf);
- if (tt_status < 0)
- return tt_status;
- return read_buf;
-
- case PT_READ_D :
- tt_status = call_ttrace (TT_PROC_RDDATA, /* Implicit 4-byte xfer becomes block-xfer. */
- gdb_tid,
- tt_addr,
- (TTRACE_ARG_TYPE) 4,
- (TTRACE_ARG_TYPE) &read_buf);
- if (tt_status < 0)
- return tt_status;
- return read_buf;
-
- case PT_ATTACH :
- tt_status = call_real_ttrace (TT_PROC_ATTACH,
- map_from_gdb_tid (gdb_tid),
- (lwpid_t) TT_NIL,
- tt_addr,
- (TTRACE_ARG_TYPE) TT_VERSION,
- tt_addr2);
- if (tt_status < 0)
- return tt_status;
- return tt_status;
+ */
+ case PT_SETTRC:
+ return parent_attach_all ();
+
+ case PT_RUREGS:
+ tt_status = read_from_register_save_state (gdb_tid,
+ tt_addr,
+ ®ister_value,
+ sizeof (register_value));
+ if (tt_status < 0)
+ return tt_status;
+ return register_value;
+
+ case PT_WUREGS:
+ register_value = (int) tt_data;
+ tt_status = write_to_register_save_state (gdb_tid,
+ tt_addr,
+ ®ister_value,
+ sizeof (register_value));
+ return tt_status;
+ break;
+
+ case PT_READ_I:
+ tt_status = call_ttrace (TT_PROC_RDTEXT, /* Implicit 4-byte xfer becomes block-xfer. */
+ gdb_tid,
+ tt_addr,
+ (TTRACE_ARG_TYPE) 4,
+ (TTRACE_ARG_TYPE) & read_buf);
+ if (tt_status < 0)
+ return tt_status;
+ return read_buf;
+
+ case PT_READ_D:
+ tt_status = call_ttrace (TT_PROC_RDDATA, /* Implicit 4-byte xfer becomes block-xfer. */
+ gdb_tid,
+ tt_addr,
+ (TTRACE_ARG_TYPE) 4,
+ (TTRACE_ARG_TYPE) & read_buf);
+ if (tt_status < 0)
+ return tt_status;
+ return read_buf;
+
+ case PT_ATTACH:
+ tt_status = call_real_ttrace (TT_PROC_ATTACH,
+ map_from_gdb_tid (gdb_tid),
+ (lwpid_t) TT_NIL,
+ tt_addr,
+ (TTRACE_ARG_TYPE) TT_VERSION,
+ tt_addr2);
+ if (tt_status < 0)
+ return tt_status;
+ return tt_status;
/* The following cases are handled by merely adjusting the ptrace
arguments and feeding into the generic call to ttrace.
- */
- case PT_DETACH :
- tt_request = TT_PROC_DETACH;
- break;
-
- case PT_WRITE_I :
- tt_request = TT_PROC_WRTEXT; /* Translates 4-byte xfer to block-xfer. */
- tt_data = 4; /* This many bytes. */
- tt_addr2 = (TTRACE_ARG_TYPE) &data; /* Address of xfer source. */
- break;
-
- case PT_WRITE_D :
- tt_request = TT_PROC_WRDATA; /* Translates 4-byte xfer to block-xfer. */
- tt_data = 4; /* This many bytes. */
- tt_addr2 = (TTRACE_ARG_TYPE) &data; /* Address of xfer source. */
- break;
-
- case PT_RDTEXT :
- tt_request = TT_PROC_RDTEXT;
- break;
-
- case PT_RDDATA :
- tt_request = TT_PROC_RDDATA;
- break;
-
- case PT_WRTEXT :
- tt_request = TT_PROC_WRTEXT;
- break;
-
- case PT_WRDATA :
- tt_request = TT_PROC_WRDATA;
- break;
-
- case PT_CONTINUE :
- tt_request = TT_PROC_CONTINUE;
- break;
-
- case PT_STEP :
- tt_request = TT_LWP_SINGLE; /* Should not be making this request? */
- break;
-
- case PT_KILL :
- tt_request = TT_PROC_EXIT;
- break;
-
- case PT_GET_PROCESS_PATHNAME :
- tt_request = TT_PROC_GET_PATHNAME;
- break;
-
- default :
- tt_request = pt_request; /* Let ttrace be the one to complain. */
- break;
- }
+ */
+ case PT_DETACH:
+ tt_request = TT_PROC_DETACH;
+ break;
+
+ case PT_WRITE_I:
+ tt_request = TT_PROC_WRTEXT; /* Translates 4-byte xfer to block-xfer. */
+ tt_data = 4; /* This many bytes. */
+ tt_addr2 = (TTRACE_ARG_TYPE) & data; /* Address of xfer source. */
+ break;
+
+ case PT_WRITE_D:
+ tt_request = TT_PROC_WRDATA; /* Translates 4-byte xfer to block-xfer. */
+ tt_data = 4; /* This many bytes. */
+ tt_addr2 = (TTRACE_ARG_TYPE) & data; /* Address of xfer source. */
+ break;
+
+ case PT_RDTEXT:
+ tt_request = TT_PROC_RDTEXT;
+ break;
+
+ case PT_RDDATA:
+ tt_request = TT_PROC_RDDATA;
+ break;
+
+ case PT_WRTEXT:
+ tt_request = TT_PROC_WRTEXT;
+ break;
+
+ case PT_WRDATA:
+ tt_request = TT_PROC_WRDATA;
+ break;
+
+ case PT_CONTINUE:
+ tt_request = TT_PROC_CONTINUE;
+ break;
+
+ case PT_STEP:
+ tt_request = TT_LWP_SINGLE; /* Should not be making this request? */
+ break;
+
+ case PT_KILL:
+ tt_request = TT_PROC_EXIT;
+ break;
+
+ case PT_GET_PROCESS_PATHNAME:
+ tt_request = TT_PROC_GET_PATHNAME;
+ break;
+
+ default:
+ tt_request = pt_request; /* Let ttrace be the one to complain. */
+ break;
+ }
return call_ttrace (tt_request,
- gdb_tid,
- tt_addr,
- tt_data,
- tt_addr2);
+ gdb_tid,
+ tt_addr,
+ tt_data,
+ tt_addr2);
}
/* Kill that pesky process!
void
kill_inferior ()
{
- int tid;
- int wait_status;
- thread_info * t;
+ int tid;
+ int wait_status;
+ thread_info *t;
thread_info **paranoia;
- int para_count, i;
+ int para_count, i;
if (inferior_pid == 0)
return;
But we can't just call target_mourn_inferior() for each, since that
zaps the target vector.
- */
+ */
- paranoia = (thread_info **) malloc( thread_head.count *
- sizeof(thread_info *));
+ paranoia = (thread_info **) malloc (thread_head.count *
+ sizeof (thread_info *));
para_count = 0;
-
+
t = thread_head.head;
- while (t) {
-
- paranoia[ para_count ] = t;
- for( i = 0; i < para_count; i++ ){
- if( t->next == paranoia[i] ) {
- warning( "Bad data in gdb's thread data; repairing." );
- t->next = 0;
- }
- }
- para_count++;
-
- if (t->am_pseudo && (t->pid != inferior_pid))
- {
- /* TT_PROC_STOP doesn't require a subsequent ttrace_wait, as it
- * generates no event.
- */
- call_ttrace (TT_PROC_STOP,
- t->pid,
- TT_NIL,
- TT_NIL,
- TT_NIL);
-
- call_ttrace (TT_PROC_DETACH,
- t->pid,
- TT_NIL,
- (TTRACE_ARG_TYPE) TARGET_SIGNAL_0,
- TT_NIL);
- }
- t = t->next;
- }
+ while (t)
+ {
+
+ paranoia[para_count] = t;
+ for (i = 0; i < para_count; i++)
+ {
+ if (t->next == paranoia[i])
+ {
+ warning ("Bad data in gdb's thread data; repairing.");
+ t->next = 0;
+ }
+ }
+ para_count++;
+
+ if (t->am_pseudo && (t->pid != inferior_pid))
+ {
+ /* TT_PROC_STOP doesn't require a subsequent ttrace_wait, as it
+ * generates no event.
+ */
+ call_ttrace (TT_PROC_STOP,
+ t->pid,
+ TT_NIL,
+ TT_NIL,
+ TT_NIL);
+
+ call_ttrace (TT_PROC_DETACH,
+ t->pid,
+ TT_NIL,
+ (TTRACE_ARG_TYPE) TARGET_SIGNAL_0,
+ TT_NIL);
+ }
+ t = t->next;
+ }
+
+ free (paranoia);
- free( paranoia );
-
call_ttrace (TT_PROC_STOP,
- inferior_pid,
- TT_NIL,
- TT_NIL,
- TT_NIL);
+ inferior_pid,
+ TT_NIL,
+ TT_NIL,
+ TT_NIL);
target_mourn_inferior ();
- clear_thread_info();
+ clear_thread_info ();
}
/* Sanity check a thread about to be continued.
*/
static void
-thread_dropping_event_check( p )
- thread_info *p;
+thread_dropping_event_check (p)
+ thread_info *p;
{
- if( !p->handled ) {
- /*
- * This seems to happen when we "next" over a
- * "fork()" while following the parent. If it's
- * the FORK event, that's ok. If it's a SIGNAL
- * in the unfollowed child, that's ok to--but
- * how can we know that's what's going on?
- *
- * FIXME!
- */
- if( p->have_state ) {
- if( p->last_stop_state.tts_event == TTEVT_FORK ) {
- /* Ok */
- ;
- }
- else if( p->last_stop_state.tts_event == TTEVT_SIGNAL ) {
- /* Ok, close eyes and let it happen.
- */
- ;
- }
- else {
- /* This shouldn't happen--we're dropping a
- * real event.
- */
- warning( "About to continue process %d, thread %d with unhandled event %s.",
- p->pid, p->tid,
- get_printable_name_of_ttrace_event(
- p->last_stop_state.tts_event ));
+ if (!p->handled)
+ {
+ /*
+ * This seems to happen when we "next" over a
+ * "fork()" while following the parent. If it's
+ * the FORK event, that's ok. If it's a SIGNAL
+ * in the unfollowed child, that's ok to--but
+ * how can we know that's what's going on?
+ *
+ * FIXME!
+ */
+ if (p->have_state)
+ {
+ if (p->last_stop_state.tts_event == TTEVT_FORK)
+ {
+ /* Ok */
+ ;
+ }
+ else if (p->last_stop_state.tts_event == TTEVT_SIGNAL)
+ {
+ /* Ok, close eyes and let it happen.
+ */
+ ;
+ }
+ else
+ {
+ /* This shouldn't happen--we're dropping a
+ * real event.
+ */
+ warning ("About to continue process %d, thread %d with unhandled event %s.",
+ p->pid, p->tid,
+ get_printable_name_of_ttrace_event (
+ p->last_stop_state.tts_event));
#ifdef PARANOIA
- if( debug_on )
- print_tthread( p );
+ if (debug_on)
+ print_tthread (p);
#endif
- }
- }
- else {
- /* No saved state, have to assume it failed.
- */
- warning( "About to continue process %d, thread %d with unhandled event.",
- p->pid, p->tid );
+ }
+ }
+ else
+ {
+ /* No saved state, have to assume it failed.
+ */
+ warning ("About to continue process %d, thread %d with unhandled event.",
+ p->pid, p->tid);
#ifdef PARANOIA
- if( debug_on )
- print_tthread( p );
+ if (debug_on)
+ print_tthread (p);
#endif
- }
+ }
}
-
-} /* thread_dropping_event_check */
+
+} /* thread_dropping_event_check */
/* Use a loop over the threads to continue all the threads but
* the one specified, which is to be stepped.
*/
static void
-threads_continue_all_but_one( gdb_tid, signal )
- lwpid_t gdb_tid;
- int signal;
+threads_continue_all_but_one (gdb_tid, signal)
+ lwpid_t gdb_tid;
+ int signal;
{
- thread_info *p;
- int thread_signal;
- lwpid_t real_tid;
- lwpid_t scan_tid;
- ttstate_t state;
- int real_pid;
-
+ thread_info *p;
+ int thread_signal;
+ lwpid_t real_tid;
+ lwpid_t scan_tid;
+ ttstate_t state;
+ int real_pid;
+
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Using loop over threads to step/resume with signals\n" );
+ if (debug_on)
+ printf ("Using loop over threads to step/resume with signals\n");
#endif
- /* First update the thread list.
- */
- set_all_unseen();
- real_tid = map_from_gdb_tid( gdb_tid );
- real_pid = get_pid_for( real_tid );
-
- scan_tid = get_process_first_stopped_thread_id( real_pid, &state );
- while ( 0 != scan_tid ) {
-
+ /* First update the thread list.
+ */
+ set_all_unseen ();
+ real_tid = map_from_gdb_tid (gdb_tid);
+ real_pid = get_pid_for (real_tid);
+
+ scan_tid = get_process_first_stopped_thread_id (real_pid, &state);
+ while (0 != scan_tid)
+ {
+
#ifdef THREAD_DEBUG
- /* FIX: later should check state is stopped;
- * state.tts_flags & TTS_STATEMASK == TTS_WASSUSPENDED
- */
- if( debug_on )
- if( state.tts_flags & TTS_STATEMASK != TTS_WASSUSPENDED )
- printf( "About to continue non-stopped thread %d\n", scan_tid );
+ /* FIX: later should check state is stopped;
+ * state.tts_flags & TTS_STATEMASK == TTS_WASSUSPENDED
+ */
+ if (debug_on)
+ if (state.tts_flags & TTS_STATEMASK != TTS_WASSUSPENDED)
+ printf ("About to continue non-stopped thread %d\n", scan_tid);
#endif
- p = find_thread_info( scan_tid );
- if( NULL == p ) {
- add_tthread( real_pid, scan_tid );
- p = find_thread_info( scan_tid );
-
- /* This is either a newly-created thread or the
- * result of a fork; in either case there's no
- * actual event to worry about.
- */
- p->handled = 1;
-
- if( state.tts_event != TTEVT_NONE ) {
- /* Oops, do need to worry!
- */
- warning( "Unexpected thread with \"%s\" event.",
- get_printable_name_of_ttrace_event( state.tts_event ));
- }
- }
- else if( scan_tid != p->tid )
- error( "Bad data in thread database." );
+ p = find_thread_info (scan_tid);
+ if (NULL == p)
+ {
+ add_tthread (real_pid, scan_tid);
+ p = find_thread_info (scan_tid);
+
+ /* This is either a newly-created thread or the
+ * result of a fork; in either case there's no
+ * actual event to worry about.
+ */
+ p->handled = 1;
+
+ if (state.tts_event != TTEVT_NONE)
+ {
+ /* Oops, do need to worry!
+ */
+ warning ("Unexpected thread with \"%s\" event.",
+ get_printable_name_of_ttrace_event (state.tts_event));
+ }
+ }
+ else if (scan_tid != p->tid)
+ error ("Bad data in thread database.");
#ifdef THREAD_DEBUG
- if( debug_on )
- if( p->terminated )
- printf( "Why are we continuing a dead thread?\n" );
+ if (debug_on)
+ if (p->terminated)
+ printf ("Why are we continuing a dead thread?\n");
#endif
- p->seen = 1;
-
- scan_tid = get_process_next_stopped_thread_id( real_pid, &state );
+ p->seen = 1;
+
+ scan_tid = get_process_next_stopped_thread_id (real_pid, &state);
}
- /* Remove unseen threads.
- */
- update_thread_list();
+ /* Remove unseen threads.
+ */
+ update_thread_list ();
- /* Now run down the thread list and continue or step.
- */
- for( p = thread_head.head; p; p = p->next ) {
-
- /* Sanity check.
- */
- thread_dropping_event_check( p );
-
- /* Pass the correct signals along.
- */
- if( p->have_signal ) {
- thread_signal = p->signal_value;
- p->have_signal = 0;
- }
- else
- thread_signal = 0;
-
- if( p->tid != real_tid ) {
- /*
- * Not the thread of interest, so continue it
- * as the user expects.
- */
- if( p->stepping_mode == DO_STEP ) {
- /* Just step this thread.
- */
- call_ttrace(
- TT_LWP_SINGLE,
- p->tid,
- TT_USE_CURRENT_PC,
- (TTRACE_ARG_TYPE) target_signal_to_host( signal ),
- TT_NIL );
- }
- else {
- /* Regular continue (default case).
- */
- call_ttrace(
- TT_LWP_CONTINUE,
- p->tid,
- TT_USE_CURRENT_PC,
- (TTRACE_ARG_TYPE) target_signal_to_host( thread_signal ),
- TT_NIL );
- }
- }
- else {
- /* Step the thread of interest.
- */
- call_ttrace(
- TT_LWP_SINGLE,
- real_tid,
- TT_USE_CURRENT_PC,
- (TTRACE_ARG_TYPE) target_signal_to_host( signal ),
- TT_NIL );
- }
- } /* Loop over threads */
-} /* End threads_continue_all_but_one */
+ /* Now run down the thread list and continue or step.
+ */
+ for (p = thread_head.head; p; p = p->next)
+ {
+
+ /* Sanity check.
+ */
+ thread_dropping_event_check (p);
+
+ /* Pass the correct signals along.
+ */
+ if (p->have_signal)
+ {
+ thread_signal = p->signal_value;
+ p->have_signal = 0;
+ }
+ else
+ thread_signal = 0;
+
+ if (p->tid != real_tid)
+ {
+ /*
+ * Not the thread of interest, so continue it
+ * as the user expects.
+ */
+ if (p->stepping_mode == DO_STEP)
+ {
+ /* Just step this thread.
+ */
+ call_ttrace (
+ TT_LWP_SINGLE,
+ p->tid,
+ TT_USE_CURRENT_PC,
+ (TTRACE_ARG_TYPE) target_signal_to_host (signal),
+ TT_NIL);
+ }
+ else
+ {
+ /* Regular continue (default case).
+ */
+ call_ttrace (
+ TT_LWP_CONTINUE,
+ p->tid,
+ TT_USE_CURRENT_PC,
+ (TTRACE_ARG_TYPE) target_signal_to_host (thread_signal),
+ TT_NIL);
+ }
+ }
+ else
+ {
+ /* Step the thread of interest.
+ */
+ call_ttrace (
+ TT_LWP_SINGLE,
+ real_tid,
+ TT_USE_CURRENT_PC,
+ (TTRACE_ARG_TYPE) target_signal_to_host (signal),
+ TT_NIL);
+ }
+ } /* Loop over threads */
+} /* End threads_continue_all_but_one */
/* Use a loop over the threads to continue all the threads.
* This is done when a signal must be sent to any of the threads.
*/
static void
-threads_continue_all_with_signals( gdb_tid, signal )
- lwpid_t gdb_tid;
- int signal;
+threads_continue_all_with_signals (gdb_tid, signal)
+ lwpid_t gdb_tid;
+ int signal;
{
- thread_info *p;
- int thread_signal;
- lwpid_t real_tid;
- lwpid_t scan_tid;
- ttstate_t state;
- int real_pid;
+ thread_info *p;
+ int thread_signal;
+ lwpid_t real_tid;
+ lwpid_t scan_tid;
+ ttstate_t state;
+ int real_pid;
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Using loop over threads to resume with signals\n" );
+ if (debug_on)
+ printf ("Using loop over threads to resume with signals\n");
#endif
- /* Scan and update thread list.
- */
- set_all_unseen();
- real_tid = map_from_gdb_tid( gdb_tid );
- real_pid = get_pid_for( real_tid );
+ /* Scan and update thread list.
+ */
+ set_all_unseen ();
+ real_tid = map_from_gdb_tid (gdb_tid);
+ real_pid = get_pid_for (real_tid);
+
+ scan_tid = get_process_first_stopped_thread_id (real_pid, &state);
+ while (0 != scan_tid)
+ {
+
+#ifdef THREAD_DEBUG
+ if (debug_on)
+ if (state.tts_flags & TTS_STATEMASK != TTS_WASSUSPENDED)
+ warning ("About to continue non-stopped thread %d\n", scan_tid);
+#endif
+
+ p = find_thread_info (scan_tid);
+ if (NULL == p)
+ {
+ add_tthread (real_pid, scan_tid);
+ p = find_thread_info (scan_tid);
+
+ /* This is either a newly-created thread or the
+ * result of a fork; in either case there's no
+ * actual event to worry about.
+ */
+ p->handled = 1;
+
+ if (state.tts_event != TTEVT_NONE)
+ {
+ /* Oops, do need to worry!
+ */
+ warning ("Unexpected thread with \"%s\" event.",
+ get_printable_name_of_ttrace_event (state.tts_event));
+ }
+ }
- scan_tid = get_process_first_stopped_thread_id( real_pid, &state );
- while ( 0 != scan_tid ) {
-
#ifdef THREAD_DEBUG
- if( debug_on )
- if( state.tts_flags & TTS_STATEMASK != TTS_WASSUSPENDED )
- warning( "About to continue non-stopped thread %d\n", scan_tid );
+ if (debug_on)
+ if (p->terminated)
+ printf ("Why are we continuing a dead thread? (1)\n");
#endif
- p = find_thread_info( scan_tid );
- if( NULL == p ) {
- add_tthread( real_pid, scan_tid );
- p = find_thread_info( scan_tid );
-
- /* This is either a newly-created thread or the
- * result of a fork; in either case there's no
- * actual event to worry about.
- */
- p->handled = 1;
-
- if( state.tts_event != TTEVT_NONE ) {
- /* Oops, do need to worry!
- */
- warning( "Unexpected thread with \"%s\" event.",
- get_printable_name_of_ttrace_event( state.tts_event ));
- }
- }
+ p->seen = 1;
-#ifdef THREAD_DEBUG
- if( debug_on )
- if( p->terminated )
- printf( "Why are we continuing a dead thread? (1)\n" );
-#endif
+ scan_tid = get_process_next_stopped_thread_id (real_pid, &state);
+ }
- p->seen = 1;
+ /* Remove unseen threads from our list.
+ */
+ update_thread_list ();
- scan_tid = get_process_next_stopped_thread_id( real_pid, &state );
- }
+ /* Continue the threads.
+ */
+ for (p = thread_head.head; p; p = p->next)
+ {
- /* Remove unseen threads from our list.
- */
- update_thread_list();
+ /* Sanity check.
+ */
+ thread_dropping_event_check (p);
- /* Continue the threads.
- */
- for( p = thread_head.head; p; p = p->next ) {
-
- /* Sanity check.
- */
- thread_dropping_event_check( p );
-
- /* Pass the correct signals along.
- */
- if( p->tid == real_tid ) {
- thread_signal = signal;
- p->have_signal = 0;
- }
- else if( p->have_signal ) {
- thread_signal = p->signal_value;
- p->have_signal = 0;
- }
- else
- thread_signal = 0;
-
- if( p->stepping_mode == DO_STEP ) {
- call_ttrace(
- TT_LWP_SINGLE,
- p->tid,
- TT_USE_CURRENT_PC,
- (TTRACE_ARG_TYPE) target_signal_to_host( signal ),
- TT_NIL );
- }
- else {
- /* Continue this thread (default case).
- */
- call_ttrace(
- TT_LWP_CONTINUE,
- p->tid,
- TT_USE_CURRENT_PC,
- (TTRACE_ARG_TYPE) target_signal_to_host( thread_signal ),
- TT_NIL );
- }
- }
-} /* End threads_continue_all_with_signals */
+ /* Pass the correct signals along.
+ */
+ if (p->tid == real_tid)
+ {
+ thread_signal = signal;
+ p->have_signal = 0;
+ }
+ else if (p->have_signal)
+ {
+ thread_signal = p->signal_value;
+ p->have_signal = 0;
+ }
+ else
+ thread_signal = 0;
+
+ if (p->stepping_mode == DO_STEP)
+ {
+ call_ttrace (
+ TT_LWP_SINGLE,
+ p->tid,
+ TT_USE_CURRENT_PC,
+ (TTRACE_ARG_TYPE) target_signal_to_host (signal),
+ TT_NIL);
+ }
+ else
+ {
+ /* Continue this thread (default case).
+ */
+ call_ttrace (
+ TT_LWP_CONTINUE,
+ p->tid,
+ TT_USE_CURRENT_PC,
+ (TTRACE_ARG_TYPE) target_signal_to_host (thread_signal),
+ TT_NIL);
+ }
+ }
+} /* End threads_continue_all_with_signals */
/* Step one thread only.
*/
static void
-thread_fake_step( tid, signal )
- lwpid_t tid;
- enum target_signal signal;
+thread_fake_step (tid, signal)
+ lwpid_t tid;
+ enum target_signal signal;
{
- thread_info *p;
+ thread_info *p;
#ifdef THREAD_DEBUG
- if( debug_on ) {
- printf( "Doing a fake-step over a bpt, etc. for %d\n", tid );
+ if (debug_on)
+ {
+ printf ("Doing a fake-step over a bpt, etc. for %d\n", tid);
- if( is_terminated( tid ))
- printf( "Why are we continuing a dead thread? (4)\n" );
+ if (is_terminated (tid))
+ printf ("Why are we continuing a dead thread? (4)\n");
}
#endif
-
- if( doing_fake_step )
- warning( "Step while step already in progress." );
- /* See if there's a saved signal value for this
- * thread to be passed on, but no current signal.
- */
- p = find_thread_info( tid );
- if( p != NULL ) {
- if( p->have_signal && signal == NULL ) {
- /* Pass on a saved signal.
- */
- signal = p->signal_value;
- }
-
- p->have_signal = 0;
- }
-
- if( !p->handled )
- warning( "Internal error: continuing unhandled thread." );
-
- call_ttrace( TT_LWP_SINGLE,
- tid,
- TT_USE_CURRENT_PC,
- (TTRACE_ARG_TYPE) target_signal_to_host (signal),
- TT_NIL );
-
- /* Do bookkeeping so "call_ttrace_wait" knows it has to wait
- * for this thread only, and clear any saved signal info.
- */
- doing_fake_step = 1;
- fake_step_tid = tid;
+ if (doing_fake_step)
+ warning ("Step while step already in progress.");
+
+ /* See if there's a saved signal value for this
+ * thread to be passed on, but no current signal.
+ */
+ p = find_thread_info (tid);
+ if (p != NULL)
+ {
+ if (p->have_signal && signal == NULL)
+ {
+ /* Pass on a saved signal.
+ */
+ signal = p->signal_value;
+ }
+
+ p->have_signal = 0;
+ }
+
+ if (!p->handled)
+ warning ("Internal error: continuing unhandled thread.");
-} /* End thread_fake_step */
+ call_ttrace (TT_LWP_SINGLE,
+ tid,
+ TT_USE_CURRENT_PC,
+ (TTRACE_ARG_TYPE) target_signal_to_host (signal),
+ TT_NIL);
+
+ /* Do bookkeeping so "call_ttrace_wait" knows it has to wait
+ * for this thread only, and clear any saved signal info.
+ */
+ doing_fake_step = 1;
+ fake_step_tid = tid;
+
+} /* End thread_fake_step */
/* Continue one thread when a signal must be sent to it.
*/
static void
-threads_continue_one_with_signal( gdb_tid, signal )
- lwpid_t gdb_tid;
- int signal;
+threads_continue_one_with_signal (gdb_tid, signal)
+ lwpid_t gdb_tid;
+ int signal;
{
- thread_info *p;
- lwpid_t real_tid;
- int real_pid;
-
+ thread_info *p;
+ lwpid_t real_tid;
+ int real_pid;
+
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Continuing one thread with a signal\n" );
+ if (debug_on)
+ printf ("Continuing one thread with a signal\n");
#endif
- real_tid = map_from_gdb_tid( gdb_tid );
- real_pid = get_pid_for( real_tid );
+ real_tid = map_from_gdb_tid (gdb_tid);
+ real_pid = get_pid_for (real_tid);
- p = find_thread_info( real_tid );
- if( NULL == p ) {
- add_tthread( real_pid, real_tid );
+ p = find_thread_info (real_tid);
+ if (NULL == p)
+ {
+ add_tthread (real_pid, real_tid);
}
#ifdef THREAD_DEBUG
- if( debug_on )
- if( p->terminated )
- printf( "Why are we continuing a dead thread? (2)\n" );
+ if (debug_on)
+ if (p->terminated)
+ printf ("Why are we continuing a dead thread? (2)\n");
#endif
- if( !p->handled )
- warning( "Internal error: continuing unhandled thread." );
-
- p->have_signal = 0;
-
- call_ttrace( TT_LWP_CONTINUE,
- gdb_tid,
- TT_USE_CURRENT_PC,
- (TTRACE_ARG_TYPE) target_signal_to_host( signal ),
- TT_NIL );
+ if (!p->handled)
+ warning ("Internal error: continuing unhandled thread.");
+
+ p->have_signal = 0;
+
+ call_ttrace (TT_LWP_CONTINUE,
+ gdb_tid,
+ TT_USE_CURRENT_PC,
+ (TTRACE_ARG_TYPE) target_signal_to_host (signal),
+ TT_NIL);
}
#endif
#ifndef CHILD_RESUME
/* Resume execution of the inferior process.
- *
+
* This routine is in charge of setting the "handled" bits.
*
* If STEP is zero, continue it.
* | user command.
*/
void
-child_resume( gdb_tid, step, signal )
+child_resume (gdb_tid, step, signal)
lwpid_t gdb_tid;
- int step;
+ int step;
enum target_signal signal;
{
- int resume_all_threads;
+ int resume_all_threads;
lwpid_t tid;
- process_state_t new_process_state;
+ process_state_t new_process_state;
resume_all_threads =
(gdb_tid == INFTTRACE_ALL_THREADS) ||
(vfork_in_flight);
- if (resume_all_threads) {
- /* Resume all threads, but first pick a tid value
- * so we can get the pid when in call_ttrace doing
- * the map.
- */
- if (vfork_in_flight)
- tid = vforking_child_pid;
- else
- tid = map_from_gdb_tid( inferior_pid );
- }
+ if (resume_all_threads)
+ {
+ /* Resume all threads, but first pick a tid value
+ * so we can get the pid when in call_ttrace doing
+ * the map.
+ */
+ if (vfork_in_flight)
+ tid = vforking_child_pid;
+ else
+ tid = map_from_gdb_tid (inferior_pid);
+ }
else
- tid = map_from_gdb_tid( gdb_tid );
+ tid = map_from_gdb_tid (gdb_tid);
#ifdef THREAD_DEBUG
- if( debug_on ) {
- if( more_events_left )
- printf( "More events; " );
+ if (debug_on)
+ {
+ if (more_events_left)
+ printf ("More events; ");
- if( signal != 0 )
- printf( "Sending signal %d; ", signal );
-
- if( resume_all_threads ) {
- if( step == 0 )
- printf( "Continue process %d\n", tid );
- else
- printf( "Step/continue thread %d\n", tid );
- }
- else {
- if( step == 0 )
- printf( "Continue thread %d\n", tid );
- else
- printf( "Step just thread %d\n", tid );
- }
-
- if( vfork_in_flight )
- printf( "Vfork in flight\n" );
- }
+ if (signal != 0)
+ printf ("Sending signal %d; ", signal);
+
+ if (resume_all_threads)
+ {
+ if (step == 0)
+ printf ("Continue process %d\n", tid);
+ else
+ printf ("Step/continue thread %d\n", tid);
+ }
+ else
+ {
+ if (step == 0)
+ printf ("Continue thread %d\n", tid);
+ else
+ printf ("Step just thread %d\n", tid);
+ }
+
+ if (vfork_in_flight)
+ printf ("Vfork in flight\n");
+ }
#endif
- if( process_state == RUNNING )
- warning( "Internal error in resume logic; doing resume or step anyway." );
-
- if( !step /* Asked to continue... */
- && resume_all_threads /* whole process.. */
- && signal != 0 /* with a signal... */
- && more_events_left > 0 ) { /* but we can't yet--save it! */
+ if (process_state == RUNNING)
+ warning ("Internal error in resume logic; doing resume or step anyway.");
+
+ if (!step /* Asked to continue... */
+ && resume_all_threads /* whole process.. */
+ && signal != 0 /* with a signal... */
+ && more_events_left > 0)
+ { /* but we can't yet--save it! */
/* Continue with signal means we have to set the pending
* signal value for this thread.
*/
thread_info *k;
-
+
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Saving signal %d for thread %d\n", signal, tid );
+ if (debug_on)
+ printf ("Saving signal %d for thread %d\n", signal, tid);
#endif
- k = find_thread_info( tid );
- if( k != NULL ) {
- k->have_signal = 1;
- k->signal_value = signal;
+ k = find_thread_info (tid);
+ if (k != NULL)
+ {
+ k->have_signal = 1;
+ k->signal_value = signal;
#ifdef THREAD_DEBUG
- if( debug_on )
- if( k->terminated )
- printf( "Why are we continuing a dead thread? (3)\n" );
+ if (debug_on)
+ if (k->terminated)
+ printf ("Why are we continuing a dead thread? (3)\n");
#endif
- }
+ }
#ifdef THREAD_DEBUG
- else if( debug_on ) {
- printf( "No thread info for tid %d\n", tid );
- }
+ else if (debug_on)
+ {
+ printf ("No thread info for tid %d\n", tid);
+ }
#endif
- }
+ }
/* Are we faking this "continue" or "step"?
- *
+
* We used to do steps by continuing all the threads for
* which the events had been handled already. While
* conceptually nicer (hides it all in a lower level), this
* and one thread is in the join, and the user wants to step that
* thread).
*/
- if( resume_all_threads /* Whole process, therefore user command */
- && more_events_left > 0 ) { /* But we can't do this yet--fake it! */
+ if (resume_all_threads /* Whole process, therefore user command */
+ && more_events_left > 0)
+ { /* But we can't do this yet--fake it! */
thread_info *p;
-
- if( !step ) {
- /* No need to do any notes on a per-thread
- * basis--we're done!
- */
+
+ if (!step)
+ {
+ /* No need to do any notes on a per-thread
+ * basis--we're done!
+ */
#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "Faking a process resume.\n" );
+ if (debug_on)
+ printf ("Faking a process resume.\n");
#endif
- return;
- }
- else {
+ return;
+ }
+ else
+ {
#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "Faking a process step.\n" );
+ if (debug_on)
+ printf ("Faking a process step.\n");
#endif
- }
-
- p = find_thread_info( tid );
- if( p == NULL ) {
- warning( "No thread information for tid %d, 'next' command ignored.\n", tid );
- return;
- }
- else {
+ }
+
+ p = find_thread_info (tid);
+ if (p == NULL)
+ {
+ warning ("No thread information for tid %d, 'next' command ignored.\n", tid);
+ return;
+ }
+ else
+ {
#ifdef THREAD_DEBUG
- if( debug_on )
- if( p->terminated )
- printf( "Why are we continuing a dead thread? (3.5)\n" );
+ if (debug_on)
+ if (p->terminated)
+ printf ("Why are we continuing a dead thread? (3.5)\n");
#endif
- if( p->stepping_mode != DO_DEFAULT ) {
- warning( "Step or continue command applied to thread which is already stepping or continuing; command ignored." );
+ if (p->stepping_mode != DO_DEFAULT)
+ {
+ warning ("Step or continue command applied to thread which is already stepping or continuing; command ignored.");
- return;
- }
+ return;
+ }
- if( step )
- p->stepping_mode = DO_STEP;
- else
- p->stepping_mode = DO_CONTINUE;
+ if (step)
+ p->stepping_mode = DO_STEP;
+ else
+ p->stepping_mode = DO_CONTINUE;
- return;
- } /* Have thread info */
- } /* Must fake step or go */
+ return;
+ } /* Have thread info */
+ } /* Must fake step or go */
/* Execept for fake-steps, from here on we know we are
* going to wind up with a running process which will
* continue request (by setting breakpoints on all possible successor
* instructions), so we don't have to worry about that here.
*/
- if (step) {
- if( resume_all_threads ) {
- /*
- * Regular user step: other threads get a "continue".
- */
- threads_continue_all_but_one( tid, signal );
- clear_all_handled();
- clear_all_stepping_mode();
- }
-
- else {
- /* "Fake step": gdb is stepping one thread over a
- * breakpoint, watchpoint, or out of a library load
- * event, etc. The rest just stay where they are.
- *
- * Also used when there are pending events: we really
- * step the current thread, but leave the rest stopped.
- * Users can't request this, but "wait_for_inferior"
- * does--a lot!
- */
- thread_fake_step( tid, signal );
-
- /* Clear the "handled" state of this thread, because
- * we'll soon get a new event for it. Other events
- * stay as they were.
- */
- clear_handled( tid );
- clear_stepping_mode( tid );
- new_process_state = FAKE_STEPPING;
- }
- }
-
- else {
+ if (step)
+ {
+ if (resume_all_threads)
+ {
+ /*
+ * Regular user step: other threads get a "continue".
+ */
+ threads_continue_all_but_one (tid, signal);
+ clear_all_handled ();
+ clear_all_stepping_mode ();
+ }
+
+ else
+ {
+ /* "Fake step": gdb is stepping one thread over a
+ * breakpoint, watchpoint, or out of a library load
+ * event, etc. The rest just stay where they are.
+ *
+ * Also used when there are pending events: we really
+ * step the current thread, but leave the rest stopped.
+ * Users can't request this, but "wait_for_inferior"
+ * does--a lot!
+ */
+ thread_fake_step (tid, signal);
+
+ /* Clear the "handled" state of this thread, because
+ * we'll soon get a new event for it. Other events
+ * stay as they were.
+ */
+ clear_handled (tid);
+ clear_stepping_mode (tid);
+ new_process_state = FAKE_STEPPING;
+ }
+ }
+
+ else
+ {
/* TT_LWP_CONTINUE can pass signals to threads,
* TT_PROC_CONTINUE can't. So if there are any
* signals to pass, we have to use the (slower)
* Equally, if we have to not continue some threads,
* due to saved events, we have to use the loop.
*/
- if( (signal != 0) || saved_signals_exist()) {
- if( resume_all_threads ) {
+ if ((signal != 0) || saved_signals_exist ())
+ {
+ if (resume_all_threads)
+ {
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Doing a continue by loop of all threads\n" );
+ if (debug_on)
+ printf ("Doing a continue by loop of all threads\n");
#endif
- threads_continue_all_with_signals( tid, signal );
+ threads_continue_all_with_signals (tid, signal);
- clear_all_handled();
- clear_all_stepping_mode();
- }
+ clear_all_handled ();
+ clear_all_stepping_mode ();
+ }
- else {
+ else
+ {
#ifdef THREAD_DEBUG
- printf( "Doing a continue w/signal of just thread %d\n", tid );
+ printf ("Doing a continue w/signal of just thread %d\n", tid);
#endif
- threads_continue_one_with_signal( tid, signal );
-
- /* Clear the "handled" state of this thread, because
- * we'll soon get a new event for it. Other events
- * can stay as they were.
- */
- clear_handled( tid );
- clear_stepping_mode( tid );
- }
- }
-
- else {
- /* No signals to send.
- */
- if( resume_all_threads ) {
+ threads_continue_one_with_signal (tid, signal);
+
+ /* Clear the "handled" state of this thread, because
+ * we'll soon get a new event for it. Other events
+ * can stay as they were.
+ */
+ clear_handled (tid);
+ clear_stepping_mode (tid);
+ }
+ }
+
+ else
+ {
+ /* No signals to send.
+ */
+ if (resume_all_threads)
+ {
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Doing a continue by process of process %d\n", tid );
+ if (debug_on)
+ printf ("Doing a continue by process of process %d\n", tid);
#endif
- if( more_events_left > 0 ) {
- warning( "Losing buffered events on continue." );
- more_events_left = 0;
- }
+ if (more_events_left > 0)
+ {
+ warning ("Losing buffered events on continue.");
+ more_events_left = 0;
+ }
- call_ttrace( TT_PROC_CONTINUE,
- tid,
- TT_NIL,
- TT_NIL,
- TT_NIL );
+ call_ttrace (TT_PROC_CONTINUE,
+ tid,
+ TT_NIL,
+ TT_NIL,
+ TT_NIL);
- clear_all_handled();
- clear_all_stepping_mode();
- }
+ clear_all_handled ();
+ clear_all_stepping_mode ();
+ }
- else {
+ else
+ {
#ifdef THREAD_DEBUG
- if( debug_on ) {
- printf( "Doing a continue of just thread %d\n", tid );
- if( is_terminated( tid ))
- printf( "Why are we continuing a dead thread? (5)\n" );
- }
+ if (debug_on)
+ {
+ printf ("Doing a continue of just thread %d\n", tid);
+ if (is_terminated (tid))
+ printf ("Why are we continuing a dead thread? (5)\n");
+ }
#endif
- call_ttrace( TT_LWP_CONTINUE,
- tid,
- TT_NIL,
- TT_NIL,
- TT_NIL );
-
- /* Clear the "handled" state of this thread, because
- * we'll soon get a new event for it. Other events
- * can stay as they were.
- */
- clear_handled( tid );
- clear_stepping_mode( tid );
- }
- }
- }
+ call_ttrace (TT_LWP_CONTINUE,
+ tid,
+ TT_NIL,
+ TT_NIL,
+ TT_NIL);
+
+ /* Clear the "handled" state of this thread, because
+ * we'll soon get a new event for it. Other events
+ * can stay as they were.
+ */
+ clear_handled (tid);
+ clear_stepping_mode (tid);
+ }
+ }
+ }
process_state = new_process_state;
#ifdef WAIT_BUFFER_DEBUG
- if( debug_on )
- printf( "Process set to %s\n",
- get_printable_name_of_process_state (process_state) );
+ if (debug_on)
+ printf ("Process set to %s\n",
+ get_printable_name_of_process_state (process_state));
#endif
}
#endif /* CHILD_RESUME */
-
\f
+
#ifdef ATTACH_DETACH
/*
* Like it says.
*
*/
static void
-update_thread_state_after_attach( pid, kind_of_go )
- int pid;
- attach_continue_t kind_of_go;
+update_thread_state_after_attach (pid, kind_of_go)
+ int pid;
+ attach_continue_t kind_of_go;
{
- int tt_status;
- ttstate_t thread_state;
- lwpid_t a_thread;
- lwpid_t tid;
+ int tt_status;
+ ttstate_t thread_state;
+ lwpid_t a_thread;
+ lwpid_t tid;
/* The process better be stopped.
*/
- if( process_state != STOPPED
- && process_state != VFORKING )
- warning( "Internal error attaching." );
+ if (process_state != STOPPED
+ && process_state != VFORKING)
+ warning ("Internal error attaching.");
/* Clear out old tthread info and start over. This has the
* side effect of ensuring that the TRAP is reported as being
* "require_notification_of_events" doesn't clear the thread
* info (it's called later than this routine).
*/
- clear_thread_info();
+ clear_thread_info ();
a_thread = 0;
for (tid = get_process_first_stopped_thread_id (pid, &thread_state);
tid = get_process_next_stopped_thread_id (pid, &thread_state))
{
thread_info *p;
-
+
if (a_thread == 0)
- {
- a_thread = tid;
+ {
+ a_thread = tid;
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "Attaching to process %d, thread %d\n",
- pid, a_thread );
+ if (debug_on)
+ printf ("Attaching to process %d, thread %d\n",
+ pid, a_thread);
#endif
- }
+ }
/* Tell ourselves and the "rest of gdb" that this thread
* exists.
* NOTE: it probably isn't the originating thread,
* but that doesn't matter (we hope!).
*/
- add_tthread( pid, tid );
- p = find_thread_info( tid );
- if( NULL == p ) /* ?We just added it! */
- error( "Internal error adding a thread on attach." );
-
- copy_ttstate_t( &p->last_stop_state, thread_state );
+ add_tthread (pid, tid);
+ p = find_thread_info (tid);
+ if (NULL == p) /* ?We just added it! */
+ error ("Internal error adding a thread on attach.");
+
+ copy_ttstate_t (&p->last_stop_state, thread_state);
p->have_state = 1;
-
- if( DO_ATTACH_CONTINUE == kind_of_go ) {
- /*
- * If we are going to CONTINUE afterwards,
- * raising a SIGTRAP, don't bother trying to
- * handle this event. But check first!
- */
- switch( p->last_stop_state.tts_event ) {
-
- case TTEVT_NONE:
- /* Ok to set this handled.
- */
- break;
-
- default:
- warning( "Internal error; skipping event %s on process %d, thread %d.",
- get_printable_name_of_ttrace_event(
- p->last_stop_state.tts_event ),
- p->pid, p->tid);
- }
-
- set_handled( pid, tid );
-
- }
- else {
- /* There will be no "continue" opertion, so the
- * process remains stopped. Don't set any events
- * handled except the "gimmies".
- */
- switch( p->last_stop_state.tts_event ) {
-
- case TTEVT_NONE:
- /* Ok to ignore this.
- */
- set_handled( pid, tid );
- break;
-
- case TTEVT_EXEC:
- case TTEVT_FORK:
- /* Expected "other" FORK or EXEC event from a
- * fork or vfork.
- */
- break;
-
- default:
- printf( "Internal error: failed to handle event %s on process %d, thread %d.",
- get_printable_name_of_ttrace_event(
- p->last_stop_state.tts_event ),
- p->pid, p->tid);
- }
- }
-
- add_thread( tid ); /* in thread.c */
+
+ if (DO_ATTACH_CONTINUE == kind_of_go)
+ {
+ /*
+ * If we are going to CONTINUE afterwards,
+ * raising a SIGTRAP, don't bother trying to
+ * handle this event. But check first!
+ */
+ switch (p->last_stop_state.tts_event)
+ {
+
+ case TTEVT_NONE:
+ /* Ok to set this handled.
+ */
+ break;
+
+ default:
+ warning ("Internal error; skipping event %s on process %d, thread %d.",
+ get_printable_name_of_ttrace_event (
+ p->last_stop_state.tts_event),
+ p->pid, p->tid);
+ }
+
+ set_handled (pid, tid);
+
+ }
+ else
+ {
+ /* There will be no "continue" opertion, so the
+ * process remains stopped. Don't set any events
+ * handled except the "gimmies".
+ */
+ switch (p->last_stop_state.tts_event)
+ {
+
+ case TTEVT_NONE:
+ /* Ok to ignore this.
+ */
+ set_handled (pid, tid);
+ break;
+
+ case TTEVT_EXEC:
+ case TTEVT_FORK:
+ /* Expected "other" FORK or EXEC event from a
+ * fork or vfork.
+ */
+ break;
+
+ default:
+ printf ("Internal error: failed to handle event %s on process %d, thread %d.",
+ get_printable_name_of_ttrace_event (
+ p->last_stop_state.tts_event),
+ p->pid, p->tid);
+ }
+ }
+
+ add_thread (tid); /* in thread.c */
}
-
+
#ifdef PARANOIA
- if( debug_on )
- print_tthreads();
+ if (debug_on)
+ print_tthreads ();
#endif
/* One mustn't call ttrace_wait() after attaching via ttrace,
'cause the process is stopped already.
-
+
However, the upper layers of gdb's execution control will
want to wait after attaching (but not after forks, in
which case they will be doing a "target_resume", anticipating
need one that's either TTS_WASRUNNING--but we've stopped
it and made it TTS_WASSUSPENDED. Hum...FIXME!)
*/
- if( DO_ATTACH_CONTINUE == kind_of_go ) {
- tt_status = call_real_ttrace(
- TT_LWP_CONTINUE,
- pid,
- a_thread,
- TT_USE_CURRENT_PC,
- (TTRACE_ARG_TYPE) target_signal_to_host (TARGET_SIGNAL_TRAP),
- TT_NIL);
+ if (DO_ATTACH_CONTINUE == kind_of_go)
+ {
+ tt_status = call_real_ttrace (
+ TT_LWP_CONTINUE,
+ pid,
+ a_thread,
+ TT_USE_CURRENT_PC,
+ (TTRACE_ARG_TYPE) target_signal_to_host (TARGET_SIGNAL_TRAP),
+ TT_NIL);
if (errno)
- perror_with_name ("ttrace");
+ perror_with_name ("ttrace");
- clear_handled( a_thread ); /* So TRAP will be reported. */
+ clear_handled (a_thread); /* So TRAP will be reported. */
/* Now running.
*/
process_state = RUNNING;
- }
+ }
attach_flag = 1;
}
#endif /* ATTACH_DETACH */
-
\f
+
#ifdef ATTACH_DETACH
/* Start debugging the process whose number is PID.
* (A _real_ pid).
*/
int
-attach( pid )
+attach (pid)
int pid;
{
- int tt_status;
-
+ int tt_status;
+
tt_status = call_real_ttrace (
- TT_PROC_ATTACH,
- pid,
- (lwpid_t) TT_NIL,
- TT_NIL,
- (TTRACE_ARG_TYPE) TT_VERSION,
- TT_NIL);
+ TT_PROC_ATTACH,
+ pid,
+ (lwpid_t) TT_NIL,
+ TT_NIL,
+ (TTRACE_ARG_TYPE) TT_VERSION,
+ TT_NIL);
if (errno)
perror_with_name ("ttrace attach");
* the attach, so make sure the inferior is
* running when we're done.
*/
- update_thread_state_after_attach( pid, DO_ATTACH_CONTINUE );
+ update_thread_state_after_attach (pid, DO_ATTACH_CONTINUE);
return pid;
}
#if defined(CHILD_POST_ATTACH)
void
child_post_attach (pid)
- int pid;
+ int pid;
{
#ifdef THREAD_DEBUG
- if( debug_on )
- printf( "child-post-attach call\n" );
+ if (debug_on)
+ printf ("child-post-attach call\n");
#endif
require_notification_of_events (pid);
SIGNAL = 0 means just continue it.
*/
void
-detach( signal )
+detach (signal)
int signal;
{
errno = 0;
call_ttrace (TT_PROC_DETACH,
- inferior_pid,
- TT_NIL,
- (TTRACE_ARG_TYPE) signal,
- TT_NIL);
+ inferior_pid,
+ TT_NIL,
+ (TTRACE_ARG_TYPE) signal,
+ TT_NIL);
attach_flag = 0;
- clear_thread_info();
+ clear_thread_info ();
/* Process-state? */
}
#endif /* ATTACH_DETACH */
-
\f
+
/* Default the type of the ttrace transfer to int. */
#ifndef TTRACE_XFER_TYPE
#define TTRACE_XFER_TYPE int
/* Copy LEN bytes to or from inferior's memory starting at MEMADDR
to debugger memory starting at MYADDR. Copy to inferior if
WRITE is nonzero.
-
+
Returns the length copied, which is either the LEN argument or zero.
This xfer function does not do partial moves, since child_ops
doesn't allow memory operations to cross below us in the target stack
char *myaddr;
int len;
int write;
- struct target_ops *target; /* ignored */
+ struct target_ops *target; /* ignored */
{
register int i;
/* Round starting address down to longword boundary. */
- register CORE_ADDR addr = memaddr & - sizeof (TTRACE_XFER_TYPE);
+ register CORE_ADDR addr = memaddr & -sizeof (TTRACE_XFER_TYPE);
/* Round ending address up; get number of longwords that makes. */
register int count
- = (((memaddr + len) - addr) + sizeof (TTRACE_XFER_TYPE) - 1)
- / sizeof (TTRACE_XFER_TYPE);
+ = (((memaddr + len) - addr) + sizeof (TTRACE_XFER_TYPE) - 1)
+ / sizeof (TTRACE_XFER_TYPE);
/* Allocate buffer of that many longwords. */
register TTRACE_XFER_TYPE *buffer
- = (TTRACE_XFER_TYPE *) alloca (count * sizeof (TTRACE_XFER_TYPE));
+ = (TTRACE_XFER_TYPE *) alloca (count * sizeof (TTRACE_XFER_TYPE));
if (write)
{
/* Fill start and end extra bytes of buffer with existing memory data. */
- if (addr != memaddr || len < (int) sizeof (TTRACE_XFER_TYPE)) {
- /* Need part of initial word -- fetch it. */
- buffer[0] = call_ttrace (TT_LWP_RDTEXT,
- inferior_pid,
- (TTRACE_ARG_TYPE) addr,
- TT_NIL,
- TT_NIL);
- }
+ if (addr != memaddr || len < (int) sizeof (TTRACE_XFER_TYPE))
+ {
+ /* Need part of initial word -- fetch it. */
+ buffer[0] = call_ttrace (TT_LWP_RDTEXT,
+ inferior_pid,
+ (TTRACE_ARG_TYPE) addr,
+ TT_NIL,
+ TT_NIL);
+ }
if (count > 1) /* FIXME, avoid if even boundary */
{
buffer[count - 1] = call_ttrace (TT_LWP_RDTEXT,
- inferior_pid,
- ((TTRACE_ARG_TYPE)
- (addr + (count - 1) * sizeof (TTRACE_XFER_TYPE))),
- TT_NIL,
- TT_NIL);
+ inferior_pid,
+ ((TTRACE_ARG_TYPE)
+ (addr + (count - 1) * sizeof (TTRACE_XFER_TYPE))),
+ TT_NIL,
+ TT_NIL);
}
/* Copy data to be written over corresponding part of buffer */
{
errno = 0;
call_ttrace (TT_LWP_WRDATA,
- inferior_pid,
- (TTRACE_ARG_TYPE) addr,
- (TTRACE_ARG_TYPE) buffer[i],
- TT_NIL);
+ inferior_pid,
+ (TTRACE_ARG_TYPE) addr,
+ (TTRACE_ARG_TYPE) buffer[i],
+ TT_NIL);
if (errno)
{
/* Using the appropriate one (I or D) is necessary for
- Gould NP1, at least. */
+ Gould NP1, at least. */
errno = 0;
call_ttrace (TT_LWP_WRTEXT,
- inferior_pid,
- (TTRACE_ARG_TYPE) addr,
- (TTRACE_ARG_TYPE) buffer[i],
- TT_NIL);
+ inferior_pid,
+ (TTRACE_ARG_TYPE) addr,
+ (TTRACE_ARG_TYPE) buffer[i],
+ TT_NIL);
}
if (errno)
return 0;
{
errno = 0;
buffer[i] = call_ttrace (TT_LWP_RDTEXT,
- inferior_pid,
- (TTRACE_ARG_TYPE) addr,
- TT_NIL,
- TT_NIL);
+ inferior_pid,
+ (TTRACE_ARG_TYPE) addr,
+ TT_NIL,
+ TT_NIL);
if (errno)
return 0;
QUIT;
}
return len;
}
-
\f
+
static void
udot_info ()
{
- int udot_off; /* Offset into user struct */
- int udot_val; /* Value from user struct at udot_off */
- char mess[128]; /* For messages */
+ int udot_off; /* Offset into user struct */
+ int udot_val; /* Value from user struct at udot_off */
+ char mess[128]; /* For messages */
- if (!target_has_execution)
- {
- error ("The program is not being run.");
- }
+ if (!target_has_execution)
+ {
+ error ("The program is not being run.");
+ }
#if !defined (KERNEL_U_SIZE)
printf_filtered ("%04x:", udot_off);
}
udot_val = call_ttrace (TT_LWP_RUREGS,
- inferior_pid,
- (TTRACE_ARG_TYPE) udot_off,
- TT_NIL,
- TT_NIL);
+ inferior_pid,
+ (TTRACE_ARG_TYPE) udot_off,
+ TT_NIL,
+ TT_NIL);
if (errno != 0)
{
sprintf (mess, "\nreading user struct at offset 0x%x", udot_off);
*/
char *
child_pid_to_exec_file (tid)
- int tid;
+ int tid;
{
- static char exec_file_buffer[1024];
- int tt_status;
- CORE_ADDR top_of_stack;
- char four_chars[4];
- int name_index;
- int i;
- int done;
- int saved_inferior_pid;
-
+ static char exec_file_buffer[1024];
+ int tt_status;
+ CORE_ADDR top_of_stack;
+ char four_chars[4];
+ int name_index;
+ int i;
+ int done;
+ int saved_inferior_pid;
+
/* As of 10.x HP-UX, there's an explicit request to get the
*pathname.
*/
tt_status = call_ttrace (TT_PROC_GET_PATHNAME,
- tid,
- (TTRACE_ARG_TYPE) exec_file_buffer,
- (TTRACE_ARG_TYPE) sizeof (exec_file_buffer) - 1,
- TT_NIL);
+ tid,
+ (TTRACE_ARG_TYPE) exec_file_buffer,
+ (TTRACE_ARG_TYPE) sizeof (exec_file_buffer) - 1,
+ TT_NIL);
if (tt_status >= 0)
return exec_file_buffer;
In any case, if it fails, try a really, truly amazingly gross
hack that DDE uses, of pawing through the process' data
segment to find the pathname.
- */
+ */
top_of_stack = 0x7b03a000;
name_index = 0;
done = 0;
/* On the chance that pid != inferior_pid, set inferior_pid
to pid, so that (grrrr!) implicit uses of inferior_pid get
the right id.
- */
+ */
saved_inferior_pid = inferior_pid;
inferior_pid = tid;
/* Try to grab a null-terminated string. */
- while (! done) {
- if (target_read_memory (top_of_stack, four_chars, 4) != 0)
- {
- inferior_pid = saved_inferior_pid;
- return NULL;
- }
- for (i = 0; i < 4; i++) {
- exec_file_buffer[name_index++] = four_chars[i];
- done = (four_chars[i] == '\0');
- if (done)
- break;
- }
- top_of_stack += 4;
- }
+ while (!done)
+ {
+ if (target_read_memory (top_of_stack, four_chars, 4) != 0)
+ {
+ inferior_pid = saved_inferior_pid;
+ return NULL;
+ }
+ for (i = 0; i < 4; i++)
+ {
+ exec_file_buffer[name_index++] = four_chars[i];
+ done = (four_chars[i] == '\0');
+ if (done)
+ break;
+ }
+ top_of_stack += 4;
+ }
if (exec_file_buffer[0] == '\0')
{
void
pre_fork_inferior ()
{
- int status;
+ int status;
status = pipe (startup_semaphore.parent_channel);
- if (status < 0) {
+ if (status < 0)
+ {
warning ("error getting parent pipe for startup semaphore");
return;
- }
+ }
status = pipe (startup_semaphore.child_channel);
- if (status < 0) {
+ if (status < 0)
+ {
warning ("error getting child pipe for startup semaphore");
return;
- }
+ }
}
/* Called via #define REQUIRE_ATTACH from inftarg.c,
*/
int
hppa_require_attach (pid)
- int pid;
+ int pid;
{
- int tt_status;
- CORE_ADDR pc;
- CORE_ADDR pc_addr;
- unsigned int regs_offset;
+ int tt_status;
+ CORE_ADDR pc;
+ CORE_ADDR pc_addr;
+ unsigned int regs_offset;
process_state_t old_process_state = process_state;
-
+
/* Are we already attached? There appears to be no explicit
* way to answer this via ttrace, so we try something which
* should be innocuous if we are attached. If that fails,
*/
errno = 0;
tt_status = call_real_ttrace (TT_PROC_STOP,
- pid,
- (lwpid_t) TT_NIL,
- (TTRACE_ARG_TYPE) TT_NIL,
- (TTRACE_ARG_TYPE) TT_NIL,
- TT_NIL);
-
+ pid,
+ (lwpid_t) TT_NIL,
+ (TTRACE_ARG_TYPE) TT_NIL,
+ (TTRACE_ARG_TYPE) TT_NIL,
+ TT_NIL);
+
if (errno)
{
/* No change to process-state!
*/
errno = 0;
- pid = attach (pid);
+ pid = attach (pid);
}
else
{
- /* If successful, the process is now stopped. But if
- * we're VFORKING, the parent is still running, so don't
- * change the process state.
- */
- if( process_state != VFORKING )
- process_state = STOPPED;
-
- /* If we were already attached, you'd think that we
- * would need to start going again--but you'd be wrong,
- * as the fork-following code is actually in the middle
- * of the "resume" routine in in "infrun.c" and so
- * will (almost) immediately do a resume.
- *
- * On the other hand, if we are VFORKING, which means
- * that the child and the parent share a process for a
- * while, we know that "resume" won't be resuming
- * until the child EXEC event is seen. But we still
- * don't want to continue, as the event is already
- * there waiting.
- */
- update_thread_state_after_attach( pid, DONT_ATTACH_CONTINUE );
- } /* STOP succeeded */
-
+ /* If successful, the process is now stopped. But if
+ * we're VFORKING, the parent is still running, so don't
+ * change the process state.
+ */
+ if (process_state != VFORKING)
+ process_state = STOPPED;
+
+ /* If we were already attached, you'd think that we
+ * would need to start going again--but you'd be wrong,
+ * as the fork-following code is actually in the middle
+ * of the "resume" routine in in "infrun.c" and so
+ * will (almost) immediately do a resume.
+ *
+ * On the other hand, if we are VFORKING, which means
+ * that the child and the parent share a process for a
+ * while, we know that "resume" won't be resuming
+ * until the child EXEC event is seen. But we still
+ * don't want to continue, as the event is already
+ * there waiting.
+ */
+ update_thread_state_after_attach (pid, DONT_ATTACH_CONTINUE);
+ } /* STOP succeeded */
+
return pid;
}
int
hppa_require_detach (pid, signal)
- int pid;
- int signal;
+ int pid;
+ int signal;
{
- int tt_status;
+ int tt_status;
/* If signal is non-zero, we must pass the signal on to the active
thread prior to detaching. We do this by continuing the threads
if (signal != 0)
{
errno = 0;
- threads_continue_all_with_signals( pid, signal );
+ threads_continue_all_with_signals (pid, signal);
}
errno = 0;
tt_status = call_ttrace (TT_PROC_DETACH,
- pid,
- TT_NIL,
- TT_NIL,
- TT_NIL);
+ pid,
+ TT_NIL,
+ TT_NIL,
+ TT_NIL);
- errno = 0; /* Ignore any errors. */
+ errno = 0; /* Ignore any errors. */
/* process_state? */
-
+
return pid;
}
/* Given the starting address of a memory page, hash it to a bucket in
the memory page dictionary.
- */
+ */
static int
get_dictionary_bucket_of_page (page_start)
- CORE_ADDR page_start;
+ CORE_ADDR page_start;
{
- int hash;
+ int hash;
hash = (page_start / memory_page_dictionary.page_size);
hash = hash % MEMORY_PAGE_DICTIONARY_BUCKET_COUNT;
or create a new) dictionary entry for the page. The page will be
write-protected when this function returns, but may have a reference
count of 0 (if the page was newly-added to the dictionary).
- */
+ */
static memory_page_t *
get_dictionary_entry_of_page (pid, page_start)
- int pid;
- CORE_ADDR page_start;
+ int pid;
+ CORE_ADDR page_start;
{
- int bucket;
- memory_page_t * page = NULL;
- memory_page_t * previous_page = NULL;
+ int bucket;
+ memory_page_t *page = NULL;
+ memory_page_t *previous_page = NULL;
/* We're going to be using the dictionary now, than-kew. */
require_memory_page_dictionary (pid);
/* Try to find an existing dictionary entry for this page. Hash
on the page's starting address.
- */
+ */
bucket = get_dictionary_bucket_of_page (page_start);
page = &memory_page_dictionary.buckets[bucket];
while (page != NULL)
{
if (page->page_start == page_start)
- break;
+ break;
previous_page = page;
page = page->next;
}
/* Did we find a dictionary entry for this page? If not, then
add it to the dictionary now.
- */
+ */
if (page == NULL)
{
/* Create a new entry. */
static void
remove_dictionary_entry_of_page (pid, page)
- int pid;
- memory_page_t * page;
+ int pid;
+ memory_page_t *page;
{
/* Restore the page's original permissions. */
unwrite_protect_page (pid, page->page_start, page->original_permissions);
static void
hppa_enable_syscall_events (pid)
- int pid;
+ int pid;
{
- int tt_status;
- ttevent_t ttrace_events;
+ int tt_status;
+ ttevent_t ttrace_events;
/* Get the set of events that are currently enabled. */
tt_status = call_ttrace (TT_PROC_GET_EVENT_MASK,
- pid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
+ pid,
+ (TTRACE_ARG_TYPE) & ttrace_events,
+ (TTRACE_ARG_TYPE) sizeof (ttrace_events),
+ TT_NIL);
if (errno)
perror_with_name ("ttrace");
ttrace_events.tte_events |= TTEVT_SYSCALL_RETURN;
tt_status = call_ttrace (TT_PROC_SET_EVENT_MASK,
- pid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
+ pid,
+ (TTRACE_ARG_TYPE) & ttrace_events,
+ (TTRACE_ARG_TYPE) sizeof (ttrace_events),
+ TT_NIL);
if (errno)
perror_with_name ("ttrace");
}
static void
hppa_disable_syscall_events (pid)
- int pid;
+ int pid;
{
- int tt_status;
- ttevent_t ttrace_events;
+ int tt_status;
+ ttevent_t ttrace_events;
/* Get the set of events that are currently enabled. */
tt_status = call_ttrace (TT_PROC_GET_EVENT_MASK,
- pid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
+ pid,
+ (TTRACE_ARG_TYPE) & ttrace_events,
+ (TTRACE_ARG_TYPE) sizeof (ttrace_events),
+ TT_NIL);
if (errno)
perror_with_name ("ttrace");
ttrace_events.tte_events &= ~TTEVT_SYSCALL_RETURN;
tt_status = call_ttrace (TT_PROC_SET_EVENT_MASK,
- pid,
- (TTRACE_ARG_TYPE) &ttrace_events,
- (TTRACE_ARG_TYPE) sizeof (ttrace_events),
- TT_NIL);
+ pid,
+ (TTRACE_ARG_TYPE) & ttrace_events,
+ (TTRACE_ARG_TYPE) sizeof (ttrace_events),
+ TT_NIL);
if (errno)
perror_with_name ("ttrace");
}
Set protection for all pages that overlap that range.
Note that our caller sets TYPE to:
- 0 for a bp_hardware_watchpoint,
- 1 for a bp_read_watchpoint,
- 2 for a bp_access_watchpoint
+ 0 for a bp_hardware_watchpoint,
+ 1 for a bp_read_watchpoint,
+ 2 for a bp_access_watchpoint
(Yes, this is intentionally (though lord only knows why) different
from the TYPE that is passed to hppa_remove_hw_watchpoint.)
- */
+ */
int
hppa_insert_hw_watchpoint (pid, start, len, type)
- int pid;
- CORE_ADDR start;
- LONGEST len;
- int type;
+ int pid;
+ CORE_ADDR start;
+ LONGEST len;
+ int type;
{
- CORE_ADDR page_start;
- int dictionary_was_empty;
- int page_size;
- int page_id;
- LONGEST range_size_in_pages;
+ CORE_ADDR page_start;
+ int dictionary_was_empty;
+ int page_size;
+ int page_id;
+ LONGEST range_size_in_pages;
if (type != 0)
error ("read or access hardware watchpoints not supported on HP-UX");
page_start = (start / page_size) * page_size;
range_size_in_pages = ((LONGEST) len + (LONGEST) page_size - 1) / (LONGEST) page_size;
- for (page_id=0; page_id < range_size_in_pages; page_id++, page_start+=page_size)
+ for (page_id = 0; page_id < range_size_in_pages; page_id++, page_start += page_size)
{
- memory_page_t * page;
+ memory_page_t *page;
/* This gets the page entered into the dictionary if it was
not already entered.
- */
+ */
page = get_dictionary_entry_of_page (pid, page_start);
page->reference_count++;
}
If errno is set upon syscall exit to EFAULT, we must perform some fairly
hackish stuff to determine whether the failure really was due to a
page-protect trap on a watched location.
- */
+ */
if (dictionary_was_empty)
hppa_enable_syscall_events (pid);
which has been removed. Remove protection for all pages that
overlap that range, which are not also being watched by other
watchpoints.
- */
+ */
int
hppa_remove_hw_watchpoint (pid, start, len, type)
- int pid;
- CORE_ADDR start;
- LONGEST len;
- enum bptype type;
+ int pid;
+ CORE_ADDR start;
+ LONGEST len;
+ enum bptype type;
{
- CORE_ADDR page_start;
- int dictionary_is_empty;
- int page_size;
- int page_id;
- LONGEST range_size_in_pages;
+ CORE_ADDR page_start;
+ int dictionary_is_empty;
+ int page_size;
+ int page_id;
+ LONGEST range_size_in_pages;
if (type != 0)
error ("read or access hardware watchpoints not supported on HP-UX");
page_start = (start / page_size) * page_size;
range_size_in_pages = ((LONGEST) len + (LONGEST) page_size - 1) / (LONGEST) page_size;
- for (page_id=0; page_id < range_size_in_pages; page_id++, page_start+=page_size)
+ for (page_id = 0; page_id < range_size_in_pages; page_id++, page_start += page_size)
{
- memory_page_t * page;
+ memory_page_t *page;
page = get_dictionary_entry_of_page (pid, page_start);
page->reference_count--;
/* Was this the last reference of this page? If so, then we
must scrub the entry from the dictionary, and also restore
the page's original permissions.
- */
+ */
if (page->reference_count == 0)
- remove_dictionary_entry_of_page (pid, page);
+ remove_dictionary_entry_of_page (pid, page);
}
dictionary_is_empty = (memory_page_dictionary.page_count == (LONGEST) 0);
??rehrauer: Yeah, it'd be better if we had a specific flag that said,
"inferior is between syscall events now". Oh well.
- */
+ */
if (dictionary_is_empty && memory_page_dictionary.page_protections_allowed)
hppa_disable_syscall_events (pid);
for such things. See hppa_range_profitable_for_hw_watchpoint for a
query that answers whether a particular range should be watched via
hardware support.
- */
+ */
int
hppa_can_use_hw_watchpoint (type, cnt, ot)
- enum bptype type;
- int cnt;
- enum bptype ot;
+ enum bptype type;
+ int cnt;
+ enum bptype ot;
{
return (type == bp_hardware_watchpoint);
}
we think it would be profitable ("a good idea") to do so? If not,
we can always set a regular (aka single-step & test) watchpoint
on the address...
- */
+ */
int
hppa_range_profitable_for_hw_watchpoint (pid, start, len)
- int pid;
- CORE_ADDR start;
- LONGEST len;
+ int pid;
+ CORE_ADDR start;
+ LONGEST len;
{
- int range_is_stack_based;
- int range_is_accessible;
- CORE_ADDR page_start;
- int page_size;
- int page;
- LONGEST range_size_in_pages;
+ int range_is_stack_based;
+ int range_is_accessible;
+ CORE_ADDR page_start;
+ int page_size;
+ int page;
+ LONGEST range_size_in_pages;
/* ??rehrauer: For now, say that all addresses are potentially
profitable. Possibly later we'll want to test the address
for "stackness"?
- */
+ */
range_is_stack_based = 0;
/* If any page in the range is inaccessible, then we cannot
thinks we can. In that case, it's actually an error to
attempt to use hw watchpoints, so we'll tell our client
that the range is "unprofitable", and hope that they listen...
- */
- range_is_accessible = 1; /* Until proven otherwise. */
+ */
+ range_is_accessible = 1; /* Until proven otherwise. */
/* Examine all pages in the address range. */
errno = 0;
/* If we can't determine page size, we're hosed. Tell our
client it's unprofitable to use hw watchpoints for this
range.
- */
+ */
if (errno || (page_size <= 0))
{
errno = 0;
}
page_start = (start / page_size) * page_size;
- range_size_in_pages = len / (LONGEST)page_size;
+ range_size_in_pages = len / (LONGEST) page_size;
- for (page=0; page < range_size_in_pages; page++, page_start+=page_size)
+ for (page = 0; page < range_size_in_pages; page++, page_start += page_size)
{
- int tt_status;
- int page_permissions;
+ int tt_status;
+ int page_permissions;
/* Is this page accessible? */
errno = 0;
tt_status = call_ttrace (TT_PROC_GET_MPROTECT,
- pid,
- (TTRACE_ARG_TYPE) page_start,
- TT_NIL,
- (TTRACE_ARG_TYPE) &page_permissions);
+ pid,
+ (TTRACE_ARG_TYPE) page_start,
+ TT_NIL,
+ (TTRACE_ARG_TYPE) & page_permissions);
if (errno || (tt_status < 0))
- {
- errno = 0;
- range_is_accessible = 0;
- break;
- }
+ {
+ errno = 0;
+ range_is_accessible = 0;
+ break;
+ }
/* Yes, go for another... */
}
- return (! range_is_stack_based && range_is_accessible);
+ return (!range_is_stack_based && range_is_accessible);
}
char *
hppa_pid_or_tid_to_str (id)
- pid_t id;
+ pid_t id;
{
- static char buf[100]; /* Static because address returned. */
+ static char buf[100]; /* Static because address returned. */
/* Does this appear to be a process? If so, print it that way. */
if (is_process_id (id))
return buf;
}
-
\f
+
/* If the current pid is not the pid this module reported
* from "ptrace_wait" with the most recent event, then the
* user has switched threads.
* If the last reported event was a breakpoint, then return
* the old thread id, else return 0.
*/
-pid_t
-hppa_switched_threads( gdb_pid )
- pid_t gdb_pid;
+pid_t
+hppa_switched_threads (gdb_pid)
+ pid_t gdb_pid;
{
- if( gdb_pid == old_gdb_pid ) {
+ if (gdb_pid == old_gdb_pid)
+ {
/*
* Core gdb is working with the same pid that it
* was before we reported the last event. This
* No thread switch has happened.
*/
return (pid_t) 0;
- }
- else if( gdb_pid == reported_pid ) {
+ }
+ else if (gdb_pid == reported_pid)
+ {
/*
* Core gdb is working with the pid we reported, so
* any continue or step will be able to figure out
* without our (i.e. PREPARE_TO_PROCEED's) help.
*/
return (pid_t) 0;
- }
- else if( !reported_bpt ) {
- /*
- * The core switched, but we didn't just report a
- * breakpoint, so there's no just-hit breakpoint
- * instruction at "reported_pid"'s PC, and thus there
- * is no need to step over it.
- */
+ }
+ else if (!reported_bpt)
+ {
+ /*
+ * The core switched, but we didn't just report a
+ * breakpoint, so there's no just-hit breakpoint
+ * instruction at "reported_pid"'s PC, and thus there
+ * is no need to step over it.
+ */
return (pid_t) 0;
- }
- else {
- /* There's been a real switch, and we reported
- * a hit breakpoint. Let "hppa_prepare_to_proceed"
- * know, so it can see whether the breakpoint is
- * still active.
- */
- return reported_pid;
- }
+ }
+ else
+ {
+ /* There's been a real switch, and we reported
+ * a hit breakpoint. Let "hppa_prepare_to_proceed"
+ * know, so it can see whether the breakpoint is
+ * still active.
+ */
+ return reported_pid;
+ }
/* Keep compiler happy with an obvious return at the end.
*/
- return (pid_t) 0;
+ return (pid_t) 0;
}
void
hppa_ensure_vforking_parent_remains_stopped (pid)
- int pid;
+ int pid;
{
/* Nothing to do when using ttrace. Only the ptrace-based implementation
must do real work.
int
hppa_resume_execd_vforking_child_to_get_parent_vfork ()
{
- return 0; /* No, the parent vfork is available now. */
+ return 0; /* No, the parent vfork is available now. */
}
+\f
-\f
void
_initialize_infttrace ()
{
/* Initialize the ttrace-based hardware watchpoint implementation. */
- memory_page_dictionary.page_count = (LONGEST) -1;
+ memory_page_dictionary.page_count = (LONGEST) - 1;
memory_page_dictionary.page_protections_allowed = 1;
errno = 0;
if (errno || (memory_page_dictionary.page_size <= 0))
perror_with_name ("sysconf");
}
-
projects / thirdparty / binutils-gdb.git / blobdiff