#define MAX_BREAKPOINT_LEN 8
+/* GDB will never try to install multiple breakpoints at the same
+ address. But, we need to keep track of internal breakpoints too,
+ and so we do need to be able to install multiple breakpoints at the
+ same address transparently. We keep track of two different, and
+ closely related structures. A raw breakpoint, which manages the
+ low level, close to the metal aspect of a breakpoint. It holds the
+ breakpoint address, and a buffer holding a copy of the instructions
+ that would be in memory had not been a breakpoint there (we call
+ that the shadow memory of the breakpoint). We occasionally need to
+ temporarilly uninsert a breakpoint without the client knowing about
+ it (e.g., to step over an internal breakpoint), so we keep an
+ `inserted' state associated with this low level breakpoint
+ structure. There can only be one such object for a given address.
+ Then, we have (a bit higher level) breakpoints. This structure
+ holds a callback to be called whenever a breakpoint is hit, a
+ high-level type, and a link to a low level raw breakpoint. There
+ can be many high-level breakpoints at the same address, and all of
+ them will point to the same raw breakpoint, which is reference
+ counted. */
+
+/* The low level, physical, raw breakpoint. */
+struct raw_breakpoint
+{
+ struct raw_breakpoint *next;
+
+ /* A reference count. Each high level breakpoint referencing this
+ raw breakpoint accounts for one reference. */
+ int refcount;
+
+ /* The breakpoint's insertion address. There can only be one raw
+ breakpoint for a given PC. */
+ CORE_ADDR pc;
+
+ /* The breakpoint's shadow memory. */
+ unsigned char old_data[MAX_BREAKPOINT_LEN];
+
+ /* Non-zero if this breakpoint is currently inserted in the
+ inferior. */
+ int inserted;
+};
+
/* The type of a breakpoint. */
enum bkpt_type
{
+ /* A GDB breakpoint, requested with a Z0 packet. */
+ gdb_breakpoint,
+
/* A basic-software-single-step breakpoint. */
reinsert_breakpoint,
other_breakpoint,
};
+/* A high level (in gdbserver's perspective) breakpoint. */
struct breakpoint
{
struct breakpoint *next;
- CORE_ADDR pc;
- unsigned char old_data[MAX_BREAKPOINT_LEN];
-
- /* Non-zero if this breakpoint is currently inserted in the
- inferior. */
- int inserted;
/* The breakpoint's type. */
enum bkpt_type type;
+ /* Link to this breakpoint's raw breakpoint. This is always
+ non-NULL. */
+ struct raw_breakpoint *raw;
+
/* Function to call when we hit this breakpoint. If it returns 1,
- the breakpoint shall be deleted; 0, it will be left inserted. */
+ the breakpoint shall be deleted; 0 or if this callback is NULL,
+ it will be left inserted. */
int (*handler) (CORE_ADDR);
};
-static void uninsert_breakpoint (struct breakpoint *bp);
+static struct raw_breakpoint *
+find_raw_breakpoint_at (CORE_ADDR where)
+{
+ struct process_info *proc = current_process ();
+ struct raw_breakpoint *bp;
-static struct breakpoint *
+ for (bp = proc->raw_breakpoints; bp != NULL; bp = bp->next)
+ if (bp->pc == where)
+ return bp;
+
+ return NULL;
+}
+
+static struct raw_breakpoint *
set_raw_breakpoint_at (CORE_ADDR where)
{
struct process_info *proc = current_process ();
- struct breakpoint *bp;
+ struct raw_breakpoint *bp;
int err;
if (breakpoint_data == NULL)
error ("Target does not support breakpoints.");
+ bp = find_raw_breakpoint_at (where);
+ if (bp != NULL)
+ {
+ bp->refcount++;
+ return bp;
+ }
+
bp = xcalloc (1, sizeof (*bp));
bp->pc = where;
+ bp->refcount = 1;
err = (*the_target->read_memory) (where, bp->old_data,
breakpoint_len);
/* Link the breakpoint in. */
bp->inserted = 1;
- bp->next = proc->breakpoints;
- proc->breakpoints = bp;
+ bp->next = proc->raw_breakpoints;
+ proc->raw_breakpoints = bp;
return bp;
}
{
struct process_info *proc = current_process ();
struct breakpoint *bp;
+ struct raw_breakpoint *raw;
- bp = set_raw_breakpoint_at (where);
+ raw = set_raw_breakpoint_at (where);
- if (bp == NULL)
+ if (raw == NULL)
{
/* warn? */
return NULL;
bp = xcalloc (1, sizeof (struct breakpoint));
bp->type = other_breakpoint;
+
+ bp->raw = raw;
bp->handler = handler;
bp->next = proc->breakpoints;
return bp;
}
-static void
-delete_breakpoint (struct breakpoint *todel)
+static int
+delete_raw_breakpoint (struct process_info *proc, struct raw_breakpoint *todel)
+{
+ struct raw_breakpoint *bp, **bp_link;
+ int ret;
+
+ bp = proc->raw_breakpoints;
+ bp_link = &proc->raw_breakpoints;
+
+ while (bp)
+ {
+ if (bp == todel)
+ {
+ if (bp->inserted)
+ {
+ struct raw_breakpoint *prev_bp_link = *bp_link;
+
+ *bp_link = bp->next;
+
+ ret = (*the_target->write_memory) (bp->pc, bp->old_data,
+ breakpoint_len);
+ if (ret != 0)
+ {
+ /* Something went wrong, relink the breakpoint. */
+ *bp_link = prev_bp_link;
+
+ if (debug_threads)
+ fprintf (stderr,
+ "Failed to uninsert raw breakpoint "
+ "at 0x%s (%s) while deleting it.\n",
+ paddress (bp->pc), strerror (ret));
+ return ret;
+ }
+
+ }
+ else
+ *bp_link = bp->next;
+
+ free (bp);
+ return 0;
+ }
+ else
+ {
+ bp_link = &bp->next;
+ bp = *bp_link;
+ }
+ }
+
+ warning ("Could not find raw breakpoint in list.");
+ return ENOENT;
+}
+
+static int
+release_breakpoint (struct process_info *proc, struct breakpoint *bp)
+{
+ int newrefcount;
+ int ret;
+
+ newrefcount = bp->raw->refcount - 1;
+ if (newrefcount == 0)
+ {
+ ret = delete_raw_breakpoint (proc, bp->raw);
+ if (ret != 0)
+ return ret;
+ }
+ else
+ bp->raw->refcount = newrefcount;
+
+ free (bp);
+
+ return 0;
+}
+
+static int
+delete_breakpoint_1 (struct process_info *proc, struct breakpoint *todel)
{
- struct process_info *proc = current_process ();
struct breakpoint *bp, **bp_link;
+ int err;
bp = proc->breakpoints;
bp_link = &proc->breakpoints;
{
*bp_link = bp->next;
- uninsert_breakpoint (bp);
- free (bp);
- return;
+ err = release_breakpoint (proc, bp);
+ if (err != 0)
+ return err;
+
+ bp = *bp_link;
+ return 0;
}
else
{
}
warning ("Could not find breakpoint in list.");
+ return ENOENT;
+}
+
+static int
+delete_breakpoint (struct breakpoint *todel)
+{
+ struct process_info *proc = current_process ();
+ return delete_breakpoint_1 (proc, todel);
}
static struct breakpoint *
-find_breakpoint_at (CORE_ADDR where)
+find_gdb_breakpoint_at (CORE_ADDR where)
{
struct process_info *proc = current_process ();
- struct breakpoint *bp = proc->breakpoints;
+ struct breakpoint *bp;
- while (bp != NULL)
- {
- if (bp->pc == where)
- return bp;
- bp = bp->next;
- }
+ for (bp = proc->breakpoints; bp != NULL; bp = bp->next)
+ if (bp->type == gdb_breakpoint && bp->raw->pc == where)
+ return bp;
return NULL;
}
-void
-delete_breakpoint_at (CORE_ADDR addr)
+int
+set_gdb_breakpoint_at (CORE_ADDR where)
{
- struct breakpoint *bp = find_breakpoint_at (addr);
- if (bp != NULL)
- delete_breakpoint (bp);
+ struct breakpoint *bp;
+
+ if (breakpoint_data == NULL)
+ return 1;
+
+ bp = set_breakpoint_at (where, NULL);
+ if (bp == NULL)
+ return -1;
+
+ bp->type = gdb_breakpoint;
+ return 0;
+}
+
+int
+delete_gdb_breakpoint_at (CORE_ADDR addr)
+{
+ struct breakpoint *bp;
+ int err;
+
+ if (breakpoint_data == NULL)
+ return 1;
+
+ bp = find_gdb_breakpoint_at (addr);
+ if (bp == NULL)
+ return -1;
+
+ err = delete_breakpoint (bp);
+ if (err)
+ return -1;
+
+ return 0;
+}
+
+int
+gdb_breakpoint_here (CORE_ADDR where)
+{
+ struct breakpoint *bp = find_gdb_breakpoint_at (where);
+
+ return (bp != NULL);
}
void
struct breakpoint *bp;
bp = set_breakpoint_at (stop_at, NULL);
-
bp->type = reinsert_breakpoint;
}
if (bp->type == reinsert_breakpoint)
{
*bp_link = bp->next;
-
- /* If something goes wrong, maybe this is a shared library
- breakpoint, and the shared library has been unmapped.
- Assume the breakpoint is gone anyway. */
- uninsert_breakpoint (bp);
- free (bp);
-
+ release_breakpoint (proc, bp);
bp = *bp_link;
}
else
}
static void
-uninsert_breakpoint (struct breakpoint *bp)
+uninsert_raw_breakpoint (struct raw_breakpoint *bp)
{
if (bp->inserted)
{
void
uninsert_breakpoints_at (CORE_ADDR pc)
{
- struct breakpoint *bp;
+ struct raw_breakpoint *bp;
- bp = find_breakpoint_at (pc);
+ bp = find_raw_breakpoint_at (pc);
if (bp == NULL)
{
/* This can happen when we remove all breakpoints while handling
}
if (bp->inserted)
- uninsert_breakpoint (bp);
+ uninsert_raw_breakpoint (bp);
}
static void
-reinsert_raw_breakpoint (struct breakpoint *bp)
+reinsert_raw_breakpoint (struct raw_breakpoint *bp)
{
int err;
void
reinsert_breakpoints_at (CORE_ADDR pc)
{
- struct breakpoint *bp;
+ struct raw_breakpoint *bp;
- bp = find_breakpoint_at (pc);
+ bp = find_raw_breakpoint_at (pc);
if (bp == NULL)
{
/* This can happen when we remove all breakpoints while handling
a step-over. */
if (debug_threads)
fprintf (stderr,
- "Could not find breakpoint at 0x%s "
+ "Could not find raw breakpoint at 0x%s "
"in list (reinserting).\n",
paddress (pc));
return;
while (bp)
{
- if (bp->pc == stop_pc)
+ if (bp->raw->pc == stop_pc)
{
- if (!bp->inserted)
+ if (!bp->raw->inserted)
{
warning ("Hit a removed breakpoint?");
return;
{
*bp_link = bp->next;
- delete_breakpoint (bp);
+ release_breakpoint (proc, bp);
bp = *bp_link;
continue;
int
breakpoint_here (CORE_ADDR addr)
{
- struct process_info *proc = current_process ();
- struct breakpoint *bp;
-
- for (bp = proc->breakpoints; bp != NULL; bp = bp->next)
- if (bp->pc == addr)
- return 1;
-
- return 0;
+ return (find_raw_breakpoint_at (addr) != NULL);
}
int
breakpoint_inserted_here (CORE_ADDR addr)
{
- struct process_info *proc = current_process ();
- struct breakpoint *bp;
+ struct raw_breakpoint *bp;
- for (bp = proc->breakpoints; bp != NULL; bp = bp->next)
- if (bp->pc == addr && bp->inserted)
- return 1;
+ bp = find_raw_breakpoint_at (addr);
- return 0;
+ return (bp != NULL && bp->inserted);
}
void
check_mem_read (CORE_ADDR mem_addr, unsigned char *buf, int mem_len)
{
struct process_info *proc = current_process ();
- struct breakpoint *bp = proc->breakpoints;
+ struct raw_breakpoint *bp = proc->raw_breakpoints;
CORE_ADDR mem_end = mem_addr + mem_len;
for (; bp != NULL; bp = bp->next)
copy_offset = start - bp->pc;
buf_offset = start - mem_addr;
- memcpy (buf + buf_offset, bp->old_data + copy_offset, copy_len);
+ if (bp->inserted)
+ memcpy (buf + buf_offset, bp->old_data + copy_offset, copy_len);
}
}
check_mem_write (CORE_ADDR mem_addr, unsigned char *buf, int mem_len)
{
struct process_info *proc = current_process ();
- struct breakpoint *bp = proc->breakpoints;
+ struct raw_breakpoint *bp = proc->raw_breakpoints;
CORE_ADDR mem_end = mem_addr + mem_len;
for (; bp != NULL; bp = bp->next)
struct process_info *proc = current_process ();
while (proc->breakpoints)
- delete_breakpoint (proc->breakpoints);
+ delete_breakpoint_1 (proc, proc->breakpoints);
}
/* Release all breakpoints, but do not try to un-insert them from the
void
free_all_breakpoints (struct process_info *proc)
{
- struct breakpoint *bp;
+ struct raw_breakpoint *raw_bp;
+ for (raw_bp = proc->raw_breakpoints; raw_bp != NULL; raw_bp = raw_bp->next)
+ raw_bp->inserted = 0;
+
+ /* Note: use PROC explicitly instead of deferring to
+ delete_all_breakpoints --- CURRENT_INFERIOR may already have been
+ released when we get here. There should be no call to
+ current_process from here on. */
while (proc->breakpoints)
- {
- bp = proc->breakpoints;
- proc->breakpoints = bp->next;
- free (bp);
- }
+ delete_breakpoint_1 (proc, proc->breakpoints);
}
projects / deliverable / binutils-gdb.git / blobdiff