X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fmem-break.c;h=a251aa4337251c45687cba366b06fbc42b4082b5;hb=9d95b8e9d631e76eb152c86003db6b89e913bdd9;hp=96750c8b8f6876e4ca8315f184e14bed5f2c7db1;hpb=aaab4dba8639bf42d0f6d79ca33dd6867e212fed;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/mem-break.c b/gdb/mem-break.c index 96750c8b8f..a251aa4337 100644 --- a/gdb/mem-break.c +++ b/gdb/mem-break.c @@ -1,7 +1,6 @@ /* Simulate breakpoints by patching locations in the target system, for GDB. - Copyright 1990, 1991, 1992, 1993, 1995, 1997, 1998, 1999, 2000, - 2002 Free Software Foundation, Inc. + Copyright (C) 1990-2020 Free Software Foundation, Inc. Contributed by Cygnus Support. Written by John Gilmore. @@ -9,7 +8,7 @@ This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -18,75 +17,113 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + along with this program. If not, see . */ #include "defs.h" - -/* This file is only useful if BREAKPOINT_FROM_PC is set. If not, we - punt. */ - #include "symtab.h" #include "breakpoint.h" #include "inferior.h" #include "target.h" +#include "gdbarch.h" - -/* Insert a breakpoint on targets that don't have any better breakpoint - support. We read the contents of the target location and stash it, - then overwrite it with a breakpoint instruction. ADDR is the target - location in the target machine. CONTENTS_CACHE is a pointer to - memory allocated for saving the target contents. It is guaranteed - by the caller to be long enough to save BREAKPOINT_LEN bytes (this - is accomplished via BREAKPOINT_MAX). */ +/* Insert a breakpoint on targets that don't have any better + breakpoint support. We read the contents of the target location + and stash it, then overwrite it with a breakpoint instruction. + BP_TGT->placed_address is the target location in the target + machine. BP_TGT->shadow_contents is some memory allocated for + saving the target contents. It is guaranteed by the caller to be + long enough to save BREAKPOINT_LEN bytes (this is accomplished via + BREAKPOINT_MAX). */ int -default_memory_insert_breakpoint (CORE_ADDR addr, char *contents_cache) +default_memory_insert_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) { - int val; + CORE_ADDR addr = bp_tgt->placed_address; const unsigned char *bp; + gdb_byte *readbuf; int bplen; + int val; /* Determine appropriate breakpoint contents and size for this address. */ - bp = BREAKPOINT_FROM_PC (&addr, &bplen); - if (bp == NULL) - error ("Software breakpoints not implemented for this target."); + bp = gdbarch_sw_breakpoint_from_kind (gdbarch, bp_tgt->kind, &bplen); - /* Save the memory contents. */ - val = target_read_memory (addr, contents_cache, bplen); - - /* Write the breakpoint. */ + /* Save the memory contents in the shadow_contents buffer and then + write the breakpoint instruction. */ + readbuf = (gdb_byte *) alloca (bplen); + val = target_read_memory (addr, readbuf, bplen); if (val == 0) - val = target_write_memory (addr, (char *) bp, bplen); + { + /* These must be set together, either before or after the shadow + read, so that if we're "reinserting" a breakpoint that + doesn't have a shadow yet, the breakpoint masking code inside + target_read_memory doesn't mask out this breakpoint using an + unfilled shadow buffer. The core may be trying to reinsert a + permanent breakpoint, for targets that support breakpoint + conditions/commands on the target side for some types of + breakpoints, such as target remote. */ + bp_tgt->shadow_len = bplen; + memcpy (bp_tgt->shadow_contents, readbuf, bplen); + + val = target_write_raw_memory (addr, bp, bplen); + } return val; } int -default_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache) +default_memory_remove_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) { - const unsigned char *bp; int bplen; - /* Determine appropriate breakpoint contents and size for this address. */ - bp = BREAKPOINT_FROM_PC (&addr, &bplen); - if (bp == NULL) - error ("Software breakpoints not implemented for this target."); + gdbarch_sw_breakpoint_from_kind (gdbarch, bp_tgt->kind, &bplen); - return target_write_memory (addr, contents_cache, bplen); + return target_write_raw_memory (bp_tgt->placed_address, bp_tgt->shadow_contents, + bplen); } int -memory_insert_breakpoint (CORE_ADDR addr, char *contents_cache) +memory_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) { - return MEMORY_INSERT_BREAKPOINT(addr, contents_cache); + return gdbarch_memory_insert_breakpoint (gdbarch, bp_tgt); } int -memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache) +memory_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt, + enum remove_bp_reason reason) { - return MEMORY_REMOVE_BREAKPOINT(addr, contents_cache); + return gdbarch_memory_remove_breakpoint (gdbarch, bp_tgt); +} + +int +memory_validate_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) +{ + CORE_ADDR addr = bp_tgt->placed_address; + const gdb_byte *bp; + int val; + int bplen; + gdb_byte cur_contents[BREAKPOINT_MAX]; + + /* Determine appropriate breakpoint contents and size for this + address. */ + bp = gdbarch_breakpoint_from_pc (gdbarch, &addr, &bplen); + + if (bp == NULL) + return 0; + + /* Make sure we see the memory breakpoints. */ + scoped_restore restore_memory + = make_scoped_restore_show_memory_breakpoints (1); + val = target_read_memory (addr, cur_contents, bplen); + + /* If our breakpoint is no longer at the address, this means that + the program modified the code on us, so it is wrong to put back + the old value. */ + return (val == 0 && memcmp (bp, cur_contents, bplen) == 0); }