* breakpoint.c, target.h: Move defaults of watchpoint related
macros back to breakpoint.c. Required to get GDB compiling on Solaris again.
This commit is contained in:
Jim Kingdon
parent
fc18000d56
commit
e8bf33c4ac
|
|
@ -1,3 +1,22 @@
|
|||
Mon May 22 06:47:30 1995 Jim Kingdon (kingdon@lioth.cygnus.com)
|
||||
|
||||
* breakpoint.c, target.h: Move defaults of watchpoint related
|
||||
macros back to breakpoint.c. Required to get GDB compiling
|
||||
on Solaris again.
|
||||
|
||||
Fri May 19 14:49:37 1995 J.T. Conklin <jtc@rtl.cygnus.com>
|
||||
|
||||
* defs.h (ATTR_FORMAT): New macro, expands to gcc's format
|
||||
attribute when compiled by gcc.
|
||||
* defs.h, language.h, monitor.h: Changed many function
|
||||
declarations to use ATTR_FORMAT.
|
||||
|
||||
* breakpoint.c (delete_command); source.c (directory_command);
|
||||
top.c (define_command): Changed call to query() that had too
|
||||
many arguments.
|
||||
* printcmd.c (address_info): Changed call to printf_filtered()
|
||||
that had too many arguments.
|
||||
|
||||
Fri May 19 09:52:07 1995 Jim Kingdon (kingdon@lioth.cygnus.com)
|
||||
|
||||
* infrun.c (wait_for_inferior): Move assignments to stop_signal
|
||||
|
|
@ -24,7 +43,7 @@ Thu May 18 15:58:46 1995 J.T. Conklin <jtc@rtl.cygnus.com>
|
|||
printf_filtered, printf_unfiltered, printfi_filtered, query, warning,
|
||||
error, fatal, fatal_dump_core): Use stdarg.h macros when compiling
|
||||
with an ANSI compiler.
|
||||
* complain.c (complain): Likewise.
|
||||
* complaints.c (complain): Likewise.
|
||||
* language.c (type_error, range_error): Likewise.
|
||||
* monitor.c (monitor_printf, monitor_printf_noecho): Likewise.
|
||||
* remote-array.c (printf_monitor, debuglogs): Likewise.
|
||||
|
|
@ -35,7 +54,7 @@ start-sanitize-gdbtk
|
|||
* gdbtk.c (gdbtk_query): Likewise.
|
||||
end-sanitize-gdbtk
|
||||
|
||||
* defs.h, complain.h, language.h, monitor.h: Add prototypes to
|
||||
* defs.h, complaints.h, language.h, monitor.h: Add prototypes to
|
||||
match above changes.
|
||||
|
||||
* printcmd.c: Remove uneeded #include <varargs.h>.
|
||||
|
|
|
|||
143
gdb/breakpoint.c
143
gdb/breakpoint.c
|
|
@ -1,5 +1,5 @@
|
|||
/* Everything about breakpoints, for GDB.
|
||||
Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994
|
||||
Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995
|
||||
Free Software Foundation, Inc.
|
||||
|
||||
This file is part of GDB.
|
||||
|
|
@ -58,15 +58,9 @@ enable_once_breakpoint PARAMS ((struct breakpoint *));
|
|||
static void
|
||||
disable_command PARAMS ((char *, int));
|
||||
|
||||
static void
|
||||
disable_breakpoint PARAMS ((struct breakpoint *));
|
||||
|
||||
static void
|
||||
enable_command PARAMS ((char *, int));
|
||||
|
||||
static void
|
||||
enable_breakpoint PARAMS ((struct breakpoint *));
|
||||
|
||||
static void
|
||||
map_breakpoint_numbers PARAMS ((char *, void (*)(struct breakpoint *)));
|
||||
|
||||
|
|
@ -158,9 +152,21 @@ static int executing_breakpoint_commands;
|
|||
b? (tmp=b->next, 1): 0; \
|
||||
b = tmp)
|
||||
|
||||
/* By default no support for hardware watchpoints is assumed. */
|
||||
/* Provide defaults for systems that don't support hardware watchpoints. */
|
||||
|
||||
#ifndef TARGET_CAN_USE_HARDWARE_WATCHPOINT
|
||||
|
||||
/* Returns non-zero if we can set a hardware watchpoint of type TYPE. TYPE is
|
||||
one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint, or
|
||||
bp_hardware_breakpoint. CNT is the number of such watchpoints used so far
|
||||
(including this one?). OTHERTYPE is who knows what... */
|
||||
|
||||
#define TARGET_CAN_USE_HARDWARE_WATCHPOINT(TYPE,CNT,OTHERTYPE) 0
|
||||
|
||||
/* Set/clear a hardware watchpoint starting at ADDR, for LEN bytes. TYPE is 1
|
||||
for read and 2 for read/write accesses. Returns 0 for success, non-zero for
|
||||
failure. */
|
||||
|
||||
#define target_remove_watchpoint(ADDR,LEN,TYPE) -1
|
||||
#define target_insert_watchpoint(ADDR,LEN,TYPE) -1
|
||||
#endif
|
||||
|
|
@ -180,7 +186,7 @@ int show_breakpoint_hit_counts = 1;
|
|||
|
||||
/* Chain of all breakpoints defined. */
|
||||
|
||||
static struct breakpoint *breakpoint_chain;
|
||||
struct breakpoint *breakpoint_chain;
|
||||
|
||||
/* Number of last breakpoint made. */
|
||||
|
||||
|
|
@ -935,6 +941,7 @@ bpstat_do_actions (bsp)
|
|||
{
|
||||
bpstat bs;
|
||||
struct cleanup *old_chain;
|
||||
struct command_line *cmd;
|
||||
|
||||
executing_breakpoint_commands = 1;
|
||||
old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
|
||||
|
|
@ -945,18 +952,20 @@ top:
|
|||
breakpoint_proceeded = 0;
|
||||
for (; bs != NULL; bs = bs->next)
|
||||
{
|
||||
while (bs->commands)
|
||||
cmd = bs->commands;
|
||||
while (cmd != NULL)
|
||||
{
|
||||
struct command_line *cmd = bs->commands;
|
||||
bs->commands = bs->commands->next;
|
||||
execute_control_command (cmd);
|
||||
/* If the inferior is proceeded by the command, bomb out now.
|
||||
The bpstat chain has been blown away by wait_for_inferior.
|
||||
But since execution has stopped again, there is a new bpstat
|
||||
to look at, so start over. */
|
||||
if (breakpoint_proceeded)
|
||||
goto top;
|
||||
cmd = cmd->next;
|
||||
}
|
||||
if (breakpoint_proceeded)
|
||||
/* The inferior is proceeded by the command; bomb out now.
|
||||
The bpstat chain has been blown away by wait_for_inferior.
|
||||
But since execution has stopped again, there is a new bpstat
|
||||
to look at, so start over. */
|
||||
goto top;
|
||||
else
|
||||
bs->commands = NULL;
|
||||
}
|
||||
|
||||
executing_breakpoint_commands = 0;
|
||||
|
|
@ -1094,6 +1103,9 @@ bpstat_alloc (b, cbs)
|
|||
/* The value has not changed. */
|
||||
#define WP_VALUE_NOT_CHANGED 3
|
||||
|
||||
#define BP_TEMPFLAG 1
|
||||
#define BP_HARDWAREFLAG 2
|
||||
|
||||
/* Check watchpoint condition. */
|
||||
|
||||
static int
|
||||
|
|
@ -1223,7 +1235,7 @@ bpstat_stop_status (pc, not_a_breakpoint)
|
|||
int real_breakpoint = 0;
|
||||
#endif
|
||||
/* Root of the chain of bpstat's */
|
||||
struct bpstat root_bs[1];
|
||||
struct bpstats root_bs[1];
|
||||
/* Pointer to the last thing in the chain currently. */
|
||||
bpstat bs = root_bs;
|
||||
static char message1[] =
|
||||
|
|
@ -1246,9 +1258,14 @@ bpstat_stop_status (pc, not_a_breakpoint)
|
|||
&& b->address != bp_addr)
|
||||
continue;
|
||||
|
||||
/* If defined, then we need to decr pc by this much after a hardware break-
|
||||
point. Presumably should override DECR_PC_AFTER_BREAK, though it doesn't
|
||||
now... */
|
||||
|
||||
#ifndef DECR_PC_AFTER_HW_BREAK
|
||||
#define DECR_PC_AFTER_HW_BREAK 0
|
||||
#endif
|
||||
|
||||
if (b->type == bp_hardware_breakpoint
|
||||
&& b->address != (bp_addr - DECR_PC_AFTER_HW_BREAK))
|
||||
continue;
|
||||
|
|
@ -1983,7 +2000,7 @@ create_longjmp_breakpoint(func_name)
|
|||
{
|
||||
struct minimal_symbol *m;
|
||||
|
||||
m = lookup_minimal_symbol(func_name, (struct objfile *)NULL);
|
||||
m = lookup_minimal_symbol_text (func_name, NULL, (struct objfile *)NULL);
|
||||
if (m)
|
||||
sal.pc = SYMBOL_VALUE_ADDRESS (m);
|
||||
else
|
||||
|
|
@ -2270,8 +2287,8 @@ break_command_1 (arg, flag, from_tty)
|
|||
int i;
|
||||
int thread;
|
||||
|
||||
hardwareflag = flag & 2;
|
||||
tempflag = flag & 1;
|
||||
hardwareflag = flag & BP_HARDWAREFLAG;
|
||||
tempflag = flag & BP_TEMPFLAG;
|
||||
|
||||
sals.sals = NULL;
|
||||
sals.nelts = 0;
|
||||
|
|
@ -2422,7 +2439,7 @@ break_command_1 (arg, flag, from_tty)
|
|||
b->cond_string = savestring (cond_start, cond_end - cond_start);
|
||||
|
||||
b->enable = enabled;
|
||||
b->disposition = tempflag ? delete : donttouch;
|
||||
b->disposition = tempflag ? del : donttouch;
|
||||
|
||||
mention (b);
|
||||
}
|
||||
|
|
@ -2453,8 +2470,6 @@ resolve_sal_pc (sal)
|
|||
}
|
||||
}
|
||||
|
||||
#define BP_TEMPFLAG 1
|
||||
#define BP_HARDWAREFLAG 2
|
||||
void
|
||||
break_command (arg, from_tty)
|
||||
char *arg;
|
||||
|
|
@ -2615,7 +2630,7 @@ watch_command_1 (arg, accessflag, from_tty)
|
|||
scope_breakpoint->enable = enabled;
|
||||
|
||||
/* Automatically delete the breakpoint when it hits. */
|
||||
scope_breakpoint->disposition = delete;
|
||||
scope_breakpoint->disposition = del;
|
||||
|
||||
/* Only break in the proper frame (help with recursion). */
|
||||
scope_breakpoint->frame = prev_frame->frame;
|
||||
|
|
@ -3019,7 +3034,7 @@ catch_command_1 (arg, tempflag, from_tty)
|
|||
b->type = bp_breakpoint;
|
||||
b->cond = cond;
|
||||
b->enable = enabled;
|
||||
b->disposition = tempflag ? delete : donttouch;
|
||||
b->disposition = tempflag ? del : donttouch;
|
||||
|
||||
mention (b);
|
||||
}
|
||||
|
|
@ -3032,6 +3047,22 @@ catch_command_1 (arg, tempflag, from_tty)
|
|||
free ((PTR)sals.sals);
|
||||
}
|
||||
|
||||
/* Used by the gui, could be made a worker for other things. */
|
||||
|
||||
struct breakpoint *
|
||||
set_breakpoint_sal (sal)
|
||||
struct symtab_and_line sal;
|
||||
{
|
||||
struct breakpoint *b;
|
||||
b = set_raw_breakpoint (sal);
|
||||
set_breakpoint_count (breakpoint_count + 1);
|
||||
b->number = breakpoint_count;
|
||||
b->type = bp_breakpoint;
|
||||
b->cond = 0;
|
||||
b->thread = -1;
|
||||
return b;
|
||||
}
|
||||
|
||||
#if 0
|
||||
/* These aren't used; I don't know what they were for. */
|
||||
/* Disable breakpoints on all catch clauses described in ARGS. */
|
||||
|
|
@ -3166,7 +3197,7 @@ breakpoint_auto_delete (bs)
|
|||
bpstat bs;
|
||||
{
|
||||
for (; bs; bs = bs->next)
|
||||
if (bs->breakpoint_at && bs->breakpoint_at->disposition == delete
|
||||
if (bs->breakpoint_at && bs->breakpoint_at->disposition == del
|
||||
&& bs->stop)
|
||||
delete_breakpoint (bs->breakpoint_at);
|
||||
}
|
||||
|
|
@ -3253,7 +3284,7 @@ delete_command (arg, from_tty)
|
|||
{
|
||||
/* Ask user only if there are some breakpoints to delete. */
|
||||
if (!from_tty
|
||||
|| (breakpoint_chain && query ("Delete all breakpoints? ", 0, 0)))
|
||||
|| (breakpoint_chain && query ("Delete all breakpoints? ")))
|
||||
{
|
||||
/* No arg; clear all breakpoints. */
|
||||
while (breakpoint_chain)
|
||||
|
|
@ -3538,7 +3569,7 @@ map_breakpoint_numbers (args, function)
|
|||
}
|
||||
}
|
||||
|
||||
static void
|
||||
void
|
||||
enable_breakpoint (bpt)
|
||||
struct breakpoint *bpt;
|
||||
{
|
||||
|
|
@ -3547,9 +3578,6 @@ enable_breakpoint (bpt)
|
|||
int target_resources_ok, other_type_used;
|
||||
struct value *mark;
|
||||
|
||||
if (enable_breakpoint_hook)
|
||||
enable_breakpoint_hook (bpt);
|
||||
|
||||
if (bpt->type == bp_hardware_breakpoint)
|
||||
{
|
||||
int i;
|
||||
|
|
@ -3618,6 +3646,9 @@ have been allocated for other watchpoints.\n", bpt->number);
|
|||
select_frame (save_selected_frame, save_selected_frame_level);
|
||||
value_free_to_mark (mark);
|
||||
}
|
||||
|
||||
if (modify_breakpoint_hook)
|
||||
modify_breakpoint_hook (bpt);
|
||||
}
|
||||
|
||||
/* ARGSUSED */
|
||||
|
|
@ -3645,7 +3676,7 @@ enable_command (args, from_tty)
|
|||
map_breakpoint_numbers (args, enable_breakpoint);
|
||||
}
|
||||
|
||||
static void
|
||||
void
|
||||
disable_breakpoint (bpt)
|
||||
struct breakpoint *bpt;
|
||||
{
|
||||
|
|
@ -3655,12 +3686,12 @@ disable_breakpoint (bpt)
|
|||
if (bpt->type == bp_watchpoint_scope)
|
||||
return;
|
||||
|
||||
if (disable_breakpoint_hook)
|
||||
disable_breakpoint_hook (bpt);
|
||||
|
||||
bpt->enable = disabled;
|
||||
|
||||
check_duplicates (bpt->address);
|
||||
|
||||
if (modify_breakpoint_hook)
|
||||
modify_breakpoint_hook (bpt);
|
||||
}
|
||||
|
||||
/* ARGSUSED */
|
||||
|
|
@ -3782,7 +3813,7 @@ enable_delete_breakpoint (bpt)
|
|||
struct breakpoint *bpt;
|
||||
{
|
||||
bpt->enable = enabled;
|
||||
bpt->disposition = delete;
|
||||
bpt->disposition = del;
|
||||
|
||||
check_duplicates (bpt->address);
|
||||
breakpoints_changed ();
|
||||
|
|
@ -4026,39 +4057,3 @@ an expression is either read or written.");
|
|||
"Synonym for ``info breakpoints''.");
|
||||
|
||||
}
|
||||
|
||||
/* OK, when we call objfile_relocate, we need to relocate breakpoints
|
||||
too. breakpoint_re_set is not a good choice--for example, if
|
||||
addr_string contains just a line number without a file name the
|
||||
breakpoint might get set in a different file. In general, there is
|
||||
no need to go all the way back to the user's string (though this might
|
||||
work if some effort were made to canonicalize it), since symtabs and
|
||||
everything except addresses are still valid.
|
||||
|
||||
Probably the best way to solve this is to have each breakpoint save
|
||||
the objfile and the section number that was used to set it (if set
|
||||
by "*addr", probably it is best to use find_pc_line to get a symtab
|
||||
and use the objfile and block_line_section for that symtab). Then
|
||||
objfile_relocate can call fixup_breakpoints with the objfile and
|
||||
the new_offsets, and it can relocate only the appropriate breakpoints. */
|
||||
|
||||
#ifdef IBM6000_TARGET
|
||||
/* But for now, just kludge it based on the concept that before an
|
||||
objfile is relocated the breakpoint is below 0x10000000, and afterwards
|
||||
it is higher, so that way we only relocate each breakpoint once. */
|
||||
|
||||
void
|
||||
fixup_breakpoints (low, high, delta)
|
||||
CORE_ADDR low;
|
||||
CORE_ADDR high;
|
||||
CORE_ADDR delta;
|
||||
{
|
||||
struct breakpoint *b;
|
||||
|
||||
ALL_BREAKPOINTS (b)
|
||||
{
|
||||
if (b->address >= low && b->address <= high)
|
||||
b->address += delta;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
138
gdb/target.h
138
gdb/target.h
|
|
@ -46,6 +46,7 @@ enum strata {
|
|||
dummy_stratum, /* The lowest of the low */
|
||||
file_stratum, /* Executable files, etc */
|
||||
core_stratum, /* Core dump files */
|
||||
download_stratum, /* Downloading of remote targets */
|
||||
process_stratum /* Executing processes */
|
||||
};
|
||||
|
||||
|
|
@ -144,6 +145,38 @@ enum target_signal {
|
|||
TARGET_SIGNAL_MSG = 41,
|
||||
TARGET_SIGNAL_SOUND = 42,
|
||||
TARGET_SIGNAL_SAK = 43,
|
||||
TARGET_SIGNAL_PRIO = 44,
|
||||
TARGET_SIGNAL_REALTIME_33 = 45,
|
||||
TARGET_SIGNAL_REALTIME_34 = 46,
|
||||
TARGET_SIGNAL_REALTIME_35 = 47,
|
||||
TARGET_SIGNAL_REALTIME_36 = 48,
|
||||
TARGET_SIGNAL_REALTIME_37 = 49,
|
||||
TARGET_SIGNAL_REALTIME_38 = 50,
|
||||
TARGET_SIGNAL_REALTIME_39 = 51,
|
||||
TARGET_SIGNAL_REALTIME_40 = 52,
|
||||
TARGET_SIGNAL_REALTIME_41 = 53,
|
||||
TARGET_SIGNAL_REALTIME_42 = 54,
|
||||
TARGET_SIGNAL_REALTIME_43 = 55,
|
||||
TARGET_SIGNAL_REALTIME_44 = 56,
|
||||
TARGET_SIGNAL_REALTIME_45 = 57,
|
||||
TARGET_SIGNAL_REALTIME_46 = 58,
|
||||
TARGET_SIGNAL_REALTIME_47 = 59,
|
||||
TARGET_SIGNAL_REALTIME_48 = 60,
|
||||
TARGET_SIGNAL_REALTIME_49 = 61,
|
||||
TARGET_SIGNAL_REALTIME_50 = 62,
|
||||
TARGET_SIGNAL_REALTIME_51 = 63,
|
||||
TARGET_SIGNAL_REALTIME_52 = 64,
|
||||
TARGET_SIGNAL_REALTIME_53 = 65,
|
||||
TARGET_SIGNAL_REALTIME_54 = 66,
|
||||
TARGET_SIGNAL_REALTIME_55 = 67,
|
||||
TARGET_SIGNAL_REALTIME_56 = 68,
|
||||
TARGET_SIGNAL_REALTIME_57 = 69,
|
||||
TARGET_SIGNAL_REALTIME_58 = 70,
|
||||
TARGET_SIGNAL_REALTIME_59 = 71,
|
||||
TARGET_SIGNAL_REALTIME_60 = 72,
|
||||
TARGET_SIGNAL_REALTIME_61 = 73,
|
||||
TARGET_SIGNAL_REALTIME_62 = 74,
|
||||
TARGET_SIGNAL_REALTIME_63 = 75,
|
||||
|
||||
/* Some signal we don't know about. */
|
||||
TARGET_SIGNAL_UNKNOWN,
|
||||
|
|
@ -175,6 +208,14 @@ extern char *target_signal_to_name PARAMS ((enum target_signal));
|
|||
/* Given a name (SIGHUP, etc.), return its signal. */
|
||||
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. */
|
||||
extern int target_activity_fd;
|
||||
/* Returns zero to leave the inferior alone, one to interrupt it. */
|
||||
extern int (*target_activity_function) PARAMS ((void));
|
||||
|
||||
struct target_ops
|
||||
{
|
||||
char *to_shortname; /* Name this target type */
|
||||
|
|
@ -231,7 +272,7 @@ struct target_ops
|
|||
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, \
|
||||
(*current_target.to_search) (len, data, mask, startaddr, increment, \
|
||||
lorange, hirange, addr_found, data_found)
|
||||
#endif /* 0 */
|
||||
|
||||
|
|
@ -250,9 +291,10 @@ struct target_ops
|
|||
void (*to_mourn_inferior) PARAMS ((void));
|
||||
int (*to_can_run) PARAMS ((void));
|
||||
void (*to_notice_signals) PARAMS ((int pid));
|
||||
void (*to_stop) PARAMS ((void));
|
||||
enum strata to_stratum;
|
||||
struct target_ops
|
||||
*to_next;
|
||||
*DONT_USE; /* formerly to_next */
|
||||
int to_has_all_memory;
|
||||
int to_has_memory;
|
||||
int to_has_stack;
|
||||
|
|
@ -275,18 +317,30 @@ struct target_ops
|
|||
/* The ops structure for our "current" target process. This should
|
||||
never be NULL. If there is no target, it points to the dummy_target. */
|
||||
|
||||
extern struct target_ops *current_target;
|
||||
extern struct target_ops current_target;
|
||||
|
||||
/* An item on the target stack. */
|
||||
|
||||
struct target_stack_item
|
||||
{
|
||||
struct target_stack_item *next;
|
||||
struct target_ops *target_ops;
|
||||
};
|
||||
|
||||
/* The target stack. */
|
||||
|
||||
extern struct target_stack_item *target_stack;
|
||||
|
||||
/* Define easy words for doing these operations on our current target. */
|
||||
|
||||
#define target_shortname (current_target->to_shortname)
|
||||
#define target_longname (current_target->to_longname)
|
||||
#define target_shortname (current_target.to_shortname)
|
||||
#define target_longname (current_target.to_longname)
|
||||
|
||||
/* 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
|
||||
|
|
@ -297,7 +351,7 @@ extern struct target_ops *current_target;
|
|||
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
|
||||
|
|
@ -308,7 +362,7 @@ extern struct target_ops *current_target;
|
|||
(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)
|
||||
|
||||
/* Takes a program previously attached to and detaches it.
|
||||
The program may resume execution (some targets do, some don't) and will
|
||||
|
|
@ -326,7 +380,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;
|
||||
|
|
@ -337,19 +391,19 @@ 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)
|
||||
|
||||
/* 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
|
||||
|
|
@ -358,7 +412,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 *));
|
||||
|
||||
|
|
@ -393,7 +447,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) (current_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
|
||||
|
|
@ -402,7 +456,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
|
||||
|
|
@ -410,19 +464,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,
|
||||
|
|
@ -433,32 +487,32 @@ 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. */
|
||||
|
||||
#define target_load(arg, from_tty) \
|
||||
(*current_target->to_load) (arg, from_tty)
|
||||
(*current_target.to_load) (arg, 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
|
||||
|
|
@ -469,7 +523,7 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
|
|||
doing a complain(). */
|
||||
|
||||
#define target_lookup_symbol(name, addrp) \
|
||||
(*current_target->to_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.
|
||||
|
|
@ -478,12 +532,12 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
|
|||
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)
|
||||
|
||||
/* 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? */
|
||||
|
||||
|
|
@ -493,35 +547,41 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
|
|||
/* 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)
|
||||
|
||||
/* 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 ()
|
||||
|
||||
/* 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
|
||||
|
|
@ -531,7 +591,7 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
|
|||
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)
|
||||
|
||||
extern void target_link PARAMS ((char *, CORE_ADDR *));
|
||||
|
||||
|
|
@ -545,6 +605,15 @@ extern void target_link PARAMS ((char *, CORE_ADDR *));
|
|||
extern char *normal_pid_to_str PARAMS ((int pid));
|
||||
#endif
|
||||
|
||||
/* Hardware watchpoint interfaces. */
|
||||
|
||||
/* Returns non-zero if we were stopped by a hardware watchpoint (memory read or
|
||||
write). */
|
||||
|
||||
#ifndef STOPPED_BY_WATCHPOINT
|
||||
#define STOPPED_BY_WATCHPOINT(w) 0
|
||||
#endif
|
||||
|
||||
/* Routines for maintenance of the target structures...
|
||||
|
||||
add_target: Add a target to the list of all possible targets.
|
||||
|
|
@ -635,4 +704,7 @@ extern void store_waitstatus PARAMS ((struct target_waitstatus *, int));
|
|||
extern enum target_signal target_signal_from_host PARAMS ((int));
|
||||
extern int target_signal_to_host PARAMS ((enum target_signal));
|
||||
|
||||
/* Convert from a number used in a GDB command to an enum target_signal. */
|
||||
extern enum target_signal target_signal_from_command PARAMS ((int));
|
||||
|
||||
#endif /* !defined (TARGET_H) */
|
||||
|
|
|
|||
Loading…
Reference in New Issue