FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

* breakpoint.h (struct breakpoint): New member GDBARCH.

Browse source 
* breakpoint.c: Include "arch-utils.h".
	(set_raw_breakpoint_without_location): Add GDBARCH parameter.
	Use it to set breakpoint architecture.
	(set_raw_breakpoint): Add GDBARCH parameter.
	(create_internal_breakpoint): Likewise.
	(create_catchpoint): Likewise.
	(create_fork_vfork_event_catchpoint): Likewise.
	(create_breakpoint): Likewise.
	(create_breakpoints): Likewise.
	(break_command_really): Likewise.
	(create_ada_exception_breakpoint): Likewise.
	Update local callers to pass architecture:
	(create_internal_breakpoint): Update.
	(create_overlay_event_breakpoint): Update.
	(create_longjmp_master_breakpoint): Update.
	(create_thread_event_breakpoint): Update.
	(create_solib_event_breakpoint): Update.
	(create_catchpoint): Update.
	(create_fork_vfork_event_catchpoint): Update.
	(set_momentary_breakpoint): Update.
	(clone_momentary_breakpoint): Update.
	(create_breakpoint): Update.
	(create_breakpoints): Update.
	(break_command_really): Update.
	(break_command_1): Update.
	(set_breakpoint): Update.
	(watch_command_1): Update.
	(catch_fork_command_1): Update.
	(catch_exec_commnd_1): Update.
	(handle_gnu_v3_exceptions): Update.
	(create_ada_exception_breakpoint): Update.
	(catch_ada_exception_command): Update.
	(catch_assert_command): Update.
	(trace_command): Update.

	* breakpoint.h (struct bp_location): New member GDBARCH.
	* breakpoint.c (get_sal_arch): New function.
	(set_raw_breakpoint): Set location architecture.
	(add_location_to_breakpoint): Likewise.
	(clone_momentary_breakpoint): Likewise.
	(watch_command_1): Likewise.
	(update_watchpoint): Likewise.
	(bp_loc_is_permanent): Use location architecture instead of
	current_gdbarch.
	(adjust_breakpoint_address): Add GDBARCH parameter; use it
	instead of current_gdbarch.
	Update callers of adjust_breakpoint_address to pass
	breakpoint location architecture:
	(set_raw_breakpoint): Update.
	(watch_command_1): Update.

        * tracepoint.c: (collect_symbol): Add GDBARCH parameter, use instead
	of current_gdbarch.
	(add_local_symbols): Add GDBARCH parameter.  Pass to collect_symbol.
	(encode_actions): Pass tracepoint architecture to add_local_symbols
	(encode_actions): Use tracepoint architecture instead of
	current_gdbarch.  Pass it to add_local_symbols and collect_symbol.

	* breakpoint.h (struct breakpoint_ops): Replace last_addr parameter
	of print_one callback with last_loc.
	* breakpoint.c (print_one_breakpoint_location): Replace last_addr
	parameter with last_loc.
	(print_one_breakpoint): Likewise.
	(do_captured_breakpoint_query): Update call.
	(breakpoint_1): Pass last_loc instead of last_addr to
	print_one_breakpoint.  Pass last location architecture instead of
	current_gdbarch to set_next_address.
	Update all implementations of the print_one callback:
	* breakpoint.c (print_one_catch_fork): Update.
	(print_one_catch_vfork): Update.
	(print_one_catch_exec): Update.
	(print_one_exception_catchpoint): Update.
	* ada-lang.c (print_one_exception): Update.
	(print_one_catch_exception): Update.
	(print_one_catch_exception_unhandled): Update.
	(print_one_catch_assert): Update.

	* breakpoint.c (print_one_breakpoint_location): Add PRINT_ADDRESS_BITS
	parameter.  Use it instead of gdbarch_addr_bit (current_gdbarch).
	(print_one_breakpoint): Add PRINT_ADDRESS_BITS parameter and pass it
	to print_one_breakpoint_location.
	(breakpoint_address_bits): New function.
	(do_captured_breakpoint_query): Compute number of address bits to print
	and pass it to print_one_breakpoint.
	(breakpoint_1): Likewise.  Use it instead of current_gdbarch.

	* breakpoint.h (create_thread_event_breakpoint): Add GDBARCH.
	* breakpoint.c (create_thread_event_breakpoint): Likewise.
	Update callers to create_thread_event_breakpoint:
	* aix-thread.c (pd_enable): Update.
	* linux-thread-db.c (enable_thread_event): Update.

	* breakpoint.h (create_solib_event_breakpoint): Add GDBARCH.
	* breakpoint.c (create_solib_event_breakpoint): Likewise.
	Update callers to create_solib_event_breakpoint:
	* solib-frv.c (enable_break, enable_break2): Update.
	* solib-pa64.c (pa64_solib_create_inferior_hook): Update.
	* solib-som.c (som_solib_create_inferior_hook): Update.
	* solib-darwin.c (darwin_solib_create_inferior_hook): Update.
	* solib-svr4.c (enable_break): Update.

	* breakpoint.h (insert_single_step_breakpoint): Add GDBARCH.
	* breakpoint.c (insert_single_step_breakpoint): Likewise.
	Update callers to insert_single_step_breakpoint:
	* alpha-tdep.c (alpha_software_single_step): Update.
	* arm-linux-tdep.c (arm_linux_software_single_step): Update.
	* arm-tdep.c (arm_software_single_step): Update.
	* cris-tdep.c (cris_software_single_step): Update.
	* rs6000-aix-tdep.c (rs6000_software_single_step): Update.
	* rs6000-tdep.c (ppc_deal_with_atomic_sequence): Update.
	* sparc-tdep.c (sparc_software_single_step): Update.
	* spu-tdep.c (spu_software_single_step): Update.
	* mips-tdep.c (deal_with_atomic_sequence): Add GDBARCH parameter.
	Pass it to insert_single_step_breakpoint.
	(mips_software_single_step): Pass architecture to
	deal_with_atomic_sequence and insert_single_step_breakpoint.

	* breakpoint.h (deprecated_insert_raw_breakpoint): Add GDBARCH.
	(deprecated_remove_raw_breakpoint): Likewise.
	* breakpoint.c (deprecated_insert_raw_breakpoint): Add GDBARCH.
	(deprecated_remove_raw_breakpoint): Likewise.
	Update callers to deprecated_insert_raw_breakpoint and
	deprecated_remove_raw_breakpoint:
	* breakpoint.c (single_step_gdbarch): New static variable.
	(insert_single_step_breakpoint): Pass GDBARCH parameter to
	deprecated_insert_raw_breakpoint.  Store it in single_step_gdbarch.
	(remove_single_step_breakpoints): Pass architecture stored in
	single_step_gdbarch to deprecated_remove_raw_breakpoint.
	* rs6000-nat.c (exec_one_dummy_insn): Update.
	* solib-irix.c (enable_break, disable_break): Update.
	* procfs.c (procfs_mourn_inferior): Update.
	(remove_dbx_link_breakpoint): Update.

	* breakpoint.h (set_breakpoint): Add GDBARCH parameter.
	(set_momentary_breakpoint, set_momentary_breakpoint_at_pc): Likewise.
	* breakpoint.c (set_breakpoint): Add GDBARCH parameter.
	(set_momentary_breakpoint, set_momentary_breakpoint_at_pc): Likewise.
	Update callers to set_breakpoint, set_momentary_breakpoint and
	set_momentary_breakpoint_at_pc:
	* breakpoint.c (set_momentary_breakpoint_at_pc): Update.
	(until_break_command): Update.
	* infcall.c (call_function_by_hand): Update.
	* infcmd.c (finish_backward, finish_forward): Update.
	* infrun.c (insert_step_resume_breakpoint_at_sal): Add GDBARCH
	parameter.  Pass it to set_momentary_breakpoint.
	(insert_longjmp_resume_breakpoint): Add GDBARCH parameter.
	Pass it to set_momentary_breakpoint_at_pc.
	(handle_inferior_event): Update.
	(insert_step_resume_breakpoint_at_frame): Update.
	(insert_step_resume_breakpoint_at_caller): Update..
	* mi/mi-cmd-break.c: Include "arch-utils.h".
	(mi_cmd_break_insert): Update.

	* target.h (struct target_ops): Add GDBARCH parameter to
	to_insert_breakpoint, to_remove_breakpoint, to_insert_hw_breakpoint,
	and to_remove_hw_breakpoint members.
	(target_insert_breakpoint, target_remove_breakpoint,
	target_insert_hw_breakpoint, target_remove_hw_breakpoint): Add GDBARCH
	parameter, pass to target routine.
	(memory_remove_breakpoint, memory_insert_breakpoint): Add GDBARCH
	parameter.
	* target.c (debug_to_insert_breakpoint, debug_to_remove_breakpoint,
	debug_to_insert_hw_breakpoint, debug_to_remove_hw_breakpoint): Add
	GDBARCH parameter, pass to target routine.
	(update_current_target): Update function signature.
	* breakpoint.c (insert_bp_location, remove_breakpoint,
	deprecated_insert_raw_breakpoint, deprecated_remove_raw_breakpoint):
	Pass architecture to target_ routines.
	Update all implementations of the target breakpoint routines to take
	GDBARCH parameter and use it instead of GDBARCH as appropriate:
	* corelow.c (ignore): Update.
	* exec.c (ignore): Update.
	* mem-break.c (memory_insert_breakpoint): Update.
	(memory_remove_breakpoint): Update.
	* monitor.c (monitor_insert_breakpoint): Update.
	(monitor_remove_breakpoint): Update.
	* record.c (record_insert_breakpoint): Update.
	(record_beneath_to_insert_breakpoint): Update.
	(record_remove_breakpoint): Update.
	(record_beneath_to_remove_breakpoint): Update.
	* remote.c (remote_insert_breakpoint): Update.
	(remote_remove_breakpoint): Update.
	(remote_insert_hw_breakpoint): Update.
	(remote_remove_hw_breakpoint): Update.
	* remote-m32r-sdi.c (m32r_insert_breakpoint): Update.
	(m32r_remove_breakpoint): Update.
	* remote-mips.c (mips_insert_breakpoint): Update.
	(mips_remove_breakpoint): Update.
	* i386-nat.c (i386_insert_hw_breakpoint): Update.
	(i386_remove_hw_breakpoint): Update.
	* nto-procfs.c (procfs_insert_breakpoint):  Update.
	(procfs_remove_breakpoint): Update.
	(procfs_insert_hw_breakpoint): Update.
	(procfs_remove_hw_breakpoint): Update.

doc/ChangeLog:

	* gdbint.texi (Examples of Use of @code{ui_out} functions):
	Update example code extrated from breakpoint.c.
This commit is contained in:
Ulrich Weigand 2009-07-02 17:12:28 +00:00
parent 36f15f554f
commit a6d9a66e23
42 changed files with 632 additions and 251 deletions
Download patch file Download diff file Expand all files Collapse all files

198
gdb/ChangeLog
View file

@ -1,3 +1,201 @@
2009-07-02 Ulrich Weigand <uweigand@de.ibm.com>
* breakpoint.h (struct breakpoint): New member GDBARCH.
* breakpoint.c: Include "arch-utils.h".
(set_raw_breakpoint_without_location): Add GDBARCH parameter.
Use it to set breakpoint architecture.
(set_raw_breakpoint): Add GDBARCH parameter.
(create_internal_breakpoint): Likewise.
(create_catchpoint): Likewise.
(create_fork_vfork_event_catchpoint): Likewise.
(create_breakpoint): Likewise.
(create_breakpoints): Likewise.
(break_command_really): Likewise.
(create_ada_exception_breakpoint): Likewise.
Update local callers to pass architecture:
(create_internal_breakpoint): Update.
(create_overlay_event_breakpoint): Update.
(create_longjmp_master_breakpoint): Update.
(create_thread_event_breakpoint): Update.
(create_solib_event_breakpoint): Update.
(create_catchpoint): Update.
(create_fork_vfork_event_catchpoint): Update.
(set_momentary_breakpoint): Update.
(clone_momentary_breakpoint): Update.
(create_breakpoint): Update.
(create_breakpoints): Update.
(break_command_really): Update.
(break_command_1): Update.
(set_breakpoint): Update.
(watch_command_1): Update.
(catch_fork_command_1): Update.
(catch_exec_commnd_1): Update.
(handle_gnu_v3_exceptions): Update.
(create_ada_exception_breakpoint): Update.
(catch_ada_exception_command): Update.
(catch_assert_command): Update.
(trace_command): Update.
* breakpoint.h (struct bp_location): New member GDBARCH.
* breakpoint.c (get_sal_arch): New function.
(set_raw_breakpoint): Set location architecture.
(add_location_to_breakpoint): Likewise.
(clone_momentary_breakpoint): Likewise.
(watch_command_1): Likewise.
(update_watchpoint): Likewise.
(bp_loc_is_permanent): Use location architecture instead of
current_gdbarch.
(adjust_breakpoint_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
Update callers of adjust_breakpoint_address to pass
breakpoint location architecture:
(set_raw_breakpoint): Update.
(watch_command_1): Update.
* tracepoint.c: (collect_symbol): Add GDBARCH parameter, use instead
of current_gdbarch.
(add_local_symbols): Add GDBARCH parameter. Pass to collect_symbol.
(encode_actions): Pass tracepoint architecture to add_local_symbols
(encode_actions): Use tracepoint architecture instead of
current_gdbarch. Pass it to add_local_symbols and collect_symbol.
* breakpoint.h (struct breakpoint_ops): Replace last_addr parameter
of print_one callback with last_loc.
* breakpoint.c (print_one_breakpoint_location): Replace last_addr
parameter with last_loc.
(print_one_breakpoint): Likewise.
(do_captured_breakpoint_query): Update call.
(breakpoint_1): Pass last_loc instead of last_addr to
print_one_breakpoint. Pass last location architecture instead of
current_gdbarch to set_next_address.
Update all implementations of the print_one callback:
* breakpoint.c (print_one_catch_fork): Update.
(print_one_catch_vfork): Update.
(print_one_catch_exec): Update.
(print_one_exception_catchpoint): Update.
* ada-lang.c (print_one_exception): Update.
(print_one_catch_exception): Update.
(print_one_catch_exception_unhandled): Update.
(print_one_catch_assert): Update.
* breakpoint.c (print_one_breakpoint_location): Add PRINT_ADDRESS_BITS
parameter. Use it instead of gdbarch_addr_bit (current_gdbarch).
(print_one_breakpoint): Add PRINT_ADDRESS_BITS parameter and pass it
to print_one_breakpoint_location.
(breakpoint_address_bits): New function.
(do_captured_breakpoint_query): Compute number of address bits to print
and pass it to print_one_breakpoint.
(breakpoint_1): Likewise. Use it instead of current_gdbarch.
* breakpoint.h (create_thread_event_breakpoint): Add GDBARCH.
* breakpoint.c (create_thread_event_breakpoint): Likewise.
Update callers to create_thread_event_breakpoint:
* aix-thread.c (pd_enable): Update.
* linux-thread-db.c (enable_thread_event): Update.
* breakpoint.h (create_solib_event_breakpoint): Add GDBARCH.
* breakpoint.c (create_solib_event_breakpoint): Likewise.
Update callers to create_solib_event_breakpoint:
* solib-frv.c (enable_break, enable_break2): Update.
* solib-pa64.c (pa64_solib_create_inferior_hook): Update.
* solib-som.c (som_solib_create_inferior_hook): Update.
* solib-darwin.c (darwin_solib_create_inferior_hook): Update.
* solib-svr4.c (enable_break): Update.
* breakpoint.h (insert_single_step_breakpoint): Add GDBARCH.
* breakpoint.c (insert_single_step_breakpoint): Likewise.
Update callers to insert_single_step_breakpoint:
* alpha-tdep.c (alpha_software_single_step): Update.
* arm-linux-tdep.c (arm_linux_software_single_step): Update.
* arm-tdep.c (arm_software_single_step): Update.
* cris-tdep.c (cris_software_single_step): Update.
* rs6000-aix-tdep.c (rs6000_software_single_step): Update.
* rs6000-tdep.c (ppc_deal_with_atomic_sequence): Update.
* sparc-tdep.c (sparc_software_single_step): Update.
* spu-tdep.c (spu_software_single_step): Update.
* mips-tdep.c (deal_with_atomic_sequence): Add GDBARCH parameter.
Pass it to insert_single_step_breakpoint.
(mips_software_single_step): Pass architecture to
deal_with_atomic_sequence and insert_single_step_breakpoint.
* breakpoint.h (deprecated_insert_raw_breakpoint): Add GDBARCH.
(deprecated_remove_raw_breakpoint): Likewise.
* breakpoint.c (deprecated_insert_raw_breakpoint): Add GDBARCH.
(deprecated_remove_raw_breakpoint): Likewise.
Update callers to deprecated_insert_raw_breakpoint and
deprecated_remove_raw_breakpoint:
* breakpoint.c (single_step_gdbarch): New static variable.
(insert_single_step_breakpoint): Pass GDBARCH parameter to
deprecated_insert_raw_breakpoint. Store it in single_step_gdbarch.
(remove_single_step_breakpoints): Pass architecture stored in
single_step_gdbarch to deprecated_remove_raw_breakpoint.
* rs6000-nat.c (exec_one_dummy_insn): Update.
* solib-irix.c (enable_break, disable_break): Update.
* procfs.c (procfs_mourn_inferior): Update.
(remove_dbx_link_breakpoint): Update.
* breakpoint.h (set_breakpoint): Add GDBARCH parameter.
(set_momentary_breakpoint, set_momentary_breakpoint_at_pc): Likewise.
* breakpoint.c (set_breakpoint): Add GDBARCH parameter.
(set_momentary_breakpoint, set_momentary_breakpoint_at_pc): Likewise.
Update callers to set_breakpoint, set_momentary_breakpoint and
set_momentary_breakpoint_at_pc:
* breakpoint.c (set_momentary_breakpoint_at_pc): Update.
(until_break_command): Update.
* infcall.c (call_function_by_hand): Update.
* infcmd.c (finish_backward, finish_forward): Update.
* infrun.c (insert_step_resume_breakpoint_at_sal): Add GDBARCH
parameter. Pass it to set_momentary_breakpoint.
(insert_longjmp_resume_breakpoint): Add GDBARCH parameter.
Pass it to set_momentary_breakpoint_at_pc.
(handle_inferior_event): Update.
(insert_step_resume_breakpoint_at_frame): Update.
(insert_step_resume_breakpoint_at_caller): Update..
* mi/mi-cmd-break.c: Include "arch-utils.h".
(mi_cmd_break_insert): Update.
* target.h (struct target_ops): Add GDBARCH parameter to
to_insert_breakpoint, to_remove_breakpoint, to_insert_hw_breakpoint,
and to_remove_hw_breakpoint members.
(target_insert_breakpoint, target_remove_breakpoint,
target_insert_hw_breakpoint, target_remove_hw_breakpoint): Add GDBARCH
parameter, pass to target routine.
(memory_remove_breakpoint, memory_insert_breakpoint): Add GDBARCH
parameter.
* target.c (debug_to_insert_breakpoint, debug_to_remove_breakpoint,
debug_to_insert_hw_breakpoint, debug_to_remove_hw_breakpoint): Add
GDBARCH parameter, pass to target routine.
(update_current_target): Update function signature.
* breakpoint.c (insert_bp_location, remove_breakpoint,
deprecated_insert_raw_breakpoint, deprecated_remove_raw_breakpoint):
Pass architecture to target_ routines.
Update all implementations of the target breakpoint routines to take
GDBARCH parameter and use it instead of GDBARCH as appropriate:
* corelow.c (ignore): Update.
* exec.c (ignore): Update.
* mem-break.c (memory_insert_breakpoint): Update.
(memory_remove_breakpoint): Update.
* monitor.c (monitor_insert_breakpoint): Update.
(monitor_remove_breakpoint): Update.
* record.c (record_insert_breakpoint): Update.
(record_beneath_to_insert_breakpoint): Update.
(record_remove_breakpoint): Update.
(record_beneath_to_remove_breakpoint): Update.
* remote.c (remote_insert_breakpoint): Update.
(remote_remove_breakpoint): Update.
(remote_insert_hw_breakpoint): Update.
(remote_remove_hw_breakpoint): Update.
* remote-m32r-sdi.c (m32r_insert_breakpoint): Update.
(m32r_remove_breakpoint): Update.
* remote-mips.c (mips_insert_breakpoint): Update.
(mips_remove_breakpoint): Update.
* i386-nat.c (i386_insert_hw_breakpoint): Update.
(i386_remove_hw_breakpoint): Update.
* nto-procfs.c (procfs_insert_breakpoint): Update.
(procfs_remove_breakpoint): Update.
(procfs_insert_hw_breakpoint): Update.
(procfs_remove_hw_breakpoint): Update.
2009-07-02 Ulrich Weigand <uweigand@de.ibm.com> 2009-07-02 Ulrich Weigand <uweigand@de.ibm.com>
* frame.h (frame_unwind_arch): New. * frame.h (frame_unwind_arch): New.

17
gdb/ada-lang.c
View file

@ -10293,7 +10293,7 @@ print_it_exception (enum exception_catchpoint_kind ex, struct breakpoint *b)
static void static void
print_one_exception (enum exception_catchpoint_kind ex, print_one_exception (enum exception_catchpoint_kind ex,
struct breakpoint *b, CORE_ADDR *last_addr) struct breakpoint *b, struct bp_location **last_loc)
{ {
struct value_print_options opts; struct value_print_options opts;
@ -10305,7 +10305,7 @@ print_one_exception (enum exception_catchpoint_kind ex,
} }
annotate_field (5); annotate_field (5);
*last_addr = b->loc->address; *last_loc = b->loc;
switch (ex) switch (ex)
{ {
case ex_catch_exception: case ex_catch_exception:
@ -10377,9 +10377,9 @@ print_it_catch_exception (struct breakpoint *b)
} }
static void static void
print_one_catch_exception (struct breakpoint *b, CORE_ADDR *last_addr) print_one_catch_exception (struct breakpoint *b, struct bp_location **last_loc)
{ {
print_one_exception (ex_catch_exception, b, last_addr); print_one_exception (ex_catch_exception, b, last_loc);
} }
static void static void
@ -10407,9 +10407,10 @@ print_it_catch_exception_unhandled (struct breakpoint *b)
} }
static void static void
print_one_catch_exception_unhandled (struct breakpoint *b, CORE_ADDR *last_addr) print_one_catch_exception_unhandled (struct breakpoint *b,
struct bp_location **last_loc)
{ {
print_one_exception (ex_catch_exception_unhandled, b, last_addr); print_one_exception (ex_catch_exception_unhandled, b, last_loc);
} }
static void static void
@ -10436,9 +10437,9 @@ print_it_catch_assert (struct breakpoint *b)
} }
static void static void
print_one_catch_assert (struct breakpoint *b, CORE_ADDR *last_addr) print_one_catch_assert (struct breakpoint *b, struct bp_location **last_loc)
{ {
print_one_exception (ex_catch_assert, b, last_addr); print_one_exception (ex_catch_assert, b, last_loc);
} }
static void static void

2
gdb/aix-thread.c
View file

@ -901,7 +901,7 @@ pd_enable (void)
if (!(ms = lookup_minimal_symbol (stub_name, NULL, NULL))) if (!(ms = lookup_minimal_symbol (stub_name, NULL, NULL)))
return; return;
pd_brk_addr = SYMBOL_VALUE_ADDRESS (ms); pd_brk_addr = SYMBOL_VALUE_ADDRESS (ms);
if (!create_thread_event_breakpoint (pd_brk_addr)) if (!create_thread_event_breakpoint (target_gdbarch, pd_brk_addr))
return; return;
/* Prepare for thread debugging. */ /* Prepare for thread debugging. */

3
gdb/alpha-tdep.c
View file

@ -1478,12 +1478,13 @@ alpha_next_pc (struct frame_info *frame, CORE_ADDR pc)
int int
alpha_software_single_step (struct frame_info *frame) alpha_software_single_step (struct frame_info *frame)
{ {
struct gdbarch *gdbarch = get_frame_arch (frame);
CORE_ADDR pc, next_pc; CORE_ADDR pc, next_pc;
pc = get_frame_pc (frame); pc = get_frame_pc (frame);
next_pc = alpha_next_pc (frame, pc); next_pc = alpha_next_pc (frame, pc);
insert_single_step_breakpoint (next_pc); insert_single_step_breakpoint (gdbarch, next_pc);
return 1; return 1;
} }

3
gdb/arm-linux-tdep.c
View file

@ -575,6 +575,7 @@ arm_linux_regset_from_core_section (struct gdbarch *gdbarch,
static int static int
arm_linux_software_single_step (struct frame_info *frame) arm_linux_software_single_step (struct frame_info *frame)
{ {
struct gdbarch *gdbarch = get_frame_arch (frame);
CORE_ADDR next_pc = arm_get_next_pc (frame, get_frame_pc (frame)); CORE_ADDR next_pc = arm_get_next_pc (frame, get_frame_pc (frame));
/* The Linux kernel offers some user-mode helpers in a high page. We can /* The Linux kernel offers some user-mode helpers in a high page. We can
@ -585,7 +586,7 @@ arm_linux_software_single_step (struct frame_info *frame)
if (next_pc > 0xffff0000) if (next_pc > 0xffff0000)
next_pc = get_frame_register_unsigned (frame, ARM_LR_REGNUM); next_pc = get_frame_register_unsigned (frame, ARM_LR_REGNUM);
insert_single_step_breakpoint (next_pc); insert_single_step_breakpoint (gdbarch, next_pc);
return 1; return 1;
} }

4
gdb/arm-tdep.c
View file

@ -2180,12 +2180,14 @@ arm_get_next_pc (struct frame_info *frame, CORE_ADDR pc)
int int
arm_software_single_step (struct frame_info *frame) arm_software_single_step (struct frame_info *frame)
{ {
struct gdbarch *gdbarch = get_frame_arch (frame);
/* NOTE: This may insert the wrong breakpoint instruction when /* NOTE: This may insert the wrong breakpoint instruction when
single-stepping over a mode-changing instruction, if the single-stepping over a mode-changing instruction, if the
CPSR heuristics are used. */ CPSR heuristics are used. */
CORE_ADDR next_pc = arm_get_next_pc (frame, get_frame_pc (frame)); CORE_ADDR next_pc = arm_get_next_pc (frame, get_frame_pc (frame));
insert_single_step_breakpoint (next_pc); insert_single_step_breakpoint (gdbarch, next_pc);
return 1; return 1;
} }

303
gdb/breakpoint.c
View file

@ -20,6 +20,7 @@
along with this program. If not, see <http://www.gnu.org/licenses/>. */ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h" #include "defs.h"
#include "arch-utils.h"
#include <ctype.h> #include <ctype.h>
#include "hashtab.h" #include "hashtab.h"
#include "symtab.h" #include "symtab.h"
@ -104,13 +105,16 @@ static void break_command_1 (char *, int, int);
static void mention (struct breakpoint *); static void mention (struct breakpoint *);
struct breakpoint *set_raw_breakpoint (struct symtab_and_line, enum bptype); static struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
struct symtab_and_line,
enum bptype);
static void check_duplicates (struct breakpoint *); static void check_duplicates (struct breakpoint *);
static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int); static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
static CORE_ADDR adjust_breakpoint_address (CORE_ADDR bpaddr, static CORE_ADDR adjust_breakpoint_address (struct gdbarch *gdbarch,
CORE_ADDR bpaddr,
enum bptype bptype); enum bptype bptype);
static void describe_other_breakpoints (CORE_ADDR, struct obj_section *, int); static void describe_other_breakpoints (CORE_ADDR, struct obj_section *, int);
@ -1005,6 +1009,7 @@ update_watchpoint (struct breakpoint *b, int reparse)
for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next)) for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
; ;
*tmp = loc; *tmp = loc;
loc->gdbarch = get_type_arch (value_type (v));
loc->address = addr; loc->address = addr;
loc->length = len; loc->length = len;
loc->watchpoint_type = type; loc->watchpoint_type = type;
@ -1147,9 +1152,11 @@ Note: automatically using hardware breakpoints for read-only addresses.\n"));
/* No overlay handling: just set the breakpoint. */ /* No overlay handling: just set the breakpoint. */
if (bpt->loc_type == bp_loc_hardware_breakpoint) if (bpt->loc_type == bp_loc_hardware_breakpoint)
val = target_insert_hw_breakpoint (&bpt->target_info); val = target_insert_hw_breakpoint (bpt->gdbarch,
&bpt->target_info);
else else
val = target_insert_breakpoint (&bpt->target_info); val = target_insert_breakpoint (bpt->gdbarch,
&bpt->target_info);
} }
else else
{ {
@ -1170,7 +1177,8 @@ Note: automatically using hardware breakpoints for read-only addresses.\n"));
/* Set a software (trap) breakpoint at the LMA. */ /* Set a software (trap) breakpoint at the LMA. */
bpt->overlay_target_info = bpt->target_info; bpt->overlay_target_info = bpt->target_info;
bpt->overlay_target_info.placed_address = addr; bpt->overlay_target_info.placed_address = addr;
val = target_insert_breakpoint (&bpt->overlay_target_info); val = target_insert_breakpoint (bpt->gdbarch,
&bpt->overlay_target_info);
if (val != 0) if (val != 0)
fprintf_unfiltered (tmp_error_stream, fprintf_unfiltered (tmp_error_stream,
"Overlay breakpoint %d failed: in ROM?\n", "Overlay breakpoint %d failed: in ROM?\n",
@ -1182,9 +1190,11 @@ Note: automatically using hardware breakpoints for read-only addresses.\n"));
{ {
/* Yes. This overlay section is mapped into memory. */ /* Yes. This overlay section is mapped into memory. */
if (bpt->loc_type == bp_loc_hardware_breakpoint) if (bpt->loc_type == bp_loc_hardware_breakpoint)
val = target_insert_hw_breakpoint (&bpt->target_info); val = target_insert_hw_breakpoint (bpt->gdbarch,
&bpt->target_info);
else else
val = target_insert_breakpoint (&bpt->target_info); val = target_insert_breakpoint (bpt->gdbarch,
&bpt->target_info);
} }
else else
{ {
@ -1458,7 +1468,8 @@ reattach_breakpoints (int pid)
static int internal_breakpoint_number = -1; static int internal_breakpoint_number = -1;
static struct breakpoint * static struct breakpoint *
create_internal_breakpoint (CORE_ADDR address, enum bptype type) create_internal_breakpoint (struct gdbarch *gdbarch,
CORE_ADDR address, enum bptype type)
{ {
struct symtab_and_line sal; struct symtab_and_line sal;
struct breakpoint *b; struct breakpoint *b;
@ -1468,7 +1479,7 @@ create_internal_breakpoint (CORE_ADDR address, enum bptype type)
sal.pc = address; sal.pc = address;
sal.section = find_pc_overlay (sal.pc); sal.section = find_pc_overlay (sal.pc);
b = set_raw_breakpoint (sal, type); b = set_raw_breakpoint (gdbarch, sal, type);
b->number = internal_breakpoint_number--; b->number = internal_breakpoint_number--;
b->disposition = disp_donttouch; b->disposition = disp_donttouch;
@ -1489,7 +1500,8 @@ create_overlay_event_breakpoint (char *func_name)
if (m == NULL) if (m == NULL)
continue; continue;
b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m), b = create_internal_breakpoint (get_objfile_arch (objfile),
SYMBOL_VALUE_ADDRESS (m),
bp_overlay_event); bp_overlay_event);
b->addr_string = xstrdup (func_name); b->addr_string = xstrdup (func_name);
@ -1524,7 +1536,8 @@ create_longjmp_master_breakpoint (char *func_name)
if (m == NULL) if (m == NULL)
continue; continue;
b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m), b = create_internal_breakpoint (get_objfile_arch (objfile),
SYMBOL_VALUE_ADDRESS (m),
bp_longjmp_master); bp_longjmp_master);
b->addr_string = xstrdup (func_name); b->addr_string = xstrdup (func_name);
b->enable_state = bp_disabled; b->enable_state = bp_disabled;
@ -1696,9 +1709,9 @@ remove_breakpoint (struct bp_location *b, insertion_state_t is)
/* No overlay handling: just remove the breakpoint. */ /* No overlay handling: just remove the breakpoint. */
if (b->loc_type == bp_loc_hardware_breakpoint) if (b->loc_type == bp_loc_hardware_breakpoint)
val = target_remove_hw_breakpoint (&b->target_info); val = target_remove_hw_breakpoint (b->gdbarch, &b->target_info);
else else
val = target_remove_breakpoint (&b->target_info); val = target_remove_breakpoint (b->gdbarch, &b->target_info);
} }
else else
{ {
@ -1712,9 +1725,11 @@ remove_breakpoint (struct bp_location *b, insertion_state_t is)
/* Ignore any failures: if the LMA is in ROM, we will /* Ignore any failures: if the LMA is in ROM, we will
have already warned when we failed to insert it. */ have already warned when we failed to insert it. */
if (b->loc_type == bp_loc_hardware_breakpoint) if (b->loc_type == bp_loc_hardware_breakpoint)
target_remove_hw_breakpoint (&b->overlay_target_info); target_remove_hw_breakpoint (b->gdbarch,
&b->overlay_target_info);
else else
target_remove_breakpoint (&b->overlay_target_info); target_remove_breakpoint (b->gdbarch,
&b->overlay_target_info);
} }
/* Did we set a breakpoint at the VMA? /* Did we set a breakpoint at the VMA?
If so, we will have marked the breakpoint 'inserted'. */ If so, we will have marked the breakpoint 'inserted'. */
@ -1725,13 +1740,15 @@ remove_breakpoint (struct bp_location *b, insertion_state_t is)
unmapped, but let's not rely on that being safe. We unmapped, but let's not rely on that being safe. We
don't know what the overlay manager might do. */ don't know what the overlay manager might do. */
if (b->loc_type == bp_loc_hardware_breakpoint) if (b->loc_type == bp_loc_hardware_breakpoint)
val = target_remove_hw_breakpoint (&b->target_info); val = target_remove_hw_breakpoint (b->gdbarch,
&b->target_info);
/* However, we should remove *software* breakpoints only /* However, we should remove *software* breakpoints only
if the section is still mapped, or else we overwrite if the section is still mapped, or else we overwrite
wrong code with the saved shadow contents. */ wrong code with the saved shadow contents. */
else if (section_is_mapped (b->section)) else if (section_is_mapped (b->section))
val = target_remove_breakpoint (&b->target_info); val = target_remove_breakpoint (b->gdbarch,
&b->target_info);
else else
val = 0; val = 0;
} }
@ -3541,7 +3558,8 @@ static void
print_one_breakpoint_location (struct breakpoint *b, print_one_breakpoint_location (struct breakpoint *b,
struct bp_location *loc, struct bp_location *loc,
int loc_number, int loc_number,
CORE_ADDR *last_addr) struct bp_location **last_loc,
int print_address_bits)
{ {
struct command_line *l; struct command_line *l;
struct symbol *sym; struct symbol *sym;
@ -3650,7 +3668,7 @@ print_one_breakpoint_location (struct breakpoint *b,
strcpy (wrap_indent, " "); strcpy (wrap_indent, " ");
if (opts.addressprint) if (opts.addressprint)
{ {
if (gdbarch_addr_bit (current_gdbarch) <= 32) if (print_address_bits <= 32)
strcat (wrap_indent, " "); strcat (wrap_indent, " ");
else else
strcat (wrap_indent, " "); strcat (wrap_indent, " ");
@ -3663,7 +3681,7 @@ print_one_breakpoint_location (struct breakpoint *b,
to get any nice result. So, make sure there's to get any nice result. So, make sure there's
just one location. */ just one location. */
gdb_assert (b->loc == NULL || b->loc->next == NULL); gdb_assert (b->loc == NULL || b->loc->next == NULL);
b->ops->print_one (b, last_addr); b->ops->print_one (b, last_loc);
} }
else else
switch (b->type) switch (b->type)
@ -3714,7 +3732,7 @@ print_one_breakpoint_location (struct breakpoint *b,
if (!header_of_multiple) if (!header_of_multiple)
print_breakpoint_location (b, loc, wrap_indent, stb); print_breakpoint_location (b, loc, wrap_indent, stb);
if (b->loc) if (b->loc)
*last_addr = b->loc->address; *last_loc = b->loc;
break; break;
} }
@ -3850,9 +3868,9 @@ print_one_breakpoint_location (struct breakpoint *b,
static void static void
print_one_breakpoint (struct breakpoint *b, print_one_breakpoint (struct breakpoint *b,
CORE_ADDR *last_addr) struct bp_location **last_loc, int print_address_bits)
{ {
print_one_breakpoint_location (b, NULL, 0, last_addr); print_one_breakpoint_location (b, NULL, 0, last_loc, print_address_bits);
/* If this breakpoint has custom print function, /* If this breakpoint has custom print function,
it's already printed. Otherwise, print individual it's already printed. Otherwise, print individual
@ -3875,11 +3893,27 @@ print_one_breakpoint (struct breakpoint *b,
struct bp_location *loc; struct bp_location *loc;
int n = 1; int n = 1;
for (loc = b->loc; loc; loc = loc->next, ++n) for (loc = b->loc; loc; loc = loc->next, ++n)
print_one_breakpoint_location (b, loc, n, last_addr); print_one_breakpoint_location (b, loc, n, last_loc,
print_address_bits);
} }
} }
} }
static int
breakpoint_address_bits (struct breakpoint *b)
{
int print_address_bits = 0;
struct bp_location *loc;
for (loc = b->loc; loc; loc = loc->next)
{
int addr_bit = gdbarch_addr_bit (b->gdbarch);
if (addr_bit > print_address_bits)
print_address_bits = addr_bit;
}
return print_address_bits;
}
struct captured_breakpoint_query_args struct captured_breakpoint_query_args
{ {
@ -3891,12 +3925,13 @@ do_captured_breakpoint_query (struct ui_out *uiout, void *data)
{ {
struct captured_breakpoint_query_args *args = data; struct captured_breakpoint_query_args *args = data;
struct breakpoint *b; struct breakpoint *b;
CORE_ADDR dummy_addr = 0; struct bp_location *dummy_loc = NULL;
ALL_BREAKPOINTS (b) ALL_BREAKPOINTS (b)
{ {
if (args->bnum == b->number) if (args->bnum == b->number)
{ {
print_one_breakpoint (b, &dummy_addr); int print_address_bits = breakpoint_address_bits (b);
print_one_breakpoint (b, &dummy_loc, print_address_bits);
return GDB_RC_OK; return GDB_RC_OK;
} }
} }
@ -3941,21 +3976,29 @@ static void
breakpoint_1 (int bnum, int allflag) breakpoint_1 (int bnum, int allflag)
{ {
struct breakpoint *b; struct breakpoint *b;
CORE_ADDR last_addr = (CORE_ADDR) -1; struct bp_location *last_loc = NULL;
int nr_printable_breakpoints; int nr_printable_breakpoints;
struct cleanup *bkpttbl_chain; struct cleanup *bkpttbl_chain;
struct value_print_options opts; struct value_print_options opts;
int print_address_bits = 0;
get_user_print_options (&opts); get_user_print_options (&opts);
/* Compute the number of rows in the table. */ /* Compute the number of rows in the table, as well as the
size required for address fields. */
nr_printable_breakpoints = 0; nr_printable_breakpoints = 0;
ALL_BREAKPOINTS (b) ALL_BREAKPOINTS (b)
if (bnum == -1 if (bnum == -1
|| bnum == b->number) || bnum == b->number)
{ {
if (allflag || user_settable_breakpoint (b)) if (allflag || user_settable_breakpoint (b))
nr_printable_breakpoints++; {
int addr_bit = breakpoint_address_bits (b);
if (addr_bit > print_address_bits)
print_address_bits = addr_bit;
nr_printable_breakpoints++;
}
} }
if (opts.addressprint) if (opts.addressprint)
@ -3985,7 +4028,7 @@ breakpoint_1 (int bnum, int allflag)
{ {
if (nr_printable_breakpoints > 0) if (nr_printable_breakpoints > 0)
annotate_field (4); annotate_field (4);
if (gdbarch_addr_bit (current_gdbarch) <= 32) if (print_address_bits <= 32)
ui_out_table_header (uiout, 10, ui_left, "addr", "Address");/* 5 */ ui_out_table_header (uiout, 10, ui_left, "addr", "Address");/* 5 */
else else
ui_out_table_header (uiout, 18, ui_left, "addr", "Address");/* 5 */ ui_out_table_header (uiout, 18, ui_left, "addr", "Address");/* 5 */
@ -4004,7 +4047,7 @@ breakpoint_1 (int bnum, int allflag)
/* We only print out user settable breakpoints unless the /* We only print out user settable breakpoints unless the
allflag is set. */ allflag is set. */
if (allflag || user_settable_breakpoint (b)) if (allflag || user_settable_breakpoint (b))
print_one_breakpoint (b, &last_addr); print_one_breakpoint (b, &last_loc, print_address_bits);
} }
do_cleanups (bkpttbl_chain); do_cleanups (bkpttbl_chain);
@ -4019,10 +4062,8 @@ breakpoint_1 (int bnum, int allflag)
} }
else else
{ {
/* Compare against (CORE_ADDR)-1 in case some compiler decides if (last_loc && !server_command)
that a comparison of an unsigned with -1 is always false. */ set_next_address (last_loc->gdbarch, last_loc->address);
if (last_addr != (CORE_ADDR) -1 && !server_command)
set_next_address (current_gdbarch, last_addr);
} }
/* FIXME? Should this be moved up so that it is only called when /* FIXME? Should this be moved up so that it is only called when
@ -4251,9 +4292,10 @@ breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
this function is simply the identity function. */ this function is simply the identity function. */
static CORE_ADDR static CORE_ADDR
adjust_breakpoint_address (CORE_ADDR bpaddr, enum bptype bptype) adjust_breakpoint_address (struct gdbarch *gdbarch,
CORE_ADDR bpaddr, enum bptype bptype)
{ {
if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch)) if (!gdbarch_adjust_breakpoint_address_p (gdbarch))
{ {
/* Very few targets need any kind of breakpoint adjustment. */ /* Very few targets need any kind of breakpoint adjustment. */
return bpaddr; return bpaddr;
@ -4274,8 +4316,7 @@ adjust_breakpoint_address (CORE_ADDR bpaddr, enum bptype bptype)
/* Some targets have architectural constraints on the placement /* Some targets have architectural constraints on the placement
of breakpoint instructions. Obtain the adjusted address. */ of breakpoint instructions. Obtain the adjusted address. */
adjusted_bpaddr = gdbarch_adjust_breakpoint_address (current_gdbarch, adjusted_bpaddr = gdbarch_adjust_breakpoint_address (gdbarch, bpaddr);
bpaddr);
/* An adjusted breakpoint address can significantly alter /* An adjusted breakpoint address can significantly alter
a user's expectations. Print a warning if an adjustment a user's expectations. Print a warning if an adjustment
@ -4353,7 +4394,8 @@ static void free_bp_location (struct bp_location *loc)
that has type BPTYPE and has no locations as yet. */ that has type BPTYPE and has no locations as yet. */
static struct breakpoint * static struct breakpoint *
set_raw_breakpoint_without_location (enum bptype bptype) set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
enum bptype bptype)
{ {
struct breakpoint *b, *b1; struct breakpoint *b, *b1;
@ -4361,6 +4403,7 @@ set_raw_breakpoint_without_location (enum bptype bptype)
memset (b, 0, sizeof (*b)); memset (b, 0, sizeof (*b));
b->type = bptype; b->type = bptype;
b->gdbarch = gdbarch;
b->language = current_language->la_language; b->language = current_language->la_language;
b->input_radix = input_radix; b->input_radix = input_radix;
b->thread = -1; b->thread = -1;
@ -4406,6 +4449,18 @@ set_breakpoint_location_function (struct bp_location *loc)
} }
} }
/* Attempt to determine architecture of location identified by SAL. */
static struct gdbarch *
get_sal_arch (struct symtab_and_line sal)
{
if (sal.section)
return get_objfile_arch (sal.section->objfile);
if (sal.symtab)
return get_objfile_arch (sal.symtab->objfile);
return NULL;
}
/* set_raw_breakpoint is a low level routine for allocating and /* set_raw_breakpoint is a low level routine for allocating and
partially initializing a breakpoint of type BPTYPE. The newly partially initializing a breakpoint of type BPTYPE. The newly
created breakpoint's address, section, source file name, and line created breakpoint's address, section, source file name, and line
@ -4421,11 +4476,17 @@ set_breakpoint_location_function (struct bp_location *loc)
prior to completing the initialization of the breakpoint. If this prior to completing the initialization of the breakpoint. If this
should happen, a bogus breakpoint will be left on the chain. */ should happen, a bogus breakpoint will be left on the chain. */
struct breakpoint * static struct breakpoint *
set_raw_breakpoint (struct symtab_and_line sal, enum bptype bptype) set_raw_breakpoint (struct gdbarch *gdbarch,
struct symtab_and_line sal, enum bptype bptype)
{ {
struct breakpoint *b = set_raw_breakpoint_without_location (bptype); struct breakpoint *b = set_raw_breakpoint_without_location (gdbarch, bptype);
CORE_ADDR adjusted_address; CORE_ADDR adjusted_address;
struct gdbarch *loc_gdbarch;
loc_gdbarch = get_sal_arch (sal);
if (!loc_gdbarch)
loc_gdbarch = b->gdbarch;
/* Adjust the breakpoint's address prior to allocating a location. /* Adjust the breakpoint's address prior to allocating a location.
Once we call allocate_bp_location(), that mostly uninitialized Once we call allocate_bp_location(), that mostly uninitialized
@ -4433,9 +4494,10 @@ set_raw_breakpoint (struct symtab_and_line sal, enum bptype bptype)
breakpoint may cause target_read_memory() to be called and we do breakpoint may cause target_read_memory() to be called and we do
not want its scan of the location chain to find a breakpoint and not want its scan of the location chain to find a breakpoint and
location that's only been partially initialized. */ location that's only been partially initialized. */
adjusted_address = adjust_breakpoint_address (sal.pc, b->type); adjusted_address = adjust_breakpoint_address (loc_gdbarch, sal.pc, b->type);
b->loc = allocate_bp_location (b); b->loc = allocate_bp_location (b);
b->loc->gdbarch = loc_gdbarch;
b->loc->requested_address = sal.pc; b->loc->requested_address = sal.pc;
b->loc->address = adjusted_address; b->loc->address = adjusted_address;
@ -4536,11 +4598,11 @@ disable_overlay_breakpoints (void)
} }
struct breakpoint * struct breakpoint *
create_thread_event_breakpoint (CORE_ADDR address) create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
{ {
struct breakpoint *b; struct breakpoint *b;
b = create_internal_breakpoint (address, bp_thread_event); b = create_internal_breakpoint (gdbarch, address, bp_thread_event);
b->enable_state = bp_enabled; b->enable_state = bp_enabled;
/* addr_string has to be used or breakpoint_re_set will delete me. */ /* addr_string has to be used or breakpoint_re_set will delete me. */
@ -4587,11 +4649,11 @@ remove_solib_event_breakpoints (void)
} }
struct breakpoint * struct breakpoint *
create_solib_event_breakpoint (CORE_ADDR address) create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
{ {
struct breakpoint *b; struct breakpoint *b;
b = create_internal_breakpoint (address, bp_shlib_event); b = create_internal_breakpoint (gdbarch, address, bp_shlib_event);
update_global_location_list_nothrow (1); update_global_location_list_nothrow (1);
return b; return b;
} }
@ -4711,7 +4773,7 @@ print_it_catch_fork (struct breakpoint *b)
/* Implement the "print_one" breakpoint_ops method for fork catchpoints. */ /* Implement the "print_one" breakpoint_ops method for fork catchpoints. */
static void static void
print_one_catch_fork (struct breakpoint *b, CORE_ADDR *last_addr) print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
{ {
struct value_print_options opts; struct value_print_options opts;
@ -4793,7 +4855,7 @@ print_it_catch_vfork (struct breakpoint *b)
/* Implement the "print_one" breakpoint_ops method for vfork catchpoints. */ /* Implement the "print_one" breakpoint_ops method for vfork catchpoints. */
static void static void
print_one_catch_vfork (struct breakpoint *b, CORE_ADDR *last_addr) print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
{ {
struct value_print_options opts; struct value_print_options opts;
@ -4843,8 +4905,8 @@ static struct breakpoint_ops catch_vfork_breakpoint_ops =
to the catchpoint. */ to the catchpoint. */
static struct breakpoint * static struct breakpoint *
create_catchpoint (int tempflag, char *cond_string, create_catchpoint (struct gdbarch *gdbarch, int tempflag,
struct breakpoint_ops *ops) char *cond_string, struct breakpoint_ops *ops)
{ {
struct symtab_and_line sal; struct symtab_and_line sal;
struct breakpoint *b; struct breakpoint *b;
@ -4854,7 +4916,7 @@ create_catchpoint (int tempflag, char *cond_string,
sal.symtab = NULL; sal.symtab = NULL;
sal.line = 0; sal.line = 0;
b = set_raw_breakpoint (sal, bp_catchpoint); b = set_raw_breakpoint (gdbarch, sal, bp_catchpoint);
set_breakpoint_count (breakpoint_count + 1); set_breakpoint_count (breakpoint_count + 1);
b->number = breakpoint_count; b->number = breakpoint_count;
@ -4872,10 +4934,12 @@ create_catchpoint (int tempflag, char *cond_string,
} }
static void static void
create_fork_vfork_event_catchpoint (int tempflag, char *cond_string, create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
int tempflag, char *cond_string,
struct breakpoint_ops *ops) struct breakpoint_ops *ops)
{ {
struct breakpoint *b = create_catchpoint (tempflag, cond_string, ops); struct breakpoint *b
= create_catchpoint (gdbarch, tempflag, cond_string, ops);
/* FIXME: We should put this information in a breakpoint private data /* FIXME: We should put this information in a breakpoint private data
area. */ area. */
@ -4912,7 +4976,7 @@ print_it_catch_exec (struct breakpoint *b)
} }
static void static void
print_one_catch_exec (struct breakpoint *b, CORE_ADDR *last_addr) print_one_catch_exec (struct breakpoint *b, struct bp_location **last_loc)
{ {
struct value_print_options opts; struct value_print_options opts;
@ -5030,8 +5094,8 @@ enable_watchpoints_after_interactive_call_stop (void)
Restrict it to frame FRAME if FRAME is nonzero. */ Restrict it to frame FRAME if FRAME is nonzero. */
struct breakpoint * struct breakpoint *
set_momentary_breakpoint (struct symtab_and_line sal, struct frame_id frame_id, set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
enum bptype type) struct frame_id frame_id, enum bptype type)
{ {
struct breakpoint *b; struct breakpoint *b;
@ -5039,7 +5103,7 @@ set_momentary_breakpoint (struct symtab_and_line sal, struct frame_id frame_id,
one. */ one. */
gdb_assert (!frame_id_inlined_p (frame_id)); gdb_assert (!frame_id_inlined_p (frame_id));
b = set_raw_breakpoint (sal, type); b = set_raw_breakpoint (gdbarch, sal, type);
b->enable_state = bp_enabled; b->enable_state = bp_enabled;
b->disposition = disp_donttouch; b->disposition = disp_donttouch;
b->frame_id = frame_id; b->frame_id = frame_id;
@ -5067,10 +5131,11 @@ clone_momentary_breakpoint (struct breakpoint *orig)
if (orig == NULL) if (orig == NULL)
return NULL; return NULL;
copy = set_raw_breakpoint_without_location (orig->type); copy = set_raw_breakpoint_without_location (orig->gdbarch, orig->type);
copy->loc = allocate_bp_location (copy); copy->loc = allocate_bp_location (copy);
set_breakpoint_location_function (copy->loc); set_breakpoint_location_function (copy->loc);
copy->loc->gdbarch = orig->loc->gdbarch;
copy->loc->requested_address = orig->loc->requested_address; copy->loc->requested_address = orig->loc->requested_address;
copy->loc->address = orig->loc->address; copy->loc->address = orig->loc->address;
copy->loc->section = orig->loc->section; copy->loc->section = orig->loc->section;
@ -5093,7 +5158,8 @@ clone_momentary_breakpoint (struct breakpoint *orig)
} }
struct breakpoint * struct breakpoint *
set_momentary_breakpoint_at_pc (CORE_ADDR pc, enum bptype type) set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
enum bptype type)
{ {
struct symtab_and_line sal; struct symtab_and_line sal;
@ -5102,7 +5168,7 @@ set_momentary_breakpoint_at_pc (CORE_ADDR pc, enum bptype type)
sal.section = find_pc_overlay (pc); sal.section = find_pc_overlay (pc);
sal.explicit_pc = 1; sal.explicit_pc = 1;
return set_momentary_breakpoint (sal, null_frame_id, type); return set_momentary_breakpoint (gdbarch, sal, null_frame_id, type);
} }
@ -5256,8 +5322,12 @@ add_location_to_breakpoint (struct breakpoint *b,
for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next)) for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
; ;
*tmp = loc; *tmp = loc;
loc->gdbarch = get_sal_arch (*sal);
if (!loc->gdbarch)
loc->gdbarch = b->gdbarch;
loc->requested_address = sal->pc; loc->requested_address = sal->pc;
loc->address = adjust_breakpoint_address (loc->requested_address, b->type); loc->address = adjust_breakpoint_address (loc->gdbarch,
loc->requested_address, b->type);
loc->section = sal->section; loc->section = sal->section;
set_breakpoint_location_function (loc); set_breakpoint_location_function (loc);
@ -5281,7 +5351,7 @@ bp_loc_is_permanent (struct bp_location *loc)
gdb_assert (loc != NULL); gdb_assert (loc != NULL);
addr = loc->address; addr = loc->address;
brk = gdbarch_breakpoint_from_pc (current_gdbarch, &addr, &len); brk = gdbarch_breakpoint_from_pc (loc->gdbarch, &addr, &len);
/* Software breakpoints unsupported? */ /* Software breakpoints unsupported? */
if (brk == NULL) if (brk == NULL)
@ -5310,7 +5380,8 @@ bp_loc_is_permanent (struct bp_location *loc)
as condition expression. */ as condition expression. */
static void static void
create_breakpoint (struct symtabs_and_lines sals, char *addr_string, create_breakpoint (struct gdbarch *gdbarch,
struct symtabs_and_lines sals, char *addr_string,
char *cond_string, char *cond_string,
enum bptype type, enum bpdisp disposition, enum bptype type, enum bpdisp disposition,
int thread, int task, int ignore_count, int thread, int task, int ignore_count,
@ -5341,7 +5412,7 @@ create_breakpoint (struct symtabs_and_lines sals, char *addr_string,
if (i == 0) if (i == 0)
{ {
b = set_raw_breakpoint (sal, type); b = set_raw_breakpoint (gdbarch, sal, type);
set_breakpoint_count (breakpoint_count + 1); set_breakpoint_count (breakpoint_count + 1);
b->number = breakpoint_count; b->number = breakpoint_count;
b->thread = thread; b->thread = thread;
@ -5540,7 +5611,8 @@ expand_line_sal_maybe (struct symtab_and_line sal)
COND and SALS arrays and each of those arrays contents. */ COND and SALS arrays and each of those arrays contents. */
static void static void
create_breakpoints (struct symtabs_and_lines sals, char **addr_string, create_breakpoints (struct gdbarch *gdbarch,
struct symtabs_and_lines sals, char **addr_string,
char *cond_string, char *cond_string,
enum bptype type, enum bpdisp disposition, enum bptype type, enum bpdisp disposition,
int thread, int task, int ignore_count, int thread, int task, int ignore_count,
@ -5553,7 +5625,7 @@ create_breakpoints (struct symtabs_and_lines sals, char **addr_string,
struct symtabs_and_lines expanded = struct symtabs_and_lines expanded =
expand_line_sal_maybe (sals.sals[i]); expand_line_sal_maybe (sals.sals[i]);
create_breakpoint (expanded, addr_string[i], create_breakpoint (gdbarch, expanded, addr_string[i],
cond_string, type, disposition, cond_string, type, disposition,
thread, task, ignore_count, ops, from_tty, enabled); thread, task, ignore_count, ops, from_tty, enabled);
} }
@ -5739,7 +5811,8 @@ find_condition_and_thread (char *tok, CORE_ADDR pc,
parameters. */ parameters. */
static void static void
break_command_really (char *arg, char *cond_string, int thread, break_command_really (struct gdbarch *gdbarch,
char *arg, char *cond_string, int thread,
int parse_condition_and_thread, int parse_condition_and_thread,
int tempflag, int hardwareflag, int traceflag, int tempflag, int hardwareflag, int traceflag,
int ignore_count, int ignore_count,
@ -5881,7 +5954,7 @@ break_command_really (char *arg, char *cond_string, int thread,
make_cleanup (xfree, cond_string); make_cleanup (xfree, cond_string);
} }
} }
create_breakpoints (sals, addr_string, cond_string, type_wanted, create_breakpoints (gdbarch, sals, addr_string, cond_string, type_wanted,
tempflag ? disp_del : disp_donttouch, tempflag ? disp_del : disp_donttouch,
thread, task, ignore_count, ops, from_tty, enabled); thread, task, ignore_count, ops, from_tty, enabled);
} }
@ -5892,7 +5965,7 @@ break_command_really (char *arg, char *cond_string, int thread,
make_cleanup (xfree, copy_arg); make_cleanup (xfree, copy_arg);
b = set_raw_breakpoint_without_location (type_wanted); b = set_raw_breakpoint_without_location (gdbarch, type_wanted);
set_breakpoint_count (breakpoint_count + 1); set_breakpoint_count (breakpoint_count + 1);
b->number = breakpoint_count; b->number = breakpoint_count;
b->thread = -1; b->thread = -1;
@ -5933,7 +6006,8 @@ break_command_1 (char *arg, int flag, int from_tty)
int hardwareflag = flag & BP_HARDWAREFLAG; int hardwareflag = flag & BP_HARDWAREFLAG;
int tempflag = flag & BP_TEMPFLAG; int tempflag = flag & BP_TEMPFLAG;
break_command_really (arg, break_command_really (get_current_arch (),
arg,
NULL, 0, 1 /* parse arg */, NULL, 0, 1 /* parse arg */,
tempflag, hardwareflag, 0 /* traceflag */, tempflag, hardwareflag, 0 /* traceflag */,
0 /* Ignore count */, 0 /* Ignore count */,
@ -5945,12 +6019,14 @@ break_command_1 (char *arg, int flag, int from_tty)
void void
set_breakpoint (char *address, char *condition, set_breakpoint (struct gdbarch *gdbarch,
char *address, char *condition,
int hardwareflag, int tempflag, int hardwareflag, int tempflag,
int thread, int ignore_count, int thread, int ignore_count,
int pending, int enabled) int pending, int enabled)
{ {
break_command_really (address, condition, thread, break_command_really (gdbarch,
address, condition, thread,
0 /* condition and thread are valid. */, 0 /* condition and thread are valid. */,
tempflag, hardwareflag, 0 /* traceflag */, tempflag, hardwareflag, 0 /* traceflag */,
ignore_count, ignore_count,
@ -6144,6 +6220,7 @@ stopat_command (char *arg, int from_tty)
static void static void
watch_command_1 (char *arg, int accessflag, int from_tty) watch_command_1 (char *arg, int accessflag, int from_tty)
{ {
struct gdbarch *gdbarch = get_current_arch ();
struct breakpoint *b, *scope_breakpoint = NULL; struct breakpoint *b, *scope_breakpoint = NULL;
struct symtab_and_line sal; struct symtab_and_line sal;
struct expression *exp; struct expression *exp;
@ -6299,7 +6376,8 @@ watch_command_1 (char *arg, int accessflag, int from_tty)
if (frame_id_p (frame_unwind_caller_id (frame))) if (frame_id_p (frame_unwind_caller_id (frame)))
{ {
scope_breakpoint scope_breakpoint
= create_internal_breakpoint (frame_unwind_caller_pc (frame), = create_internal_breakpoint (frame_unwind_caller_arch (frame),
frame_unwind_caller_pc (frame),
bp_watchpoint_scope); bp_watchpoint_scope);
scope_breakpoint->enable_state = bp_enabled; scope_breakpoint->enable_state = bp_enabled;
@ -6311,16 +6389,19 @@ watch_command_1 (char *arg, int accessflag, int from_tty)
scope_breakpoint->frame_id = frame_unwind_caller_id (frame); scope_breakpoint->frame_id = frame_unwind_caller_id (frame);
/* Set the address at which we will stop. */ /* Set the address at which we will stop. */
scope_breakpoint->loc->gdbarch
= frame_unwind_caller_arch (frame);
scope_breakpoint->loc->requested_address scope_breakpoint->loc->requested_address
= frame_unwind_caller_pc (frame); = frame_unwind_caller_pc (frame);
scope_breakpoint->loc->address scope_breakpoint->loc->address
= adjust_breakpoint_address (scope_breakpoint->loc->requested_address, = adjust_breakpoint_address (scope_breakpoint->loc->gdbarch,
scope_breakpoint->loc->requested_address,
scope_breakpoint->type); scope_breakpoint->type);
} }
} }
/* Now set up the breakpoint. */ /* Now set up the breakpoint. */
b = set_raw_breakpoint (sal, bp_type); b = set_raw_breakpoint (gdbarch, sal, bp_type);
set_breakpoint_count (breakpoint_count + 1); set_breakpoint_count (breakpoint_count + 1);
b->number = breakpoint_count; b->number = breakpoint_count;
b->thread = thread; b->thread = thread;
@ -6527,11 +6608,13 @@ until_break_command (char *arg, int from_tty, int anywhere)
if (anywhere) if (anywhere)
/* If the user told us to continue until a specified location, /* If the user told us to continue until a specified location,
we don't specify a frame at which we need to stop. */ we don't specify a frame at which we need to stop. */
breakpoint = set_momentary_breakpoint (sal, null_frame_id, bp_until); breakpoint = set_momentary_breakpoint (get_frame_arch (frame), sal,
null_frame_id, bp_until);
else else
/* Otherwise, specify the selected frame, because we want to stop only /* Otherwise, specify the selected frame, because we want to stop only
at the very same frame. */ at the very same frame. */
breakpoint = set_momentary_breakpoint (sal, get_stack_frame_id (frame), breakpoint = set_momentary_breakpoint (get_frame_arch (frame), sal,
get_stack_frame_id (frame),
bp_until); bp_until);
old_chain = make_cleanup_delete_breakpoint (breakpoint); old_chain = make_cleanup_delete_breakpoint (breakpoint);
@ -6543,7 +6626,8 @@ until_break_command (char *arg, int from_tty, int anywhere)
{ {
sal = find_pc_line (frame_unwind_caller_pc (frame), 0); sal = find_pc_line (frame_unwind_caller_pc (frame), 0);
sal.pc = frame_unwind_caller_pc (frame); sal.pc = frame_unwind_caller_pc (frame);
breakpoint2 = set_momentary_breakpoint (sal, breakpoint2 = set_momentary_breakpoint (frame_unwind_caller_arch (frame),
sal,
frame_unwind_caller_id (frame), frame_unwind_caller_id (frame),
bp_until); bp_until);
make_cleanup_delete_breakpoint (breakpoint2); make_cleanup_delete_breakpoint (breakpoint2);
@ -6661,6 +6745,7 @@ catch_fork_kind;
static void static void
catch_fork_command_1 (char *arg, int from_tty, struct cmd_list_element *command) catch_fork_command_1 (char *arg, int from_tty, struct cmd_list_element *command)
{ {
struct gdbarch *gdbarch = get_current_arch ();
char *cond_string = NULL; char *cond_string = NULL;
catch_fork_kind fork_kind; catch_fork_kind fork_kind;
int tempflag; int tempflag;
@ -6689,12 +6774,12 @@ catch_fork_command_1 (char *arg, int from_tty, struct cmd_list_element *command)
{ {
case catch_fork_temporary: case catch_fork_temporary:
case catch_fork_permanent: case catch_fork_permanent:
create_fork_vfork_event_catchpoint (tempflag, cond_string, create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
&catch_fork_breakpoint_ops); &catch_fork_breakpoint_ops);
break; break;
case catch_vfork_temporary: case catch_vfork_temporary:
case catch_vfork_permanent: case catch_vfork_permanent:
create_fork_vfork_event_catchpoint (tempflag, cond_string, create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
&catch_vfork_breakpoint_ops); &catch_vfork_breakpoint_ops);
break; break;
default: default:
@ -6706,6 +6791,7 @@ catch_fork_command_1 (char *arg, int from_tty, struct cmd_list_element *command)
static void static void
catch_exec_command_1 (char *arg, int from_tty, struct cmd_list_element *command) catch_exec_command_1 (char *arg, int from_tty, struct cmd_list_element *command)
{ {
struct gdbarch *gdbarch = get_current_arch ();
int tempflag; int tempflag;
char *cond_string = NULL; char *cond_string = NULL;
@ -6727,7 +6813,8 @@ catch_exec_command_1 (char *arg, int from_tty, struct cmd_list_element *command)
/* If this target supports it, create an exec catchpoint /* If this target supports it, create an exec catchpoint
and enable reporting of such events. */ and enable reporting of such events. */
create_catchpoint (tempflag, cond_string, &catch_exec_breakpoint_ops); create_catchpoint (gdbarch, tempflag, cond_string,
&catch_exec_breakpoint_ops);
} }
static enum print_stop_action static enum print_stop_action
@ -6762,7 +6849,7 @@ print_exception_catchpoint (struct breakpoint *b)
} }
static void static void
print_one_exception_catchpoint (struct breakpoint *b, CORE_ADDR *last_addr) print_one_exception_catchpoint (struct breakpoint *b, struct bp_location **last_loc)
{ {
struct value_print_options opts; struct value_print_options opts;
get_user_print_options (&opts); get_user_print_options (&opts);
@ -6776,7 +6863,7 @@ print_one_exception_catchpoint (struct breakpoint *b, CORE_ADDR *last_addr)
} }
annotate_field (5); annotate_field (5);
if (b->loc) if (b->loc)
*last_addr = b->loc->address; *last_loc = b->loc;
if (strstr (b->addr_string, "throw") != NULL) if (strstr (b->addr_string, "throw") != NULL)
ui_out_field_string (uiout, "what", "exception throw"); ui_out_field_string (uiout, "what", "exception throw");
else else
@ -6818,7 +6905,8 @@ handle_gnu_v3_exceptions (int tempflag, char *cond_string,
else else
trigger_func_name = "__cxa_throw"; trigger_func_name = "__cxa_throw";
break_command_really (trigger_func_name, cond_string, -1, break_command_really (get_current_arch (),
trigger_func_name, cond_string, -1,
0 /* condition and thread are valid. */, 0 /* condition and thread are valid. */,
tempflag, 0, 0, tempflag, 0, 0,
0, 0,
@ -6878,7 +6966,8 @@ catch_throw_command (char *arg, int from_tty, struct cmd_list_element *command)
/* Create a breakpoint struct for Ada exception catchpoints. */ /* Create a breakpoint struct for Ada exception catchpoints. */
static void static void
create_ada_exception_breakpoint (struct symtab_and_line sal, create_ada_exception_breakpoint (struct gdbarch *gdbarch,
struct symtab_and_line sal,
char *addr_string, char *addr_string,
char *exp_string, char *exp_string,
char *cond_string, char *cond_string,
@ -6902,7 +6991,7 @@ create_ada_exception_breakpoint (struct symtab_and_line sal,
enough for now, though. */ enough for now, though. */
} }
b = set_raw_breakpoint (sal, bp_breakpoint); b = set_raw_breakpoint (gdbarch, sal, bp_breakpoint);
set_breakpoint_count (breakpoint_count + 1); set_breakpoint_count (breakpoint_count + 1);
b->enable_state = bp_enabled; b->enable_state = bp_enabled;
@ -6927,6 +7016,7 @@ static void
catch_ada_exception_command (char *arg, int from_tty, catch_ada_exception_command (char *arg, int from_tty,
struct cmd_list_element *command) struct cmd_list_element *command)
{ {
struct gdbarch *gdbarch = get_current_arch ();
int tempflag; int tempflag;
struct symtab_and_line sal; struct symtab_and_line sal;
enum bptype type; enum bptype type;
@ -6942,7 +7032,7 @@ catch_ada_exception_command (char *arg, int from_tty,
arg = ""; arg = "";
sal = ada_decode_exception_location (arg, &addr_string, &exp_string, sal = ada_decode_exception_location (arg, &addr_string, &exp_string,
&cond_string, &cond, &ops); &cond_string, &cond, &ops);
create_ada_exception_breakpoint (sal, addr_string, exp_string, create_ada_exception_breakpoint (gdbarch, sal, addr_string, exp_string,
cond_string, cond, ops, tempflag, cond_string, cond, ops, tempflag,
from_tty); from_tty);
} }
@ -6952,6 +7042,7 @@ catch_ada_exception_command (char *arg, int from_tty,
static void static void
catch_assert_command (char *arg, int from_tty, struct cmd_list_element *command) catch_assert_command (char *arg, int from_tty, struct cmd_list_element *command)
{ {
struct gdbarch *gdbarch = get_current_arch ();
int tempflag; int tempflag;
struct symtab_and_line sal; struct symtab_and_line sal;
char *addr_string = NULL; char *addr_string = NULL;
@ -6962,8 +7053,8 @@ catch_assert_command (char *arg, int from_tty, struct cmd_list_element *command)
if (!arg) if (!arg)
arg = ""; arg = "";
sal = ada_decode_assert_location (arg, &addr_string, &ops); sal = ada_decode_assert_location (arg, &addr_string, &ops);
create_ada_exception_breakpoint (sal, addr_string, NULL, NULL, NULL, ops, create_ada_exception_breakpoint (gdbarch, sal, addr_string, NULL, NULL, NULL,
tempflag, from_tty); ops, tempflag, from_tty);
} }
static void static void
@ -8230,7 +8321,7 @@ decode_line_spec_1 (char *string, int funfirstline)
someday. */ someday. */
void * void *
deprecated_insert_raw_breakpoint (CORE_ADDR pc) deprecated_insert_raw_breakpoint (struct gdbarch *gdbarch, CORE_ADDR pc)
{ {
struct bp_target_info *bp_tgt; struct bp_target_info *bp_tgt;
@ -8238,7 +8329,7 @@ deprecated_insert_raw_breakpoint (CORE_ADDR pc)
memset (bp_tgt, 0, sizeof (struct bp_target_info)); memset (bp_tgt, 0, sizeof (struct bp_target_info));
bp_tgt->placed_address = pc; bp_tgt->placed_address = pc;
if (target_insert_breakpoint (bp_tgt) != 0) if (target_insert_breakpoint (gdbarch, bp_tgt) != 0)
{ {
/* Could not insert the breakpoint. */ /* Could not insert the breakpoint. */
xfree (bp_tgt); xfree (bp_tgt);
@ -8251,12 +8342,12 @@ deprecated_insert_raw_breakpoint (CORE_ADDR pc)
/* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */ /* Remove a breakpoint BP inserted by deprecated_insert_raw_breakpoint. */
int int
deprecated_remove_raw_breakpoint (void *bp) deprecated_remove_raw_breakpoint (struct gdbarch *gdbarch, void *bp)
{ {
struct bp_target_info *bp_tgt = bp; struct bp_target_info *bp_tgt = bp;
int ret; int ret;
ret = target_remove_breakpoint (bp_tgt); ret = target_remove_breakpoint (gdbarch, bp_tgt);
xfree (bp_tgt); xfree (bp_tgt);
return ret; return ret;
@ -8265,20 +8356,25 @@ deprecated_remove_raw_breakpoint (void *bp)
/* One (or perhaps two) breakpoints used for software single stepping. */ /* One (or perhaps two) breakpoints used for software single stepping. */
static void *single_step_breakpoints[2]; static void *single_step_breakpoints[2];
static struct gdbarch *single_step_gdbarch[2];
/* Create and insert a breakpoint for software single step. */ /* Create and insert a breakpoint for software single step. */
void void
insert_single_step_breakpoint (CORE_ADDR next_pc) insert_single_step_breakpoint (struct gdbarch *gdbarch, CORE_ADDR next_pc)
{ {
void **bpt_p; void **bpt_p;
if (single_step_breakpoints[0] == NULL) if (single_step_breakpoints[0] == NULL)
bpt_p = &single_step_breakpoints[0]; {
bpt_p = &single_step_breakpoints[0];
single_step_gdbarch[0] = gdbarch;
}
else else
{ {
gdb_assert (single_step_breakpoints[1] == NULL); gdb_assert (single_step_breakpoints[1] == NULL);
bpt_p = &single_step_breakpoints[1]; bpt_p = &single_step_breakpoints[1];
single_step_gdbarch[1] = gdbarch;
} }
/* NOTE drow/2006-04-11: A future improvement to this function would be /* NOTE drow/2006-04-11: A future improvement to this function would be
@ -8288,7 +8384,7 @@ insert_single_step_breakpoint (CORE_ADDR next_pc)
corresponding changes elsewhere where single step breakpoints are corresponding changes elsewhere where single step breakpoints are
handled, however. So, for now, we use this. */ handled, however. So, for now, we use this. */
*bpt_p = deprecated_insert_raw_breakpoint (next_pc); *bpt_p = deprecated_insert_raw_breakpoint (gdbarch, next_pc);
if (*bpt_p == NULL) if (*bpt_p == NULL)
error (_("Could not insert single-step breakpoint at 0x%s"), error (_("Could not insert single-step breakpoint at 0x%s"),
paddr_nz (next_pc)); paddr_nz (next_pc));
@ -8303,12 +8399,16 @@ remove_single_step_breakpoints (void)
/* See insert_single_step_breakpoint for more about this deprecated /* See insert_single_step_breakpoint for more about this deprecated
call. */ call. */
deprecated_remove_raw_breakpoint (single_step_breakpoints[0]); deprecated_remove_raw_breakpoint (single_step_gdbarch[0],
single_step_breakpoints[0]);
single_step_gdbarch[0] = NULL;
single_step_breakpoints[0] = NULL; single_step_breakpoints[0] = NULL;
if (single_step_breakpoints[1] != NULL) if (single_step_breakpoints[1] != NULL)
{ {
deprecated_remove_raw_breakpoint (single_step_breakpoints[1]); deprecated_remove_raw_breakpoint (single_step_gdbarch[1],
single_step_breakpoints[1]);
single_step_gdbarch[1] = NULL;
single_step_breakpoints[1] = NULL; single_step_breakpoints[1] = NULL;
} }
} }
@ -8343,7 +8443,8 @@ set_tracepoint_count (int num)
void void
trace_command (char *arg, int from_tty) trace_command (char *arg, int from_tty)
{ {
break_command_really (arg, break_command_really (get_current_arch (),
arg,
NULL, 0, 1 /* parse arg */, NULL, 0, 1 /* parse arg */,
0 /* tempflag */, 0 /* hardwareflag */, 0 /* tempflag */, 0 /* hardwareflag */,
1 /* traceflag */, 1 /* traceflag */,

27
gdb/breakpoint.h
View file

@ -258,6 +258,10 @@ struct bp_location
/* Data for specific breakpoint types. These could be a union, but /* Data for specific breakpoint types. These could be a union, but
simplicity is more important than memory usage for breakpoints. */ simplicity is more important than memory usage for breakpoints. */
/* Architecture associated with this location's address. May be
different from the breakpoint architecture. */
struct gdbarch *gdbarch;
/* Note that zero is a perfectly valid code address on some platforms /* Note that zero is a perfectly valid code address on some platforms
(for example, the mn10200 (OBSOLETE) and mn10300 simulators). NULL (for example, the mn10200 (OBSOLETE) and mn10300 simulators). NULL
is not a special value for this field. Valid for all types except is not a special value for this field. Valid for all types except
@ -326,7 +330,7 @@ struct breakpoint_ops
enum print_stop_action (*print_it) (struct breakpoint *); enum print_stop_action (*print_it) (struct breakpoint *);
/* Display information about this breakpoint, for "info breakpoints". */ /* Display information about this breakpoint, for "info breakpoints". */
void (*print_one) (struct breakpoint *, CORE_ADDR *); void (*print_one) (struct breakpoint *, struct bp_location **);
/* Display information about this breakpoint after setting it (roughly /* Display information about this breakpoint after setting it (roughly
speaking; this is called from "mention"). */ speaking; this is called from "mention"). */
@ -394,6 +398,8 @@ struct breakpoint
/* String we used to set the breakpoint (malloc'd). */ /* String we used to set the breakpoint (malloc'd). */
char *addr_string; char *addr_string;
/* Architecture we used to set the breakpoint. */
struct gdbarch *gdbarch;
/* Language we used to set the breakpoint. */ /* Language we used to set the breakpoint. */
enum language language; enum language language;
/* Input radix we used to set the breakpoint. */ /* Input radix we used to set the breakpoint. */
@ -698,10 +704,10 @@ extern void breakpoint_re_set (void);
extern void breakpoint_re_set_thread (struct breakpoint *); extern void breakpoint_re_set_thread (struct breakpoint *);
extern struct breakpoint *set_momentary_breakpoint extern struct breakpoint *set_momentary_breakpoint
(struct symtab_and_line, struct frame_id, enum bptype); (struct gdbarch *, struct symtab_and_line, struct frame_id, enum bptype);
extern struct breakpoint *set_momentary_breakpoint_at_pc extern struct breakpoint *set_momentary_breakpoint_at_pc
(CORE_ADDR pc, enum bptype type); (struct gdbarch *, CORE_ADDR pc, enum bptype type);
extern struct breakpoint *clone_momentary_breakpoint (struct breakpoint *bpkt); extern struct breakpoint *clone_momentary_breakpoint (struct breakpoint *bpkt);
@ -727,7 +733,8 @@ extern void awatch_command_wrapper (char *, int);
extern void rwatch_command_wrapper (char *, int); extern void rwatch_command_wrapper (char *, int);
extern void tbreak_command (char *, int); extern void tbreak_command (char *, int);
extern void set_breakpoint (char *address, char *condition, extern void set_breakpoint (struct gdbarch *gdbarch,
char *address, char *condition,
int hardwareflag, int tempflag, int hardwareflag, int tempflag,
int thread, int ignore_count, int thread, int ignore_count,
int pending, int pending,
@ -834,9 +841,11 @@ extern void mark_breakpoints_out (void);
extern void make_breakpoint_permanent (struct breakpoint *); extern void make_breakpoint_permanent (struct breakpoint *);
extern struct breakpoint *create_solib_event_breakpoint (CORE_ADDR); extern struct breakpoint *create_solib_event_breakpoint (struct gdbarch *,
CORE_ADDR);
extern struct breakpoint *create_thread_event_breakpoint (CORE_ADDR); extern struct breakpoint *create_thread_event_breakpoint (struct gdbarch *,
CORE_ADDR);
extern void remove_solib_event_breakpoints (void); extern void remove_solib_event_breakpoints (void);
@ -857,14 +866,14 @@ extern int remove_hw_watchpoints (void);
/* Manage a software single step breakpoint (or two). Insert may be called /* Manage a software single step breakpoint (or two). Insert may be called
twice before remove is called. */ twice before remove is called. */
extern void insert_single_step_breakpoint (CORE_ADDR); extern void insert_single_step_breakpoint (struct gdbarch *, CORE_ADDR);
extern void remove_single_step_breakpoints (void); extern void remove_single_step_breakpoints (void);
/* Manage manual breakpoints, separate from the normal chain of /* Manage manual breakpoints, separate from the normal chain of
breakpoints. These functions are used in murky target-specific breakpoints. These functions are used in murky target-specific
ways. Please do not add more uses! */ ways. Please do not add more uses! */
extern void *deprecated_insert_raw_breakpoint (CORE_ADDR); extern void *deprecated_insert_raw_breakpoint (struct gdbarch *, CORE_ADDR);
extern int deprecated_remove_raw_breakpoint (void *); extern int deprecated_remove_raw_breakpoint (struct gdbarch *, void *);
/* Check if any hardware watchpoints have triggered, according to the /* Check if any hardware watchpoints have triggered, according to the
target. */ target. */

2
gdb/corelow.c
View file

@ -695,7 +695,7 @@ core_xfer_partial (struct target_ops *ops, enum target_object object,
`gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */ `gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */
static int static int
ignore (struct bp_target_info *bp_tgt) ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
{ {
return 0; return 0;
} }

9
gdb/cris-tdep.c
View file

@ -2120,6 +2120,7 @@ find_step_target (struct frame_info *frame, inst_env_type *inst_env)
static int static int
cris_software_single_step (struct frame_info *frame) cris_software_single_step (struct frame_info *frame)
{ {
struct gdbarch *gdbarch = get_frame_arch (frame);
inst_env_type inst_env; inst_env_type inst_env;
/* Analyse the present instruction environment and insert /* Analyse the present instruction environment and insert
@ -2135,15 +2136,15 @@ cris_software_single_step (struct frame_info *frame)
{ {
/* Insert at most two breakpoints. One for the next PC content /* Insert at most two breakpoints. One for the next PC content
and possibly another one for a branch, jump, etc. */ and possibly another one for a branch, jump, etc. */
CORE_ADDR next_pc = CORE_ADDR next_pc
(CORE_ADDR) inst_env.reg[gdbarch_pc_regnum (get_frame_arch (frame))]; = (CORE_ADDR) inst_env.reg[gdbarch_pc_regnum (gdbarch)];
insert_single_step_breakpoint (next_pc); insert_single_step_breakpoint (gdbarch, next_pc);
if (inst_env.branch_found if (inst_env.branch_found
&& (CORE_ADDR) inst_env.branch_break_address != next_pc) && (CORE_ADDR) inst_env.branch_break_address != next_pc)
{ {
CORE_ADDR branch_target_address CORE_ADDR branch_target_address
= (CORE_ADDR) inst_env.branch_break_address; = (CORE_ADDR) inst_env.branch_break_address;
insert_single_step_breakpoint (branch_target_address); insert_single_step_breakpoint (gdbarch, branch_target_address);
} }
} }

5
gdb/doc/ChangeLog
View file

@ -1,3 +1,8 @@
2009-07-02 Ulrich Weigand <uweigand@de.ibm.com>
* gdbint.texi (Examples of Use of @code{ui_out} functions):
Update example code extrated from breakpoint.c.
2009-06-28 Paul Pluzhnikov <ppluzhnikov@google.com> 2009-06-28 Paul Pluzhnikov <ppluzhnikov@google.com>
* gdb.texinfo (GDB/MI Program Context): @ignore unimplemented * gdb.texinfo (GDB/MI Program Context): @ignore unimplemented

2
gdb/doc/gdbint.texinfo
View file

@ -1589,7 +1589,7 @@ Here's the new version:
@{ @{
if (nr_printable_breakpoints > 0) if (nr_printable_breakpoints > 0)
annotate_field (4); annotate_field (4);
if (gdbarch_addr_bit (current_gdbarch) <= 32) if (print_address_bits <= 32)
ui_out_table_header (uiout, 10, ui_left, "addr", "Address");/* 5 */ ui_out_table_header (uiout, 10, ui_left, "addr", "Address");/* 5 */
else else
ui_out_table_header (uiout, 18, ui_left, "addr", "Address");/* 5 */ ui_out_table_header (uiout, 18, ui_left, "addr", "Address");/* 5 */

2
gdb/exec.c
View file

@ -776,7 +776,7 @@ exec_set_section_address (const char *filename, int index, CORE_ADDR address)
breakpoint_init_inferior). */ breakpoint_init_inferior). */
static int static int
ignore (struct bp_target_info *bp_tgt) ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
{ {
return 0; return 0;
} }

6
gdb/i386-nat.c
View file

@ -601,7 +601,8 @@ i386_stopped_by_hwbp (void)
/* Insert a hardware-assisted breakpoint at BP_TGT->placed_address. /* Insert a hardware-assisted breakpoint at BP_TGT->placed_address.
Return 0 on success, EBUSY on failure. */ Return 0 on success, EBUSY on failure. */
static int static int
i386_insert_hw_breakpoint (struct bp_target_info *bp_tgt) i386_insert_hw_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
unsigned len_rw = i386_length_and_rw_bits (1, hw_execute); unsigned len_rw = i386_length_and_rw_bits (1, hw_execute);
CORE_ADDR addr = bp_tgt->placed_address; CORE_ADDR addr = bp_tgt->placed_address;
@ -617,7 +618,8 @@ i386_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
Return 0 on success, -1 on failure. */ Return 0 on success, -1 on failure. */
static int static int
i386_remove_hw_breakpoint (struct bp_target_info *bp_tgt) i386_remove_hw_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
unsigned len_rw = i386_length_and_rw_bits (1, hw_execute); unsigned len_rw = i386_length_and_rw_bits (1, hw_execute);
CORE_ADDR addr = bp_tgt->placed_address; CORE_ADDR addr = bp_tgt->placed_address;

4
gdb/infcall.c
View file

@ -738,7 +738,7 @@ call_function_by_hand (struct value *function, int nargs, struct value **args)
/* Sanity. The exact same SP value is returned by /* Sanity. The exact same SP value is returned by
PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
dummy_id to form the frame ID's stack address. */ dummy_id to form the frame ID's stack address. */
bpt = set_momentary_breakpoint (sal, dummy_id, bp_call_dummy); bpt = set_momentary_breakpoint (gdbarch, sal, dummy_id, bp_call_dummy);
bpt->disposition = disp_del; bpt->disposition = disp_del;
} }
@ -760,7 +760,7 @@ call_function_by_hand (struct value *function, int nargs, struct value **args)
NULL, NULL); NULL, NULL);
if (tm != NULL) if (tm != NULL)
terminate_bp = set_momentary_breakpoint_at_pc terminate_bp = set_momentary_breakpoint_at_pc
(SYMBOL_VALUE_ADDRESS (tm), bp_breakpoint); (gdbarch, SYMBOL_VALUE_ADDRESS (tm), bp_breakpoint);
} }
/* Everything's ready, push all the info needed to restore the /* Everything's ready, push all the info needed to restore the

11
gdb/infcmd.c
View file

@ -1461,10 +1461,13 @@ finish_backward (struct symbol *function)
if (sal.pc != pc) if (sal.pc != pc)
{ {
struct frame_info *frame = get_selected_frame (NULL);
struct gdbarch *gdbarch = get_frame_arch (frame);
/* Set breakpoint and continue. */ /* Set breakpoint and continue. */
breakpoint = breakpoint =
set_momentary_breakpoint (sal, set_momentary_breakpoint (gdbarch, sal,
get_stack_frame_id (get_selected_frame (NULL)), get_stack_frame_id (frame),
bp_breakpoint); bp_breakpoint);
/* Tell the breakpoint to keep quiet. We won't be done /* Tell the breakpoint to keep quiet. We won't be done
until we've done another reverse single-step. */ until we've done another reverse single-step. */
@ -1493,6 +1496,7 @@ finish_backward (struct symbol *function)
static void static void
finish_forward (struct symbol *function, struct frame_info *frame) finish_forward (struct symbol *function, struct frame_info *frame)
{ {
struct gdbarch *gdbarch = get_frame_arch (frame);
struct symtab_and_line sal; struct symtab_and_line sal;
struct thread_info *tp = inferior_thread (); struct thread_info *tp = inferior_thread ();
struct breakpoint *breakpoint; struct breakpoint *breakpoint;
@ -1502,7 +1506,8 @@ finish_forward (struct symbol *function, struct frame_info *frame)
sal = find_pc_line (get_frame_pc (frame), 0); sal = find_pc_line (get_frame_pc (frame), 0);
sal.pc = get_frame_pc (frame); sal.pc = get_frame_pc (frame);
breakpoint = set_momentary_breakpoint (sal, get_stack_frame_id (frame), breakpoint = set_momentary_breakpoint (gdbarch, sal,
get_stack_frame_id (frame),
bp_finish); bp_finish);
old_chain = make_cleanup_delete_breakpoint (breakpoint); old_chain = make_cleanup_delete_breakpoint (breakpoint);

44
gdb/infrun.c
View file

@ -1759,9 +1759,10 @@ static void handle_step_into_function_backward (struct gdbarch *gdbarch,
struct execution_control_state *ecs); struct execution_control_state *ecs);
static void insert_step_resume_breakpoint_at_frame (struct frame_info *step_frame); static void insert_step_resume_breakpoint_at_frame (struct frame_info *step_frame);
static void insert_step_resume_breakpoint_at_caller (struct frame_info *); static void insert_step_resume_breakpoint_at_caller (struct frame_info *);
static void insert_step_resume_breakpoint_at_sal (struct symtab_and_line sr_sal, static void insert_step_resume_breakpoint_at_sal (struct gdbarch *gdbarch,
struct symtab_and_line sr_sal,
struct frame_id sr_id); struct frame_id sr_id);
static void insert_longjmp_resume_breakpoint (CORE_ADDR); static void insert_longjmp_resume_breakpoint (struct gdbarch *, CORE_ADDR);
static void stop_stepping (struct execution_control_state *ecs); static void stop_stepping (struct execution_control_state *ecs);
static void prepare_to_wait (struct execution_control_state *ecs); static void prepare_to_wait (struct execution_control_state *ecs);
@ -3411,7 +3412,7 @@ infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME (!gdbarch_get_longjmp_target)\n");
delete_step_resume_breakpoint (ecs->event_thread); delete_step_resume_breakpoint (ecs->event_thread);
/* Insert a breakpoint at resume address. */ /* Insert a breakpoint at resume address. */
insert_longjmp_resume_breakpoint (jmp_buf_pc); insert_longjmp_resume_breakpoint (gdbarch, jmp_buf_pc);
keep_going (ecs); keep_going (ecs);
return; return;
@ -3732,7 +3733,8 @@ infrun: not switching back to stepped thread, it has vanished\n");
init_sal (&sr_sal); init_sal (&sr_sal);
sr_sal.pc = pc_after_resolver; sr_sal.pc = pc_after_resolver;
insert_step_resume_breakpoint_at_sal (sr_sal, null_frame_id); insert_step_resume_breakpoint_at_sal (gdbarch,
sr_sal, null_frame_id);
} }
keep_going (ecs); keep_going (ecs);
@ -3828,7 +3830,8 @@ infrun: not switching back to stepped thread, it has vanished\n");
/* Normal function call return (static or dynamic). */ /* Normal function call return (static or dynamic). */
init_sal (&sr_sal); init_sal (&sr_sal);
sr_sal.pc = ecs->stop_func_start; sr_sal.pc = ecs->stop_func_start;
insert_step_resume_breakpoint_at_sal (sr_sal, null_frame_id); insert_step_resume_breakpoint_at_sal (gdbarch,
sr_sal, null_frame_id);
} }
else else
insert_step_resume_breakpoint_at_caller (frame); insert_step_resume_breakpoint_at_caller (frame);
@ -3854,7 +3857,8 @@ infrun: not switching back to stepped thread, it has vanished\n");
init_sal (&sr_sal); init_sal (&sr_sal);
sr_sal.pc = ecs->stop_func_start; sr_sal.pc = ecs->stop_func_start;
insert_step_resume_breakpoint_at_sal (sr_sal, null_frame_id); insert_step_resume_breakpoint_at_sal (gdbarch,
sr_sal, null_frame_id);
keep_going (ecs); keep_going (ecs);
return; return;
} }
@ -3898,7 +3902,8 @@ infrun: not switching back to stepped thread, it has vanished\n");
struct symtab_and_line sr_sal; struct symtab_and_line sr_sal;
init_sal (&sr_sal); init_sal (&sr_sal);
sr_sal.pc = ecs->stop_func_start; sr_sal.pc = ecs->stop_func_start;
insert_step_resume_breakpoint_at_sal (sr_sal, null_frame_id); insert_step_resume_breakpoint_at_sal (gdbarch,
sr_sal, null_frame_id);
} }
else else
/* Set a breakpoint at callee's return address (the address /* Set a breakpoint at callee's return address (the address
@ -3934,7 +3939,8 @@ infrun: not switching back to stepped thread, it has vanished\n");
/* Do not specify what the fp should be when we stop since /* Do not specify what the fp should be when we stop since
on some machines the prologue is where the new fp value on some machines the prologue is where the new fp value
is established. */ is established. */
insert_step_resume_breakpoint_at_sal (sr_sal, null_frame_id); insert_step_resume_breakpoint_at_sal (gdbarch,
sr_sal, null_frame_id);
/* Restart without fiddling with the step ranges or /* Restart without fiddling with the step ranges or
other state. */ other state. */
@ -4212,7 +4218,7 @@ handle_step_into_function (struct gdbarch *gdbarch,
/* Do not specify what the fp should be when we stop since on /* Do not specify what the fp should be when we stop since on
some machines the prologue is where the new fp value is some machines the prologue is where the new fp value is
established. */ established. */
insert_step_resume_breakpoint_at_sal (sr_sal, null_frame_id); insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal, null_frame_id);
/* And make sure stepping stops right away then. */ /* And make sure stepping stops right away then. */
ecs->event_thread->step_range_end = ecs->event_thread->step_range_start; ecs->event_thread->step_range_end = ecs->event_thread->step_range_start;
@ -4262,7 +4268,8 @@ handle_step_into_function_backward (struct gdbarch *gdbarch,
This is used to both functions and to skip over code. */ This is used to both functions and to skip over code. */
static void static void
insert_step_resume_breakpoint_at_sal (struct symtab_and_line sr_sal, insert_step_resume_breakpoint_at_sal (struct gdbarch *gdbarch,
struct symtab_and_line sr_sal,
struct frame_id sr_id) struct frame_id sr_id)
{ {
/* There should never be more than one step-resume or longjmp-resume /* There should never be more than one step-resume or longjmp-resume
@ -4276,7 +4283,7 @@ insert_step_resume_breakpoint_at_sal (struct symtab_and_line sr_sal,
paddr_nz (sr_sal.pc)); paddr_nz (sr_sal.pc));
inferior_thread ()->step_resume_breakpoint inferior_thread ()->step_resume_breakpoint
= set_momentary_breakpoint (sr_sal, sr_id, bp_step_resume); = set_momentary_breakpoint (gdbarch, sr_sal, sr_id, bp_step_resume);
} }
/* Insert a "step-resume breakpoint" at RETURN_FRAME.pc. This is used /* Insert a "step-resume breakpoint" at RETURN_FRAME.pc. This is used
@ -4289,16 +4296,18 @@ insert_step_resume_breakpoint_at_sal (struct symtab_and_line sr_sal,
static void static void
insert_step_resume_breakpoint_at_frame (struct frame_info *return_frame) insert_step_resume_breakpoint_at_frame (struct frame_info *return_frame)
{ {
struct gdbarch *gdbarch = get_frame_arch (return_frame);
struct symtab_and_line sr_sal; struct symtab_and_line sr_sal;
struct gdbarch *gdbarch;
gdb_assert (return_frame != NULL); gdb_assert (return_frame != NULL);
init_sal (&sr_sal); /* initialize to zeros */ init_sal (&sr_sal); /* initialize to zeros */
gdbarch = get_frame_arch (return_frame);
sr_sal.pc = gdbarch_addr_bits_remove (gdbarch, get_frame_pc (return_frame)); sr_sal.pc = gdbarch_addr_bits_remove (gdbarch, get_frame_pc (return_frame));
sr_sal.section = find_pc_overlay (sr_sal.pc); sr_sal.section = find_pc_overlay (sr_sal.pc);
insert_step_resume_breakpoint_at_sal (sr_sal, get_stack_frame_id (return_frame)); insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal,
get_stack_frame_id (return_frame));
} }
/* Similar to insert_step_resume_breakpoint_at_frame, except /* Similar to insert_step_resume_breakpoint_at_frame, except
@ -4319,8 +4328,8 @@ insert_step_resume_breakpoint_at_frame (struct frame_info *return_frame)
static void static void
insert_step_resume_breakpoint_at_caller (struct frame_info *next_frame) insert_step_resume_breakpoint_at_caller (struct frame_info *next_frame)
{ {
struct gdbarch *gdbarch = get_frame_arch (next_frame);
struct symtab_and_line sr_sal; struct symtab_and_line sr_sal;
struct gdbarch *gdbarch;
/* We shouldn't have gotten here if we don't know where the call site /* We shouldn't have gotten here if we don't know where the call site
is. */ is. */
@ -4328,11 +4337,12 @@ insert_step_resume_breakpoint_at_caller (struct frame_info *next_frame)
init_sal (&sr_sal); /* initialize to zeros */ init_sal (&sr_sal); /* initialize to zeros */
gdbarch = frame_unwind_caller_arch (next_frame);
sr_sal.pc = gdbarch_addr_bits_remove (gdbarch, sr_sal.pc = gdbarch_addr_bits_remove (gdbarch,
frame_unwind_caller_pc (next_frame)); frame_unwind_caller_pc (next_frame));
sr_sal.section = find_pc_overlay (sr_sal.pc); sr_sal.section = find_pc_overlay (sr_sal.pc);
insert_step_resume_breakpoint_at_sal (sr_sal, insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal,
frame_unwind_caller_id (next_frame)); frame_unwind_caller_id (next_frame));
} }
@ -4342,7 +4352,7 @@ insert_step_resume_breakpoint_at_caller (struct frame_info *next_frame)
"step-resume" breakpoints. */ "step-resume" breakpoints. */
static void static void
insert_longjmp_resume_breakpoint (CORE_ADDR pc) insert_longjmp_resume_breakpoint (struct gdbarch *gdbarch, CORE_ADDR pc)
{ {
/* There should never be more than one step-resume or longjmp-resume /* There should never be more than one step-resume or longjmp-resume
breakpoint per thread, so we should never be setting a new breakpoint per thread, so we should never be setting a new
@ -4355,7 +4365,7 @@ insert_longjmp_resume_breakpoint (CORE_ADDR pc)
paddr_nz (pc)); paddr_nz (pc));
inferior_thread ()->step_resume_breakpoint = inferior_thread ()->step_resume_breakpoint =
set_momentary_breakpoint_at_pc (pc, bp_longjmp_resume); set_momentary_breakpoint_at_pc (gdbarch, pc, bp_longjmp_resume);
} }
static void static void

2
gdb/linux-thread-db.c
View file

@ -515,7 +515,7 @@ enable_thread_event (int event, CORE_ADDR *bp)
? (CORE_ADDR) (intptr_t) notify.u.bptaddr ? (CORE_ADDR) (intptr_t) notify.u.bptaddr
: (CORE_ADDR) (uintptr_t) notify.u.bptaddr), : (CORE_ADDR) (uintptr_t) notify.u.bptaddr),
&current_target)); &current_target));
create_thread_event_breakpoint ((*bp)); create_thread_event_breakpoint (target_gdbarch, *bp);
return TD_OK; return TD_OK;
} }

10
gdb/mem-break.c
View file

@ -78,13 +78,15 @@ default_memory_remove_breakpoint (struct gdbarch *gdbarch,
int int
memory_insert_breakpoint (struct bp_target_info *bp_tgt) memory_insert_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
return gdbarch_memory_insert_breakpoint (current_gdbarch, bp_tgt); return gdbarch_memory_insert_breakpoint (gdbarch, bp_tgt);
} }
int int
memory_remove_breakpoint (struct bp_target_info *bp_tgt) memory_remove_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
return gdbarch_memory_remove_breakpoint (current_gdbarch, bp_tgt); return gdbarch_memory_remove_breakpoint (gdbarch, bp_tgt);
} }

5
gdb/mi/mi-cmd-break.c
View file

@ -19,6 +19,7 @@
along with this program. If not, see <http://www.gnu.org/licenses/>. */ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h" #include "defs.h"
#include "arch-utils.h"
#include "mi-cmds.h" #include "mi-cmds.h"
#include "ui-out.h" #include "ui-out.h"
#include "mi-out.h" #include "mi-out.h"
@ -153,13 +154,13 @@ mi_cmd_break_insert (char *command, char **argv, int argc)
switch (type) switch (type)
{ {
case REG_BP: case REG_BP:
set_breakpoint (address, condition, set_breakpoint (get_current_arch (), address, condition,
0 /*hardwareflag */ , temp_p, 0 /*hardwareflag */ , temp_p,
thread, ignore_count, thread, ignore_count,
pending, enabled); pending, enabled);
break; break;
case HW_BP: case HW_BP:
set_breakpoint (address, condition, set_breakpoint (get_current_arch (), address, condition,
1 /*hardwareflag */ , temp_p, 1 /*hardwareflag */ , temp_p,
thread, ignore_count, thread, ignore_count,
pending, enabled); pending, enabled);

9
gdb/mips-tdep.c
View file

@ -2377,7 +2377,7 @@ mips_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
the sequence. */ the sequence. */
static int static int
deal_with_atomic_sequence (CORE_ADDR pc) deal_with_atomic_sequence (struct gdbarch *gdbarch, CORE_ADDR pc)
{ {
CORE_ADDR breaks[2] = {-1, -1}; CORE_ADDR breaks[2] = {-1, -1};
CORE_ADDR loc = pc; CORE_ADDR loc = pc;
@ -2465,7 +2465,7 @@ deal_with_atomic_sequence (CORE_ADDR pc)
/* Effectively inserts the breakpoints. */ /* Effectively inserts the breakpoints. */
for (index = 0; index <= last_breakpoint; index++) for (index = 0; index <= last_breakpoint; index++)
insert_single_step_breakpoint (breaks[index]); insert_single_step_breakpoint (gdbarch, breaks[index]);
return 1; return 1;
} }
@ -2478,15 +2478,16 @@ deal_with_atomic_sequence (CORE_ADDR pc)
int int
mips_software_single_step (struct frame_info *frame) mips_software_single_step (struct frame_info *frame)
{ {
struct gdbarch *gdbarch = get_frame_arch (frame);
CORE_ADDR pc, next_pc; CORE_ADDR pc, next_pc;
pc = get_frame_pc (frame); pc = get_frame_pc (frame);
if (deal_with_atomic_sequence (pc)) if (deal_with_atomic_sequence (gdbarch, pc))
return 1; return 1;
next_pc = mips_next_pc (frame, pc); next_pc = mips_next_pc (frame, pc);
insert_single_step_breakpoint (next_pc); insert_single_step_breakpoint (gdbarch, next_pc);
return 1; return 1;
} }

10
gdb/monitor.c
View file

@ -2027,7 +2027,8 @@ monitor_mourn_inferior (struct target_ops *ops)
/* Tell the monitor to add a breakpoint. */ /* Tell the monitor to add a breakpoint. */
static int static int
monitor_insert_breakpoint (struct bp_target_info *bp_tgt) monitor_insert_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
CORE_ADDR addr = bp_tgt->placed_address; CORE_ADDR addr = bp_tgt->placed_address;
int i; int i;
@ -2038,10 +2039,10 @@ monitor_insert_breakpoint (struct bp_target_info *bp_tgt)
error (_("No set_break defined for this monitor")); error (_("No set_break defined for this monitor"));
if (current_monitor->flags & MO_ADDR_BITS_REMOVE) if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
addr = gdbarch_addr_bits_remove (current_gdbarch, addr); addr = gdbarch_addr_bits_remove (gdbarch, addr);
/* Determine appropriate breakpoint size for this address. */ /* Determine appropriate breakpoint size for this address. */
gdbarch_breakpoint_from_pc (current_gdbarch, &addr, &bplen); gdbarch_breakpoint_from_pc (gdbarch, &addr, &bplen);
bp_tgt->placed_address = addr; bp_tgt->placed_address = addr;
bp_tgt->placed_size = bplen; bp_tgt->placed_size = bplen;
@ -2062,7 +2063,8 @@ monitor_insert_breakpoint (struct bp_target_info *bp_tgt)
/* Tell the monitor to remove a breakpoint. */ /* Tell the monitor to remove a breakpoint. */
static int static int
monitor_remove_breakpoint (struct bp_target_info *bp_tgt) monitor_remove_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
CORE_ADDR addr = bp_tgt->placed_address; CORE_ADDR addr = bp_tgt->placed_address;
int i; int i;

12
gdb/nto-procfs.c
View file

@ -824,26 +824,30 @@ procfs_breakpoint (CORE_ADDR addr, int type, int size)
} }
static int static int
procfs_insert_breakpoint (struct bp_target_info *bp_tgt) procfs_insert_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, 0); return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, 0);
} }
static int static int
procfs_remove_breakpoint (struct bp_target_info *bp_tgt) procfs_remove_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1); return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1);
} }
static int static int
procfs_insert_hw_breakpoint (struct bp_target_info *bp_tgt) procfs_insert_hw_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
return procfs_breakpoint (bp_tgt->placed_address, return procfs_breakpoint (bp_tgt->placed_address,
_DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0); _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
} }
static int static int
procfs_remove_hw_breakpoint (struct bp_target_info *bp_tgt) procfs_remove_hw_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
return procfs_breakpoint (bp_tgt->placed_address, return procfs_breakpoint (bp_tgt->placed_address,
_DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1); _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);

7
gdb/procfs.c
View file

@ -4803,7 +4803,7 @@ procfs_mourn_inferior (struct target_ops *ops)
if (dbx_link_bpt != NULL) if (dbx_link_bpt != NULL)
{ {
deprecated_remove_raw_breakpoint (dbx_link_bpt); deprecated_remove_raw_breakpoint (target_gdbarch, dbx_link_bpt);
dbx_link_bpt_addr = 0; dbx_link_bpt_addr = 0;
dbx_link_bpt = NULL; dbx_link_bpt = NULL;
} }
@ -5592,7 +5592,7 @@ remove_dbx_link_breakpoint (void)
if (dbx_link_bpt_addr == 0) if (dbx_link_bpt_addr == 0)
return; return;
if (deprecated_remove_raw_breakpoint (dbx_link_bpt) != 0) if (deprecated_remove_raw_breakpoint (target_gdbarch, dbx_link_bpt) != 0)
warning (_("Unable to remove __dbx_link breakpoint.")); warning (_("Unable to remove __dbx_link breakpoint."));
dbx_link_bpt_addr = 0; dbx_link_bpt_addr = 0;
@ -5664,7 +5664,8 @@ insert_dbx_link_bpt_in_file (int fd, CORE_ADDR ignored)
{ {
/* Insert the breakpoint. */ /* Insert the breakpoint. */
dbx_link_bpt_addr = sym_addr; dbx_link_bpt_addr = sym_addr;
dbx_link_bpt = deprecated_insert_raw_breakpoint (sym_addr); dbx_link_bpt = deprecated_insert_raw_breakpoint (target_gdbarch,
sym_addr);
if (dbx_link_bpt == NULL) if (dbx_link_bpt == NULL)
{ {
warning (_("Failed to insert dbx_link breakpoint.")); warning (_("Failed to insert dbx_link breakpoint."));

16
gdb/record.c
View file

@ -112,8 +112,10 @@ static LONGEST (*record_beneath_to_xfer_partial) (struct target_ops *ops,
const gdb_byte *writebuf, const gdb_byte *writebuf,
ULONGEST offset, ULONGEST offset,
LONGEST len); LONGEST len);
static int (*record_beneath_to_insert_breakpoint) (struct bp_target_info *); static int (*record_beneath_to_insert_breakpoint) (struct gdbarch *,
static int (*record_beneath_to_remove_breakpoint) (struct bp_target_info *); struct bp_target_info *);
static int (*record_beneath_to_remove_breakpoint) (struct gdbarch *,
struct bp_target_info *);
static void static void
record_list_release (struct record_entry *rec) record_list_release (struct record_entry *rec)
@ -1046,12 +1048,13 @@ record_xfer_partial (struct target_ops *ops, enum target_object object,
nor when recording. */ nor when recording. */
static int static int
record_insert_breakpoint (struct bp_target_info *bp_tgt) record_insert_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
if (!RECORD_IS_REPLAY) if (!RECORD_IS_REPLAY)
{ {
struct cleanup *old_cleanups = record_gdb_operation_disable_set (); struct cleanup *old_cleanups = record_gdb_operation_disable_set ();
int ret = record_beneath_to_insert_breakpoint (bp_tgt); int ret = record_beneath_to_insert_breakpoint (gdbarch, bp_tgt);
do_cleanups (old_cleanups); do_cleanups (old_cleanups);
@ -1062,12 +1065,13 @@ record_insert_breakpoint (struct bp_target_info *bp_tgt)
} }
static int static int
record_remove_breakpoint (struct bp_target_info *bp_tgt) record_remove_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
if (!RECORD_IS_REPLAY) if (!RECORD_IS_REPLAY)
{ {
struct cleanup *old_cleanups = record_gdb_operation_disable_set (); struct cleanup *old_cleanups = record_gdb_operation_disable_set ();
int ret = record_beneath_to_remove_breakpoint (bp_tgt); int ret = record_beneath_to_remove_breakpoint (gdbarch, bp_tgt);
do_cleanups (old_cleanups); do_cleanups (old_cleanups);

6
gdb/remote-m32r-sdi.c
View file

@ -1140,7 +1140,8 @@ m32r_mourn_inferior (struct target_ops *ops)
} }
static int static int
m32r_insert_breakpoint (struct bp_target_info *bp_tgt) m32r_insert_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
CORE_ADDR addr = bp_tgt->placed_address; CORE_ADDR addr = bp_tgt->placed_address;
int ib_breakpoints; int ib_breakpoints;
@ -1183,7 +1184,8 @@ m32r_insert_breakpoint (struct bp_target_info *bp_tgt)
} }
static int static int
m32r_remove_breakpoint (struct bp_target_info *bp_tgt) m32r_remove_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
CORE_ADDR addr = bp_tgt->placed_address; CORE_ADDR addr = bp_tgt->placed_address;
int i; int i;

10
gdb/remote-mips.c
View file

@ -2228,23 +2228,25 @@ mips_mourn_inferior (struct target_ops *ops)
target contents. */ target contents. */
static int static int
mips_insert_breakpoint (struct bp_target_info *bp_tgt) mips_insert_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
if (monitor_supports_breakpoints) if (monitor_supports_breakpoints)
return mips_set_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE, return mips_set_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE,
BREAK_FETCH); BREAK_FETCH);
else else
return memory_insert_breakpoint (bp_tgt); return memory_insert_breakpoint (gdbarch, bp_tgt);
} }
static int static int
mips_remove_breakpoint (struct bp_target_info *bp_tgt) mips_remove_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
if (monitor_supports_breakpoints) if (monitor_supports_breakpoints)
return mips_clear_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE, return mips_clear_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE,
BREAK_FETCH); BREAK_FETCH);
else else
return memory_remove_breakpoint (bp_tgt); return memory_remove_breakpoint (gdbarch, bp_tgt);
} }
/* Tell whether this target can support a hardware breakpoint. CNT /* Tell whether this target can support a hardware breakpoint. CNT

20
gdb/remote.c
View file

@ -6792,7 +6792,8 @@ extended_remote_create_inferior (struct target_ops *ops,
which don't, we insert a traditional memory breakpoint. */ which don't, we insert a traditional memory breakpoint. */
static int static int
remote_insert_breakpoint (struct bp_target_info *bp_tgt) remote_insert_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
/* Try the "Z" s/w breakpoint packet if it is not already disabled. /* Try the "Z" s/w breakpoint packet if it is not already disabled.
If it succeeds, then set the support to PACKET_ENABLE. If it If it succeeds, then set the support to PACKET_ENABLE. If it
@ -6806,7 +6807,7 @@ remote_insert_breakpoint (struct bp_target_info *bp_tgt)
char *p; char *p;
int bpsize; int bpsize;
gdbarch_breakpoint_from_pc (target_gdbarch, &addr, &bpsize); gdbarch_breakpoint_from_pc (gdbarch, &addr, &bpsize);
rs = get_remote_state (); rs = get_remote_state ();
p = rs->buf; p = rs->buf;
@ -6834,11 +6835,12 @@ remote_insert_breakpoint (struct bp_target_info *bp_tgt)
} }
} }
return memory_insert_breakpoint (bp_tgt); return memory_insert_breakpoint (gdbarch, bp_tgt);
} }
static int static int
remote_remove_breakpoint (struct bp_target_info *bp_tgt) remote_remove_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
CORE_ADDR addr = bp_tgt->placed_address; CORE_ADDR addr = bp_tgt->placed_address;
struct remote_state *rs = get_remote_state (); struct remote_state *rs = get_remote_state ();
@ -6862,7 +6864,7 @@ remote_remove_breakpoint (struct bp_target_info *bp_tgt)
return (rs->buf[0] == 'E'); return (rs->buf[0] == 'E');
} }
return memory_remove_breakpoint (bp_tgt); return memory_remove_breakpoint (gdbarch, bp_tgt);
} }
static int static int
@ -6998,7 +7000,8 @@ remote_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
static int static int
remote_insert_hw_breakpoint (struct bp_target_info *bp_tgt) remote_insert_hw_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
CORE_ADDR addr; CORE_ADDR addr;
struct remote_state *rs; struct remote_state *rs;
@ -7008,7 +7011,7 @@ remote_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
instruction, even though we aren't inserting one ourselves. */ instruction, even though we aren't inserting one ourselves. */
gdbarch_breakpoint_from_pc gdbarch_breakpoint_from_pc
(target_gdbarch, &bp_tgt->placed_address, &bp_tgt->placed_size); (gdbarch, &bp_tgt->placed_address, &bp_tgt->placed_size);
if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE) if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
return -1; return -1;
@ -7041,7 +7044,8 @@ remote_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
static int static int
remote_remove_hw_breakpoint (struct bp_target_info *bp_tgt) remote_remove_hw_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
CORE_ADDR addr; CORE_ADDR addr;
struct remote_state *rs = get_remote_state (); struct remote_state *rs = get_remote_state ();

3
gdb/rs6000-aix-tdep.c
View file

@ -663,6 +663,7 @@ branch_dest (struct frame_info *frame, int opcode, int instr,
static int static int
rs6000_software_single_step (struct frame_info *frame) rs6000_software_single_step (struct frame_info *frame)
{ {
struct gdbarch *gdbarch = get_frame_arch (frame);
int ii, insn; int ii, insn;
CORE_ADDR loc; CORE_ADDR loc;
CORE_ADDR breaks[2]; CORE_ADDR breaks[2];
@ -688,7 +689,7 @@ rs6000_software_single_step (struct frame_info *frame)
/* ignore invalid breakpoint. */ /* ignore invalid breakpoint. */
if (breaks[ii] == -1) if (breaks[ii] == -1)
continue; continue;
insert_single_step_breakpoint (breaks[ii]); insert_single_step_breakpoint (gdbarch, breaks[ii]);
} }
errno = 0; /* FIXME, don't ignore errors! */ errno = 0; /* FIXME, don't ignore errors! */

5
gdb/rs6000-nat.c
View file

@ -581,6 +581,7 @@ exec_one_dummy_insn (struct regcache *regcache)
{ {
#define DUMMY_INSN_ADDR AIX_TEXT_SEGMENT_BASE+0x200 #define DUMMY_INSN_ADDR AIX_TEXT_SEGMENT_BASE+0x200
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int ret, status, pid; int ret, status, pid;
CORE_ADDR prev_pc; CORE_ADDR prev_pc;
void *bp; void *bp;
@ -589,7 +590,7 @@ exec_one_dummy_insn (struct regcache *regcache)
assume that this address will never be executed again by the real assume that this address will never be executed again by the real
code. */ code. */
bp = deprecated_insert_raw_breakpoint (DUMMY_INSN_ADDR); bp = deprecated_insert_raw_breakpoint (gdbarch, DUMMY_INSN_ADDR);
/* You might think this could be done with a single ptrace call, and /* You might think this could be done with a single ptrace call, and
you'd be correct for just about every platform I've ever worked you'd be correct for just about every platform I've ever worked
@ -613,7 +614,7 @@ exec_one_dummy_insn (struct regcache *regcache)
while (pid != PIDGET (inferior_ptid)); while (pid != PIDGET (inferior_ptid));
regcache_write_pc (regcache, prev_pc); regcache_write_pc (regcache, prev_pc);
deprecated_remove_raw_breakpoint (bp); deprecated_remove_raw_breakpoint (gdbarch, bp);
} }

3
gdb/rs6000-tdep.c
View file

@ -1071,6 +1071,7 @@ ppc_displaced_step_fixup (struct gdbarch *gdbarch,
int int
ppc_deal_with_atomic_sequence (struct frame_info *frame) ppc_deal_with_atomic_sequence (struct frame_info *frame)
{ {
struct gdbarch *gdbarch = get_frame_arch (frame);
CORE_ADDR pc = get_frame_pc (frame); CORE_ADDR pc = get_frame_pc (frame);
CORE_ADDR breaks[2] = {-1, -1}; CORE_ADDR breaks[2] = {-1, -1};
CORE_ADDR loc = pc; CORE_ADDR loc = pc;
@ -1143,7 +1144,7 @@ ppc_deal_with_atomic_sequence (struct frame_info *frame)
/* Effectively inserts the breakpoints. */ /* Effectively inserts the breakpoints. */
for (index = 0; index <= last_breakpoint; index++) for (index = 0; index <= last_breakpoint; index++)
insert_single_step_breakpoint (breaks[index]); insert_single_step_breakpoint (gdbarch, breaks[index]);
return 1; return 1;
} }

2
gdb/solib-darwin.c
View file

@ -360,7 +360,7 @@ darwin_solib_create_inferior_hook (void)
darwin_load_image_infos (); darwin_load_image_infos ();
if (dyld_all_image.version == DYLD_VERSION) if (dyld_all_image.version == DYLD_VERSION)
create_solib_event_breakpoint (dyld_all_image.notifier); create_solib_event_breakpoint (target_gdbarch, dyld_all_image.notifier);
} }
static void static void

5
gdb/solib-frv.c
View file

@ -788,7 +788,7 @@ enable_break2 (void)
xfree (ldm); xfree (ldm);
/* Now (finally!) create the solib breakpoint. */ /* Now (finally!) create the solib breakpoint. */
create_solib_event_breakpoint (addr); create_solib_event_breakpoint (target_gdbarch, addr);
return 1; return 1;
} }
@ -817,7 +817,8 @@ enable_break (void)
if (interp_sect) if (interp_sect)
{ {
enable_break1_done = 1; enable_break1_done = 1;
create_solib_event_breakpoint (symfile_objfile->ei.entry_point); create_solib_event_breakpoint (target_gdbarch,
symfile_objfile->ei.entry_point);
if (solib_frv_debug) if (solib_frv_debug)
fprintf_unfiltered (gdb_stdlog, fprintf_unfiltered (gdb_stdlog,

5
gdb/solib-irix.c
View file

@ -320,7 +320,7 @@ disable_break (void)
/* Note that breakpoint address and original contents are in our address /* Note that breakpoint address and original contents are in our address
space, so we just need to write the original contents back. */ space, so we just need to write the original contents back. */
if (deprecated_remove_raw_breakpoint (base_breakpoint) != 0) if (deprecated_remove_raw_breakpoint (target_gdbarch, base_breakpoint) != 0)
{ {
status = 0; status = 0;
} }
@ -358,7 +358,8 @@ enable_break (void)
if (symfile_objfile != NULL) if (symfile_objfile != NULL)
{ {
base_breakpoint base_breakpoint
= deprecated_insert_raw_breakpoint (entry_point_address ()); = deprecated_insert_raw_breakpoint (target_gdbarch,
entry_point_address ());
if (base_breakpoint != NULL) if (base_breakpoint != NULL)
return 1; return 1;

2
gdb/solib-pa64.c
View file

@ -428,7 +428,7 @@ pa64_solib_create_inferior_hook (void)
/* Create the shared library breakpoint. */ /* Create the shared library breakpoint. */
{ {
struct breakpoint *b struct breakpoint *b
= create_solib_event_breakpoint (sym_addr); = create_solib_event_breakpoint (target_gdbarch, sym_addr);
/* The breakpoint is actually hard-coded into the dynamic linker, /* The breakpoint is actually hard-coded into the dynamic linker,
so we don't need to actually insert a breakpoint instruction so we don't need to actually insert a breakpoint instruction

5
gdb/solib-som.c
View file

@ -290,7 +290,8 @@ Suggest linking with /opt/langtools/lib/end.o.\n\
GDB will be unable to track shl_load/shl_unload calls")); GDB will be unable to track shl_load/shl_unload calls"));
goto keep_going; goto keep_going;
} }
create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol)); create_solib_event_breakpoint (target_gdbarch,
SYMBOL_VALUE_ADDRESS (msymbol));
/* We have all the support usually found in end.o, so we can track /* We have all the support usually found in end.o, so we can track
shl_load and shl_unload calls. */ shl_load and shl_unload calls. */
@ -353,7 +354,7 @@ keep_going:
anaddr = SYMBOL_VALUE_ADDRESS (msymbol); anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
/* Make the breakpoint at "_start" a shared library event breakpoint. */ /* Make the breakpoint at "_start" a shared library event breakpoint. */
create_solib_event_breakpoint (anaddr); create_solib_event_breakpoint (target_gdbarch, anaddr);
clear_symtab_users (); clear_symtab_users ();
} }

10
gdb/solib-svr4.c
View file

@ -1309,7 +1309,7 @@ enable_break (struct svr4_info *info)
interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect); interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
} }
create_solib_event_breakpoint (sym_addr); create_solib_event_breakpoint (target_gdbarch, sym_addr);
return 1; return 1;
} }
} }
@ -1435,7 +1435,7 @@ enable_break (struct svr4_info *info)
if (sym_addr != 0) if (sym_addr != 0)
{ {
create_solib_event_breakpoint (load_addr + sym_addr); create_solib_event_breakpoint (target_gdbarch, load_addr + sym_addr);
xfree (interp_name); xfree (interp_name);
return 1; return 1;
} }
@ -1457,7 +1457,8 @@ enable_break (struct svr4_info *info)
msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile); msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0)) if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
{ {
create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol)); create_solib_event_breakpoint (target_gdbarch,
SYMBOL_VALUE_ADDRESS (msymbol));
return 1; return 1;
} }
} }
@ -1467,7 +1468,8 @@ enable_break (struct svr4_info *info)
msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile); msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0)) if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
{ {
create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol)); create_solib_event_breakpoint (target_gdbarch,
SYMBOL_VALUE_ADDRESS (msymbol));
return 1; return 1;
} }
} }

4
gdb/sparc-tdep.c
View file

@ -1314,10 +1314,10 @@ sparc_software_single_step (struct frame_info *frame)
/* Analyze the instruction at PC. */ /* Analyze the instruction at PC. */
nnpc = sparc_analyze_control_transfer (frame, pc, &npc); nnpc = sparc_analyze_control_transfer (frame, pc, &npc);
if (npc != 0) if (npc != 0)
insert_single_step_breakpoint (npc); insert_single_step_breakpoint (arch, npc);
if (nnpc != 0) if (nnpc != 0)
insert_single_step_breakpoint (nnpc); insert_single_step_breakpoint (arch, nnpc);
/* Assert that we have set at least one breakpoint, and that /* Assert that we have set at least one breakpoint, and that
they're not set at the same spot - unless we're going they're not set at the same spot - unless we're going

5
gdb/spu-tdep.c
View file

@ -1288,6 +1288,7 @@ spu_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR * pcptr, int *lenptr)
static int static int
spu_software_single_step (struct frame_info *frame) spu_software_single_step (struct frame_info *frame)
{ {
struct gdbarch *gdbarch = get_frame_arch (frame);
CORE_ADDR pc, next_pc; CORE_ADDR pc, next_pc;
unsigned int insn; unsigned int insn;
int offset, reg; int offset, reg;
@ -1307,7 +1308,7 @@ spu_software_single_step (struct frame_info *frame)
else else
next_pc = (pc + 4) & (SPU_LS_SIZE - 1); next_pc = (pc + 4) & (SPU_LS_SIZE - 1);
insert_single_step_breakpoint (next_pc); insert_single_step_breakpoint (gdbarch, next_pc);
if (is_branch (insn, &offset, &reg)) if (is_branch (insn, &offset, &reg))
{ {
@ -1323,7 +1324,7 @@ spu_software_single_step (struct frame_info *frame)
target = target & (SPU_LS_SIZE - 1); target = target & (SPU_LS_SIZE - 1);
if (target != next_pc) if (target != next_pc)
insert_single_step_breakpoint (target); insert_single_step_breakpoint (gdbarch, target);
} }
return 1; return 1;

36
gdb/target.c
View file

@ -106,15 +106,19 @@ static void debug_to_prepare_to_store (struct regcache *);
static void debug_to_files_info (struct target_ops *); static void debug_to_files_info (struct target_ops *);
static int debug_to_insert_breakpoint (struct bp_target_info *); static int debug_to_insert_breakpoint (struct gdbarch *,
struct bp_target_info *);
static int debug_to_remove_breakpoint (struct bp_target_info *); static int debug_to_remove_breakpoint (struct gdbarch *,
struct bp_target_info *);
static int debug_to_can_use_hw_breakpoint (int, int, int); static int debug_to_can_use_hw_breakpoint (int, int, int);
static int debug_to_insert_hw_breakpoint (struct bp_target_info *); static int debug_to_insert_hw_breakpoint (struct gdbarch *,
struct bp_target_info *);
static int debug_to_remove_hw_breakpoint (struct bp_target_info *); static int debug_to_remove_hw_breakpoint (struct gdbarch *,
struct bp_target_info *);
static int debug_to_insert_watchpoint (CORE_ADDR, int, int); static int debug_to_insert_watchpoint (CORE_ADDR, int, int);
@ -679,10 +683,10 @@ update_current_target (void)
(int (*) (int, int, int)) (int (*) (int, int, int))
return_zero); return_zero);
de_fault (to_insert_hw_breakpoint, de_fault (to_insert_hw_breakpoint,
(int (*) (struct bp_target_info *)) (int (*) (struct gdbarch *, struct bp_target_info *))
return_minus_one); return_minus_one);
de_fault (to_remove_hw_breakpoint, de_fault (to_remove_hw_breakpoint,
(int (*) (struct bp_target_info *)) (int (*) (struct gdbarch *, struct bp_target_info *))
return_minus_one); return_minus_one);
de_fault (to_insert_watchpoint, de_fault (to_insert_watchpoint,
(int (*) (CORE_ADDR, int, int)) (int (*) (CORE_ADDR, int, int))
@ -2905,11 +2909,12 @@ debug_to_files_info (struct target_ops *target)
} }
static int static int
debug_to_insert_breakpoint (struct bp_target_info *bp_tgt) debug_to_insert_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
int retval; int retval;
retval = debug_target.to_insert_breakpoint (bp_tgt); retval = debug_target.to_insert_breakpoint (gdbarch, bp_tgt);
fprintf_unfiltered (gdb_stdlog, fprintf_unfiltered (gdb_stdlog,
"target_insert_breakpoint (0x%lx, xxx) = %ld\n", "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
@ -2919,11 +2924,12 @@ debug_to_insert_breakpoint (struct bp_target_info *bp_tgt)
} }
static int static int
debug_to_remove_breakpoint (struct bp_target_info *bp_tgt) debug_to_remove_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
int retval; int retval;
retval = debug_target.to_remove_breakpoint (bp_tgt); retval = debug_target.to_remove_breakpoint (gdbarch, bp_tgt);
fprintf_unfiltered (gdb_stdlog, fprintf_unfiltered (gdb_stdlog,
"target_remove_breakpoint (0x%lx, xxx) = %ld\n", "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
@ -3008,11 +3014,12 @@ debug_to_watchpoint_addr_within_range (struct target_ops *target,
} }
static int static int
debug_to_insert_hw_breakpoint (struct bp_target_info *bp_tgt) debug_to_insert_hw_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
int retval; int retval;
retval = debug_target.to_insert_hw_breakpoint (bp_tgt); retval = debug_target.to_insert_hw_breakpoint (gdbarch, bp_tgt);
fprintf_unfiltered (gdb_stdlog, fprintf_unfiltered (gdb_stdlog,
"target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n", "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
@ -3022,11 +3029,12 @@ debug_to_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
} }
static int static int
debug_to_remove_hw_breakpoint (struct bp_target_info *bp_tgt) debug_to_remove_hw_breakpoint (struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{ {
int retval; int retval;
retval = debug_target.to_remove_hw_breakpoint (bp_tgt); retval = debug_target.to_remove_hw_breakpoint (gdbarch, bp_tgt);
fprintf_unfiltered (gdb_stdlog, fprintf_unfiltered (gdb_stdlog,
"target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n", "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",

28
gdb/target.h
View file

@ -367,11 +367,11 @@ struct target_ops
struct target_ops *target); struct target_ops *target);
void (*to_files_info) (struct target_ops *); void (*to_files_info) (struct target_ops *);
int (*to_insert_breakpoint) (struct bp_target_info *); int (*to_insert_breakpoint) (struct gdbarch *, struct bp_target_info *);
int (*to_remove_breakpoint) (struct bp_target_info *); int (*to_remove_breakpoint) (struct gdbarch *, struct bp_target_info *);
int (*to_can_use_hw_breakpoint) (int, int, int); int (*to_can_use_hw_breakpoint) (int, int, int);
int (*to_insert_hw_breakpoint) (struct bp_target_info *); int (*to_insert_hw_breakpoint) (struct gdbarch *, struct bp_target_info *);
int (*to_remove_hw_breakpoint) (struct bp_target_info *); int (*to_remove_hw_breakpoint) (struct gdbarch *, struct bp_target_info *);
int (*to_remove_watchpoint) (CORE_ADDR, int, int); int (*to_remove_watchpoint) (CORE_ADDR, int, int);
int (*to_insert_watchpoint) (CORE_ADDR, int, int); int (*to_insert_watchpoint) (CORE_ADDR, int, int);
int (*to_stopped_by_watchpoint) (void); int (*to_stopped_by_watchpoint) (void);
@ -739,14 +739,14 @@ extern int inferior_has_execd (ptid_t pid, char **execd_pathname);
/* Insert a breakpoint at address BP_TGT->placed_address in the target /* Insert a breakpoint at address BP_TGT->placed_address in the target
machine. Result is 0 for success, or an errno value. */ machine. Result is 0 for success, or an errno value. */
#define target_insert_breakpoint(bp_tgt) \ #define target_insert_breakpoint(gdbarch, bp_tgt) \
(*current_target.to_insert_breakpoint) (bp_tgt) (*current_target.to_insert_breakpoint) (gdbarch, bp_tgt)
/* Remove a breakpoint at address BP_TGT->placed_address in the target /* Remove a breakpoint at address BP_TGT->placed_address in the target
machine. Result is 0 for success, or an errno value. */ machine. Result is 0 for success, or an errno value. */
#define target_remove_breakpoint(bp_tgt) \ #define target_remove_breakpoint(gdbarch, bp_tgt) \
(*current_target.to_remove_breakpoint) (bp_tgt) (*current_target.to_remove_breakpoint) (gdbarch, bp_tgt)
/* Initialize the terminal settings we record for the inferior, /* Initialize the terminal settings we record for the inferior,
before we actually run the inferior. */ before we actually run the inferior. */
@ -1109,11 +1109,11 @@ extern char *normal_pid_to_str (ptid_t ptid);
#define target_remove_watchpoint(addr, len, type) \ #define target_remove_watchpoint(addr, len, type) \
(*current_target.to_remove_watchpoint) (addr, len, type) (*current_target.to_remove_watchpoint) (addr, len, type)
#define target_insert_hw_breakpoint(bp_tgt) \ #define target_insert_hw_breakpoint(gdbarch, bp_tgt) \
(*current_target.to_insert_hw_breakpoint) (bp_tgt) (*current_target.to_insert_hw_breakpoint) (gdbarch, bp_tgt)
#define target_remove_hw_breakpoint(bp_tgt) \ #define target_remove_hw_breakpoint(gdbarch, bp_tgt) \
(*current_target.to_remove_hw_breakpoint) (bp_tgt) (*current_target.to_remove_hw_breakpoint) (gdbarch, bp_tgt)
#define target_stopped_data_address(target, x) \ #define target_stopped_data_address(target, x) \
(*target.to_stopped_data_address) (target, x) (*target.to_stopped_data_address) (target, x)
@ -1229,9 +1229,9 @@ extern struct target_section_table *target_get_section_table
/* From mem-break.c */ /* From mem-break.c */
extern int memory_remove_breakpoint (struct bp_target_info *); extern int memory_remove_breakpoint (struct gdbarch *, struct bp_target_info *);
extern int memory_insert_breakpoint (struct bp_target_info *); extern int memory_insert_breakpoint (struct gdbarch *, struct bp_target_info *);
extern int default_memory_remove_breakpoint (struct gdbarch *, struct bp_target_info *); extern int default_memory_remove_breakpoint (struct gdbarch *, struct bp_target_info *);

21
gdb/tracepoint.c
View file

@ -722,6 +722,7 @@ add_memrange (struct collection_list *memranges,
static void static void
collect_symbol (struct collection_list *collect, collect_symbol (struct collection_list *collect,
struct symbol *sym, struct symbol *sym,
struct gdbarch *gdbarch,
long frame_regno, long frame_offset) long frame_regno, long frame_offset)
{ {
unsigned long len; unsigned long len;
@ -754,7 +755,7 @@ collect_symbol (struct collection_list *collect,
add_memrange (collect, memrange_absolute, offset, len); add_memrange (collect, memrange_absolute, offset, len);
break; break;
case LOC_REGISTER: case LOC_REGISTER:
reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, current_gdbarch); reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
if (info_verbose) if (info_verbose)
printf_filtered ("LOC_REG[parm] %s: ", printf_filtered ("LOC_REG[parm] %s: ",
SYMBOL_PRINT_NAME (sym)); SYMBOL_PRINT_NAME (sym));
@ -762,7 +763,7 @@ collect_symbol (struct collection_list *collect,
/* Check for doubles stored in two registers. */ /* Check for doubles stored in two registers. */
/* FIXME: how about larger types stored in 3 or more regs? */ /* FIXME: how about larger types stored in 3 or more regs? */
if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT && if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
len > register_size (current_gdbarch, reg)) len > register_size (gdbarch, reg))
add_register (collect, reg + 1); add_register (collect, reg + 1);
break; break;
case LOC_REF_ARG: case LOC_REF_ARG:
@ -819,7 +820,8 @@ collect_symbol (struct collection_list *collect,
/* Add all locals (or args) symbols to collection list */ /* Add all locals (or args) symbols to collection list */
static void static void
add_local_symbols (struct collection_list *collect, CORE_ADDR pc, add_local_symbols (struct collection_list *collect,
struct gdbarch *gdbarch, CORE_ADDR pc,
long frame_regno, long frame_offset, int type) long frame_regno, long frame_offset, int type)
{ {
struct symbol *sym; struct symbol *sym;
@ -838,8 +840,8 @@ add_local_symbols (struct collection_list *collect, CORE_ADDR pc,
: type == 'L') /* collecting Locals */ : type == 'L') /* collecting Locals */
{ {
count++; count++;
collect_symbol (collect, sym, frame_regno, collect_symbol (collect, sym, gdbarch,
frame_offset); frame_regno, frame_offset);
} }
} }
if (BLOCK_FUNCTION (block)) if (BLOCK_FUNCTION (block))
@ -1025,7 +1027,7 @@ encode_actions (struct breakpoint *t, char ***tdp_actions,
*tdp_actions = NULL; *tdp_actions = NULL;
*stepping_actions = NULL; *stepping_actions = NULL;
gdbarch_virtual_frame_pointer (current_gdbarch, gdbarch_virtual_frame_pointer (t->gdbarch,
t->loc->address, &frame_reg, &frame_offset); t->loc->address, &frame_reg, &frame_offset);
for (action = t->actions; action; action = action->next) for (action = t->actions; action; action = action->next)
@ -1052,13 +1054,14 @@ encode_actions (struct breakpoint *t, char ***tdp_actions,
if (0 == strncasecmp ("$reg", action_exp, 4)) if (0 == strncasecmp ("$reg", action_exp, 4))
{ {
for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++) for (i = 0; i < gdbarch_num_regs (t->gdbarch); i++)
add_register (collect, i); add_register (collect, i);
action_exp = strchr (action_exp, ','); /* more? */ action_exp = strchr (action_exp, ','); /* more? */
} }
else if (0 == strncasecmp ("$arg", action_exp, 4)) else if (0 == strncasecmp ("$arg", action_exp, 4))
{ {
add_local_symbols (collect, add_local_symbols (collect,
t->gdbarch,
t->loc->address, t->loc->address,
frame_reg, frame_reg,
frame_offset, frame_offset,
@ -1068,6 +1071,7 @@ encode_actions (struct breakpoint *t, char ***tdp_actions,
else if (0 == strncasecmp ("$loc", action_exp, 4)) else if (0 == strncasecmp ("$loc", action_exp, 4))
{ {
add_local_symbols (collect, add_local_symbols (collect,
t->gdbarch,
t->loc->address, t->loc->address,
frame_reg, frame_reg,
frame_offset, frame_offset,
@ -1091,7 +1095,7 @@ encode_actions (struct breakpoint *t, char ***tdp_actions,
{ {
const char *name = &exp->elts[2].string; const char *name = &exp->elts[2].string;
i = user_reg_map_name_to_regnum (current_gdbarch, i = user_reg_map_name_to_regnum (t->gdbarch,
name, strlen (name)); name, strlen (name));
if (i == -1) if (i == -1)
internal_error (__FILE__, __LINE__, internal_error (__FILE__, __LINE__,
@ -1114,6 +1118,7 @@ encode_actions (struct breakpoint *t, char ***tdp_actions,
case OP_VAR_VALUE: case OP_VAR_VALUE:
collect_symbol (collect, collect_symbol (collect,
exp->elts[2].symbol, exp->elts[2].symbol,
t->gdbarch,
frame_reg, frame_reg,
frame_offset); frame_offset);
break; break;