27 #define MAX_BREAKPOINT_LEN 8
36 #define APPEND_TO_LIST(listpp, itemp, tailp) \
39 if ((tailp) == NULL) \
40 *(listpp) = (itemp); \
42 (tailp)->next = (itemp); \
209 "bad raw breakpoint type %d", (
int) raw_type);
304 if (breakpoint_data == NULL)
310 if (bp->
size != breakpoint_len)
313 debug_printf (
"Don't know how to insert breakpoints of size %d.\n",
326 " breakpoint at 0x%s (%s).\n",
331 memcpy (bp->
old_data, buf, breakpoint_len);
338 debug_printf (
"Failed to insert breakpoint at 0x%s (%s).\n",
342 return err != 0 ? -1 : 0;
361 memcpy (buf, bp->
old_data, breakpoint_len);
367 "at 0x%s (%s) while deleting it.\n",
370 return err != 0 ? -1 : 0;
387 if (bp != NULL && bp->
size != size)
392 debug_printf (
"Inconsistent breakpoint size? Was %d, now %d.\n",
407 bp =
xcalloc (1,
sizeof (*bp));
417 debug_printf (
"Failed to insert breakpoint at 0x%s (%d).\n",
468 #define fast_tracepoint_jump_insn(fp) \
469 ((fp)->insn_and_shadow + 0)
472 #define fast_tracepoint_jump_shadow(fp) \
473 ((fp)->insn_and_shadow + (fp)->length)
536 *bp_link = prev_bp_link;
539 debug_printf (
"Failed to uninsert fast tracepoint jump "
540 "at 0x%s (%s) while deleting it.\n",
557 warning (
"Could not find fast tracepoint jump in list.");
588 jp =
xcalloc (1,
sizeof (*jp) + (length * 2));
603 " fast tracepoint at 0x%s (%s).\n",
627 debug_printf (
"Failed to insert fast tracepoint jump at 0x%s (%s).\n",
652 debug_printf (
"Could not find fast tracepoint jump at 0x%s "
653 "in list (uninserting).\n",
681 debug_printf (
"Failed to uninsert fast tracepoint jump at"
701 debug_printf (
"Could not find fast tracepoint jump at 0x%s "
702 "in list (reinserting).\n",
708 error (
"Jump already inserted at reinsert time.");
728 debug_printf (
"Failed to reinsert fast tracepoint jump at"
778 where, breakpoint_len,
handler,
807 *bp_link = prev_bp_link;
811 "at 0x%s while deleting it.\n",
829 warning (
"Could not find raw breakpoint in list.");
840 if (newrefcount == 0)
883 warning (
"Could not find breakpoint in list.");
906 if (bp->
type == type && bp->
raw->
pc == addr
907 && (size == -1 || bp->
raw->
size == size))
916 return (z_type >=
'0' && z_type <=
'4'
1118 while (cond != NULL)
1122 cond_next = cond->
next;
1147 cmd_next = cmd->
next;
1172 new_cond =
xcalloc (1,
sizeof (*new_cond));
1173 new_cond->
cond = condition;
1185 char *actparm = *condition;
1188 if (condition == NULL)
1198 fprintf (stderr,
"Condition evaluation failed. "
1199 "Assuming unconditional.\n");
1205 *condition = actparm;
1241 cl && !value && !err; cl = cl->
next)
1250 return (value != 0);
1270 new_cmd =
xcalloc (1,
sizeof (*new_cmd));
1271 new_cmd->
cmd = commands;
1285 char *actparm = *command;
1288 if (command == NULL)
1298 fprintf (stderr,
"Command evaluation failed. "
1322 debug_printf (
"at 0x%s, type Z%c, bp command_list is 0x%s\n",
1360 cl && !value && !err; cl = cl->
next)
1414 *bp_link = bp->
next;
1420 bp_link = &bp->
next;
1432 debug_printf (
"Breakpoint at %s is marked insert-disabled.\n",
1447 debug_printf (
"Failed to uninsert raw breakpoint at 0x%s.\n",
1477 "in list (uninserting).\n",
1501 error (
"Breakpoint already inserted at reinsert time.");
1507 debug_printf (
"Failed to reinsert breakpoint at 0x%s (%d).\n",
1534 "in list (reinserting).\n",
1567 && raw->
pc == stop_pc)
1571 warning (
"Hit a removed breakpoint?");
1577 *bp_link = bp->
next;
1586 bp_link = &bp->
next;
1594 breakpoint_data = bp_data;
1595 breakpoint_len = bp_len;
1672 buf =
alloca (breakpoint_len);
1674 if (err || memcmp (buf, breakpoint_data, breakpoint_len) != 0)
1690 for (bp = proc->
breakpoints; bp != NULL; bp = next)
1729 int disabled_one = 0;
1731 for (; jp != NULL; jp = jp->
next)
1735 int copy_offset, copy_len, buf_offset;
1740 if (mem_addr >= bp_end)
1742 if (jp->
pc >= mem_end)
1746 if (mem_addr > start)
1753 copy_len = end - start;
1754 copy_offset = start - jp->
pc;
1755 buf_offset = start - mem_addr;
1758 memcpy (buf + buf_offset,
1763 for (; bp != NULL; bp = bp->
next)
1767 int copy_offset, copy_len, buf_offset;
1775 if (mem_addr >= bp_end)
1777 if (bp->
pc >= mem_end)
1781 if (mem_addr > start)
1788 copy_len = end - start;
1789 copy_offset = start - bp->
pc;
1790 buf_offset = start - mem_addr;
1795 memcpy (buf + buf_offset, bp->
old_data + copy_offset, copy_len);
1807 const unsigned char *myaddr,
int mem_len)
1813 int disabled_one = 0;
1817 for (; jp != NULL; jp = jp->
next)
1821 int copy_offset, copy_len, buf_offset;
1828 if (mem_addr >= jp_end)
1830 if (jp->
pc >= mem_end)
1834 if (mem_addr > start)
1841 copy_len = end - start;
1842 copy_offset = start - jp->
pc;
1843 buf_offset = start - mem_addr;
1846 myaddr + buf_offset, copy_len);
1848 memcpy (buf + buf_offset,
1852 for (; bp != NULL; bp = bp->
next)
1856 int copy_offset, copy_len, buf_offset;
1864 if (mem_addr >= bp_end)
1866 if (bp->
pc >= mem_end)
1870 if (mem_addr > start)
1877 copy_len = end - start;
1878 copy_offset = start - bp->
pc;
1879 buf_offset = start - mem_addr;
1881 memcpy (bp->
old_data + copy_offset, myaddr + buf_offset, copy_len);
1885 memcpy (buf + buf_offset, breakpoint_data + copy_offset, copy_len);
1940 ax =
xcalloc (1,
sizeof (*ax));
1962 dest_raw =
xcalloc (1,
sizeof (*dest_raw));
1971 dest =
xcalloc (1,
sizeof (*dest));
1973 dest->
raw = dest_raw;
1977 for (current_cond = src->
cond_list; current_cond != NULL;
1978 current_cond = current_cond->
next)
1980 new_cond =
xcalloc (1,
sizeof (*new_cond));
1986 for (current_cmd = src->
command_list; current_cmd != NULL;
1987 current_cmd = current_cmd->
next)
1989 new_cmd =
xcalloc (1,
sizeof (*new_cmd));
2012 for (bp = src_list; bp != NULL; bp = bp->
next)
enum target_hw_bp_type raw_bkpt_type_to_target_hw_bp_type(enum raw_bkpt_type raw_type)
void check_mem_read(CORE_ADDR mem_addr, unsigned char *buf, int mem_len)
struct thread_info * current_thread
static int delete_breakpoint_1(struct process_info *proc, struct breakpoint *todel)
int gdb_condition_true_at_breakpoint(CORE_ADDR where)
static struct fast_tracepoint_jump * find_fast_tracepoint_jump_at(CORE_ADDR where)
struct point_command_list * command_list
static int gdb_no_commands_at_breakpoint_z_type(char z_type, CORE_ADDR addr)
#define APPEND_TO_LIST(listpp, itemp, tailp)
static enum bkpt_type Z_packet_to_bkpt_type(char z_type)
struct point_cond_list * cond_list
unsigned char insn_and_shadow[0]
static int delete_raw_breakpoint(struct process_info *proc, struct raw_breakpoint *todel)
static void clear_breakpoint_commands(struct breakpoint *bp)
void clone_all_breakpoints(struct breakpoint **new_list, struct raw_breakpoint **new_raw_list, const struct breakpoint *src_list)
void warning(const char *fmt,...)
static struct breakpoint * set_breakpoint(enum bkpt_type type, enum raw_bkpt_type raw_type, CORE_ADDR where, int size, int(*handler)(CORE_ADDR), int *err)
static int release_breakpoint(struct process_info *proc, struct breakpoint *bp)
void internal_error(const char *file, int line, const char *fmt,...)
struct raw_breakpoint * raw_breakpoints
int(* insert_point)(enum raw_bkpt_type type, CORE_ADDR addr, int size, struct raw_breakpoint *bp)
struct point_cond_list * next
char * paddress(CORE_ADDR addr)
void set_breakpoint_data(const unsigned char *bp_data, int bp_len)
static struct raw_breakpoint * find_enabled_raw_code_breakpoint_at(CORE_ADDR addr, enum raw_bkpt_type type)
static void reinsert_raw_breakpoint(struct raw_breakpoint *bp)
int(* remove_point)(enum raw_bkpt_type type, CORE_ADDR addr, int size, struct raw_breakpoint *bp)
void free_all_breakpoints(struct process_info *proc)
void uninsert_all_breakpoints(void)
struct target_ops * the_target
int delete_gdb_breakpoint(char z_type, CORE_ADDR addr, int size)
struct raw_breakpoint * raw
const unsigned char * breakpoint_data
void reinsert_all_breakpoints(void)
int fast_tracepoint_jump_here(CORE_ADDR where)
void clear_breakpoint_conditions_and_commands(struct breakpoint *bp)
static void add_condition_to_breakpoint(struct breakpoint *bp, struct agent_expr *condition)
static int delete_gdb_breakpoint_1(char z_type, CORE_ADDR addr, int size)
void add_commands_to_breakpoint(struct breakpoint *bp, struct agent_expr *commands, int persist)
int hardware_breakpoint_inserted_here(CORE_ADDR addr)
void set_reinsert_breakpoint(CORE_ADDR stop_at)
void uninsert_breakpoints_at(CORE_ADDR pc)
struct point_command_list * next
struct fast_tracepoint_jump * fast_tracepoint_jumps
int(* write_memory)(CORE_ADDR memaddr, const unsigned char *myaddr, int len)
void uninsert_fast_tracepoint_jumps_at(CORE_ADDR pc)
static void delete_disabled_breakpoints(void)
enum raw_bkpt_type raw_type
int read_inferior_memory(CORE_ADDR memaddr, unsigned char *myaddr, int len)
#define gdb_assert_not_reached(message)
static int check_gdb_bp_preconditions(char z_type, int *err)
struct tracepoint * tpoint
int software_breakpoint_inserted_here(CORE_ADDR addr)
int breakpoint_here(CORE_ADDR addr)
#define done_accessing_memory()
enum eval_result_type gdb_eval_agent_expr(struct eval_agent_expr_context *ctx, struct agent_expr *aexpr, ULONGEST *rslt)
void check_breakpoints(CORE_ADDR stop_pc)
void delete_all_breakpoints(void)
int gdb_no_commands_at_breakpoint(CORE_ADDR where)
void check_mem_write(CORE_ADDR mem_addr, unsigned char *buf, const unsigned char *myaddr, int mem_len)
struct process_info * current_process(void)
static struct breakpoint * clone_one_breakpoint(const struct breakpoint *src)
static int run_breakpoint_commands_z_type(char z_type, CORE_ADDR addr)
struct traceframe * tframe
unsigned char old_data[MAX_BREAKPOINT_LEN]
static int validate_inserted_breakpoint(struct raw_breakpoint *bp)
#define prepare_to_access_memory()
static void uninsert_raw_breakpoint(struct raw_breakpoint *bp)
struct fast_tracepoint_jump * set_fast_tracepoint_jump(CORE_ADDR where, unsigned char *insn, ULONGEST length)
void reinsert_fast_tracepoint_jumps_at(CORE_ADDR where)
void run_breakpoint_commands(CORE_ADDR where)
struct agent_expr * gdb_parse_agent_expr(char **actparm)
int write_inferior_memory(CORE_ADDR memaddr, const unsigned char *myaddr, int len)
struct raw_breakpoint * next
static struct raw_breakpoint * set_raw_breakpoint_at(enum raw_bkpt_type type, CORE_ADDR where, int size, int *err)
struct breakpoint * set_gdb_breakpoint(char z_type, CORE_ADDR addr, int size, int *err)
static int z_type_supported(char z_type)
char * phex_nz(ULONGEST l, int sizeof_l)
struct fast_tracepoint_jump * next
void reinsert_breakpoints_at(CORE_ADDR pc)
void gdb_free_agent_expr(struct agent_expr *aexpr)
static void clear_breakpoint_conditions(struct breakpoint *bp)
void delete_reinsert_breakpoints(void)
static struct breakpoint * set_gdb_breakpoint_1(char z_type, CORE_ADDR addr, int size, int *err)
int(* read_memory)(CORE_ADDR memaddr, unsigned char *myaddr, int len)
struct regcache * get_thread_regcache(struct thread_info *thread, int fetch)
#define fast_tracepoint_jump_shadow(fp)
#define Z_PACKET_ACCESS_WP
int delete_fast_tracepoint_jump(struct fast_tracepoint_jump *todel)
enum raw_bkpt_type Z_packet_to_raw_bkpt_type(char z_type)
int insert_memory_breakpoint(struct raw_breakpoint *bp)
int breakpoint_inserted_here(CORE_ADDR addr)
int(* supports_z_point_type)(char z_type)
#define fast_tracepoint_jump_insn(fp)
unsigned long long ULONGEST
static struct breakpoint * find_gdb_breakpoint(char z_type, CORE_ADDR addr, int size)
int any_persistent_commands()
struct breakpoint * set_breakpoint_at(CORE_ADDR where, int(*handler)(CORE_ADDR))
int add_breakpoint_commands(struct breakpoint *bp, char **command, int persist)
void inc_ref_fast_tracepoint_jump(struct fast_tracepoint_jump *jp)
struct breakpoint * breakpoints
static int gdb_condition_true_at_breakpoint_z_type(char z_type, CORE_ADDR addr)
static struct agent_expr * clone_agent_expr(const struct agent_expr *src_ax)
void debug_printf(const char *fmt,...)
#define MAX_BREAKPOINT_LEN
int remove_memory_breakpoint(struct raw_breakpoint *bp)
PTR xcalloc(size_t number, size_t size)
int add_breakpoint_condition(struct breakpoint *bp, char **condition)
void validate_breakpoints(void)
void mark_breakpoints_out(struct process_info *proc)
struct regcache * regcache
void error(const char *fmt,...)
int delete_breakpoint(struct breakpoint *todel)
static struct raw_breakpoint * find_raw_breakpoint_at(CORE_ADDR addr, enum raw_bkpt_type type, int size)
int(* handler)(CORE_ADDR)
int gdb_breakpoint_here(CORE_ADDR where)
#define Z_PACKET_WRITE_WP