interesting
/
riscv-openocd
mirror of https://github.com/riscv/riscv-openocd.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge commit '022e438292de992cc558f268b2679e76ad313db6' into from_upstream 

There was a big conflict with this one incoming change. This version of
the code passes all the tests (which don't test for the changed behavior
at all AFAIK), and at least passes errors back everywhere.

Conflicts:
	src/target/breakpoints.c

Change-Id: I72f75a3e08deda7e624e8bb82e1a9ea07a7a9276
This commit is contained in:
Tim Newsome 2023-11-21 12:00:45 -08:00
parent 92213132a6 022e438292
commit 0deaa63f50
3 changed files with 137 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

148
src/target/breakpoints.c
View File

@ -278,7 +278,7 @@ int hybrid_breakpoint_add(struct target *target,
* that is currently unavailable, but the breakpoint also affects a target that * that is currently unavailable, but the breakpoint also affects a target that
* is available. * is available.
*/ */
static void breakpoint_free(struct target *data_target, struct target *breakpoint_target, static int breakpoint_free(struct target *data_target, struct target *breakpoint_target,
struct breakpoint *breakpoint_to_remove) struct breakpoint *breakpoint_to_remove)
{ {
struct breakpoint *breakpoint = data_target->breakpoints; struct breakpoint *breakpoint = data_target->breakpoints;
@ -293,36 +293,49 @@ static void breakpoint_free(struct target *data_target, struct target *breakpoin
} }
if (!breakpoint) if (!breakpoint)
return; return ERROR_BREAKPOINT_NOT_FOUND;
retval = target_remove_breakpoint(breakpoint_target, breakpoint); retval = target_remove_breakpoint(breakpoint_target, breakpoint);
if (retval != ERROR_OK) {
LOG_TARGET_ERROR(breakpoint_target, "could not remove breakpoint #%d on this target",
breakpoint->number);
return retval;
}
LOG_DEBUG("free BPID: %" PRIu32 " --> %d", breakpoint->unique_id, retval); LOG_DEBUG("free BPID: %" PRIu32 " --> %d", breakpoint->unique_id, retval);
(*breakpoint_p) = breakpoint->next; (*breakpoint_p) = breakpoint->next;
free(breakpoint->orig_instr); free(breakpoint->orig_instr);
free(breakpoint); free(breakpoint);
return ERROR_OK;
} }
static void breakpoint_remove_all_internal(struct target *target) static int breakpoint_remove_all_internal(struct target *target)
{ {
struct breakpoint *breakpoint = target->breakpoints; struct breakpoint *breakpoint = target->breakpoints;
int retval = ERROR_OK;
while (breakpoint) { while (breakpoint) {
struct breakpoint *tmp = breakpoint; struct breakpoint *tmp = breakpoint;
breakpoint = breakpoint->next; breakpoint = breakpoint->next;
breakpoint_free(target, target, tmp); int status = breakpoint_free(target, target, tmp);
if (status != ERROR_OK)
retval = status;
} }
return retval;
} }
void breakpoint_remove(struct target *target, target_addr_t address) int breakpoint_remove(struct target *target, target_addr_t address)
{ {
if (!target->smp) { if (!target->smp) {
struct breakpoint *breakpoint = breakpoint_find(target, address); struct breakpoint *breakpoint = breakpoint_find(target, address);
if (breakpoint) if (breakpoint)
breakpoint_free(target, target, breakpoint); return breakpoint_free(target, target, breakpoint);
return; return ERROR_BREAKPOINT_NOT_FOUND;
} }
int retval = ERROR_OK;
unsigned int found = 0; unsigned int found = 0;
struct target_list *head; struct target_list *head;
/* Target where we found a software breakpoint. */ /* Target where we found a software breakpoint. */
@ -360,13 +373,15 @@ void breakpoint_remove(struct target *target, target_addr_t address)
software_breakpoint = breakpoint; software_breakpoint = breakpoint;
} }
} else { } else {
breakpoint_free(curr, curr, breakpoint); int status = breakpoint_free(curr, curr, breakpoint);
if (status != ERROR_OK)
retval = status;
} }
} }
if (!found) { if (!found) {
LOG_ERROR("no breakpoint at address " TARGET_ADDR_FMT " found", address); LOG_ERROR("no breakpoint at address " TARGET_ADDR_FMT " found", address);
return; return ERROR_BREAKPOINT_NOT_FOUND;
} }
if (software_breakpoint) { if (software_breakpoint) {
@ -387,50 +402,75 @@ void breakpoint_remove(struct target *target, target_addr_t address)
/* Remove the software breakpoint through /* Remove the software breakpoint through
* remove_target, but update the breakpoints structure * remove_target, but update the breakpoints structure
* of software_breakpoint_target. */ * of software_breakpoint_target. */
/* TODO: If there is an error, can we try to remove the int status = breakpoint_free(software_breakpoint_target, remove_target, software_breakpoint);
* same breakpoint from a different target? */ if (status != ERROR_OK)
breakpoint_free(software_breakpoint_target, remove_target, software_breakpoint); /* TODO: If there is an error, can we try to remove the
* same breakpoint from a different target? */
retval = status;
} else { } else {
LOG_WARNING("No halted target found to remove software breakpoint at " LOG_WARNING("No halted target found to remove software breakpoint at "
TARGET_ADDR_FMT ".", address); TARGET_ADDR_FMT ".", address);
} }
} }
return retval;
} }
void breakpoint_remove_all(struct target *target) int breakpoint_remove_all(struct target *target)
{ {
int retval = ERROR_OK;
if (target->smp) { if (target->smp) {
struct target_list *head; struct target_list *head;
foreach_smp_target(head, target->smp_targets) { foreach_smp_target(head, target->smp_targets) {
struct target *curr = head->target; struct target *curr = head->target;
breakpoint_remove_all_internal(curr); int status = breakpoint_remove_all_internal(curr);
if (status != ERROR_OK)
retval = status;
} }
} else { } else {
breakpoint_remove_all_internal(target); retval = breakpoint_remove_all_internal(target);
} }
return retval;
} }
static void breakpoint_clear_target_internal(struct target *target) static int breakpoint_clear_target_internal(struct target *target)
{ {
LOG_DEBUG("Delete all breakpoints for target: %s", LOG_DEBUG("Delete all breakpoints for target: %s",
target_name(target)); target_name(target));
while (target->breakpoints)
breakpoint_free(target, target, target->breakpoints); int retval = ERROR_OK;
while (target->breakpoints) {
int status = breakpoint_free(target, target, target->breakpoints);
if (status != ERROR_OK)
retval = status;
}
return retval;
} }
void breakpoint_clear_target(struct target *target) int breakpoint_clear_target(struct target *target)
{ {
int retval = ERROR_OK;
if (target->smp) { if (target->smp) {
struct target_list *head; struct target_list *head;
foreach_smp_target(head, target->smp_targets) { foreach_smp_target(head, target->smp_targets) {
struct target *curr = head->target; struct target *curr = head->target;
breakpoint_clear_target_internal(curr); int status = breakpoint_clear_target_internal(curr);
if (status != ERROR_OK)
retval = status;
} }
} else { } else {
breakpoint_clear_target_internal(target); retval = breakpoint_clear_target_internal(target);
} }
return retval;
} }
struct breakpoint *breakpoint_find(struct target *target, target_addr_t address) struct breakpoint *breakpoint_find(struct target *target, target_addr_t address)
@ -536,7 +576,7 @@ int watchpoint_add(struct target *target, target_addr_t address,
} }
} }
static void watchpoint_free(struct target *target, struct watchpoint *watchpoint_to_remove) static int watchpoint_free(struct target *target, struct watchpoint *watchpoint_to_remove)
{ {
struct watchpoint *watchpoint = target->watchpoints; struct watchpoint *watchpoint = target->watchpoints;
struct watchpoint **watchpoint_p = &target->watchpoints; struct watchpoint **watchpoint_p = &target->watchpoints;
@ -550,11 +590,19 @@ static void watchpoint_free(struct target *target, struct watchpoint *watchpoint
} }
if (!watchpoint) if (!watchpoint)
return; return ERROR_WATCHPOINT_NOT_FOUND;
retval = target_remove_watchpoint(target, watchpoint); retval = target_remove_watchpoint(target, watchpoint);
if (retval != ERROR_OK) {
LOG_TARGET_ERROR(target, "could not remove watchpoint #%d on this target",
watchpoint->number);
return retval;
}
LOG_DEBUG("free WPID: %d --> %d", watchpoint->unique_id, retval); LOG_DEBUG("free WPID: %d --> %d", watchpoint->unique_id, retval);
(*watchpoint_p) = watchpoint->next; (*watchpoint_p) = watchpoint->next;
free(watchpoint); free(watchpoint);
return ERROR_OK;
} }
static int watchpoint_remove_internal(struct target *target, target_addr_t address) static int watchpoint_remove_internal(struct target *target, target_addr_t address)
@ -568,38 +616,64 @@ static int watchpoint_remove_internal(struct target *target, target_addr_t addre
} }
if (watchpoint) { if (watchpoint) {
watchpoint_free(target, watchpoint); return watchpoint_free(target, watchpoint);
return 1;
} else { } else {
if (!target->smp) return ERROR_WATCHPOINT_NOT_FOUND;
LOG_ERROR("no watchpoint at address " TARGET_ADDR_FMT " found", address);
return 0;
} }
} }
void watchpoint_remove(struct target *target, target_addr_t address) int watchpoint_remove(struct target *target, target_addr_t address)
{ {
int retval = ERROR_OK;
unsigned int num_found_watchpoints = 0;
if (target->smp) { if (target->smp) {
unsigned int num_watchpoints = 0;
struct target_list *head; struct target_list *head;
foreach_smp_target(head, target->smp_targets) { foreach_smp_target(head, target->smp_targets) {
struct target *curr = head->target; struct target *curr = head->target;
num_watchpoints += watchpoint_remove_internal(curr, address); int status = watchpoint_remove_internal(curr, address);
if (status != ERROR_WATCHPOINT_NOT_FOUND) {
num_found_watchpoints++;
if (status != ERROR_OK) {
LOG_TARGET_ERROR(curr, "failed to remove watchpoint at address" TARGET_ADDR_FMT, address);
retval = status;
}
}
} }
if (num_watchpoints == 0)
LOG_ERROR("no watchpoint at address " TARGET_ADDR_FMT " num_watchpoints", address);
} else { } else {
watchpoint_remove_internal(target, address); retval = watchpoint_remove_internal(target, address);
if (retval != ERROR_WATCHPOINT_NOT_FOUND) {
num_found_watchpoints++;
if (retval != ERROR_OK)
LOG_TARGET_ERROR(target, "failed to remove watchpoint at address" TARGET_ADDR_FMT, address);
}
} }
if (num_found_watchpoints == 0) {
LOG_TARGET_ERROR(target, "no watchpoint at address " TARGET_ADDR_FMT " found", address);
return ERROR_WATCHPOINT_NOT_FOUND;
}
return retval;
} }
void watchpoint_clear_target(struct target *target) int watchpoint_clear_target(struct target *target)
{ {
int retval = ERROR_OK;
LOG_DEBUG("Delete all watchpoints for target: %s", LOG_DEBUG("Delete all watchpoints for target: %s",
target_name(target)); target_name(target));
while (target->watchpoints) while (target->watchpoints) {
watchpoint_free(target, target->watchpoints); int status = watchpoint_free(target, target->watchpoints);
if (status != ERROR_OK)
retval = status;
}
return retval;
} }
int watchpoint_hit(struct target *target, enum watchpoint_rw *rw, int watchpoint_hit(struct target *target, enum watchpoint_rw *rw,

13
src/target/breakpoints.h
View File

@ -50,15 +50,15 @@ struct watchpoint {
uint32_t unique_id; uint32_t unique_id;
}; };
void breakpoint_clear_target(struct target *target); int breakpoint_clear_target(struct target *target);
int breakpoint_add(struct target *target, int breakpoint_add(struct target *target,
target_addr_t address, uint32_t length, enum breakpoint_type type); target_addr_t address, uint32_t length, enum breakpoint_type type);
int context_breakpoint_add(struct target *target, int context_breakpoint_add(struct target *target,
uint32_t asid, uint32_t length, enum breakpoint_type type); uint32_t asid, uint32_t length, enum breakpoint_type type);
int hybrid_breakpoint_add(struct target *target, int hybrid_breakpoint_add(struct target *target,
target_addr_t address, uint32_t asid, uint32_t length, enum breakpoint_type type); target_addr_t address, uint32_t asid, uint32_t length, enum breakpoint_type type);
void breakpoint_remove(struct target *target, target_addr_t address); int breakpoint_remove(struct target *target, target_addr_t address);
void breakpoint_remove_all(struct target *target); int breakpoint_remove_all(struct target *target);
struct breakpoint *breakpoint_find(struct target *target, target_addr_t address); struct breakpoint *breakpoint_find(struct target *target, target_addr_t address);
@ -68,11 +68,11 @@ static inline void breakpoint_hw_set(struct breakpoint *breakpoint, unsigned int
breakpoint->number = hw_number; breakpoint->number = hw_number;
} }
void watchpoint_clear_target(struct target *target); int watchpoint_clear_target(struct target *target);
int watchpoint_add(struct target *target, int watchpoint_add(struct target *target,
target_addr_t address, uint32_t length, target_addr_t address, uint32_t length,
enum watchpoint_rw rw, uint64_t value, uint64_t mask); enum watchpoint_rw rw, uint64_t value, uint64_t mask);
void watchpoint_remove(struct target *target, target_addr_t address); int watchpoint_remove(struct target *target, target_addr_t address);
/* report type and address of just hit watchpoint */ /* report type and address of just hit watchpoint */
int watchpoint_hit(struct target *target, enum watchpoint_rw *rw, int watchpoint_hit(struct target *target, enum watchpoint_rw *rw,
@ -84,4 +84,7 @@ static inline void watchpoint_set(struct watchpoint *watchpoint, unsigned int nu
watchpoint->number = number; watchpoint->number = number;
} }
#define ERROR_BREAKPOINT_NOT_FOUND (-1600)
#define ERROR_WATCHPOINT_NOT_FOUND (-1601)
#endif /* OPENOCD_TARGET_BREAKPOINTS_H */ #endif /* OPENOCD_TARGET_BREAKPOINTS_H */

23
src/target/target.c
View File

@ -4036,21 +4036,31 @@ COMMAND_HANDLER(handle_bp_command)
COMMAND_HANDLER(handle_rbp_command) COMMAND_HANDLER(handle_rbp_command)
{ {
int retval;
if (CMD_ARGC != 1) if (CMD_ARGC != 1)
return ERROR_COMMAND_SYNTAX_ERROR; return ERROR_COMMAND_SYNTAX_ERROR;
struct target *target = get_current_target(CMD_CTX); struct target *target = get_current_target(CMD_CTX);
if (!strcmp(CMD_ARGV[0], "all")) { if (!strcmp(CMD_ARGV[0], "all")) {
breakpoint_remove_all(target); retval = breakpoint_remove_all(target);
if (retval != ERROR_OK) {
command_print(CMD, "Error encountered during removal of all breakpoints.");
command_print(CMD, "Some breakpoints may have remained set.");
}
} else { } else {
target_addr_t addr; target_addr_t addr;
COMMAND_PARSE_ADDRESS(CMD_ARGV[0], addr); COMMAND_PARSE_ADDRESS(CMD_ARGV[0], addr);
breakpoint_remove(target, addr); retval = breakpoint_remove(target, addr);
if (retval != ERROR_OK)
command_print(CMD, "Error during removal of breakpoint at address " TARGET_ADDR_FMT, addr);
} }
return ERROR_OK; return retval;
} }
COMMAND_HANDLER(handle_wp_command) COMMAND_HANDLER(handle_wp_command)
@ -4135,9 +4145,12 @@ COMMAND_HANDLER(handle_rwp_command)
COMMAND_PARSE_ADDRESS(CMD_ARGV[0], addr); COMMAND_PARSE_ADDRESS(CMD_ARGV[0], addr);
struct target *target = get_current_target(CMD_CTX); struct target *target = get_current_target(CMD_CTX);
watchpoint_remove(target, addr); int retval = watchpoint_remove(target, addr);
return ERROR_OK; if (retval != ERROR_OK)
command_print(CMD, "Error during removal of watchpoint at address " TARGET_ADDR_FMT, addr);
return retval;
} }
/** /**