import gdb-2000-01-10 snapshot
This commit is contained in:
Jason Molenda
parent
3b7c8b7414
commit
0d06e24ba7
|
|
@ -1,3 +1,88 @@
|
|||
2000-01-09 Christopher Faylor <cgf@cygnus.com>
|
||||
|
||||
* win32nat.c (handle_exceptions): Handle various arithmetic exceptions.
|
||||
* configure.in: Add an additional library to cygwin link.
|
||||
* configure: Regenerate.
|
||||
|
||||
Patch from Egor Duda <deo@logos-m.ru>:
|
||||
* coffread.c (coff_symfile_read): Reinstate ability to recognize "pe"
|
||||
type.
|
||||
|
||||
2000-01-07 Michael Snyder <msnyder@cleaver.cygnus.com>
|
||||
|
||||
* uw-thread.c: New file to support UnixWare user-mode threads:
|
||||
contributed by Nickolas Duffek <nsd@cygnus.com>.
|
||||
* target.h (struct target_ops): New vector, to_extra_thread_info,
|
||||
allows back-ends to give extra details in info thread display.
|
||||
(target_extra_thread_info): define new macro.
|
||||
(target_find_new_threads): simplify macro. Cleanup comments.
|
||||
* target.c (to_extra_thread_info): default and inherit new vector.
|
||||
(cleanup_target): eliminate PARAMS, break up long lines,
|
||||
provide default definition for to_extra_thread_info, and
|
||||
to_find_new_threads. Default to_thread_alive and to_query
|
||||
to return_zero, not target_ignore (they each return int not void).
|
||||
(debug_to_find_new_threads): new debug entry.
|
||||
(setup_target_debug): add debug_to_find_new_threads.
|
||||
* gdbthread.h: export struct thread_info, find_thread_pid, and
|
||||
iterate_over_threads. Add comments. Eliminate PARAMS. Update
|
||||
copyright. Add new private data pointer for use by target back-ends.
|
||||
* thread.c (struct thread_info): move definition to gdbthread.h.
|
||||
(find_thread_pid): new exported function for thread lookup.
|
||||
(iterate_over_threads): new exported function for applying
|
||||
arbitrary operations to threads. Update copyright to 2000.
|
||||
(info_threads_command): use new target_extra_thread_info vector
|
||||
to display extra information about each thread (if implemented).
|
||||
* config/i386/tm-i386v42mp.h: remove obsolete #defines for procfs.
|
||||
Add defines for PIDGET, etc.
|
||||
* config/i386/tm-i386sol2.h: ditto.
|
||||
* config/sparc/tm-sun4sol2.h: ditto.
|
||||
* config/i386/i386v42mp.mh: add uw-thread.o to NATDEPFILES.
|
||||
* testsuite/gdb.threads/pthreads.exp: Try to link with -lthread
|
||||
if -lpthread and -lpthreads fail.
|
||||
|
||||
* procfs.c: (PIDGET, TIDGET, MERGEPID): change default to no-op.
|
||||
(proc_flags): combine flags that UnixWare splits into two locations.
|
||||
(proc_modify_flag): add support for PR_KLC (kill on last close).
|
||||
(proc_[un]set_kill_on_last_close): new functions.
|
||||
|
||||
2000-01-06 Fernando Nasser <fnasser@totem.to.cygnus.com>
|
||||
|
||||
* remote.c (remote_open_1): Fix message so it does not imply a
|
||||
specific syntax for serial ports, as it is OS dependent.
|
||||
(remote_async_open_1): Ibid.
|
||||
(init_remote_ops): Ibid.
|
||||
|
||||
2000-01-06 Fernando Nasser <fnasser@totem.to.cygnus.com>
|
||||
|
||||
* rdi-share/serdrv.c (SerialOpen): Use speed from "-b" argument or
|
||||
"set remotebaud" command (if set) when no speed is specified on
|
||||
the "target rdi" command.
|
||||
|
||||
2000-01-06 Fernando Nasser <fnasser@totem.to.cygnus.com>
|
||||
|
||||
* rdi-share/serdrv.c (find_baud_rate): Add entries for 57600 and
|
||||
115200.
|
||||
(baud_options[]): Ibid.
|
||||
|
||||
2000-01-06 Fernando Nasser <fnasser@totem.to.cygnus.com>
|
||||
|
||||
* rdi-share/unixcomm.c: Fix SERIAL_PREFIX so it matches the prefix
|
||||
used by each operating system.
|
||||
|
||||
2000-01-06 Elena Zannoni <ezannoni@kwikemart.cygnus.com>
|
||||
|
||||
* breakpoint.c (until_break_command): Add an argument for the
|
||||
continuation, the beginning of the cleanups set up by this
|
||||
command.
|
||||
(until_break_command_continuation): Do cleanups until the one
|
||||
passed in as argument instead of doing all of them.
|
||||
|
||||
* infcmd.c (finish_command_continuation): Expect a new argument,
|
||||
which indicates up to where to do cleanups. Update calls to
|
||||
do_exec_cleanups to use this marker, instead of ALL_CLEANUPS.
|
||||
(finish_command): Add another argument for the continuation: the
|
||||
starting cleanup for this command.
|
||||
|
||||
2000-01-05 Fernando Nasser <fnasser@totem.to.cygnus.com>
|
||||
|
||||
From Grant Edwards <grante@visi.com> (original patch from Thomas
|
||||
|
|
|
|||
|
|
@ -229,7 +229,7 @@ CDEPS = $(XM_CDEPS) $(TM_CDEPS) $(NAT_CDEPS) $(SIM) $(BFD) $(READLINE) \
|
|||
ADD_FILES = $(REGEX) $(XM_ADD_FILES) $(TM_ADD_FILES) $(NAT_ADD_FILES)
|
||||
ADD_DEPS = $(REGEX1) $(XM_ADD_FILES) $(TM_ADD_FILES) $(NAT_ADD_FILES)
|
||||
|
||||
VERSION = 20000105
|
||||
VERSION = 20000110
|
||||
DIST=gdb
|
||||
|
||||
LINT=/usr/5bin/lint
|
||||
|
|
|
|||
|
|
@ -5215,10 +5215,10 @@ awatch_command (arg, from_tty)
|
|||
static void
|
||||
until_break_command_continuation (struct continuation_arg *arg)
|
||||
{
|
||||
/* Do all the exec cleanups, which at this point should only be the
|
||||
one set up in the first part of the until_break_command
|
||||
function. */
|
||||
do_exec_cleanups (ALL_CLEANUPS);
|
||||
struct cleanup *cleanups;
|
||||
|
||||
cleanups = (struct cleanup *) arg->data;
|
||||
do_exec_cleanups (cleanups);
|
||||
}
|
||||
|
||||
/* ARGSUSED */
|
||||
|
|
@ -5232,6 +5232,8 @@ until_break_command (arg, from_tty)
|
|||
struct frame_info *prev_frame = get_prev_frame (selected_frame);
|
||||
struct breakpoint *breakpoint;
|
||||
struct cleanup *old_chain;
|
||||
struct continuation_arg *arg1;
|
||||
|
||||
|
||||
clear_proceed_status ();
|
||||
|
||||
|
|
@ -5262,7 +5264,7 @@ until_break_command (arg, from_tty)
|
|||
old_chain = make_cleanup ((make_cleanup_func) delete_breakpoint,
|
||||
breakpoint);
|
||||
else
|
||||
make_exec_cleanup ((make_cleanup_func) delete_breakpoint, breakpoint);
|
||||
old_chain = make_exec_cleanup ((make_cleanup_func) delete_breakpoint, breakpoint);
|
||||
|
||||
/* If we are running asynchronously, and the target supports async
|
||||
execution, we are not waiting for the target to stop, in the call
|
||||
|
|
@ -5273,11 +5275,16 @@ until_break_command (arg, from_tty)
|
|||
|
||||
if (event_loop_p && target_can_async_p ())
|
||||
{
|
||||
/* In this case we don't need args for the continuation, because
|
||||
all it needs to do is do the cleanups in the
|
||||
exec_cleanup_chain, which will be only those inserted by this
|
||||
function. We can get away by using ALL_CLEANUPS. */
|
||||
add_continuation (until_break_command_continuation, NULL);
|
||||
/* In this case the arg for the continuation is just the point
|
||||
in the exec_cleanups chain from where to start doing
|
||||
cleanups, because all the continuation does is the cleanups in
|
||||
the exec_cleanup_chain. */
|
||||
arg1 =
|
||||
(struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
|
||||
arg1->next = NULL;
|
||||
arg1->data = (PTR) old_chain;
|
||||
|
||||
add_continuation (until_break_command_continuation, arg1);
|
||||
}
|
||||
|
||||
/* Keep within the current frame */
|
||||
|
|
|
|||
|
|
@ -645,9 +645,9 @@ coff_symfile_read (objfile, mainline)
|
|||
from the section address, rather than as absolute addresses.
|
||||
FIXME: We should use BFD to read the symbol table, and thus avoid
|
||||
this problem. */
|
||||
pe_file = !
|
||||
( strncmp (bfd_get_target (objfile->obfd), "pe", 2)
|
||||
| strncmp (bfd_get_target (objfile->obfd), "epoc-pe", 7));
|
||||
pe_file =
|
||||
strncmp (bfd_get_target (objfile->obfd), "pe", 2) == 0
|
||||
|| strncmp (bfd_get_target (objfile->obfd), "epoc-pe", 7) == 0;
|
||||
|
||||
/* End of warning */
|
||||
|
||||
|
|
|
|||
|
|
@ -9,5 +9,5 @@ XM_CLIBS= -lsocket -lnsl
|
|||
# appropriate for i386v42mp
|
||||
NAT_FILE= nm-i386v42mp.h
|
||||
NATDEPFILES= corelow.o core-regset.o solib.o fork-child.o i386v4-nat.o \
|
||||
procfs.o proc_api.o proc_events.o proc_flags.o proc_why.o
|
||||
procfs.o proc_api.o proc_events.o proc_flags.o proc_why.o uw-thread.o
|
||||
|
||||
|
|
|
|||
|
|
@ -46,18 +46,4 @@ extern char *sunpro_static_transform_name PARAMS ((char *));
|
|||
#define PIDGET(pid) ((pid) & 0xffff)
|
||||
#define TIDGET(pid) (((pid) >> 16) & 0xffff)
|
||||
|
||||
/* Macro to extract carry from given regset. */
|
||||
#define PS_FLAG_CARRY 0x1 /* Carry bit in PS */
|
||||
#define PROCFS_GET_CARRY(regset) ((regset)[EFL] & PS_FLAG_CARRY)
|
||||
|
||||
#ifdef HAVE_THREAD_DB_LIB
|
||||
|
||||
extern char *solaris_pid_to_str PARAMS ((int pid));
|
||||
|
||||
#else
|
||||
|
||||
extern char *procfs_pid_to_str PARAMS ((int pid));
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* ifndef TM_I386SOL2_H */
|
||||
|
|
|
|||
|
|
@ -26,20 +26,39 @@
|
|||
|
||||
#include "i386/tm-i386v4.h"
|
||||
|
||||
/* procfs on this architecture has multiple fds (ctl, as, map, status)
|
||||
including a control fd */
|
||||
|
||||
#ifndef HAVE_MULTIPLE_PROC_FDS
|
||||
#define HAVE_MULTIPLE_PROC_FDS
|
||||
#endif
|
||||
|
||||
/* procfs on this architecture communicates with read/write instead
|
||||
of ioctl */
|
||||
|
||||
#define PROCFS_USE_READ_WRITE
|
||||
|
||||
/* define to select for other sysv4.2mp weirdness */
|
||||
/* define to select for other sysv4.2mp weirdness (see procfs.c) */
|
||||
|
||||
#define UNIXWARE
|
||||
|
||||
/* The following macros extract process and lwp/thread ids from a
|
||||
composite id.
|
||||
|
||||
For consistency with UnixWare core files, allocate bits 0-15 for
|
||||
process ids and bits 16 and up for lwp ids. Reserve bit 31 for
|
||||
negative return values to indicate exceptions, and use bit 30 as a
|
||||
flag to indicate a user-mode thread, leaving 14 bits for lwp
|
||||
ids. */
|
||||
|
||||
/* Number of bits in composite id allocated to process number. */
|
||||
#define PIDBITS 16
|
||||
|
||||
/* Return the process id stored in composite PID. */
|
||||
#define PIDGET(PID) (((PID) & ((1 << PIDBITS) - 1)))
|
||||
|
||||
/* Return the thread or lwp id stored in composite PID. */
|
||||
#define TIDGET(PID) (((PID) & 0x3fffffff) >> PIDBITS)
|
||||
#define LIDGET(PID) TIDGET(PID)
|
||||
|
||||
/* Construct a composite id from lwp LID and the process portion of
|
||||
composite PID. */
|
||||
#define MERGEPID(PID, LID) (PIDGET(PID) | ((LID) << PIDBITS))
|
||||
#define MKLID(PID, LID) MERGEPID(PID, LID)
|
||||
|
||||
/* Construct a composite id from thread TID and the process portion of
|
||||
composite PID. */
|
||||
#define MKTID(PID, TID) (MERGEPID(PID, TID) | 0x40000000)
|
||||
|
||||
/* Return whether PID contains a user-space thread id. */
|
||||
#define ISTID(PID) ((PID) & 0x40000000)
|
||||
|
||||
#endif /* ifndef TM_I386V42MP_H */
|
||||
|
|
|
|||
|
|
@ -79,15 +79,3 @@ extern char *sunpro_static_transform_name PARAMS ((char *));
|
|||
#define PIDGET(pid) ((pid) & 0xffff)
|
||||
#define TIDGET(pid) (((pid) >> 16) & 0xffff)
|
||||
|
||||
/* Macro to extract carry from given regset. */
|
||||
#define PROCFS_GET_CARRY(regset) ((regset)[R_PSR] & PS_FLAG_CARRY)
|
||||
|
||||
#ifdef HAVE_THREAD_DB_LIB
|
||||
|
||||
extern char *solaris_pid_to_str PARAMS ((int pid));
|
||||
|
||||
#else
|
||||
|
||||
extern char *procfs_pid_to_str PARAMS ((int pid));
|
||||
|
||||
#endif
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -488,7 +488,7 @@ AC_SUBST(TERM_LIB)
|
|||
# libreadline needs libuser32.a in a cygwin environment
|
||||
WIN32LIBS=
|
||||
if test x$gdb_cv_os_cygwin = xyes; then
|
||||
WIN32LIBS="-luser32"
|
||||
WIN32LIBS="-luser32 -limagehlp"
|
||||
fi
|
||||
AC_SUBST(WIN32LIBS)
|
||||
|
||||
|
|
|
|||
|
|
@ -169,6 +169,7 @@ mips64*-big-*) gdb_target=bigmips64 ;;
|
|||
mips*-big-*) gdb_target=bigmips ;;
|
||||
mips*-dec-mach3*) gdb_target=mach3 ;;
|
||||
mips*-dec-*) gdb_target=decstation ;;
|
||||
mips*-*-pe) gdb_target=mips-pe ;;
|
||||
mips64*el-*-ecoff*) gdb_target=embedl64 ;;
|
||||
mips64*-*-ecoff*) gdb_target=embed64 ;;
|
||||
mips64*vr4xxx*el-*-elf*)gdb_target=vr4xxxel ;;
|
||||
|
|
|
|||
119
gdb/gdbthread.h
119
gdb/gdbthread.h
|
|
@ -1,5 +1,5 @@
|
|||
/* Multi-process/thread control defs for GDB, the GNU debugger.
|
||||
Copyright 1987, 88, 89, 90, 91, 92, 1993, 1998
|
||||
Copyright 1987, 88, 89, 90, 91, 92, 1993, 1998, 1999, 2000
|
||||
|
||||
Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA.
|
||||
Free Software Foundation, Inc.
|
||||
|
|
@ -27,31 +27,114 @@
|
|||
/* For bpstat */
|
||||
#include "breakpoint.h"
|
||||
|
||||
extern void init_thread_list PARAMS ((void));
|
||||
struct thread_info
|
||||
{
|
||||
struct thread_info *next;
|
||||
int pid; /* "Actual process id";
|
||||
In fact, this may be overloaded with
|
||||
kernel thread id, etc. */
|
||||
int num; /* Convenient handle (GDB thread id) */
|
||||
/* State from wait_for_inferior */
|
||||
CORE_ADDR prev_pc;
|
||||
CORE_ADDR prev_func_start;
|
||||
char *prev_func_name;
|
||||
struct breakpoint *step_resume_breakpoint;
|
||||
struct breakpoint *through_sigtramp_breakpoint;
|
||||
CORE_ADDR step_range_start;
|
||||
CORE_ADDR step_range_end;
|
||||
CORE_ADDR step_frame_address;
|
||||
int trap_expected;
|
||||
int handling_longjmp;
|
||||
int another_trap;
|
||||
|
||||
extern void add_thread PARAMS ((int pid));
|
||||
/* This is set TRUE when a catchpoint of a shared library event
|
||||
triggers. Since we don't wish to leave the inferior in the
|
||||
solib hook when we report the event, we step the inferior
|
||||
back to user code before stopping and reporting the event. */
|
||||
int stepping_through_solib_after_catch;
|
||||
|
||||
extern void delete_thread PARAMS ((int));
|
||||
/* When stepping_through_solib_after_catch is TRUE, this is a
|
||||
list of the catchpoints that should be reported as triggering
|
||||
when we finally do stop stepping. */
|
||||
bpstat stepping_through_solib_catchpoints;
|
||||
|
||||
extern int thread_id_to_pid PARAMS ((int));
|
||||
/* This is set to TRUE when this thread is in a signal handler
|
||||
trampoline and we're single-stepping through it. */
|
||||
int stepping_through_sigtramp;
|
||||
|
||||
extern int in_thread_list PARAMS ((int pid));
|
||||
/* Private data used by the target vector implementation. */
|
||||
struct private_thread_info *private;
|
||||
};
|
||||
|
||||
extern int pid_to_thread_id PARAMS ((int pid));
|
||||
/* Create an empty thread list, or empty the existing one. */
|
||||
extern void init_thread_list (void);
|
||||
|
||||
extern int valid_thread_id PARAMS ((int thread));
|
||||
/* Add a thread to the thread list.
|
||||
Note that add_thread now returns the handle of the new thread,
|
||||
so that the caller may initialize the private thread data. */
|
||||
extern struct thread_info *add_thread (int pid);
|
||||
|
||||
extern void load_infrun_state PARAMS ((int, CORE_ADDR *, CORE_ADDR *, char **,
|
||||
int *, struct breakpoint **,
|
||||
struct breakpoint **, CORE_ADDR *,
|
||||
CORE_ADDR *, CORE_ADDR *, int *, int *,
|
||||
int *, bpstat *, int *));
|
||||
/* Delete an existing thread list entry. */
|
||||
extern void delete_thread (int);
|
||||
|
||||
extern void save_infrun_state PARAMS ((int, CORE_ADDR, CORE_ADDR, char *,
|
||||
int, struct breakpoint *,
|
||||
struct breakpoint *, CORE_ADDR,
|
||||
CORE_ADDR, CORE_ADDR, int, int,
|
||||
int, bpstat, int));
|
||||
/* Translate the integer thread id (GDB's homegrown id, not the system's)
|
||||
into a "pid" (which may be overloaded with extra thread information). */
|
||||
extern int thread_id_to_pid (int);
|
||||
|
||||
/* Translate a 'pid' (which may be overloaded with extra thread information)
|
||||
into the integer thread id (GDB's homegrown id, not the system's). */
|
||||
extern int pid_to_thread_id (int pid);
|
||||
|
||||
/* Boolean test for an already-known pid (which may be overloaded with
|
||||
extra thread information). */
|
||||
extern int in_thread_list (int pid);
|
||||
|
||||
/* Boolean test for an already-known thread id (GDB's homegrown id,
|
||||
not the system's). */
|
||||
extern int valid_thread_id (int thread);
|
||||
|
||||
/* Search function to lookup a thread by 'pid'. */
|
||||
extern struct thread_info *find_thread_pid (int pid);
|
||||
|
||||
/* Iterator function to call a user-provided callback function
|
||||
once for each known thread. */
|
||||
typedef int (*thread_callback_func) (struct thread_info *, void *);
|
||||
extern struct thread_info *iterate_over_threads (thread_callback_func, void *);
|
||||
|
||||
/* infrun context switch: save the debugger state for the given thread. */
|
||||
extern void save_infrun_state (int pid,
|
||||
CORE_ADDR prev_pc,
|
||||
CORE_ADDR prev_func_start,
|
||||
char *prev_func_name,
|
||||
int trap_expected,
|
||||
struct breakpoint *step_resume_breakpoint,
|
||||
struct breakpoint *through_sigtramp_breakpoint,
|
||||
CORE_ADDR step_range_start,
|
||||
CORE_ADDR step_range_end,
|
||||
CORE_ADDR step_frame_address,
|
||||
int handling_longjmp,
|
||||
int another_trap,
|
||||
int stepping_through_solib_after_catch,
|
||||
bpstat stepping_through_solib_catchpoints,
|
||||
int stepping_through_sigtramp);
|
||||
|
||||
/* infrun context switch: load the debugger state previously saved
|
||||
for the given thread. */
|
||||
extern void load_infrun_state (int pid,
|
||||
CORE_ADDR *prev_pc,
|
||||
CORE_ADDR *prev_func_start,
|
||||
char **prev_func_name,
|
||||
int *trap_expected,
|
||||
struct breakpoint **step_resume_breakpoint,
|
||||
struct breakpoint **through_sigtramp_breakpoint,
|
||||
CORE_ADDR *step_range_start,
|
||||
CORE_ADDR *step_range_end,
|
||||
CORE_ADDR *step_frame_address,
|
||||
int *handling_longjmp,
|
||||
int *another_trap,
|
||||
int *stepping_through_solib_affter_catch,
|
||||
bpstat *stepping_through_solib_catchpoints,
|
||||
int *stepping_through_sigtramp);
|
||||
|
||||
/* Commands with a prefix of `thread'. */
|
||||
extern struct cmd_list_element *thread_cmd_list;
|
||||
|
|
|
|||
26
gdb/infcmd.c
26
gdb/infcmd.c
|
|
@ -478,7 +478,7 @@ step_1 (skip_subroutines, single_inst, count_string)
|
|||
cleanups = make_cleanup ((make_cleanup_func) disable_longjmp_breakpoint,
|
||||
0);
|
||||
else
|
||||
make_exec_cleanup ((make_cleanup_func) disable_longjmp_breakpoint, 0);
|
||||
make_exec_cleanup ((make_cleanup_func) disable_longjmp_breakpoint, 0);
|
||||
}
|
||||
|
||||
/* In synchronous case, all is well, just use the regular for loop. */
|
||||
|
|
@ -593,10 +593,12 @@ step_1_continuation (arg)
|
|||
called in case of step n with n>1, after the first step operation has
|
||||
been completed.*/
|
||||
static void
|
||||
step_once (int skip_subroutines, int single_inst, int count)
|
||||
step_once (int skip_subroutines, int single_inst, int count)
|
||||
{
|
||||
struct continuation_arg *arg1; struct continuation_arg *arg2;
|
||||
struct continuation_arg *arg3; struct frame_info *frame;
|
||||
struct continuation_arg *arg1;
|
||||
struct continuation_arg *arg2;
|
||||
struct continuation_arg *arg3;
|
||||
struct frame_info *frame;
|
||||
|
||||
if (count > 0)
|
||||
{
|
||||
|
|
@ -1049,9 +1051,11 @@ finish_command_continuation (arg)
|
|||
{
|
||||
register struct symbol *function;
|
||||
struct breakpoint *breakpoint;
|
||||
struct cleanup *cleanups;
|
||||
|
||||
breakpoint = (struct breakpoint *) arg->data;
|
||||
function = (struct symbol *) (arg->next)->data;
|
||||
cleanups = (struct cleanup *) (arg->next->next)->data;
|
||||
|
||||
if (bpstat_find_breakpoint (stop_bpstat, breakpoint) != NULL
|
||||
&& function != 0)
|
||||
|
|
@ -1066,7 +1070,7 @@ finish_command_continuation (arg)
|
|||
|
||||
if (TYPE_CODE (value_type) == TYPE_CODE_VOID)
|
||||
{
|
||||
do_exec_cleanups (ALL_CLEANUPS);
|
||||
do_exec_cleanups (cleanups);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -1079,7 +1083,7 @@ finish_command_continuation (arg)
|
|||
|
||||
print_return_value (struct_return, value_type);
|
||||
}
|
||||
do_exec_cleanups (ALL_CLEANUPS);
|
||||
do_exec_cleanups (cleanups);
|
||||
}
|
||||
|
||||
/* "finish": Set a temporary breakpoint at the place
|
||||
|
|
@ -1095,7 +1099,7 @@ finish_command (arg, from_tty)
|
|||
register struct symbol *function;
|
||||
struct breakpoint *breakpoint;
|
||||
struct cleanup *old_chain;
|
||||
struct continuation_arg *arg1, *arg2;
|
||||
struct continuation_arg *arg1, *arg2, *arg3;
|
||||
|
||||
int async_exec = 0;
|
||||
|
||||
|
|
@ -1137,7 +1141,7 @@ finish_command (arg, from_tty)
|
|||
if (!event_loop_p || !target_can_async_p ())
|
||||
old_chain = make_cleanup ((make_cleanup_func) delete_breakpoint, breakpoint);
|
||||
else
|
||||
make_exec_cleanup ((make_cleanup_func) delete_breakpoint, breakpoint);
|
||||
old_chain = make_exec_cleanup ((make_cleanup_func) delete_breakpoint, breakpoint);
|
||||
|
||||
/* Find the function we will return from. */
|
||||
|
||||
|
|
@ -1161,10 +1165,14 @@ finish_command (arg, from_tty)
|
|||
(struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
|
||||
arg2 =
|
||||
(struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
|
||||
arg3 =
|
||||
(struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
|
||||
arg1->next = arg2;
|
||||
arg2->next = NULL;
|
||||
arg2->next = arg3;
|
||||
arg3->next = NULL;
|
||||
arg1->data = (PTR) breakpoint;
|
||||
arg2->data = (PTR) function;
|
||||
arg3->data = (PTR) old_chain;
|
||||
add_continuation (finish_command_continuation, arg1);
|
||||
}
|
||||
|
||||
|
|
|
|||
112
gdb/procfs.c
112
gdb/procfs.c
|
|
@ -170,11 +170,7 @@ init_procfs_ops ()
|
|||
#ifdef NEW_PROC_API
|
||||
extern int write_with_trace PARAMS ((int, void *, size_t, char *, int));
|
||||
extern off_t lseek_with_trace PARAMS ((int, off_t, int, char *, int));
|
||||
|
||||
#if 0
|
||||
#define write(X,Y,Z) write_with_trace (X, Y, Z, __FILE__, __LINE__)
|
||||
#endif
|
||||
|
||||
#define lseek(X,Y,Z) lseek_with_trace (X, Y, Z, __FILE__, __LINE__)
|
||||
#else
|
||||
extern int ioctl_with_trace PARAMS ((int, long, void *, char *, int));
|
||||
|
|
@ -183,26 +179,14 @@ extern int ioctl_with_trace PARAMS ((int, long, void *, char *, int));
|
|||
#define open(X,Y) open_with_trace (X, Y, __FILE__, __LINE__)
|
||||
#define close(X) close_with_trace (X, __FILE__, __LINE__)
|
||||
#define wait(X) wait_with_trace (X, __FILE__, __LINE__)
|
||||
|
||||
#if 0
|
||||
#define PROCFS_NOTE(X) procfs_note (X, __FILE__, __LINE__)
|
||||
#define PROC_PRETTYFPRINT_STATUS(X,Y,Z,T) \
|
||||
proc_prettyfprint_status (X, Y, Z, T)
|
||||
#else
|
||||
#define PROCFS_NOTE(X)
|
||||
#define PROC_PRETTYFPRINT_STATUS(X,Y,Z,T)
|
||||
#endif
|
||||
|
||||
#else
|
||||
#define PROCFS_NOTE(X)
|
||||
#define PROC_PRETTYFPRINT_STATUS(X,Y,Z,T)
|
||||
#endif
|
||||
|
||||
/* temp: */
|
||||
#undef PROCFS_NOTE
|
||||
#define PROCFS_NOTE(X)
|
||||
/* suppress */
|
||||
|
||||
|
||||
/*
|
||||
* World Unification:
|
||||
|
|
@ -297,20 +281,13 @@ typedef prstatus_t gdb_lwpstatus_t;
|
|||
typedef fpregset_t gdb_fpregset_t;
|
||||
#endif
|
||||
|
||||
/* The PIDs that we pass to and from GDB will be composed from
|
||||
the actual PID plus the LWPID. These macros will be used to
|
||||
compose and decompose them. */
|
||||
/* Provide default composite pid manipulation macros for systems that
|
||||
don't have threads. */
|
||||
|
||||
#ifndef PIDGET
|
||||
#define PIDGET(PID) (((PID) & 0xffff))
|
||||
#endif
|
||||
|
||||
#ifndef TIDGET
|
||||
#define TIDGET(PID) (((PID) & 0x7fffffff) >> 16)
|
||||
#endif
|
||||
|
||||
#ifndef MERGEPID
|
||||
#define MERGEPID(PID, TID) (((PID) & 0xffff) | ((TID) << 16))
|
||||
#define PIDGET(PID) (PID)
|
||||
#define TIDGET(PID) (PID)
|
||||
#define MERGEPID(PID, TID) (PID)
|
||||
#endif
|
||||
|
||||
typedef struct procinfo {
|
||||
|
|
@ -611,7 +588,7 @@ create_procinfo (pid, tid)
|
|||
{
|
||||
procinfo *pi, *parent;
|
||||
|
||||
if (pi = find_procinfo (pid, tid))
|
||||
if ((pi = find_procinfo (pid, tid)))
|
||||
return pi; /* Already exists, nothing to do. */
|
||||
|
||||
/* find parent before doing malloc, to save having to cleanup */
|
||||
|
|
@ -959,7 +936,14 @@ proc_flags (pi)
|
|||
return 0; /* FIXME: not a good failure value (but what is?) */
|
||||
|
||||
#ifdef NEW_PROC_API
|
||||
# ifdef UNIXWARE
|
||||
/* UnixWare 7.1 puts process status flags, e.g. PR_ASYNC, in
|
||||
pstatus_t and LWP status flags, e.g. PR_STOPPED, in lwpstatus_t.
|
||||
The two sets of flags don't overlap. */
|
||||
return pi->prstatus.pr_flags | pi->prstatus.pr_lwp.pr_flags;
|
||||
# else
|
||||
return pi->prstatus.pr_lwp.pr_flags;
|
||||
# endif
|
||||
#else
|
||||
return pi->prstatus.pr_flags;
|
||||
#endif
|
||||
|
|
@ -1093,7 +1077,7 @@ proc_cursig (struct procinfo *pi)
|
|||
}
|
||||
|
||||
/*
|
||||
* Function: proc_modify_flags
|
||||
* Function: proc_modify_flag
|
||||
*
|
||||
* === I appologize for the messiness of this function.
|
||||
* === This is an area where the different versions of
|
||||
|
|
@ -1102,6 +1086,7 @@ proc_cursig (struct procinfo *pi)
|
|||
* Set or reset any of the following process flags:
|
||||
* PR_FORK -- forked child will inherit trace flags
|
||||
* PR_RLC -- traced process runs when last /proc file closed.
|
||||
* PR_KLC -- traced process is killed when last /proc file closed.
|
||||
* PR_ASYNC -- LWP's get to run/stop independently.
|
||||
*
|
||||
* There are three methods for doing this function:
|
||||
|
|
@ -1113,7 +1098,8 @@ proc_cursig (struct procinfo *pi)
|
|||
* [OSF, Sol5]
|
||||
*
|
||||
* Note: Irix does not define PR_ASYNC.
|
||||
* Note: OSF is the only one that can ONLY use the oldest method.
|
||||
* Note: OSF does not define PR_KLC.
|
||||
* Note: OSF is the only one that can ONLY use the oldest method.
|
||||
*
|
||||
* Arguments:
|
||||
* pi -- the procinfo
|
||||
|
|
@ -1217,6 +1203,9 @@ proc_modify_flag (pi, flag, mode)
|
|||
flag == PR_RLC ? "PR_RLC" :
|
||||
#ifdef PR_ASYNC
|
||||
flag == PR_ASYNC ? "PR_ASYNC" :
|
||||
#endif
|
||||
#ifdef PR_KLC
|
||||
flag == PR_KLC ? "PR_KLC" :
|
||||
#endif
|
||||
"<unknown flag>",
|
||||
mode == FLAG_RESET ? "off" : "on");
|
||||
|
|
@ -1258,6 +1247,42 @@ proc_unset_run_on_last_close (pi)
|
|||
return proc_modify_flag (pi, PR_RLC, FLAG_RESET);
|
||||
}
|
||||
|
||||
#ifdef PR_KLC
|
||||
/*
|
||||
* Function: proc_set_kill_on_last_close
|
||||
*
|
||||
* Set the kill_on_last_close flag.
|
||||
* Process with all threads will be killed when debugger
|
||||
* closes all /proc fds (or debugger exits or dies).
|
||||
*
|
||||
* Returns non-zero for success, zero for failure.
|
||||
*/
|
||||
|
||||
int
|
||||
proc_set_kill_on_last_close (pi)
|
||||
procinfo *pi;
|
||||
{
|
||||
return proc_modify_flag (pi, PR_KLC, FLAG_SET);
|
||||
}
|
||||
|
||||
/*
|
||||
* Function: proc_unset_kill_on_last_close
|
||||
*
|
||||
* Reset the kill_on_last_close flag.
|
||||
* Process will NOT be killed when debugger
|
||||
* closes its file handles (or exits or dies).
|
||||
*
|
||||
* Returns non-zero for success, zero for failure.
|
||||
*/
|
||||
|
||||
int
|
||||
proc_unset_kill_on_last_close (pi)
|
||||
procinfo *pi;
|
||||
{
|
||||
return proc_modify_flag (pi, PR_KLC, FLAG_RESET);
|
||||
}
|
||||
#endif /* PR_KLC */
|
||||
|
||||
/*
|
||||
* Function: proc_set_inherit_on_fork
|
||||
*
|
||||
|
|
@ -2601,7 +2626,9 @@ proc_iterate_over_mappings (func)
|
|||
{
|
||||
struct prmap *map;
|
||||
procinfo *pi;
|
||||
#ifndef NEW_PROC_API /* avoid compiler warning */
|
||||
int nmaps = 0, i;
|
||||
#endif
|
||||
int funcstat = 0;
|
||||
int fd, map_fd;
|
||||
char pathname[MAX_PROC_NAME_SIZE];
|
||||
|
|
@ -3390,7 +3417,6 @@ do_detach (signo)
|
|||
int signo;
|
||||
{
|
||||
procinfo *pi;
|
||||
long pflags;
|
||||
|
||||
/* Find procinfo for the main process */
|
||||
pi = find_procinfo_or_die (PIDGET (inferior_pid), 0); /* FIXME: threads */
|
||||
|
|
@ -3650,18 +3676,6 @@ wait_again:
|
|||
why = proc_why (pi);
|
||||
what = proc_what (pi);
|
||||
|
||||
#if 0
|
||||
{
|
||||
int stopped_pc = read_pc ();
|
||||
if (stopped_pc != 0x10c68 &&
|
||||
stopped_pc != 0x10c6c &&
|
||||
stopped_pc != 0x10c70 &&
|
||||
stopped_pc != 0x22768 &&
|
||||
stopped_pc != 0x10c74)
|
||||
printf ("%x,%d,%d\n", stopped_pc, why, what);
|
||||
}
|
||||
#endif
|
||||
|
||||
if (flags & (PR_STOPPED | PR_ISTOP))
|
||||
{
|
||||
#ifdef PR_ASYNC
|
||||
|
|
@ -3895,7 +3909,7 @@ wait_again:
|
|||
temp = MERGEPID (pi->pid, temp);
|
||||
if (!in_thread_list (temp))
|
||||
{
|
||||
printf_filtered ("[*New %s]\n",
|
||||
printf_filtered ("[New %s]\n",
|
||||
target_pid_to_str (temp));
|
||||
add_thread (temp);
|
||||
}
|
||||
|
|
@ -4427,9 +4441,9 @@ unconditionally_kill_inferior (pi)
|
|||
/* FIXME: should we use waitpid to make sure we get the right event?
|
||||
Should we check the returned event? */
|
||||
{
|
||||
#if 0
|
||||
int status, ret;
|
||||
|
||||
#if 0
|
||||
ret = waitpid (pi->pid, &status, 0);
|
||||
#else
|
||||
wait (NULL);
|
||||
|
|
@ -4547,6 +4561,10 @@ procfs_init_inferior (pid)
|
|||
if ((fail = procfs_debug_inferior (pi)) != 0)
|
||||
proc_error (pi, "init_inferior (procfs_debug_inferior)", fail);
|
||||
|
||||
/* FIXME: logically, we should really be turning OFF run-on-last-close,
|
||||
and possibly even turning ON kill-on-last-close at this point. But
|
||||
I can't make that change without careful testing which I don't have
|
||||
time to do right now... */
|
||||
/* Turn on run-on-last-close flag so that the child
|
||||
will die if GDB goes away for some reason. */
|
||||
if (!proc_set_run_on_last_close (pi))
|
||||
|
|
@ -4561,7 +4579,7 @@ procfs_init_inferior (pid)
|
|||
#else
|
||||
/* One trap to exec the shell, one to exec the program being debugged. */
|
||||
startup_inferior (2);
|
||||
#endif
|
||||
#endif /* START_INFERIOR_TRAPS_EXPECTED */
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -32,6 +32,8 @@
|
|||
#include "params.h"
|
||||
#include "logging.h"
|
||||
|
||||
extern int baud_rate; /* From gdb/top.c */
|
||||
|
||||
#ifdef COMPILING_ON_WINDOWS
|
||||
# undef ERROR
|
||||
# undef IGNORE
|
||||
|
|
@ -83,8 +85,11 @@ static struct writestate wstate;
|
|||
* The set of parameter options supported by the device
|
||||
*/
|
||||
static unsigned int baud_options[] = {
|
||||
#ifdef __hpux
|
||||
115200, 57600,
|
||||
#ifdef B115200 || __hpux
|
||||
115200,
|
||||
#endif
|
||||
#ifdef B57600 || __hpux
|
||||
57600,
|
||||
#endif
|
||||
38400, 19200, 9600
|
||||
};
|
||||
|
|
@ -229,6 +234,12 @@ static int SerialOpen(const char *name, const char *arg)
|
|||
printf( "could not understand baud rate %s\n", arg );
|
||||
#endif
|
||||
}
|
||||
else if (baud_rate > 0)
|
||||
{
|
||||
/* If the user specified a baud rate on the command line "-b" or via
|
||||
the "set remotebaud" command then try to use that one */
|
||||
process_baud_rate( baud_rate );
|
||||
}
|
||||
|
||||
#ifdef COMPILING_ON_WINDOWS
|
||||
{
|
||||
|
|
@ -514,6 +525,13 @@ static int find_baud_rate( unsigned int *speed )
|
|||
} possibleBaudRates[] = {
|
||||
#if defined(__hpux)
|
||||
{115200,_B115200}, {57600,_B57600},
|
||||
#else
|
||||
#ifdef B115200
|
||||
{115200,B115200},
|
||||
#endif
|
||||
#ifdef B57600
|
||||
{57600,B57600},
|
||||
#endif
|
||||
#endif
|
||||
#ifdef COMPILING_ON_WINDOWS
|
||||
{38400,CBR_38400}, {19200,CBR_19200}, {9600, CBR_9600}, {0,0}
|
||||
|
|
|
|||
|
|
@ -68,6 +68,7 @@
|
|||
#define PP_TIMEOUT 1 /* seconds */
|
||||
|
||||
#ifdef sun
|
||||
#define SERIAL_PREFIX "/dev/tty"
|
||||
#define SERPORT1 "/dev/ttya"
|
||||
#define SERPORT2 "/dev/ttyb"
|
||||
#define PARPORT1 "/dev/bpp0"
|
||||
|
|
@ -75,6 +76,7 @@
|
|||
#endif
|
||||
|
||||
#ifdef __hpux
|
||||
#define SERIAL_PREFIX "/dev/tty"
|
||||
#define SERPORT1 "/dev/tty00"
|
||||
#define SERPORT2 "/dev/tty01"
|
||||
#define PARPORT1 "/dev/ptr_parallel"
|
||||
|
|
@ -82,6 +84,7 @@
|
|||
#endif
|
||||
|
||||
#ifdef __linux__
|
||||
#define SERIAL_PREFIX "/dev/ttyS"
|
||||
#define SERPORT1 "/dev/ttyS0"
|
||||
#define SERPORT2 "/dev/ttyS1"
|
||||
#define PARPORT1 "/dev/par0"
|
||||
|
|
@ -89,6 +92,7 @@
|
|||
#endif
|
||||
|
||||
#if defined (__FreeBSD__) || defined (__NetBSD__) || defined (__OpenBSD__) || defined (bsdi)
|
||||
#define SERIAL_PREFIX "/dev/cuaa"
|
||||
#define SERPORT1 "/dev/cuaa0"
|
||||
#define SERPORT2 "/dev/cuaa1"
|
||||
#define PARPORT1 "/dev/lpt0"
|
||||
|
|
@ -96,14 +100,12 @@
|
|||
#endif
|
||||
|
||||
|
||||
#define SERIAL_PREFIX "/dev/tty"
|
||||
#if defined(_WIN32) || defined (__CYGWIN32__)
|
||||
#define SERIAL_PREFIX "com"
|
||||
#define SERPORT1 "com1"
|
||||
#define SERPORT2 "com2"
|
||||
#define PARPORT1 "lpt1"
|
||||
#define PARPORT2 "lpt2"
|
||||
#undef SERIAL_PREFIX
|
||||
#define SERIAL_PREFIX "com"
|
||||
#endif
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1921,7 +1921,8 @@ remote_open_1 (name, from_tty, target, extended_p)
|
|||
{
|
||||
if (name == 0)
|
||||
error ("To open a remote debug connection, you need to specify what\n\
|
||||
serial device is attached to the remote system (e.g. /dev/ttya).");
|
||||
serial device is attached to the remote system\n\
|
||||
(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
|
||||
|
||||
/* See FIXME above */
|
||||
wait_forever_enabled_p = 1;
|
||||
|
|
@ -2007,7 +2008,8 @@ remote_async_open_1 (name, from_tty, target, extended_p)
|
|||
{
|
||||
if (name == 0)
|
||||
error ("To open a remote debug connection, you need to specify what\n\
|
||||
serial device is attached to the remote system (e.g. /dev/ttya).");
|
||||
serial device is attached to the remote system\n\
|
||||
(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
|
||||
|
||||
target_preopen (from_tty);
|
||||
|
||||
|
|
@ -4855,7 +4857,8 @@ init_remote_ops ()
|
|||
remote_ops.to_longname = "Remote serial target in gdb-specific protocol";
|
||||
remote_ops.to_doc =
|
||||
"Use a remote computer via a serial line, using a gdb-specific protocol.\n\
|
||||
Specify the serial device it is connected to (e.g. /dev/ttya).";
|
||||
Specify the serial device it is connected to\n\
|
||||
(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
|
||||
remote_ops.to_open = remote_open;
|
||||
remote_ops.to_close = remote_close;
|
||||
remote_ops.to_detach = remote_detach;
|
||||
|
|
|
|||
246
gdb/target.c
246
gdb/target.c
|
|
@ -397,69 +397,181 @@ cleanup_target (t)
|
|||
{
|
||||
|
||||
#define de_fault(field, value) \
|
||||
if (!t->field) t->field = value
|
||||
if (!t->field) \
|
||||
t->field = value
|
||||
|
||||
/* FIELD DEFAULT VALUE */
|
||||
|
||||
de_fault (to_open, (void (*)PARAMS ((char *, int))) tcomplain);
|
||||
de_fault (to_close, (void (*)PARAMS ((int))) target_ignore);
|
||||
de_fault (to_attach, maybe_kill_then_attach);
|
||||
de_fault (to_post_attach, (void (*)PARAMS ((int))) target_ignore);
|
||||
de_fault (to_require_attach, maybe_kill_then_attach);
|
||||
de_fault (to_detach, (void (*)PARAMS ((char *, int))) target_ignore);
|
||||
de_fault (to_require_detach, (void (*)PARAMS ((int, char *, int))) target_ignore);
|
||||
de_fault (to_resume, (void (*)PARAMS ((int, int, enum target_signal))) noprocess);
|
||||
de_fault (to_wait, (int (*)PARAMS ((int, struct target_waitstatus *))) noprocess);
|
||||
de_fault (to_post_wait, (void (*)PARAMS ((int, int))) target_ignore);
|
||||
de_fault (to_fetch_registers, (void (*)PARAMS ((int))) target_ignore);
|
||||
de_fault (to_store_registers, (void (*)PARAMS ((int))) noprocess);
|
||||
de_fault (to_prepare_to_store, (void (*)PARAMS ((void))) noprocess);
|
||||
de_fault (to_xfer_memory, (int (*)PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *))) nomemory);
|
||||
de_fault (to_files_info, (void (*)PARAMS ((struct target_ops *))) target_ignore);
|
||||
de_fault (to_insert_breakpoint, memory_insert_breakpoint);
|
||||
de_fault (to_remove_breakpoint, memory_remove_breakpoint);
|
||||
de_fault (to_terminal_init, (void (*)PARAMS ((void))) target_ignore);
|
||||
de_fault (to_terminal_inferior, (void (*)PARAMS ((void))) target_ignore);
|
||||
de_fault (to_terminal_ours_for_output, (void (*)PARAMS ((void))) target_ignore);
|
||||
de_fault (to_terminal_ours, (void (*)PARAMS ((void))) target_ignore);
|
||||
de_fault (to_terminal_info, default_terminal_info);
|
||||
de_fault (to_kill, (void (*)PARAMS ((void))) noprocess);
|
||||
de_fault (to_load, (void (*)PARAMS ((char *, int))) tcomplain);
|
||||
de_fault (to_lookup_symbol, (int (*)PARAMS ((char *, CORE_ADDR *))) nosymbol);
|
||||
de_fault (to_create_inferior, maybe_kill_then_create_inferior);
|
||||
de_fault (to_post_startup_inferior, (void (*)PARAMS ((int))) target_ignore);
|
||||
de_fault (to_acknowledge_created_inferior, (void (*)PARAMS ((int))) target_ignore);
|
||||
de_fault (to_clone_and_follow_inferior, default_clone_and_follow_inferior);
|
||||
de_fault (to_post_follow_inferior_by_clone, (void (*)PARAMS ((void))) target_ignore);
|
||||
de_fault (to_insert_fork_catchpoint, (int (*)PARAMS ((int))) tcomplain);
|
||||
de_fault (to_remove_fork_catchpoint, (int (*)PARAMS ((int))) tcomplain);
|
||||
de_fault (to_insert_vfork_catchpoint, (int (*)PARAMS ((int))) tcomplain);
|
||||
de_fault (to_remove_vfork_catchpoint, (int (*)PARAMS ((int))) tcomplain);
|
||||
de_fault (to_has_forked, (int (*)PARAMS ((int, int *))) return_zero);
|
||||
de_fault (to_has_vforked, (int (*)PARAMS ((int, int *))) return_zero);
|
||||
de_fault (to_can_follow_vfork_prior_to_exec, (int (*)PARAMS ((void))) return_zero);
|
||||
de_fault (to_post_follow_vfork, (void (*)PARAMS ((int, int, int, int))) target_ignore);
|
||||
de_fault (to_insert_exec_catchpoint, (int (*)PARAMS ((int))) tcomplain);
|
||||
de_fault (to_remove_exec_catchpoint, (int (*)PARAMS ((int))) tcomplain);
|
||||
de_fault (to_has_execd, (int (*)PARAMS ((int, char **))) return_zero);
|
||||
de_fault (to_reported_exec_events_per_exec_call, (int (*)PARAMS ((void))) return_one);
|
||||
de_fault (to_has_syscall_event, (int (*)PARAMS ((int, enum target_waitkind *, int *))) return_zero);
|
||||
de_fault (to_has_exited, (int (*)PARAMS ((int, int, int *))) return_zero);
|
||||
de_fault (to_mourn_inferior, (void (*)PARAMS ((void))) noprocess);
|
||||
de_fault (to_can_run, return_zero);
|
||||
de_fault (to_notice_signals, (void (*)PARAMS ((int))) target_ignore);
|
||||
de_fault (to_thread_alive, (int (*)PARAMS ((int))) target_ignore);
|
||||
de_fault (to_stop, (void (*)PARAMS ((void))) target_ignore);
|
||||
de_fault (to_query, (int (*)PARAMS ((int /*char */ , char *, char *, int *))) target_ignore);
|
||||
de_fault (to_rcmd, (void (*) (char *, struct gdb_file *)) tcomplain);
|
||||
de_fault (to_enable_exception_callback, (struct symtab_and_line * (*)PARAMS ((enum exception_event_kind, int))) nosupport_runtime);
|
||||
de_fault (to_get_current_exception_event, (struct exception_event_record * (*)PARAMS ((void))) nosupport_runtime);
|
||||
|
||||
de_fault (to_pid_to_exec_file, (char *(*)PARAMS ((int))) return_zero);
|
||||
de_fault (to_core_file_to_sym_file, (char *(*)PARAMS ((char *))) return_zero);
|
||||
de_fault (to_can_async_p, (int (*) (void)) return_zero);
|
||||
de_fault (to_is_async_p, (int (*) (void)) return_zero);
|
||||
de_fault (to_async, (void (*) (void (*) (enum inferior_event_type, void*), void*)) tcomplain);
|
||||
de_fault (to_open,
|
||||
(void (*) (char *, int))
|
||||
tcomplain);
|
||||
de_fault (to_close,
|
||||
(void (*) (int))
|
||||
target_ignore);
|
||||
de_fault (to_attach,
|
||||
maybe_kill_then_attach);
|
||||
de_fault (to_post_attach,
|
||||
(void (*) (int))
|
||||
target_ignore);
|
||||
de_fault (to_require_attach,
|
||||
maybe_kill_then_attach);
|
||||
de_fault (to_detach,
|
||||
(void (*) (char *, int))
|
||||
target_ignore);
|
||||
de_fault (to_require_detach,
|
||||
(void (*) (int, char *, int))
|
||||
target_ignore);
|
||||
de_fault (to_resume,
|
||||
(void (*) (int, int, enum target_signal))
|
||||
noprocess);
|
||||
de_fault (to_wait,
|
||||
(int (*) (int, struct target_waitstatus *))
|
||||
noprocess);
|
||||
de_fault (to_post_wait,
|
||||
(void (*) (int, int))
|
||||
target_ignore);
|
||||
de_fault (to_fetch_registers,
|
||||
(void (*) (int))
|
||||
target_ignore);
|
||||
de_fault (to_store_registers,
|
||||
(void (*) (int))
|
||||
noprocess);
|
||||
de_fault (to_prepare_to_store,
|
||||
(void (*) (void))
|
||||
noprocess);
|
||||
de_fault (to_xfer_memory,
|
||||
(int (*) (CORE_ADDR, char *, int, int, struct target_ops *))
|
||||
nomemory);
|
||||
de_fault (to_files_info,
|
||||
(void (*) (struct target_ops *))
|
||||
target_ignore);
|
||||
de_fault (to_insert_breakpoint,
|
||||
memory_insert_breakpoint);
|
||||
de_fault (to_remove_breakpoint,
|
||||
memory_remove_breakpoint);
|
||||
de_fault (to_terminal_init,
|
||||
(void (*) (void))
|
||||
target_ignore);
|
||||
de_fault (to_terminal_inferior,
|
||||
(void (*) (void))
|
||||
target_ignore);
|
||||
de_fault (to_terminal_ours_for_output,
|
||||
(void (*) (void))
|
||||
target_ignore);
|
||||
de_fault (to_terminal_ours,
|
||||
(void (*) (void))
|
||||
target_ignore);
|
||||
de_fault (to_terminal_info,
|
||||
default_terminal_info);
|
||||
de_fault (to_kill,
|
||||
(void (*) (void))
|
||||
noprocess);
|
||||
de_fault (to_load,
|
||||
(void (*) (char *, int))
|
||||
tcomplain);
|
||||
de_fault (to_lookup_symbol,
|
||||
(int (*) (char *, CORE_ADDR *))
|
||||
nosymbol);
|
||||
de_fault (to_create_inferior,
|
||||
maybe_kill_then_create_inferior);
|
||||
de_fault (to_post_startup_inferior,
|
||||
(void (*) (int))
|
||||
target_ignore);
|
||||
de_fault (to_acknowledge_created_inferior,
|
||||
(void (*) (int))
|
||||
target_ignore);
|
||||
de_fault (to_clone_and_follow_inferior,
|
||||
default_clone_and_follow_inferior);
|
||||
de_fault (to_post_follow_inferior_by_clone,
|
||||
(void (*) (void))
|
||||
target_ignore);
|
||||
de_fault (to_insert_fork_catchpoint,
|
||||
(int (*) (int))
|
||||
tcomplain);
|
||||
de_fault (to_remove_fork_catchpoint,
|
||||
(int (*) (int))
|
||||
tcomplain);
|
||||
de_fault (to_insert_vfork_catchpoint,
|
||||
(int (*) (int))
|
||||
tcomplain);
|
||||
de_fault (to_remove_vfork_catchpoint,
|
||||
(int (*) (int))
|
||||
tcomplain);
|
||||
de_fault (to_has_forked,
|
||||
(int (*) (int, int *))
|
||||
return_zero);
|
||||
de_fault (to_has_vforked,
|
||||
(int (*) (int, int *))
|
||||
return_zero);
|
||||
de_fault (to_can_follow_vfork_prior_to_exec,
|
||||
(int (*) (void))
|
||||
return_zero);
|
||||
de_fault (to_post_follow_vfork,
|
||||
(void (*) (int, int, int, int))
|
||||
target_ignore);
|
||||
de_fault (to_insert_exec_catchpoint,
|
||||
(int (*) (int))
|
||||
tcomplain);
|
||||
de_fault (to_remove_exec_catchpoint,
|
||||
(int (*) (int))
|
||||
tcomplain);
|
||||
de_fault (to_has_execd,
|
||||
(int (*) (int, char **))
|
||||
return_zero);
|
||||
de_fault (to_reported_exec_events_per_exec_call,
|
||||
(int (*) (void))
|
||||
return_one);
|
||||
de_fault (to_has_syscall_event,
|
||||
(int (*) (int, enum target_waitkind *, int *))
|
||||
return_zero);
|
||||
de_fault (to_has_exited,
|
||||
(int (*) (int, int, int *))
|
||||
return_zero);
|
||||
de_fault (to_mourn_inferior,
|
||||
(void (*) (void))
|
||||
noprocess);
|
||||
de_fault (to_can_run,
|
||||
return_zero);
|
||||
de_fault (to_notice_signals,
|
||||
(void (*) (int))
|
||||
target_ignore);
|
||||
de_fault (to_thread_alive,
|
||||
(int (*) (int))
|
||||
return_zero);
|
||||
de_fault (to_find_new_threads,
|
||||
(void (*) (void))
|
||||
target_ignore);
|
||||
de_fault (to_extra_thread_info,
|
||||
(char *(*) (struct thread_info *))
|
||||
return_zero);
|
||||
de_fault (to_stop,
|
||||
(void (*) (void))
|
||||
target_ignore);
|
||||
de_fault (to_query,
|
||||
(int (*) (int, char *, char *, int *))
|
||||
return_zero);
|
||||
de_fault (to_rcmd,
|
||||
(void (*) (char *, struct gdb_file *))
|
||||
tcomplain);
|
||||
de_fault (to_enable_exception_callback,
|
||||
(struct symtab_and_line * (*) (enum exception_event_kind, int))
|
||||
nosupport_runtime);
|
||||
de_fault (to_get_current_exception_event,
|
||||
(struct exception_event_record * (*) (void))
|
||||
nosupport_runtime);
|
||||
de_fault (to_pid_to_exec_file,
|
||||
(char *(*) (int))
|
||||
return_zero);
|
||||
de_fault (to_core_file_to_sym_file,
|
||||
(char *(*) (char *))
|
||||
return_zero);
|
||||
de_fault (to_can_async_p,
|
||||
(int (*) (void))
|
||||
return_zero);
|
||||
de_fault (to_is_async_p,
|
||||
(int (*) (void))
|
||||
return_zero);
|
||||
de_fault (to_async,
|
||||
(void (*) (void (*) (enum inferior_event_type, void*), void*))
|
||||
tcomplain);
|
||||
#undef de_fault
|
||||
}
|
||||
|
||||
|
|
@ -537,6 +649,7 @@ update_current_target ()
|
|||
INHERIT (to_thread_alive, t);
|
||||
INHERIT (to_find_new_threads, t);
|
||||
INHERIT (to_pid_to_str, t);
|
||||
INHERIT (to_extra_thread_info, t);
|
||||
INHERIT (to_stop, t);
|
||||
INHERIT (to_query, t);
|
||||
INHERIT (to_rcmd, t);
|
||||
|
|
@ -2745,6 +2858,14 @@ debug_to_thread_alive (pid)
|
|||
return retval;
|
||||
}
|
||||
|
||||
static void
|
||||
debug_to_find_new_threads ()
|
||||
{
|
||||
debug_target.to_find_new_threads ();
|
||||
|
||||
fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog);
|
||||
}
|
||||
|
||||
static void
|
||||
debug_to_stop ()
|
||||
{
|
||||
|
|
@ -2880,6 +3001,7 @@ setup_target_debug ()
|
|||
current_target.to_can_run = debug_to_can_run;
|
||||
current_target.to_notice_signals = debug_to_notice_signals;
|
||||
current_target.to_thread_alive = debug_to_thread_alive;
|
||||
current_target.to_find_new_threads = debug_to_find_new_threads;
|
||||
current_target.to_stop = debug_to_stop;
|
||||
current_target.to_query = debug_to_query;
|
||||
current_target.to_rcmd = debug_to_rcmd;
|
||||
|
|
|
|||
374
gdb/target.h
374
gdb/target.h
|
|
@ -56,9 +56,9 @@ enum strata
|
|||
|
||||
enum thread_control_capabilities
|
||||
{
|
||||
tc_none = 0, /* Default: can't control thread execution. */
|
||||
tc_schedlock = 1, /* Can lock the thread scheduler. */
|
||||
tc_switch = 2 /* Can switch the running thread on demand. */
|
||||
tc_none = 0, /* Default: can't control thread execution. */
|
||||
tc_schedlock = 1, /* Can lock the thread scheduler. */
|
||||
tc_switch = 2 /* Can switch the running thread on demand. */
|
||||
};
|
||||
|
||||
/* Stuff for target_wait. */
|
||||
|
|
@ -69,7 +69,8 @@ enum target_waitkind
|
|||
/* The program has exited. The exit status is in value.integer. */
|
||||
TARGET_WAITKIND_EXITED,
|
||||
|
||||
/* The program has stopped with a signal. Which signal is in value.sig. */
|
||||
/* The program has stopped with a signal. Which signal is in
|
||||
value.sig. */
|
||||
TARGET_WAITKIND_STOPPED,
|
||||
|
||||
/* The program has terminated with a signal. Which signal is in
|
||||
|
|
@ -80,24 +81,26 @@ enum target_waitkind
|
|||
(e.g. it called load(2) on AIX). */
|
||||
TARGET_WAITKIND_LOADED,
|
||||
|
||||
/* The program has forked. A "related" process' ID is in value.related_pid.
|
||||
I.e., if the child forks, value.related_pid is the parent's ID.
|
||||
*/
|
||||
/* The program has forked. A "related" process' ID is in
|
||||
value.related_pid. I.e., if the child forks, value.related_pid
|
||||
is the parent's ID. */
|
||||
|
||||
TARGET_WAITKIND_FORKED,
|
||||
|
||||
/* The program has vforked. A "related" process's ID is in value.related_pid.
|
||||
*/
|
||||
/* The program has vforked. A "related" process's ID is in
|
||||
value.related_pid. */
|
||||
|
||||
TARGET_WAITKIND_VFORKED,
|
||||
|
||||
/* The program has exec'ed a new executable file. The new file's pathname
|
||||
is pointed to by value.execd_pathname.
|
||||
*/
|
||||
/* The program has exec'ed a new executable file. The new file's
|
||||
pathname is pointed to by value.execd_pathname. */
|
||||
|
||||
TARGET_WAITKIND_EXECD,
|
||||
|
||||
/* The program has entered or returned from a system call. On HP-UX, this
|
||||
is used in the hardware watchpoint implementation. The syscall's unique
|
||||
integer ID number is in value.syscall_id;
|
||||
*/
|
||||
/* The program has entered or returned from a system call. On
|
||||
HP-UX, this is used in the hardware watchpoint implementation.
|
||||
The syscall's unique integer ID number is in value.syscall_id */
|
||||
|
||||
TARGET_WAITKIND_SYSCALL_ENTRY,
|
||||
TARGET_WAITKIND_SYSCALL_RETURN,
|
||||
|
||||
|
|
@ -114,7 +117,7 @@ enum target_waitkind
|
|||
to the event loop and wait there for another event from the
|
||||
inferior, rather than being stuck in the remote_async_wait()
|
||||
function. This way the event loop is responsive to other events,
|
||||
like for instance the user typing. */
|
||||
like for instance the user typing. */
|
||||
TARGET_WAITKIND_IGNORE
|
||||
};
|
||||
|
||||
|
|
@ -276,24 +279,24 @@ struct target_waitstatus
|
|||
};
|
||||
|
||||
/* Possible types of events that the inferior handler will have to
|
||||
deal with. */
|
||||
deal with. */
|
||||
enum inferior_event_type
|
||||
{
|
||||
/* There is a request to quit the inferior, abandon it. */
|
||||
/* There is a request to quit the inferior, abandon it. */
|
||||
INF_QUIT_REQ,
|
||||
/* Process a normal inferior event which will result in target_wait
|
||||
being called. */
|
||||
being called. */
|
||||
INF_REG_EVENT,
|
||||
/* Deal with an error on the inferior. */
|
||||
/* Deal with an error on the inferior. */
|
||||
INF_ERROR,
|
||||
/* We are called because a timer went off. */
|
||||
/* We are called because a timer went off. */
|
||||
INF_TIMER,
|
||||
/* We are called to do stuff after the inferior stops. */
|
||||
/* We are called to do stuff after the inferior stops. */
|
||||
INF_EXEC_COMPLETE,
|
||||
/* We are called to do some stuff after the inferior stops, but we
|
||||
are expected to reenter the proceed() and
|
||||
handle_inferior_event() functions. This is used only in case of
|
||||
'step n' like commands. */
|
||||
'step n' like commands. */
|
||||
INF_EXEC_CONTINUE
|
||||
};
|
||||
|
||||
|
|
@ -310,18 +313,20 @@ enum target_signal target_signal_from_name PARAMS ((char *));
|
|||
/* If certain kinds of activity happen, target_wait should perform
|
||||
callbacks. */
|
||||
/* Right now we just call (*TARGET_ACTIVITY_FUNCTION) if I/O is possible
|
||||
on TARGET_ACTIVITY_FD. */
|
||||
on TARGET_ACTIVITY_FD. */
|
||||
extern int target_activity_fd;
|
||||
/* Returns zero to leave the inferior alone, one to interrupt it. */
|
||||
extern int (*target_activity_function) PARAMS ((void));
|
||||
|
||||
struct thread_info; /* fwd decl for parameter list below: */
|
||||
|
||||
struct target_ops
|
||||
{
|
||||
char *to_shortname; /* Name this target type */
|
||||
char *to_longname; /* Name for printing */
|
||||
char *to_doc; /* Documentation. Does not include trailing
|
||||
newline, and starts with a one-line descrip-
|
||||
tion (probably similar to to_longname). */
|
||||
tion (probably similar to to_longname). */
|
||||
void (*to_open) PARAMS ((char *, int));
|
||||
void (*to_close) PARAMS ((int));
|
||||
void (*to_attach) PARAMS ((char *, int));
|
||||
|
|
@ -368,15 +373,17 @@ struct target_ops
|
|||
not, add INCREMENT to the search address and keep trying until
|
||||
the search address is outside of the range [LORANGE,HIRANGE).
|
||||
|
||||
If we don't find anything, set *ADDR_FOUND to (CORE_ADDR)0 and return. */
|
||||
If we don't find anything, set *ADDR_FOUND to (CORE_ADDR)0 and
|
||||
return. */
|
||||
|
||||
void (*to_search) PARAMS ((int len, char *data, char *mask,
|
||||
CORE_ADDR startaddr, int increment,
|
||||
CORE_ADDR lorange, CORE_ADDR hirange,
|
||||
CORE_ADDR * addr_found, char *data_found));
|
||||
|
||||
#define target_search(len, data, mask, startaddr, increment, lorange, hirange, addr_found, data_found) \
|
||||
(*current_target.to_search) (len, data, mask, startaddr, increment, \
|
||||
lorange, hirange, addr_found, data_found)
|
||||
(*current_target.to_search) (len, data, mask, startaddr, increment, \
|
||||
lorange, hirange, addr_found, data_found)
|
||||
#endif /* 0 */
|
||||
|
||||
void (*to_files_info) PARAMS ((struct target_ops *));
|
||||
|
|
@ -415,6 +422,7 @@ struct target_ops
|
|||
int (*to_thread_alive) PARAMS ((int pid));
|
||||
void (*to_find_new_threads) PARAMS ((void));
|
||||
char *(*to_pid_to_str) PARAMS ((int));
|
||||
char *(*to_extra_thread_info) PARAMS ((struct thread_info *));
|
||||
void (*to_stop) PARAMS ((void));
|
||||
int (*to_query) PARAMS ((int /*char */ , char *, char *, int *));
|
||||
void (*to_rcmd) (char *command, struct gdb_file *output);
|
||||
|
|
@ -438,10 +446,12 @@ struct target_ops
|
|||
/* ASYNC target controls */
|
||||
int (*to_can_async_p) (void);
|
||||
int (*to_is_async_p) (void);
|
||||
void (*to_async) (void (*cb) (enum inferior_event_type, void *context), void *context);
|
||||
void (*to_async) (void (*cb) (enum inferior_event_type, void *context),
|
||||
void *context);
|
||||
int to_async_mask_value;
|
||||
int to_magic;
|
||||
/* Need sub-structure for target machine related rather than comm related? */
|
||||
/* Need sub-structure for target machine related rather than comm related?
|
||||
*/
|
||||
};
|
||||
|
||||
/* Magic number for checking ops size. If a struct doesn't end with this
|
||||
|
|
@ -475,8 +485,9 @@ extern struct target_stack_item *target_stack;
|
|||
/* The open routine takes the rest of the parameters from the command,
|
||||
and (if successful) pushes a new target onto the stack.
|
||||
Targets should supply this routine, if only to provide an error message. */
|
||||
|
||||
#define target_open(name, from_tty) \
|
||||
(*current_target.to_open) (name, from_tty)
|
||||
(*current_target.to_open) (name, from_tty)
|
||||
|
||||
/* Does whatever cleanup is required for a target that we are no longer
|
||||
going to be calling. Argument says whether we are quitting gdb and
|
||||
|
|
@ -487,7 +498,7 @@ extern struct target_stack_item *target_stack;
|
|||
do. */
|
||||
|
||||
#define target_close(quitting) \
|
||||
(*current_target.to_close) (quitting)
|
||||
(*current_target.to_close) (quitting)
|
||||
|
||||
/* Attaches to a process on the target side. Arguments are as passed
|
||||
to the `attach' command by the user. This routine can be called
|
||||
|
|
@ -498,16 +509,15 @@ extern struct target_stack_item *target_stack;
|
|||
(without waiting) to an upcoming target_wait call. */
|
||||
|
||||
#define target_attach(args, from_tty) \
|
||||
(*current_target.to_attach) (args, from_tty)
|
||||
(*current_target.to_attach) (args, from_tty)
|
||||
|
||||
/* The target_attach operation places a process under debugger control,
|
||||
and stops the process.
|
||||
|
||||
This operation provides a target-specific hook that allows the
|
||||
necessary bookkeeping to be performed after an attach completes.
|
||||
*/
|
||||
necessary bookkeeping to be performed after an attach completes. */
|
||||
#define target_post_attach(pid) \
|
||||
(*current_target.to_post_attach) (pid)
|
||||
(*current_target.to_post_attach) (pid)
|
||||
|
||||
/* Attaches to a process on the target side, if not already attached.
|
||||
(If already attached, takes no action.)
|
||||
|
|
@ -518,7 +528,7 @@ extern struct target_stack_item *target_stack;
|
|||
actual attach operation. */
|
||||
|
||||
#define target_require_attach(args, from_tty) \
|
||||
(*current_target.to_require_attach) (args, from_tty)
|
||||
(*current_target.to_require_attach) (args, from_tty)
|
||||
|
||||
/* Takes a program previously attached to and detaches it.
|
||||
The program may resume execution (some targets do, some don't) and will
|
||||
|
|
@ -542,8 +552,8 @@ target_detach PARAMS ((char *, int));
|
|||
ARGS is arguments typed by the user (e.g. a signal to send the process).
|
||||
FROM_TTY says whether to be verbose or not. */
|
||||
|
||||
#define target_require_detach(pid, args, from_tty) \
|
||||
(*current_target.to_require_detach) (pid, args, from_tty)
|
||||
#define target_require_detach(pid, args, from_tty) \
|
||||
(*current_target.to_require_detach) (pid, args, from_tty)
|
||||
|
||||
/* Resume execution of the target process PID. STEP says whether to
|
||||
single-step or to run free; SIGGNAL is the signal to be given to
|
||||
|
|
@ -551,7 +561,7 @@ target_detach PARAMS ((char *, int));
|
|||
pass TARGET_SIGNAL_DEFAULT. */
|
||||
|
||||
#define target_resume(pid, step, siggnal) \
|
||||
(*current_target.to_resume) (pid, step, siggnal)
|
||||
(*current_target.to_resume) (pid, step, siggnal)
|
||||
|
||||
/* Wait for process pid to do something. Pid = -1 to wait for any pid
|
||||
to do something. Return pid of child, or -1 in case of error;
|
||||
|
|
@ -562,7 +572,7 @@ target_detach PARAMS ((char *, int));
|
|||
stop_pc, etc., set up. */
|
||||
|
||||
#define target_wait(pid, status) \
|
||||
(*current_target.to_wait) (pid, status)
|
||||
(*current_target.to_wait) (pid, status)
|
||||
|
||||
/* The target_wait operation waits for a process event to occur, and
|
||||
thereby stop the process.
|
||||
|
|
@ -572,23 +582,22 @@ target_detach PARAMS ((char *, int));
|
|||
knowledge of what earlier events in the sequence have been seen.
|
||||
|
||||
This operation provides a target-specific hook that allows the
|
||||
necessary bookkeeping to be performed to track such sequences.
|
||||
*/
|
||||
necessary bookkeeping to be performed to track such sequences. */
|
||||
|
||||
#define target_post_wait(pid, status) \
|
||||
(*current_target.to_post_wait) (pid, status)
|
||||
(*current_target.to_post_wait) (pid, status)
|
||||
|
||||
/* Fetch register REGNO, or all regs if regno == -1. No result. */
|
||||
|
||||
#define target_fetch_registers(regno) \
|
||||
(*current_target.to_fetch_registers) (regno)
|
||||
(*current_target.to_fetch_registers) (regno)
|
||||
|
||||
/* Store at least register REGNO, or all regs if REGNO == -1.
|
||||
It can store as many registers as it wants to, so target_prepare_to_store
|
||||
must have been previously called. Calls error() if there are problems. */
|
||||
|
||||
#define target_store_registers(regs) \
|
||||
(*current_target.to_store_registers) (regs)
|
||||
(*current_target.to_store_registers) (regs)
|
||||
|
||||
/* Get ready to modify the registers array. On machines which store
|
||||
individual registers, this doesn't need to do anything. On machines
|
||||
|
|
@ -597,7 +606,7 @@ target_detach PARAMS ((char *, int));
|
|||
debugged. */
|
||||
|
||||
#define target_prepare_to_store() \
|
||||
(*current_target.to_prepare_to_store) ()
|
||||
(*current_target.to_prepare_to_store) ()
|
||||
|
||||
extern int
|
||||
target_read_string PARAMS ((CORE_ADDR, char **, int, int *));
|
||||
|
|
@ -622,7 +631,7 @@ child_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
|
|||
transfer, the number of bytes actually transfered is returned and
|
||||
ERR is set to 0. When a transfer fails, -1 is returned (the number
|
||||
of bytes actually transfered is not defined) and ERR is set to a
|
||||
non-zero error indication. */
|
||||
non-zero error indication. */
|
||||
|
||||
extern int
|
||||
target_read_memory_partial (CORE_ADDR addr, char *buf, int len, int *err);
|
||||
|
|
@ -712,7 +721,7 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
|
|||
/* Print a line about the current target. */
|
||||
|
||||
#define target_files_info() \
|
||||
(*current_target.to_files_info) (¤t_target)
|
||||
(*current_target.to_files_info) (¤t_target)
|
||||
|
||||
/* Insert a breakpoint at address ADDR in the target machine.
|
||||
SAVE is a pointer to memory allocated for saving the
|
||||
|
|
@ -721,7 +730,7 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
|
|||
an errno value. */
|
||||
|
||||
#define target_insert_breakpoint(addr, save) \
|
||||
(*current_target.to_insert_breakpoint) (addr, save)
|
||||
(*current_target.to_insert_breakpoint) (addr, save)
|
||||
|
||||
/* Remove a breakpoint at address ADDR in the target machine.
|
||||
SAVE is a pointer to the same save area
|
||||
|
|
@ -729,19 +738,19 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
|
|||
Result is 0 for success, or an errno value. */
|
||||
|
||||
#define target_remove_breakpoint(addr, save) \
|
||||
(*current_target.to_remove_breakpoint) (addr, save)
|
||||
(*current_target.to_remove_breakpoint) (addr, save)
|
||||
|
||||
/* Initialize the terminal settings we record for the inferior,
|
||||
before we actually run the inferior. */
|
||||
|
||||
#define target_terminal_init() \
|
||||
(*current_target.to_terminal_init) ()
|
||||
(*current_target.to_terminal_init) ()
|
||||
|
||||
/* Put the inferior's terminal settings into effect.
|
||||
This is preparation for starting or resuming the inferior. */
|
||||
|
||||
#define target_terminal_inferior() \
|
||||
(*current_target.to_terminal_inferior) ()
|
||||
(*current_target.to_terminal_inferior) ()
|
||||
|
||||
/* Put some of our terminal settings into effect,
|
||||
enough to get proper results from our output,
|
||||
|
|
@ -752,42 +761,42 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
|
|||
should be called to get back to a normal state of affairs. */
|
||||
|
||||
#define target_terminal_ours_for_output() \
|
||||
(*current_target.to_terminal_ours_for_output) ()
|
||||
(*current_target.to_terminal_ours_for_output) ()
|
||||
|
||||
/* Put our terminal settings into effect.
|
||||
First record the inferior's terminal settings
|
||||
so they can be restored properly later. */
|
||||
|
||||
#define target_terminal_ours() \
|
||||
(*current_target.to_terminal_ours) ()
|
||||
(*current_target.to_terminal_ours) ()
|
||||
|
||||
/* Print useful information about our terminal status, if such a thing
|
||||
exists. */
|
||||
|
||||
#define target_terminal_info(arg, from_tty) \
|
||||
(*current_target.to_terminal_info) (arg, from_tty)
|
||||
(*current_target.to_terminal_info) (arg, from_tty)
|
||||
|
||||
/* Kill the inferior process. Make it go away. */
|
||||
|
||||
#define target_kill() \
|
||||
(*current_target.to_kill) ()
|
||||
(*current_target.to_kill) ()
|
||||
|
||||
/* Load an executable file into the target process. This is expected to
|
||||
not only bring new code into the target process, but also to update
|
||||
GDB's symbol tables to match. */
|
||||
/* Load an executable file into the target process. This is expected
|
||||
to not only bring new code into the target process, but also to
|
||||
update GDB's symbol tables to match. */
|
||||
|
||||
extern void target_load (char *arg, int from_tty);
|
||||
|
||||
/* Look up a symbol in the target's symbol table. NAME is the symbol
|
||||
name. ADDRP is a CORE_ADDR * pointing to where the value of the symbol
|
||||
should be returned. The result is 0 if successful, nonzero if the
|
||||
symbol does not exist in the target environment. This function should
|
||||
not call error() if communication with the target is interrupted, since
|
||||
it is called from symbol reading, but should return nonzero, possibly
|
||||
doing a complain(). */
|
||||
name. ADDRP is a CORE_ADDR * pointing to where the value of the
|
||||
symbol should be returned. The result is 0 if successful, nonzero
|
||||
if the symbol does not exist in the target environment. This
|
||||
function should not call error() if communication with the target
|
||||
is interrupted, since it is called from symbol reading, but should
|
||||
return nonzero, possibly doing a complain(). */
|
||||
|
||||
#define target_lookup_symbol(name, addrp) \
|
||||
(*current_target.to_lookup_symbol) (name, addrp)
|
||||
#define target_lookup_symbol(name, addrp) \
|
||||
(*current_target.to_lookup_symbol) (name, addrp)
|
||||
|
||||
/* Start an inferior process and set inferior_pid to its pid.
|
||||
EXEC_FILE is the file to run.
|
||||
|
|
@ -796,7 +805,7 @@ extern void target_load (char *arg, int from_tty);
|
|||
On VxWorks and various standalone systems, we ignore exec_file. */
|
||||
|
||||
#define target_create_inferior(exec_file, args, env) \
|
||||
(*current_target.to_create_inferior) (exec_file, args, env)
|
||||
(*current_target.to_create_inferior) (exec_file, args, env)
|
||||
|
||||
|
||||
/* Some targets (such as ttrace-based HPUX) don't allow us to request
|
||||
|
|
@ -807,16 +816,16 @@ extern void target_load (char *arg, int from_tty);
|
|||
exec for each of those commands, and we will see each such fork
|
||||
event. Very bad.)
|
||||
|
||||
Such targets will supply an appropriate definition for this function.
|
||||
*/
|
||||
Such targets will supply an appropriate definition for this function. */
|
||||
|
||||
#define target_post_startup_inferior(pid) \
|
||||
(*current_target.to_post_startup_inferior) (pid)
|
||||
(*current_target.to_post_startup_inferior) (pid)
|
||||
|
||||
/* On some targets, the sequence of starting up an inferior requires
|
||||
some synchronization between gdb and the new inferior process, PID.
|
||||
*/
|
||||
some synchronization between gdb and the new inferior process, PID. */
|
||||
|
||||
#define target_acknowledge_created_inferior(pid) \
|
||||
(*current_target.to_acknowledge_created_inferior) (pid)
|
||||
(*current_target.to_acknowledge_created_inferior) (pid)
|
||||
|
||||
/* An inferior process has been created via a fork() or similar
|
||||
system call. This function will clone the debugger, then ensure
|
||||
|
|
@ -827,10 +836,10 @@ extern void target_load (char *arg, int from_tty);
|
|||
to determine which they are, if need be.)
|
||||
|
||||
(This is not a terribly useful feature without a GUI to prevent
|
||||
the two debuggers from competing for shell input.)
|
||||
*/
|
||||
the two debuggers from competing for shell input.) */
|
||||
|
||||
#define target_clone_and_follow_inferior(child_pid,followed_child) \
|
||||
(*current_target.to_clone_and_follow_inferior) (child_pid, followed_child)
|
||||
(*current_target.to_clone_and_follow_inferior) (child_pid, followed_child)
|
||||
|
||||
/* This operation is intended to be used as the last in a sequence of
|
||||
steps taken when following both parent and child of a fork. This
|
||||
|
|
@ -840,40 +849,40 @@ extern void target_load (char *arg, int from_tty);
|
|||
clone has attached to it.
|
||||
|
||||
On some targets, this requires a bit of cleanup to make it work
|
||||
correctly.
|
||||
*/
|
||||
#define target_post_follow_inferior_by_clone() \
|
||||
(*current_target.to_post_follow_inferior_by_clone) ()
|
||||
correctly. */
|
||||
|
||||
#define target_post_follow_inferior_by_clone() \
|
||||
(*current_target.to_post_follow_inferior_by_clone) ()
|
||||
|
||||
/* On some targets, we can catch an inferior fork or vfork event when
|
||||
it occurs. These functions insert/remove an already-created
|
||||
catchpoint for such events. */
|
||||
|
||||
/* On some targets, we can catch an inferior fork or vfork event when it
|
||||
occurs. These functions insert/remove an already-created catchpoint for
|
||||
such events.
|
||||
*/
|
||||
#define target_insert_fork_catchpoint(pid) \
|
||||
(*current_target.to_insert_fork_catchpoint) (pid)
|
||||
(*current_target.to_insert_fork_catchpoint) (pid)
|
||||
|
||||
#define target_remove_fork_catchpoint(pid) \
|
||||
(*current_target.to_remove_fork_catchpoint) (pid)
|
||||
(*current_target.to_remove_fork_catchpoint) (pid)
|
||||
|
||||
#define target_insert_vfork_catchpoint(pid) \
|
||||
(*current_target.to_insert_vfork_catchpoint) (pid)
|
||||
(*current_target.to_insert_vfork_catchpoint) (pid)
|
||||
|
||||
#define target_remove_vfork_catchpoint(pid) \
|
||||
(*current_target.to_remove_vfork_catchpoint) (pid)
|
||||
(*current_target.to_remove_vfork_catchpoint) (pid)
|
||||
|
||||
/* Returns TRUE if PID has invoked the fork() system call. And,
|
||||
also sets CHILD_PID to the process id of the other ("child")
|
||||
inferior process that was created by that call.
|
||||
*/
|
||||
#define target_has_forked(pid,child_pid) \
|
||||
(*current_target.to_has_forked) (pid,child_pid)
|
||||
inferior process that was created by that call. */
|
||||
|
||||
#define target_has_forked(pid,child_pid) \
|
||||
(*current_target.to_has_forked) (pid,child_pid)
|
||||
|
||||
/* Returns TRUE if PID has invoked the vfork() system call. And,
|
||||
also sets CHILD_PID to the process id of the other ("child")
|
||||
inferior process that was created by that call. */
|
||||
|
||||
/* Returns TRUE if PID has invoked the vfork() system call. And,
|
||||
also sets CHILD_PID to the process id of the other ("child")
|
||||
inferior process that was created by that call.
|
||||
*/
|
||||
#define target_has_vforked(pid,child_pid) \
|
||||
(*current_target.to_has_vforked) (pid,child_pid)
|
||||
(*current_target.to_has_vforked) (pid,child_pid)
|
||||
|
||||
/* Some platforms (such as pre-10.20 HP-UX) don't allow us to do
|
||||
anything to a vforked child before it subsequently calls exec().
|
||||
|
|
@ -882,10 +891,10 @@ extern void target_load (char *arg, int from_tty);
|
|||
|
||||
This function should be defined to return 1 by those targets
|
||||
which can allow the debugger to immediately follow a vforked
|
||||
child, and 0 if they cannot.
|
||||
*/
|
||||
child, and 0 if they cannot. */
|
||||
|
||||
#define target_can_follow_vfork_prior_to_exec() \
|
||||
(*current_target.to_can_follow_vfork_prior_to_exec) ()
|
||||
(*current_target.to_can_follow_vfork_prior_to_exec) ()
|
||||
|
||||
/* An inferior process has been created via a vfork() system call.
|
||||
The debugger has followed the parent, the child, or both. The
|
||||
|
|
@ -893,85 +902,81 @@ extern void target_load (char *arg, int from_tty);
|
|||
target-specific trickery to track the sequence of reported events.
|
||||
If so, this function should be defined by those targets that
|
||||
require the debugger to perform cleanup or initialization after
|
||||
the vfork follow.
|
||||
*/
|
||||
the vfork follow. */
|
||||
|
||||
#define target_post_follow_vfork(parent_pid,followed_parent,child_pid,followed_child) \
|
||||
(*current_target.to_post_follow_vfork) (parent_pid,followed_parent,child_pid,followed_child)
|
||||
(*current_target.to_post_follow_vfork) (parent_pid,followed_parent,child_pid,followed_child)
|
||||
|
||||
/* On some targets, we can catch an inferior exec event when it
|
||||
occurs. These functions insert/remove an already-created catchpoint
|
||||
for such events.
|
||||
*/
|
||||
occurs. These functions insert/remove an already-created
|
||||
catchpoint for such events. */
|
||||
|
||||
#define target_insert_exec_catchpoint(pid) \
|
||||
(*current_target.to_insert_exec_catchpoint) (pid)
|
||||
(*current_target.to_insert_exec_catchpoint) (pid)
|
||||
|
||||
#define target_remove_exec_catchpoint(pid) \
|
||||
(*current_target.to_remove_exec_catchpoint) (pid)
|
||||
(*current_target.to_remove_exec_catchpoint) (pid)
|
||||
|
||||
/* Returns TRUE if PID has invoked a flavor of the exec() system call.
|
||||
And, also sets EXECD_PATHNAME to the pathname of the executable file
|
||||
that was passed to exec(), and is now being executed.
|
||||
*/
|
||||
And, also sets EXECD_PATHNAME to the pathname of the executable
|
||||
file that was passed to exec(), and is now being executed. */
|
||||
|
||||
#define target_has_execd(pid,execd_pathname) \
|
||||
(*current_target.to_has_execd) (pid,execd_pathname)
|
||||
(*current_target.to_has_execd) (pid,execd_pathname)
|
||||
|
||||
/* Returns the number of exec events that are reported when a process
|
||||
invokes a flavor of the exec() system call on this target, if exec
|
||||
events are being reported.
|
||||
*/
|
||||
events are being reported. */
|
||||
|
||||
#define target_reported_exec_events_per_exec_call() \
|
||||
(*current_target.to_reported_exec_events_per_exec_call) ()
|
||||
(*current_target.to_reported_exec_events_per_exec_call) ()
|
||||
|
||||
/* Returns TRUE if PID has reported a syscall event. And, also sets
|
||||
KIND to the appropriate TARGET_WAITKIND_, and sets SYSCALL_ID to
|
||||
the unique integer ID of the syscall.
|
||||
*/
|
||||
the unique integer ID of the syscall. */
|
||||
|
||||
#define target_has_syscall_event(pid,kind,syscall_id) \
|
||||
(*current_target.to_has_syscall_event) (pid,kind,syscall_id)
|
||||
(*current_target.to_has_syscall_event) (pid,kind,syscall_id)
|
||||
|
||||
/* Returns TRUE if PID has exited. And, also sets EXIT_STATUS to the
|
||||
exit code of PID, if any.
|
||||
*/
|
||||
exit code of PID, if any. */
|
||||
|
||||
#define target_has_exited(pid,wait_status,exit_status) \
|
||||
(*current_target.to_has_exited) (pid,wait_status,exit_status)
|
||||
(*current_target.to_has_exited) (pid,wait_status,exit_status)
|
||||
|
||||
/* The debugger has completed a blocking wait() call. There is now
|
||||
some process event that must be processed. This function should
|
||||
some process event that must be processed. This function should
|
||||
be defined by those targets that require the debugger to perform
|
||||
cleanup or internal state changes in response to the process event.
|
||||
*/
|
||||
cleanup or internal state changes in response to the process event. */
|
||||
|
||||
/* The inferior process has died. Do what is right. */
|
||||
|
||||
#define target_mourn_inferior() \
|
||||
(*current_target.to_mourn_inferior) ()
|
||||
(*current_target.to_mourn_inferior) ()
|
||||
|
||||
/* Does target have enough data to do a run or attach command? */
|
||||
|
||||
#define target_can_run(t) \
|
||||
((t)->to_can_run) ()
|
||||
((t)->to_can_run) ()
|
||||
|
||||
/* post process changes to signal handling in the inferior. */
|
||||
|
||||
#define target_notice_signals(pid) \
|
||||
(*current_target.to_notice_signals) (pid)
|
||||
(*current_target.to_notice_signals) (pid)
|
||||
|
||||
/* Check to see if a thread is still alive. */
|
||||
|
||||
#define target_thread_alive(pid) \
|
||||
(*current_target.to_thread_alive) (pid)
|
||||
(*current_target.to_thread_alive) (pid)
|
||||
|
||||
/* Query for new threads and add them to the thread list. */
|
||||
|
||||
#define target_find_new_threads() \
|
||||
do { \
|
||||
if (current_target.to_find_new_threads) \
|
||||
(*current_target.to_find_new_threads) (); \
|
||||
} while (0);
|
||||
(*current_target.to_find_new_threads) (); \
|
||||
|
||||
/* Make target stop in a continuable fashion. (For instance, under Unix, this
|
||||
should act like SIGSTOP). This function is normally used by GUIs to
|
||||
implement a stop button. */
|
||||
/* Make target stop in a continuable fashion. (For instance, under
|
||||
Unix, this should act like SIGSTOP). This function is normally
|
||||
used by GUIs to implement a stop button. */
|
||||
|
||||
#define target_stop current_target.to_stop
|
||||
|
||||
|
|
@ -980,14 +985,14 @@ extern void target_load (char *arg, int from_tty);
|
|||
should process it. The second argument is a string that specifies which
|
||||
information is desired and the third is a buffer that carries back the
|
||||
response from the target side. The fourth parameter is the size of the
|
||||
output buffer supplied. */
|
||||
output buffer supplied. */
|
||||
|
||||
#define target_query(query_type, query, resp_buffer, bufffer_size) \
|
||||
(*current_target.to_query) (query_type, query, resp_buffer, bufffer_size)
|
||||
(*current_target.to_query) (query_type, query, resp_buffer, bufffer_size)
|
||||
|
||||
/* Send the specified COMMAND to the target's monitor
|
||||
(shell,interpreter) for execution. The result of the query is
|
||||
placed in OUTBUF. */
|
||||
placed in OUTBUF. */
|
||||
|
||||
#define target_rcmd(command, outbuf) \
|
||||
(*current_target.to_rcmd) (command, outbuf)
|
||||
|
|
@ -998,43 +1003,43 @@ extern void target_load (char *arg, int from_tty);
|
|||
Intended mainly for C++, and for those
|
||||
platforms/implementations where such a callback mechanism is available,
|
||||
e.g. HP-UX with ANSI C++ (aCC). Some compilers (e.g. g++) support
|
||||
different mechanisms for debugging exceptions. */
|
||||
different mechanisms for debugging exceptions. */
|
||||
|
||||
#define target_enable_exception_callback(kind, enable) \
|
||||
(*current_target.to_enable_exception_callback) (kind, enable)
|
||||
(*current_target.to_enable_exception_callback) (kind, enable)
|
||||
|
||||
/* Get the current exception event kind -- throw or catch, etc. */
|
||||
/* Get the current exception event kind -- throw or catch, etc. */
|
||||
|
||||
#define target_get_current_exception_event() \
|
||||
(*current_target.to_get_current_exception_event) ()
|
||||
(*current_target.to_get_current_exception_event) ()
|
||||
|
||||
/* Pointer to next target in the chain, e.g. a core file and an exec file. */
|
||||
|
||||
#define target_next \
|
||||
(current_target.to_next)
|
||||
(current_target.to_next)
|
||||
|
||||
/* Does the target include all of memory, or only part of it? This
|
||||
determines whether we look up the target chain for other parts of
|
||||
memory if this target can't satisfy a request. */
|
||||
|
||||
#define target_has_all_memory \
|
||||
(current_target.to_has_all_memory)
|
||||
(current_target.to_has_all_memory)
|
||||
|
||||
/* Does the target include memory? (Dummy targets don't.) */
|
||||
|
||||
#define target_has_memory \
|
||||
(current_target.to_has_memory)
|
||||
(current_target.to_has_memory)
|
||||
|
||||
/* Does the target have a stack? (Exec files don't, VxWorks doesn't, until
|
||||
we start a process.) */
|
||||
|
||||
#define target_has_stack \
|
||||
(current_target.to_has_stack)
|
||||
(current_target.to_has_stack)
|
||||
|
||||
/* Does the target have registers? (Exec files don't.) */
|
||||
|
||||
#define target_has_registers \
|
||||
(current_target.to_has_registers)
|
||||
(current_target.to_has_registers)
|
||||
|
||||
/* Does the target have execution? Can we make it jump (through
|
||||
hoops), or pop its stack a few times? FIXME: If this is to work that
|
||||
|
|
@ -1044,17 +1049,17 @@ extern void target_load (char *arg, int from_tty);
|
|||
this just tells us whether this target is *capable* of execution. */
|
||||
|
||||
#define target_has_execution \
|
||||
(current_target.to_has_execution)
|
||||
(current_target.to_has_execution)
|
||||
|
||||
/* Can the target support the debugger control of thread execution?
|
||||
a) Can it lock the thread scheduler?
|
||||
b) Can it switch the currently running thread? */
|
||||
|
||||
#define target_can_lock_scheduler \
|
||||
(current_target.to_has_thread_control & tc_schedlock)
|
||||
(current_target.to_has_thread_control & tc_schedlock)
|
||||
|
||||
#define target_can_switch_threads \
|
||||
(current_target.to_has_thread_control & tc_switch)
|
||||
(current_target.to_has_thread_control & tc_switch)
|
||||
|
||||
/* Can the target support asynchronous execution? */
|
||||
#define target_can_async_p() (current_target.to_can_async_p ())
|
||||
|
|
@ -1063,7 +1068,8 @@ extern void target_load (char *arg, int from_tty);
|
|||
#define target_is_async_p() (current_target.to_is_async_p())
|
||||
|
||||
/* Put the target in async mode with the specified callback function. */
|
||||
#define target_async(CALLBACK,CONTEXT) (current_target.to_async((CALLBACK), (CONTEXT)))
|
||||
#define target_async(CALLBACK,CONTEXT) \
|
||||
(current_target.to_async((CALLBACK), (CONTEXT)))
|
||||
|
||||
/* This is to be used ONLY within run_stack_dummy(). It
|
||||
provides a workaround, to have inferior function calls done in
|
||||
|
|
@ -1077,10 +1083,10 @@ extern void target_load (char *arg, int from_tty);
|
|||
|
||||
FIXME ezannoni 1999-12-13: we won't need this once we move
|
||||
the turning async on and off to the single execution commands,
|
||||
from where it is done currently, in remote_resume().*/
|
||||
from where it is done currently, in remote_resume(). */
|
||||
|
||||
#define target_async_mask_value \
|
||||
(current_target.to_async_mask_value)
|
||||
(current_target.to_async_mask_value)
|
||||
|
||||
extern int target_async_mask (int mask);
|
||||
|
||||
|
|
@ -1095,10 +1101,16 @@ extern void target_link PARAMS ((char *, CORE_ADDR *));
|
|||
|
||||
#ifndef target_tid_to_str
|
||||
#define target_tid_to_str(PID) \
|
||||
target_pid_to_str (PID)
|
||||
target_pid_to_str (PID)
|
||||
extern char *normal_pid_to_str PARAMS ((int pid));
|
||||
#endif
|
||||
|
||||
/* Return a short string describing extra information about PID,
|
||||
e.g. "sleeping", "runnable", "running on LWP 3". Null return value
|
||||
is okay. */
|
||||
|
||||
#define target_extra_thread_info(TP) \
|
||||
(current_target.to_extra_thread_info (TP))
|
||||
|
||||
/*
|
||||
* New Objfile Event Hook:
|
||||
|
|
@ -1127,7 +1139,7 @@ extern void (*target_new_objfile_hook) PARAMS ((struct objfile *));
|
|||
|
||||
#ifndef target_pid_or_tid_to_str
|
||||
#define target_pid_or_tid_to_str(ID) \
|
||||
target_pid_to_str (ID)
|
||||
target_pid_to_str (ID)
|
||||
#endif
|
||||
|
||||
/* Attempts to find the pathname of the executable file
|
||||
|
|
@ -1140,13 +1152,12 @@ extern void (*target_new_objfile_hook) PARAMS ((struct objfile *));
|
|||
Else, a pointer to a character string containing the pathname
|
||||
is returned. This string should be copied into a buffer by
|
||||
the client if the string will not be immediately used, or if
|
||||
it must persist.
|
||||
*/
|
||||
it must persist. */
|
||||
|
||||
#define target_pid_to_exec_file(pid) \
|
||||
(current_target.to_pid_to_exec_file) (pid)
|
||||
(current_target.to_pid_to_exec_file) (pid)
|
||||
|
||||
/* Hook to call target-dependant code after reading in a new symbol table. */
|
||||
/* Hook to call target-dependant code after reading in a new symbol table. */
|
||||
|
||||
#ifndef TARGET_SYMFILE_POSTREAD
|
||||
#define TARGET_SYMFILE_POSTREAD(OBJFILE)
|
||||
|
|
@ -1170,8 +1181,8 @@ extern void (*target_new_objfile_hook) PARAMS ((struct objfile *));
|
|||
|
||||
/* HP-UX supplies these operations, which respectively disable and enable
|
||||
the memory page-protections that are used to implement hardware watchpoints
|
||||
on that platform. See wait_for_inferior's use of these.
|
||||
*/
|
||||
on that platform. See wait_for_inferior's use of these. */
|
||||
|
||||
#if !defined(TARGET_DISABLE_HW_WATCHPOINTS)
|
||||
#define TARGET_DISABLE_HW_WATCHPOINTS(pid)
|
||||
#endif
|
||||
|
|
@ -1180,7 +1191,7 @@ extern void (*target_new_objfile_hook) PARAMS ((struct objfile *));
|
|||
#define TARGET_ENABLE_HW_WATCHPOINTS(pid)
|
||||
#endif
|
||||
|
||||
/* Provide defaults for systems that don't support hardware watchpoints. */
|
||||
/* Provide defaults for systems that don't support hardware watchpoints. */
|
||||
|
||||
#ifndef TARGET_HAS_HARDWARE_WATCHPOINTS
|
||||
|
||||
|
|
@ -1193,7 +1204,7 @@ extern void (*target_new_objfile_hook) PARAMS ((struct objfile *));
|
|||
|
||||
#if !defined(TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT)
|
||||
#define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(byte_count) \
|
||||
(LONGEST)(byte_count) <= REGISTER_SIZE
|
||||
(LONGEST)(byte_count) <= REGISTER_SIZE
|
||||
#endif
|
||||
|
||||
/* However, some addresses may not be profitable to use hardware to watch,
|
||||
|
|
@ -1201,8 +1212,8 @@ extern void (*target_new_objfile_hook) PARAMS ((struct objfile *));
|
|||
scope, and hence should be unwatched. On some targets, this may have
|
||||
severe performance penalties, such that we might as well use regular
|
||||
watchpoints, and save (possibly precious) hardware watchpoints for other
|
||||
locations.
|
||||
*/
|
||||
locations. */
|
||||
|
||||
#if !defined(TARGET_RANGE_PROFITABLE_FOR_HW_WATCHPOINT)
|
||||
#define TARGET_RANGE_PROFITABLE_FOR_HW_WATCHPOINT(pid,start,len) 0
|
||||
#endif
|
||||
|
|
@ -1236,8 +1247,8 @@ extern void (*target_new_objfile_hook) PARAMS ((struct objfile *));
|
|||
/* Sometimes gdb may pick up what appears to be a valid target address
|
||||
from a minimal symbol, but the value really means, essentially,
|
||||
"This is an index into a table which is populated when the inferior
|
||||
is run. Therefore, do not attempt to use this as a PC."
|
||||
*/
|
||||
is run. Therefore, do not attempt to use this as a PC." */
|
||||
|
||||
#if !defined(PC_REQUIRES_RUN_BEFORE_USE)
|
||||
#define PC_REQUIRES_RUN_BEFORE_USE(pc) (0)
|
||||
#endif
|
||||
|
|
@ -1248,8 +1259,7 @@ extern void (*target_new_objfile_hook) PARAMS ((struct objfile *));
|
|||
On some targets (such as HP-UX 10.20 and earlier), resuming a newly vforked
|
||||
child process after it has exec'd, causes the parent process to resume as
|
||||
well. To prevent the parent from running spontaneously, such targets should
|
||||
define this to a function that prevents that from happening.
|
||||
*/
|
||||
define this to a function that prevents that from happening. */
|
||||
#if !defined(ENSURE_VFORKING_PARENT_REMAINS_STOPPED)
|
||||
#define ENSURE_VFORKING_PARENT_REMAINS_STOPPED(PID) (0)
|
||||
#endif
|
||||
|
|
@ -1259,8 +1269,8 @@ extern void (*target_new_objfile_hook) PARAMS ((struct objfile *));
|
|||
|
||||
On some targets (such as HP-UX 10.20 and earlier), a newly vforked child
|
||||
process must be resumed when it delivers its exec event, before the parent
|
||||
vfork event will be delivered to us.
|
||||
*/
|
||||
vfork event will be delivered to us. */
|
||||
|
||||
#if !defined(RESUME_EXECD_VFORKING_CHILD_TO_GET_PARENT_VFORK)
|
||||
#define RESUME_EXECD_VFORKING_CHILD_TO_GET_PARENT_VFORK() (0)
|
||||
#endif
|
||||
|
|
@ -1328,7 +1338,8 @@ extern int default_memory_insert_breakpoint PARAMS ((CORE_ADDR, char *));
|
|||
|
||||
extern breakpoint_from_pc_fn memory_breakpoint_from_pc;
|
||||
#ifndef BREAKPOINT_FROM_PC
|
||||
#define BREAKPOINT_FROM_PC(pcptr, lenptr) memory_breakpoint_from_pc (pcptr, lenptr)
|
||||
#define BREAKPOINT_FROM_PC(pcptr, lenptr) \
|
||||
memory_breakpoint_from_pc (pcptr, lenptr)
|
||||
#endif
|
||||
|
||||
|
||||
|
|
@ -1386,22 +1397,24 @@ extern asection *target_memory_bfd_section;
|
|||
extern void store_waitstatus PARAMS ((struct target_waitstatus *, int));
|
||||
|
||||
/* Predicate to target_signal_to_host(). Return non-zero if the enum
|
||||
targ_signal SIGNO has an equivalent ``host'' representation. */
|
||||
targ_signal SIGNO has an equivalent ``host'' representation. */
|
||||
/* FIXME: cagney/1999-11-22: The name below was chosen in preference
|
||||
to the shorter target_signal_p() because it is far less ambigious.
|
||||
In this context ``target_signal'' refers to GDB's internal
|
||||
representation of the target's set of signals while ``host signal''
|
||||
refers to the target operating system's signal. Confused? */
|
||||
refers to the target operating system's signal. Confused? */
|
||||
|
||||
extern int target_signal_to_host_p (enum target_signal signo);
|
||||
|
||||
/* Convert between host signal numbers and enum target_signal's.
|
||||
target_signal_to_host() returns 0 and prints a warning() on GDB's
|
||||
console if SIGNO has no equivalent host representation. */
|
||||
console if SIGNO has no equivalent host representation. */
|
||||
/* FIXME: cagney/1999-11-22: Here ``host'' is used incorrectly, it is
|
||||
refering to the target operating system's signal numbering.
|
||||
Similarly, ``enum target_signal'' is named incorrectly, ``enum
|
||||
gdb_signal'' would probably be better as it is refering to GDB's
|
||||
internal representation of a target operating system's signal. */
|
||||
internal representation of a target operating system's signal. */
|
||||
|
||||
extern enum target_signal target_signal_from_host PARAMS ((int));
|
||||
extern int target_signal_to_host PARAMS ((enum target_signal));
|
||||
|
||||
|
|
@ -1415,7 +1428,8 @@ extern void push_remote_target PARAMS ((char *name, int from_tty));
|
|||
|
||||
#ifndef SOFTWARE_SINGLE_STEP_P
|
||||
#define SOFTWARE_SINGLE_STEP_P 0
|
||||
#define SOFTWARE_SINGLE_STEP(sig,bp_p) (internal_error ("SOFTWARE_SINGLE_STEP"), 0)
|
||||
#define SOFTWARE_SINGLE_STEP(sig,bp_p) \
|
||||
(internal_error ("SOFTWARE_SINGLE_STEP"), 0)
|
||||
#endif /* SOFTWARE_SINGLE_STEP_P */
|
||||
|
||||
/* Blank target vector entries are initialized to target_ignore. */
|
||||
|
|
|
|||
|
|
@ -1,3 +1,24 @@
|
|||
2000-01-10 Elena Zannoni <ezannoni@kwikemart.cygnus.com>
|
||||
|
||||
* gdb.base/so-indr-cl.exp: Don't execute the test if not on HPUX.
|
||||
Don't use xfail's because that affects only the following test.
|
||||
|
||||
* gdb.base/so-impl-ld.exp: Don't execute the tests if not on hpux,
|
||||
solaris or linux.
|
||||
|
||||
* gdb.base/selftest.exp: Update to reflect changes to main.c.
|
||||
|
||||
2000-01-07 Michael Snyder <msnyder@cleaver.cygnus.com>
|
||||
|
||||
* gdb.base/display.exp: Some yacc parsers like to say
|
||||
"A syntax error" rather than "A parse error". Accept both.
|
||||
|
||||
2000-01-06 Fernando Nasser <fnasser@totem.to.cygnus.com>
|
||||
|
||||
* gdb.base/default.exp: Remove OS dependent string from "target
|
||||
remote" test.
|
||||
* gdb.base/help.exp: Same for "help target remote" test.
|
||||
|
||||
2000-01-04 Elena Zannoni <ezannoni@kwikemart.cygnus.com>
|
||||
|
||||
From Jim Kingdon <kingdon@redhat.com>:
|
||||
|
|
|
|||
|
|
@ -727,7 +727,7 @@ gdb_expect {
|
|||
if ![istarget "*-*-udi*"] then {
|
||||
send_gdb "target remote\n"
|
||||
gdb_expect {
|
||||
-re "To open a remote debug connection, you need to specify what.*serial.*device is attached to the remote system .e.g. /dev/ttya.*$gdb_prompt $"\
|
||||
-re "To open a remote debug connection, you need to specify what.*serial.*device is attached to the remote system .e.g. .*$gdb_prompt $"\
|
||||
{ pass "target remote" }
|
||||
-re ".*A program is being debugged already. Kill it. .y or n.*$" {
|
||||
send_gdb "n\n"
|
||||
|
|
|
|||
|
|
@ -191,7 +191,7 @@ gdb_test "p/a &sum" ".*= $hex.*<sum>.*"
|
|||
# this test will (incorrectly) fail. So use a small number.
|
||||
gdb_test "p/a main+4" ".*= $hex.*<.*>.*"
|
||||
gdb_test "p/a \$pc" ".*= $hex.*<do_vars+.*>.*"
|
||||
gdb_test "p/a &&j" ".*A parse error.*"
|
||||
gdb_test "p/a &&j" ".*A .* error in expression.*"
|
||||
|
||||
# Done!
|
||||
#
|
||||
|
|
|
|||
|
|
@ -504,7 +504,7 @@ gdb_test "help target core" ".*Use a core file as a target.*Specify the filename
|
|||
# test help target exec
|
||||
gdb_test "help target exec" "Use an executable file as a target..*\[\r\n\]+Specify the filename of the executable file." "help target exec"
|
||||
# test help target remote
|
||||
gdb_test "help target remote" "Use a remote computer via a serial line, using a gdb-specific protocol..*\[\r\n\]+Specify the serial device it is connected to .e.g. /dev/ttya..*" "help target remote"
|
||||
gdb_test "help target remote" "Use a remote computer via a serial line, using a gdb-specific protocol..*\[\r\n\]+Specify the serial device it is connected to .e.g. .*" "help target remote"
|
||||
# test help target
|
||||
# the child process target may be "target child" or "target procfs"
|
||||
gdb_test "help target" "Connect to a target machine or process..*\[\r\n\]+The first argument is the type or protocol of the target machine..*\[\r\n\]+Remaining arguments are interpreted by the target protocol. For more.*\[\r\n\]+information on the arguments for a particular protocol, type.*\[\r\n\]+`help target ' followed by the protocol name..*\[\r\n\]+List of target subcommands:.*\[\r\n\]+target exec -- Use an executable file as a target.*\[\r\n\]+Type \"help target\" followed by target subcommand name for full documentation..*\[\r\n\]+Command name abbreviations are allowed if unambiguous." "help target"
|
||||
|
|
|
|||
|
|
@ -51,9 +51,29 @@ proc do_steps_and_nexts {} {
|
|||
|
||||
gdb_reinitialize_dir $srcdir/..
|
||||
|
||||
for {set count 0} {$count < 20} {incr count} {
|
||||
for {set count 0} {$count < 22} {incr count} {
|
||||
send_gdb "list\n"
|
||||
gdb_expect {
|
||||
-re ".*context = data.*$gdb_prompt $" {
|
||||
set description "step over context initialization"
|
||||
set command "step"
|
||||
}
|
||||
-re ".*argc = context->argc.*$gdb_prompt $" {
|
||||
set description "step over argc initialization"
|
||||
set command "step"
|
||||
}
|
||||
-re ".*argv = context->argv.*$gdb_prompt $" {
|
||||
set description "step over argv initialization"
|
||||
set command "step"
|
||||
}
|
||||
-re ".*quiet = 0.*$gdb_prompt $" {
|
||||
set description "step over quiet initialization"
|
||||
set command "step"
|
||||
}
|
||||
-re ".*batch = 0.*$gdb_prompt $" {
|
||||
set description "step over batch initialization"
|
||||
set command "step"
|
||||
}
|
||||
-re ".*symarg = NULL.*$gdb_prompt $" {
|
||||
set description "step over symarg initialization"
|
||||
set command "step"
|
||||
|
|
@ -74,10 +94,6 @@ proc do_steps_and_nexts {} {
|
|||
set description "step over ttyarg initialization"
|
||||
set command "step"
|
||||
}
|
||||
-re ".*interparg = NULL.*$gdb_prompt $" {
|
||||
set description "step over interparg initialization"
|
||||
set command "step"
|
||||
}
|
||||
-re ".*time_at_startup = get_run_time.*$gdb_prompt $" {
|
||||
set description "next over get_run_time and everything it calls"
|
||||
set command "next"
|
||||
|
|
@ -106,10 +122,6 @@ proc do_steps_and_nexts {} {
|
|||
set description "next over conditional stack alignment alloca"
|
||||
set command "next"
|
||||
}
|
||||
-re ".*SET_TOP_LEVEL.*$gdb_prompt $" {
|
||||
set description "next over SET_TOP_LEVEL call"
|
||||
set command "next"
|
||||
}
|
||||
-re ".*cmdsize = 1.*$gdb_prompt $" {
|
||||
set description "step over cmdsize initialization"
|
||||
set command "next"
|
||||
|
|
@ -199,9 +211,9 @@ proc test_with_self { executable } {
|
|||
"Disassemble main"
|
||||
|
||||
# Set a breakpoint at main
|
||||
gdb_test "break main" \
|
||||
gdb_test "break captured_main" \
|
||||
"Breakpoint.*at.* file.*, line.*" \
|
||||
"breakpoint in main"
|
||||
"breakpoint in captured_main"
|
||||
|
||||
# We'll need this when we send a ^C to GDB. Need to do it before we
|
||||
# run the program and gdb starts saving and restoring tty states.
|
||||
|
|
@ -222,13 +234,13 @@ proc test_with_self { executable } {
|
|||
# so we bump it back up for the duration of this command.
|
||||
set timeout 600
|
||||
|
||||
set description "run until breakpoint at main"
|
||||
set description "run until breakpoint at captured_main"
|
||||
send_gdb "run -nw\n"
|
||||
gdb_expect {
|
||||
-re "Starting program.*Breakpoint \[0-9\]+,.*main .argc.*argv.* at .*main.c:.*$gdb_prompt $" {
|
||||
-re "Starting program.*Breakpoint \[0-9\]+,.*captured_main .data.* at .*main.c:.*$gdb_prompt $" {
|
||||
pass "$description"
|
||||
}
|
||||
-re "Starting program.*Breakpoint \[0-9\]+,.*main .argc.*argv.*$gdb_prompt $" {
|
||||
-re "Starting program.*Breakpoint \[0-9\]+,.*captured_main .data.*$gdb_prompt $" {
|
||||
xfail "$description (line numbers scrambled?)"
|
||||
}
|
||||
-re "vfork: No more processes.*$gdb_prompt $" {
|
||||
|
|
|
|||
|
|
@ -32,9 +32,13 @@ if ![isnative] then {
|
|||
# This test is presently only valid on HP-UX, since it requires
|
||||
# that we use HP-UX-specific compiler & linker options to build
|
||||
# the testcase.
|
||||
#
|
||||
setup_xfail "*-*-*"
|
||||
clear_xfail "hppa*-*-*hpux*"
|
||||
# Actually this test works on solaris, and linux too.
|
||||
|
||||
if {! ([istarget "hppa*-*-*hpux*"]
|
||||
|| [istarget "sparc-sun-solaris*"]
|
||||
|| [istarget " *-*-linux-gnu"]) } {
|
||||
return
|
||||
}
|
||||
|
||||
set libfile "solib"
|
||||
set testfile "so-impl-ld"
|
||||
|
|
@ -160,3 +164,9 @@ gdb_expect {
|
|||
|
||||
gdb_exit
|
||||
return 0
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -33,8 +33,9 @@ if ![isnative] then {
|
|||
# that we use HP-UX-specific compiler & linker options to build
|
||||
# the testcase.
|
||||
#
|
||||
setup_xfail "*-*-*"
|
||||
clear_xfail "hppa*-*-*hpux*"
|
||||
if {! [istarget "hppa*-*-*hpux*"] } {
|
||||
return
|
||||
}
|
||||
|
||||
set libfile "solib"
|
||||
set testfile "so-indr-cl"
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ if [istarget "*-*-linux"] then {
|
|||
set target_cflags ""
|
||||
}
|
||||
set why_msg "unrecognized error"
|
||||
foreach lib {-lpthreads -lpthread} {
|
||||
foreach lib {-lpthreads -lpthread -lthread} {
|
||||
set options "debug"
|
||||
lappend options "incdir=${objdir}/${subdir}"
|
||||
lappend options "libs=$lib"
|
||||
|
|
|
|||
102
gdb/thread.c
102
gdb/thread.c
|
|
@ -1,5 +1,5 @@
|
|||
/* Multi-process/thread control for GDB, the GNU debugger.
|
||||
Copyright 1986, 1987, 1988, 1993, 1998
|
||||
Copyright 1986, 1987, 1988, 1993, 1998, 1999, 2000
|
||||
|
||||
Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA.
|
||||
Free Software Foundation, Inc.
|
||||
|
|
@ -38,41 +38,7 @@
|
|||
|
||||
/*#include "lynxos-core.h" */
|
||||
|
||||
struct thread_info
|
||||
{
|
||||
struct thread_info *next;
|
||||
int pid; /* Actual process id */
|
||||
int num; /* Convenient handle */
|
||||
CORE_ADDR prev_pc; /* State from wait_for_inferior */
|
||||
CORE_ADDR prev_func_start;
|
||||
char *prev_func_name;
|
||||
struct breakpoint *step_resume_breakpoint;
|
||||
struct breakpoint *through_sigtramp_breakpoint;
|
||||
CORE_ADDR step_range_start;
|
||||
CORE_ADDR step_range_end;
|
||||
CORE_ADDR step_frame_address;
|
||||
int trap_expected;
|
||||
int handling_longjmp;
|
||||
int another_trap;
|
||||
|
||||
/* This is set TRUE when a catchpoint of a shared library event
|
||||
triggers. Since we don't wish to leave the inferior in the
|
||||
solib hook when we report the event, we step the inferior
|
||||
back to user code before stopping and reporting the event.
|
||||
*/
|
||||
int stepping_through_solib_after_catch;
|
||||
|
||||
/* When stepping_through_solib_after_catch is TRUE, this is a
|
||||
list of the catchpoints that should be reported as triggering
|
||||
when we finally do stop stepping.
|
||||
*/
|
||||
bpstat stepping_through_solib_catchpoints;
|
||||
|
||||
/* This is set to TRUE when this thread is in a signal handler
|
||||
trampoline and we're single-stepping through it */
|
||||
int stepping_through_sigtramp;
|
||||
|
||||
};
|
||||
/* Definition of struct thread_info exported to gdbthread.h */
|
||||
|
||||
/* Prototypes for exported functions. */
|
||||
|
||||
|
|
@ -112,7 +78,10 @@ init_thread_list ()
|
|||
highest_thread_num = 0;
|
||||
}
|
||||
|
||||
void
|
||||
/* add_thread now returns a pointer to the new thread_info,
|
||||
so that back_ends can initialize their private data. */
|
||||
|
||||
struct thread_info *
|
||||
add_thread (pid)
|
||||
int pid;
|
||||
{
|
||||
|
|
@ -138,6 +107,7 @@ add_thread (pid)
|
|||
tp->stepping_through_sigtramp = 0;
|
||||
tp->next = thread_list;
|
||||
thread_list = tp;
|
||||
return tp;
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -165,6 +135,11 @@ delete_thread (pid)
|
|||
if (tp->step_resume_breakpoint)
|
||||
delete_breakpoint (tp->step_resume_breakpoint);
|
||||
|
||||
/* FIXME: do I ever need to call the back-end to give it a
|
||||
chance at this private data before deleting the thread? */
|
||||
if (tp->private)
|
||||
free (tp->private);
|
||||
|
||||
free (tp);
|
||||
|
||||
return;
|
||||
|
|
@ -183,6 +158,48 @@ find_thread_id (num)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
/* Find a thread_info by matching 'pid'. */
|
||||
struct thread_info *
|
||||
find_thread_pid (pid)
|
||||
int pid;
|
||||
{
|
||||
struct thread_info *tp;
|
||||
|
||||
for (tp = thread_list; tp; tp = tp->next)
|
||||
if (tp->pid == pid)
|
||||
return tp;
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Thread iterator function.
|
||||
*
|
||||
* Calls a callback function once for each thread, so long as
|
||||
* the callback function returns false. If the callback function
|
||||
* returns true, the iteration will end and the current thread
|
||||
* will be returned. This can be useful for implementing a
|
||||
* search for a thread with arbitrary attributes, or for applying
|
||||
* some operation to every thread.
|
||||
*
|
||||
* FIXME: some of the existing functionality, such as
|
||||
* "Thread apply all", might be rewritten using this functionality.
|
||||
*/
|
||||
|
||||
struct thread_info *
|
||||
iterate_over_threads (callback, data)
|
||||
int (*callback) ();
|
||||
void *data;
|
||||
{
|
||||
struct thread_info *tp;
|
||||
|
||||
for (tp = thread_list; tp; tp = tp->next)
|
||||
if ((*callback) (tp, data))
|
||||
return tp;
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int
|
||||
valid_thread_id (num)
|
||||
int num;
|
||||
|
|
@ -380,6 +397,7 @@ info_threads_command (arg, from_tty)
|
|||
struct frame_info *cur_frame;
|
||||
int saved_frame_level = selected_frame_level;
|
||||
int counter;
|
||||
char *extra_info;
|
||||
|
||||
/* Avoid coredumps which would happen if we tried to access a NULL
|
||||
selected_frame. */
|
||||
|
|
@ -397,10 +415,16 @@ info_threads_command (arg, from_tty)
|
|||
printf_filtered (" ");
|
||||
|
||||
#ifdef HPUXHPPA
|
||||
printf_filtered ("%d %s ", tp->num, target_tid_to_str (tp->pid));
|
||||
printf_filtered ("%d %s", tp->num, target_tid_to_str (tp->pid));
|
||||
#else
|
||||
printf_filtered ("%d %s ", tp->num, target_pid_to_str (tp->pid));
|
||||
printf_filtered ("%d %s", tp->num, target_pid_to_str (tp->pid));
|
||||
#endif
|
||||
|
||||
extra_info = target_extra_thread_info (tp);
|
||||
if (extra_info)
|
||||
printf_filtered (" (%s)", extra_info);
|
||||
puts_filtered (" ");
|
||||
|
||||
switch_to_thread (tp->pid);
|
||||
if (selected_frame)
|
||||
print_only_stack_frame (selected_frame, -1, 0);
|
||||
|
|
|
|||
|
|
@ -571,6 +571,15 @@ handle_exception (struct target_waitstatus *ourstatus)
|
|||
ourstatus->value.sig = TARGET_SIGNAL_SEGV;
|
||||
continue_status = DBG_EXCEPTION_NOT_HANDLED;
|
||||
break;
|
||||
case STATUS_FLOAT_UNDERFLOW:
|
||||
case STATUS_FLOAT_DIVIDE_BY_ZERO:
|
||||
case STATUS_FLOAT_OVERFLOW:
|
||||
case STATUS_INTEGER_DIVIDE_BY_ZERO:
|
||||
DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08x\n",
|
||||
current_event.u.Exception.ExceptionRecord.ExceptionAddress));
|
||||
ourstatus->value.sig = TARGET_SIGNAL_FPE;
|
||||
continue_status = DBG_EXCEPTION_NOT_HANDLED;
|
||||
break;
|
||||
case STATUS_STACK_OVERFLOW:
|
||||
DEBUG_EXCEPT (("gdb: Target exception STACK_OVERFLOW at 0x%08x\n",
|
||||
current_event.u.Exception.ExceptionRecord.ExceptionAddress));
|
||||
|
|
|
|||
Loading…
Reference in New Issue