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

target: Rework 'set' variable of break-/watchpoints 

The 'set' variable name suggests a boolean data type which determines
whether a breakpoint (or watchpoint) is active. However, it is also
used to store the number of the breakpoint.

This encoding leads to inconsistent value assignments: boolean and
integer values are mixed. Also, associated hardware comparator
numbers, which are usually numbered from 0, cannot be used directly.
An additional offset is required to store the comparator numbers.

In order to make the code more readable and the value assignment more
consistent, change the variable name to 'is_set', its data type to 'bool'
and introduce a dedicated variable for the break-/watchpoint
number.

In order to make the review easier, the data types of various related
variables (e.g. number of breakpoints) are not changed.

While at it, fix a few coding style issues.

Change-Id: I2193f5639247cce6b80580d4c1c6afee916aeb82
Signed-off-by: Marc Schink <dev@zapb.de>
Reviewed-on: https://review.openocd.org/c/openocd/+/6319
Tested-by: jenkins
Reviewed-by: Antonio Borneo <borneo.antonio@gmail.com>
This commit is contained in:
Marc Schink 2021-06-13 11:21:18 +02:00 committed by Antonio Borneo
parent ab43721be6
commit fb43f1ff4e
21 changed files with 258 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
src/target/aarch64.c
View File

@ -1236,7 +1236,7 @@ static int aarch64_set_breakpoint(struct target *target,
struct armv8_common *armv8 = &aarch64->armv8_common; struct armv8_common *armv8 = &aarch64->armv8_common;
struct aarch64_brp *brp_list = aarch64->brp_list; struct aarch64_brp *brp_list = aarch64->brp_list;
if (breakpoint->set) { if (breakpoint->is_set) {
LOG_WARNING("breakpoint already set"); LOG_WARNING("breakpoint already set");
return ERROR_OK; return ERROR_OK;
} }
@ -1249,7 +1249,7 @@ static int aarch64_set_breakpoint(struct target *target,
LOG_ERROR("ERROR Can not find free Breakpoint Register Pair"); LOG_ERROR("ERROR Can not find free Breakpoint Register Pair");
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
} }
breakpoint->set = brp_i + 1; breakpoint_hw_set(breakpoint, brp_i);
if (breakpoint->length == 2) if (breakpoint->length == 2)
byte_addr_select = (3 << (breakpoint->address & 0x02)); byte_addr_select = (3 << (breakpoint->address & 0x02));
control = ((matchmode & 0x7) << 20) control = ((matchmode & 0x7) << 20)
@ -1333,7 +1333,7 @@ static int aarch64_set_breakpoint(struct target *target,
breakpoint->address & 0xFFFFFFFFFFFFFFFE, breakpoint->address & 0xFFFFFFFFFFFFFFFE,
breakpoint->length); breakpoint->length);
breakpoint->set = 0x11; /* Any nice value but 0 */ breakpoint->is_set = true;
} }
/* Ensure that halting debug mode is enable */ /* Ensure that halting debug mode is enable */
@ -1357,7 +1357,7 @@ static int aarch64_set_context_breakpoint(struct target *target,
struct armv8_common *armv8 = &aarch64->armv8_common; struct armv8_common *armv8 = &aarch64->armv8_common;
struct aarch64_brp *brp_list = aarch64->brp_list; struct aarch64_brp *brp_list = aarch64->brp_list;
if (breakpoint->set) { if (breakpoint->is_set) {
LOG_WARNING("breakpoint already set"); LOG_WARNING("breakpoint already set");
return retval; return retval;
} }
@ -1371,7 +1371,7 @@ static int aarch64_set_context_breakpoint(struct target *target,
return ERROR_FAIL; return ERROR_FAIL;
} }
breakpoint->set = brp_i + 1; breakpoint_hw_set(breakpoint, brp_i);
control = ((matchmode & 0x7) << 20) control = ((matchmode & 0x7) << 20)
| (1 << 13) | (1 << 13)
| (byte_addr_select << 5) | (byte_addr_select << 5)
@ -1410,7 +1410,7 @@ static int aarch64_set_hybrid_breakpoint(struct target *target, struct breakpoin
struct armv8_common *armv8 = &aarch64->armv8_common; struct armv8_common *armv8 = &aarch64->armv8_common;
struct aarch64_brp *brp_list = aarch64->brp_list; struct aarch64_brp *brp_list = aarch64->brp_list;
if (breakpoint->set) { if (breakpoint->is_set) {
LOG_WARNING("breakpoint already set"); LOG_WARNING("breakpoint already set");
return retval; return retval;
} }
@ -1435,7 +1435,7 @@ static int aarch64_set_hybrid_breakpoint(struct target *target, struct breakpoin
return ERROR_FAIL; return ERROR_FAIL;
} }
breakpoint->set = brp_1 + 1; breakpoint_hw_set(breakpoint, brp_1);
breakpoint->linked_brp = brp_2; breakpoint->linked_brp = brp_2;
control_ctx = ((ctx_machmode & 0x7) << 20) control_ctx = ((ctx_machmode & 0x7) << 20)
| (brp_2 << 16) | (brp_2 << 16)
@ -1490,16 +1490,16 @@ static int aarch64_unset_breakpoint(struct target *target, struct breakpoint *br
struct armv8_common *armv8 = &aarch64->armv8_common; struct armv8_common *armv8 = &aarch64->armv8_common;
struct aarch64_brp *brp_list = aarch64->brp_list; struct aarch64_brp *brp_list = aarch64->brp_list;
if (!breakpoint->set) { if (!breakpoint->is_set) {
LOG_WARNING("breakpoint not set"); LOG_WARNING("breakpoint not set");
return ERROR_OK; return ERROR_OK;
} }
if (breakpoint->type == BKPT_HARD) { if (breakpoint->type == BKPT_HARD) {
if ((breakpoint->address != 0) && (breakpoint->asid != 0)) { if ((breakpoint->address != 0) && (breakpoint->asid != 0)) {
int brp_i = breakpoint->set - 1; int brp_i = breakpoint->number;
int brp_j = breakpoint->linked_brp; int brp_j = breakpoint->linked_brp;
if ((brp_i < 0) || (brp_i >= aarch64->brp_num)) { if (brp_i >= aarch64->brp_num) {
LOG_DEBUG("Invalid BRP number in breakpoint"); LOG_DEBUG("Invalid BRP number in breakpoint");
return ERROR_OK; return ERROR_OK;
} }
@ -1549,12 +1549,12 @@ static int aarch64_unset_breakpoint(struct target *target, struct breakpoint *br
return retval; return retval;
breakpoint->linked_brp = 0; breakpoint->linked_brp = 0;
breakpoint->set = 0; breakpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} else { } else {
int brp_i = breakpoint->set - 1; int brp_i = breakpoint->number;
if ((brp_i < 0) || (brp_i >= aarch64->brp_num)) { if (brp_i >= aarch64->brp_num) {
LOG_DEBUG("Invalid BRP number in breakpoint"); LOG_DEBUG("Invalid BRP number in breakpoint");
return ERROR_OK; return ERROR_OK;
} }
@ -1579,7 +1579,7 @@ static int aarch64_unset_breakpoint(struct target *target, struct breakpoint *br
(uint32_t)brp_list[brp_i].value); (uint32_t)brp_list[brp_i].value);
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
breakpoint->set = 0; breakpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
} else { } else {
@ -1611,7 +1611,7 @@ static int aarch64_unset_breakpoint(struct target *target, struct breakpoint *br
breakpoint->address & 0xFFFFFFFFFFFFFFFE, breakpoint->address & 0xFFFFFFFFFFFFFFFE,
breakpoint->length); breakpoint->length);
} }
breakpoint->set = 0; breakpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
@ -1676,7 +1676,7 @@ static int aarch64_remove_breakpoint(struct target *target, struct breakpoint *b
} }
#endif #endif
if (breakpoint->set) { if (breakpoint->is_set) {
aarch64_unset_breakpoint(target, breakpoint); aarch64_unset_breakpoint(target, breakpoint);
if (breakpoint->type == BKPT_HARD) if (breakpoint->type == BKPT_HARD)
aarch64->brp_num_available++; aarch64->brp_num_available++;
@ -1696,7 +1696,7 @@ static int aarch64_set_watchpoint(struct target *target,
struct armv8_common *armv8 = &aarch64->armv8_common; struct armv8_common *armv8 = &aarch64->armv8_common;
struct aarch64_brp *wp_list = aarch64->wp_list; struct aarch64_brp *wp_list = aarch64->wp_list;
if (watchpoint->set) { if (watchpoint->is_set) {
LOG_WARNING("watchpoint already set"); LOG_WARNING("watchpoint already set");
return ERROR_OK; return ERROR_OK;
} }
@ -1764,7 +1764,7 @@ static int aarch64_set_watchpoint(struct target *target,
} }
wp_list[wp_i].used = 1; wp_list[wp_i].used = 1;
watchpoint->set = wp_i + 1; watchpoint_set(watchpoint, wp_i);
return ERROR_OK; return ERROR_OK;
} }
@ -1773,18 +1773,18 @@ static int aarch64_set_watchpoint(struct target *target,
static int aarch64_unset_watchpoint(struct target *target, static int aarch64_unset_watchpoint(struct target *target,
struct watchpoint *watchpoint) struct watchpoint *watchpoint)
{ {
int retval, wp_i; int retval;
struct aarch64_common *aarch64 = target_to_aarch64(target); struct aarch64_common *aarch64 = target_to_aarch64(target);
struct armv8_common *armv8 = &aarch64->armv8_common; struct armv8_common *armv8 = &aarch64->armv8_common;
struct aarch64_brp *wp_list = aarch64->wp_list; struct aarch64_brp *wp_list = aarch64->wp_list;
if (!watchpoint->set) { if (!watchpoint->is_set) {
LOG_WARNING("watchpoint not set"); LOG_WARNING("watchpoint not set");
return ERROR_OK; return ERROR_OK;
} }
wp_i = watchpoint->set - 1; int wp_i = watchpoint->number;
if ((wp_i < 0) || (wp_i >= aarch64->wp_num)) { if (wp_i >= aarch64->wp_num) {
LOG_DEBUG("Invalid WP number in watchpoint"); LOG_DEBUG("Invalid WP number in watchpoint");
return ERROR_OK; return ERROR_OK;
} }
@ -1809,7 +1809,7 @@ static int aarch64_unset_watchpoint(struct target *target,
(uint32_t)wp_list[wp_i].value); (uint32_t)wp_list[wp_i].value);
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
watchpoint->set = 0; watchpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
@ -1837,7 +1837,7 @@ static int aarch64_remove_watchpoint(struct target *target,
{ {
struct aarch64_common *aarch64 = target_to_aarch64(target); struct aarch64_common *aarch64 = target_to_aarch64(target);
if (watchpoint->set) { if (watchpoint->is_set) {
aarch64_unset_watchpoint(target, watchpoint); aarch64_unset_watchpoint(target, watchpoint);
aarch64->wp_num_available++; aarch64->wp_num_available++;
} }

38
src/target/arc.c
View File

@ -1500,7 +1500,7 @@ static int arc_configure_actionpoint(struct target *target, uint32_t ap_num,
static int arc_set_breakpoint(struct target *target, static int arc_set_breakpoint(struct target *target,
struct breakpoint *breakpoint) struct breakpoint *breakpoint)
{ {
if (breakpoint->set) { if (breakpoint->is_set) {
LOG_WARNING("breakpoint already set"); LOG_WARNING("breakpoint already set");
return ERROR_OK; return ERROR_OK;
} }
@ -1542,7 +1542,7 @@ static int arc_set_breakpoint(struct target *target,
return ERROR_COMMAND_ARGUMENT_INVALID; return ERROR_COMMAND_ARGUMENT_INVALID;
} }
breakpoint->set = 64; /* Any nice value but 0 */ breakpoint->is_set = true;
} else if (breakpoint->type == BKPT_HARD) { } else if (breakpoint->type == BKPT_HARD) {
struct arc_common *arc = target_to_arc(target); struct arc_common *arc = target_to_arc(target);
struct arc_actionpoint *ap_list = arc->actionpoints_list; struct arc_actionpoint *ap_list = arc->actionpoints_list;
@ -1563,7 +1563,7 @@ static int arc_set_breakpoint(struct target *target,
breakpoint->address, AP_AC_TT_READWRITE, AP_AC_AT_INST_ADDR); breakpoint->address, AP_AC_TT_READWRITE, AP_AC_AT_INST_ADDR);
if (retval == ERROR_OK) { if (retval == ERROR_OK) {
breakpoint->set = bp_num + 1; breakpoint_hw_set(breakpoint, bp_num);
ap_list[bp_num].used = 1; ap_list[bp_num].used = 1;
ap_list[bp_num].bp_value = breakpoint->address; ap_list[bp_num].bp_value = breakpoint->address;
ap_list[bp_num].type = ARC_AP_BREAKPOINT; ap_list[bp_num].type = ARC_AP_BREAKPOINT;
@ -1588,7 +1588,7 @@ static int arc_unset_breakpoint(struct target *target,
{ {
int retval = ERROR_OK; int retval = ERROR_OK;
if (!breakpoint->set) { if (!breakpoint->is_set) {
LOG_WARNING("breakpoint not set"); LOG_WARNING("breakpoint not set");
return ERROR_OK; return ERROR_OK;
} }
@ -1633,14 +1633,14 @@ static int arc_unset_breakpoint(struct target *target,
LOG_ERROR("Invalid breakpoint length: target supports only 2 or 4"); LOG_ERROR("Invalid breakpoint length: target supports only 2 or 4");
return ERROR_COMMAND_ARGUMENT_INVALID; return ERROR_COMMAND_ARGUMENT_INVALID;
} }
breakpoint->set = 0; breakpoint->is_set = false;
} else if (breakpoint->type == BKPT_HARD) { } else if (breakpoint->type == BKPT_HARD) {
struct arc_common *arc = target_to_arc(target); struct arc_common *arc = target_to_arc(target);
struct arc_actionpoint *ap_list = arc->actionpoints_list; struct arc_actionpoint *ap_list = arc->actionpoints_list;
unsigned int bp_num = breakpoint->set - 1; unsigned int bp_num = breakpoint->number;
if ((breakpoint->set == 0) || (bp_num >= arc->actionpoints_num)) { if (bp_num >= arc->actionpoints_num) {
LOG_DEBUG("Invalid actionpoint ID: %u in breakpoint: %" PRIu32, LOG_DEBUG("Invalid actionpoint ID: %u in breakpoint: %" PRIu32,
bp_num, breakpoint->unique_id); bp_num, breakpoint->unique_id);
return ERROR_OK; return ERROR_OK;
@ -1650,11 +1650,11 @@ static int arc_unset_breakpoint(struct target *target,
breakpoint->address, AP_AC_TT_DISABLE, AP_AC_AT_INST_ADDR); breakpoint->address, AP_AC_TT_DISABLE, AP_AC_AT_INST_ADDR);
if (retval == ERROR_OK) { if (retval == ERROR_OK) {
breakpoint->set = 0; breakpoint->is_set = false;
ap_list[bp_num].used = 0; ap_list[bp_num].used = 0;
ap_list[bp_num].bp_value = 0; ap_list[bp_num].bp_value = 0;
LOG_DEBUG("bpid: %" PRIu32 " - released actionpoint ID: %i", LOG_DEBUG("bpid: %" PRIu32 " - released actionpoint ID: %u",
breakpoint->unique_id, bp_num); breakpoint->unique_id, bp_num);
} }
} else { } else {
@ -1684,7 +1684,7 @@ static int arc_remove_breakpoint(struct target *target,
struct breakpoint *breakpoint) struct breakpoint *breakpoint)
{ {
if (target->state == TARGET_HALTED) { if (target->state == TARGET_HALTED) {
if (breakpoint->set) if (breakpoint->is_set)
CHECK_RETVAL(arc_unset_breakpoint(target, breakpoint)); CHECK_RETVAL(arc_unset_breakpoint(target, breakpoint));
} else { } else {
LOG_WARNING("target not halted"); LOG_WARNING("target not halted");
@ -1818,7 +1818,7 @@ static int arc_set_watchpoint(struct target *target,
struct arc_common *arc = target_to_arc(target); struct arc_common *arc = target_to_arc(target);
struct arc_actionpoint *ap_list = arc->actionpoints_list; struct arc_actionpoint *ap_list = arc->actionpoints_list;
if (watchpoint->set) { if (watchpoint->is_set) {
LOG_WARNING("watchpoint already set"); LOG_WARNING("watchpoint already set");
return ERROR_OK; return ERROR_OK;
} }
@ -1859,7 +1859,7 @@ static int arc_set_watchpoint(struct target *target,
watchpoint->address, enable, AP_AC_AT_MEMORY_ADDR); watchpoint->address, enable, AP_AC_AT_MEMORY_ADDR);
if (retval == ERROR_OK) { if (retval == ERROR_OK) {
watchpoint->set = wp_num + 1; watchpoint_set(watchpoint, wp_num);
ap_list[wp_num].used = 1; ap_list[wp_num].used = 1;
ap_list[wp_num].bp_value = watchpoint->address; ap_list[wp_num].bp_value = watchpoint->address;
ap_list[wp_num].type = ARC_AP_WATCHPOINT; ap_list[wp_num].type = ARC_AP_WATCHPOINT;
@ -1878,13 +1878,13 @@ static int arc_unset_watchpoint(struct target *target,
struct arc_common *arc = target_to_arc(target); struct arc_common *arc = target_to_arc(target);
struct arc_actionpoint *ap_list = arc->actionpoints_list; struct arc_actionpoint *ap_list = arc->actionpoints_list;
if (!watchpoint->set) { if (!watchpoint->is_set) {
LOG_WARNING("watchpoint not set"); LOG_WARNING("watchpoint not set");
return ERROR_OK; return ERROR_OK;
} }
unsigned int wp_num = watchpoint->set - 1; unsigned int wp_num = watchpoint->number;
if ((watchpoint->set == 0) || (wp_num >= arc->actionpoints_num)) { if (wp_num >= arc->actionpoints_num) {
LOG_DEBUG("Invalid actionpoint ID: %u in watchpoint: %" PRIu32, LOG_DEBUG("Invalid actionpoint ID: %u in watchpoint: %" PRIu32,
wp_num, watchpoint->unique_id); wp_num, watchpoint->unique_id);
return ERROR_OK; return ERROR_OK;
@ -1894,7 +1894,7 @@ static int arc_unset_watchpoint(struct target *target,
watchpoint->address, AP_AC_TT_DISABLE, AP_AC_AT_MEMORY_ADDR); watchpoint->address, AP_AC_TT_DISABLE, AP_AC_AT_MEMORY_ADDR);
if (retval == ERROR_OK) { if (retval == ERROR_OK) {
watchpoint->set = 0; watchpoint->is_set = false;
ap_list[wp_num].used = 0; ap_list[wp_num].used = 0;
ap_list[wp_num].bp_value = 0; ap_list[wp_num].bp_value = 0;
@ -1926,7 +1926,7 @@ static int arc_remove_watchpoint(struct target *target,
return ERROR_TARGET_NOT_HALTED; return ERROR_TARGET_NOT_HALTED;
} }
if (watchpoint->set) if (watchpoint->is_set)
CHECK_RETVAL(arc_unset_watchpoint(target, watchpoint)); CHECK_RETVAL(arc_unset_watchpoint(target, watchpoint));
return ERROR_OK; return ERROR_OK;
@ -1953,8 +1953,8 @@ static int arc_hit_watchpoint(struct target *target, struct watchpoint **hit_wat
watchpoint = watchpoint->next) { watchpoint = watchpoint->next) {
if (actionpoint->bp_value == watchpoint->address) { if (actionpoint->bp_value == watchpoint->address) {
*hit_watchpoint = watchpoint; *hit_watchpoint = watchpoint;
LOG_DEBUG("Hit watchpoint, wpid: %" PRIu32 ", watchpoint num: %i", LOG_DEBUG("Hit watchpoint, wpid: %" PRIu32 ", watchpoint num: %u",
watchpoint->unique_id, watchpoint->set - 1); watchpoint->unique_id, watchpoint->number);
return ERROR_OK; return ERROR_OK;
} }
} }

49
src/target/arm7_9_common.c
View File

@ -93,19 +93,20 @@ static void arm7_9_assign_wp(struct arm7_9_common *arm7_9, struct breakpoint *br
{ {
if (!arm7_9->wp0_used) { if (!arm7_9->wp0_used) {
arm7_9->wp0_used = 1; arm7_9->wp0_used = 1;
breakpoint->set = 1; breakpoint_hw_set(breakpoint, 0);
arm7_9->wp_available--; arm7_9->wp_available--;
} else if (!arm7_9->wp1_used) { } else if (!arm7_9->wp1_used) {
arm7_9->wp1_used = 1; arm7_9->wp1_used = 1;
breakpoint->set = 2; breakpoint_hw_set(breakpoint, 1);
arm7_9->wp_available--; arm7_9->wp_available--;
} else } else {
LOG_ERROR("BUG: no hardware comparator available"); LOG_ERROR("BUG: no hardware comparator available");
}
LOG_DEBUG("BPID: %" PRIu32 " (0x%08" TARGET_PRIxADDR ") using hw wp: %d", LOG_DEBUG("BPID: %" PRIu32 " (0x%08" TARGET_PRIxADDR ") using hw wp: %u",
breakpoint->unique_id, breakpoint->unique_id,
breakpoint->address, breakpoint->address,
breakpoint->set); breakpoint->number);
} }
/** /**
@ -203,16 +204,16 @@ static int arm7_9_set_breakpoint(struct target *target, struct breakpoint *break
uint32_t mask = (breakpoint->length == 4) ? 0x3u : 0x1u; uint32_t mask = (breakpoint->length == 4) ? 0x3u : 0x1u;
/* reassign a hw breakpoint */ /* reassign a hw breakpoint */
if (breakpoint->set == 0) if (!breakpoint->is_set)
arm7_9_assign_wp(arm7_9, breakpoint); arm7_9_assign_wp(arm7_9, breakpoint);
if (breakpoint->set == 1) { if (breakpoint->number == 0) {
embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_VALUE], breakpoint->address); embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_VALUE], breakpoint->address);
embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_MASK], mask); embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_ADDR_MASK], mask);
embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_MASK], 0xffffffffu); embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_DATA_MASK], 0xffffffffu);
embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_MASK], ~EICE_W_CTRL_NOPC & 0xff); embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_MASK], ~EICE_W_CTRL_NOPC & 0xff);
embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], EICE_W_CTRL_ENABLE); embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], EICE_W_CTRL_ENABLE);
} else if (breakpoint->set == 2) { } else if (breakpoint->number == 1) {
embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_VALUE], breakpoint->address); embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_VALUE], breakpoint->address);
embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_MASK], mask); embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_MASK], mask);
embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_DATA_MASK], 0xffffffffu); embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_DATA_MASK], 0xffffffffu);
@ -226,7 +227,7 @@ static int arm7_9_set_breakpoint(struct target *target, struct breakpoint *break
retval = jtag_execute_queue(); retval = jtag_execute_queue();
} else if (breakpoint->type == BKPT_SOFT) { } else if (breakpoint->type == BKPT_SOFT) {
/* did we already set this breakpoint? */ /* did we already set this breakpoint? */
if (breakpoint->set) if (breakpoint->is_set)
return ERROR_OK; return ERROR_OK;
if (breakpoint->length == 4) { if (breakpoint->length == 4) {
@ -277,7 +278,7 @@ static int arm7_9_set_breakpoint(struct target *target, struct breakpoint *break
arm7_9->sw_breakpoint_count++; arm7_9->sw_breakpoint_count++;
breakpoint->set = 1; breakpoint->is_set = true;
} }
return retval; return retval;
@ -304,7 +305,7 @@ static int arm7_9_unset_breakpoint(struct target *target, struct breakpoint *bre
breakpoint->unique_id, breakpoint->unique_id,
breakpoint->address); breakpoint->address);
if (!breakpoint->set) { if (!breakpoint->is_set) {
LOG_WARNING("breakpoint not set"); LOG_WARNING("breakpoint not set");
return ERROR_OK; return ERROR_OK;
} }
@ -312,18 +313,18 @@ static int arm7_9_unset_breakpoint(struct target *target, struct breakpoint *bre
if (breakpoint->type == BKPT_HARD) { if (breakpoint->type == BKPT_HARD) {
LOG_DEBUG("BPID: %" PRIu32 " Releasing hw wp: %d", LOG_DEBUG("BPID: %" PRIu32 " Releasing hw wp: %d",
breakpoint->unique_id, breakpoint->unique_id,
breakpoint->set); breakpoint->is_set);
if (breakpoint->set == 1) { if (breakpoint->number == 0) {
embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], 0x0); embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], 0x0);
arm7_9->wp0_used = 0; arm7_9->wp0_used = 0;
arm7_9->wp_available++; arm7_9->wp_available++;
} else if (breakpoint->set == 2) { } else if (breakpoint->number == 1) {
embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE], 0x0); embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE], 0x0);
arm7_9->wp1_used = 0; arm7_9->wp1_used = 0;
arm7_9->wp_available++; arm7_9->wp_available++;
} }
retval = jtag_execute_queue(); retval = jtag_execute_queue();
breakpoint->set = 0; breakpoint->is_set = false;
} else { } else {
/* restore original instruction (kept in target endianness) */ /* restore original instruction (kept in target endianness) */
if (breakpoint->length == 4) { if (breakpoint->length == 4) {
@ -368,7 +369,7 @@ static int arm7_9_unset_breakpoint(struct target *target, struct breakpoint *bre
EICE_W1_CONTROL_VALUE], 0); EICE_W1_CONTROL_VALUE], 0);
} }
breakpoint->set = 0; breakpoint->is_set = false;
} }
return retval; return retval;
@ -491,7 +492,7 @@ static int arm7_9_set_watchpoint(struct target *target, struct watchpoint *watch
retval = jtag_execute_queue(); retval = jtag_execute_queue();
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
watchpoint->set = 1; watchpoint_set(watchpoint, 1);
arm7_9->wp0_used = 2; arm7_9->wp0_used = 2;
} else if (!arm7_9->wp1_used) { } else if (!arm7_9->wp1_used) {
embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_VALUE], embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_ADDR_VALUE],
@ -510,7 +511,7 @@ static int arm7_9_set_watchpoint(struct target *target, struct watchpoint *watch
retval = jtag_execute_queue(); retval = jtag_execute_queue();
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
watchpoint->set = 2; watchpoint_set(watchpoint, 2);
arm7_9->wp1_used = 2; arm7_9->wp1_used = 2;
} else { } else {
LOG_ERROR("BUG: no hardware comparator available"); LOG_ERROR("BUG: no hardware comparator available");
@ -538,25 +539,25 @@ static int arm7_9_unset_watchpoint(struct target *target, struct watchpoint *wat
return ERROR_TARGET_NOT_HALTED; return ERROR_TARGET_NOT_HALTED;
} }
if (!watchpoint->set) { if (!watchpoint->is_set) {
LOG_WARNING("breakpoint not set"); LOG_WARNING("breakpoint not set");
return ERROR_OK; return ERROR_OK;
} }
if (watchpoint->set == 1) { if (watchpoint->number == 1) {
embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], 0x0); embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W0_CONTROL_VALUE], 0x0);
retval = jtag_execute_queue(); retval = jtag_execute_queue();
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
arm7_9->wp0_used = 0; arm7_9->wp0_used = 0;
} else if (watchpoint->set == 2) { } else if (watchpoint->number == 2) {
embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE], 0x0); embeddedice_set_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE], 0x0);
retval = jtag_execute_queue(); retval = jtag_execute_queue();
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
arm7_9->wp1_used = 0; arm7_9->wp1_used = 0;
} }
watchpoint->set = 0; watchpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
@ -597,7 +598,7 @@ int arm7_9_remove_watchpoint(struct target *target, struct watchpoint *watchpoin
int retval = ERROR_OK; int retval = ERROR_OK;
struct arm7_9_common *arm7_9 = target_to_arm7_9(target); struct arm7_9_common *arm7_9 = target_to_arm7_9(target);
if (watchpoint->set) { if (watchpoint->is_set) {
retval = arm7_9_unset_watchpoint(target, watchpoint); retval = arm7_9_unset_watchpoint(target, watchpoint);
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
@ -1684,7 +1685,7 @@ static void arm7_9_enable_watchpoints(struct target *target)
struct watchpoint *watchpoint = target->watchpoints; struct watchpoint *watchpoint = target->watchpoints;
while (watchpoint) { while (watchpoint) {
if (watchpoint->set == 0) if (!watchpoint->is_set)
arm7_9_set_watchpoint(target, watchpoint); arm7_9_set_watchpoint(target, watchpoint);
watchpoint = watchpoint->next; watchpoint = watchpoint->next;
} }

6
src/target/arm_dpm.c
View File

@ -398,7 +398,7 @@ fail:
* or running debugger code. * or running debugger code.
*/ */
static int dpm_maybe_update_bpwp(struct arm_dpm *dpm, bool bpwp, static int dpm_maybe_update_bpwp(struct arm_dpm *dpm, bool bpwp,
struct dpm_bpwp *xp, int *set_p) struct dpm_bpwp *xp, bool *set_p)
{ {
int retval = ERROR_OK; int retval = ERROR_OK;
bool disable; bool disable;
@ -473,7 +473,7 @@ int arm_dpm_write_dirty_registers(struct arm_dpm *dpm, bool bpwp)
struct breakpoint *bp = dbp->bp; struct breakpoint *bp = dbp->bp;
retval = dpm_maybe_update_bpwp(dpm, bpwp, &dbp->bpwp, retval = dpm_maybe_update_bpwp(dpm, bpwp, &dbp->bpwp,
bp ? &bp->set : NULL); bp ? &bp->is_set : NULL);
if (retval != ERROR_OK) if (retval != ERROR_OK)
goto done; goto done;
} }
@ -485,7 +485,7 @@ int arm_dpm_write_dirty_registers(struct arm_dpm *dpm, bool bpwp)
struct watchpoint *wp = dwp->wp; struct watchpoint *wp = dwp->wp;
retval = dpm_maybe_update_bpwp(dpm, bpwp, &dwp->bpwp, retval = dpm_maybe_update_bpwp(dpm, bpwp, &dwp->bpwp,
wp ? &wp->set : NULL); wp ? &wp->is_set : NULL);
if (retval != ERROR_OK) if (retval != ERROR_OK)
goto done; goto done;
} }

6
src/target/armv8_dpm.c
View File

@ -818,7 +818,7 @@ fail:
* or running debugger code. * or running debugger code.
*/ */
static int dpmv8_maybe_update_bpwp(struct arm_dpm *dpm, bool bpwp, static int dpmv8_maybe_update_bpwp(struct arm_dpm *dpm, bool bpwp,
struct dpm_bpwp *xp, int *set_p) struct dpm_bpwp *xp, bool *set_p)
{ {
int retval = ERROR_OK; int retval = ERROR_OK;
bool disable; bool disable;
@ -892,7 +892,7 @@ int armv8_dpm_write_dirty_registers(struct arm_dpm *dpm, bool bpwp)
struct breakpoint *bp = dbp->bp; struct breakpoint *bp = dbp->bp;
retval = dpmv8_maybe_update_bpwp(dpm, bpwp, &dbp->bpwp, retval = dpmv8_maybe_update_bpwp(dpm, bpwp, &dbp->bpwp,
bp ? &bp->set : NULL); bp ? &bp->is_set : NULL);
if (retval != ERROR_OK) if (retval != ERROR_OK)
goto done; goto done;
} }
@ -904,7 +904,7 @@ int armv8_dpm_write_dirty_registers(struct arm_dpm *dpm, bool bpwp)
struct watchpoint *wp = dwp->wp; struct watchpoint *wp = dwp->wp;
retval = dpmv8_maybe_update_bpwp(dpm, bpwp, &dwp->bpwp, retval = dpmv8_maybe_update_bpwp(dpm, bpwp, &dwp->bpwp,
wp ? &wp->set : NULL); wp ? &wp->is_set : NULL);
if (retval != ERROR_OK) if (retval != ERROR_OK)
goto done; goto done;
} }

6
src/target/breakpoints.c
View File

@ -71,7 +71,7 @@ static int breakpoint_add_internal(struct target *target,
(*breakpoint_p)->asid = 0; (*breakpoint_p)->asid = 0;
(*breakpoint_p)->length = length; (*breakpoint_p)->length = length;
(*breakpoint_p)->type = type; (*breakpoint_p)->type = type;
(*breakpoint_p)->set = 0; (*breakpoint_p)->is_set = false;
(*breakpoint_p)->orig_instr = malloc(length); (*breakpoint_p)->orig_instr = malloc(length);
(*breakpoint_p)->next = NULL; (*breakpoint_p)->next = NULL;
(*breakpoint_p)->unique_id = bpwp_unique_id++; (*breakpoint_p)->unique_id = bpwp_unique_id++;
@ -134,7 +134,7 @@ static int context_breakpoint_add_internal(struct target *target,
(*breakpoint_p)->asid = asid; (*breakpoint_p)->asid = asid;
(*breakpoint_p)->length = length; (*breakpoint_p)->length = length;
(*breakpoint_p)->type = type; (*breakpoint_p)->type = type;
(*breakpoint_p)->set = 0; (*breakpoint_p)->is_set = false;
(*breakpoint_p)->orig_instr = malloc(length); (*breakpoint_p)->orig_instr = malloc(length);
(*breakpoint_p)->next = NULL; (*breakpoint_p)->next = NULL;
(*breakpoint_p)->unique_id = bpwp_unique_id++; (*breakpoint_p)->unique_id = bpwp_unique_id++;
@ -188,7 +188,7 @@ static int hybrid_breakpoint_add_internal(struct target *target,
(*breakpoint_p)->asid = asid; (*breakpoint_p)->asid = asid;
(*breakpoint_p)->length = length; (*breakpoint_p)->length = length;
(*breakpoint_p)->type = type; (*breakpoint_p)->type = type;
(*breakpoint_p)->set = 0; (*breakpoint_p)->is_set = false;
(*breakpoint_p)->orig_instr = malloc(length); (*breakpoint_p)->orig_instr = malloc(length);
(*breakpoint_p)->next = NULL; (*breakpoint_p)->next = NULL;
(*breakpoint_p)->unique_id = bpwp_unique_id++; (*breakpoint_p)->unique_id = bpwp_unique_id++;

18
src/target/breakpoints.h
View File

@ -39,7 +39,8 @@ struct breakpoint {
uint32_t asid; uint32_t asid;
int length; int length;
enum breakpoint_type type; enum breakpoint_type type;
int set; bool is_set;
unsigned int number;
uint8_t *orig_instr; uint8_t *orig_instr;
struct breakpoint *next; struct breakpoint *next;
uint32_t unique_id; uint32_t unique_id;
@ -52,7 +53,8 @@ struct watchpoint {
uint32_t mask; uint32_t mask;
uint32_t value; uint32_t value;
enum watchpoint_rw rw; enum watchpoint_rw rw;
int set; bool is_set;
unsigned int number;
struct watchpoint *next; struct watchpoint *next;
int unique_id; int unique_id;
}; };
@ -69,6 +71,12 @@ void 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);
inline void breakpoint_hw_set(struct breakpoint *breakpoint, unsigned int hw_number)
{
breakpoint->is_set = true;
breakpoint->number = hw_number;
}
void watchpoint_clear_target(struct target *target); void 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,
@ -79,4 +87,10 @@ void watchpoint_remove(struct target *target, target_addr_t address);
int watchpoint_hit(struct target *target, enum watchpoint_rw *rw, int watchpoint_hit(struct target *target, enum watchpoint_rw *rw,
target_addr_t *address); target_addr_t *address);
inline void watchpoint_set(struct watchpoint *watchpoint, unsigned int number)
{
watchpoint->is_set = true;
watchpoint->number = number;
}
#endif /* OPENOCD_TARGET_BREAKPOINTS_H */ #endif /* OPENOCD_TARGET_BREAKPOINTS_H */

48
src/target/cortex_a.c
View File

@ -1185,7 +1185,7 @@ static int cortex_a_step(struct target *target, int current, target_addr_t addre
stepbreakpoint.length = (arm->core_state == ARM_STATE_THUMB) stepbreakpoint.length = (arm->core_state == ARM_STATE_THUMB)
? 2 : 4; ? 2 : 4;
stepbreakpoint.type = BKPT_HARD; stepbreakpoint.type = BKPT_HARD;
stepbreakpoint.set = 0; stepbreakpoint.is_set = false;
/* Disable interrupts during single step if requested */ /* Disable interrupts during single step if requested */
if (cortex_a->isrmasking_mode == CORTEX_A_ISRMASK_ON) { if (cortex_a->isrmasking_mode == CORTEX_A_ISRMASK_ON) {
@ -1265,7 +1265,7 @@ static int cortex_a_set_breakpoint(struct target *target,
struct armv7a_common *armv7a = &cortex_a->armv7a_common; struct armv7a_common *armv7a = &cortex_a->armv7a_common;
struct cortex_a_brp *brp_list = cortex_a->brp_list; struct cortex_a_brp *brp_list = cortex_a->brp_list;
if (breakpoint->set) { if (breakpoint->is_set) {
LOG_WARNING("breakpoint already set"); LOG_WARNING("breakpoint already set");
return ERROR_OK; return ERROR_OK;
} }
@ -1277,7 +1277,7 @@ static int cortex_a_set_breakpoint(struct target *target,
LOG_ERROR("ERROR Can not find free Breakpoint Register Pair"); LOG_ERROR("ERROR Can not find free Breakpoint Register Pair");
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
} }
breakpoint->set = brp_i + 1; breakpoint_hw_set(breakpoint, brp_i);
if (breakpoint->length == 2) if (breakpoint->length == 2)
byte_addr_select = (3 << (breakpoint->address & 0x02)); byte_addr_select = (3 << (breakpoint->address & 0x02));
control = ((matchmode & 0x7) << 20) control = ((matchmode & 0x7) << 20)
@ -1342,7 +1342,7 @@ static int cortex_a_set_breakpoint(struct target *target,
armv7a_l1_i_cache_inval_virt(target, breakpoint->address, armv7a_l1_i_cache_inval_virt(target, breakpoint->address,
breakpoint->length); breakpoint->length);
breakpoint->set = 0x11; /* Any nice value but 0 */ breakpoint->is_set = true;
} }
return ERROR_OK; return ERROR_OK;
@ -1359,7 +1359,7 @@ static int cortex_a_set_context_breakpoint(struct target *target,
struct armv7a_common *armv7a = &cortex_a->armv7a_common; struct armv7a_common *armv7a = &cortex_a->armv7a_common;
struct cortex_a_brp *brp_list = cortex_a->brp_list; struct cortex_a_brp *brp_list = cortex_a->brp_list;
if (breakpoint->set) { if (breakpoint->is_set) {
LOG_WARNING("breakpoint already set"); LOG_WARNING("breakpoint already set");
return retval; return retval;
} }
@ -1373,7 +1373,7 @@ static int cortex_a_set_context_breakpoint(struct target *target,
return ERROR_FAIL; return ERROR_FAIL;
} }
breakpoint->set = brp_i + 1; breakpoint_hw_set(breakpoint, brp_i);
control = ((matchmode & 0x7) << 20) control = ((matchmode & 0x7) << 20)
| (byte_addr_select << 5) | (byte_addr_select << 5)
| (3 << 1) | 1; | (3 << 1) | 1;
@ -1411,7 +1411,7 @@ static int cortex_a_set_hybrid_breakpoint(struct target *target, struct breakpoi
struct armv7a_common *armv7a = &cortex_a->armv7a_common; struct armv7a_common *armv7a = &cortex_a->armv7a_common;
struct cortex_a_brp *brp_list = cortex_a->brp_list; struct cortex_a_brp *brp_list = cortex_a->brp_list;
if (breakpoint->set) { if (breakpoint->is_set) {
LOG_WARNING("breakpoint already set"); LOG_WARNING("breakpoint already set");
return retval; return retval;
} }
@ -1436,7 +1436,7 @@ static int cortex_a_set_hybrid_breakpoint(struct target *target, struct breakpoi
return ERROR_FAIL; return ERROR_FAIL;
} }
breakpoint->set = brp_1 + 1; breakpoint_hw_set(breakpoint, brp_1);
breakpoint->linked_brp = brp_2; breakpoint->linked_brp = brp_2;
control_ctx = ((ctx_machmode & 0x7) << 20) control_ctx = ((ctx_machmode & 0x7) << 20)
| (brp_2 << 16) | (brp_2 << 16)
@ -1485,16 +1485,16 @@ static int cortex_a_unset_breakpoint(struct target *target, struct breakpoint *b
struct armv7a_common *armv7a = &cortex_a->armv7a_common; struct armv7a_common *armv7a = &cortex_a->armv7a_common;
struct cortex_a_brp *brp_list = cortex_a->brp_list; struct cortex_a_brp *brp_list = cortex_a->brp_list;
if (!breakpoint->set) { if (!breakpoint->is_set) {
LOG_WARNING("breakpoint not set"); LOG_WARNING("breakpoint not set");
return ERROR_OK; return ERROR_OK;
} }
if (breakpoint->type == BKPT_HARD) { if (breakpoint->type == BKPT_HARD) {
if ((breakpoint->address != 0) && (breakpoint->asid != 0)) { if ((breakpoint->address != 0) && (breakpoint->asid != 0)) {
int brp_i = breakpoint->set - 1; int brp_i = breakpoint->number;
int brp_j = breakpoint->linked_brp; int brp_j = breakpoint->linked_brp;
if ((brp_i < 0) || (brp_i >= cortex_a->brp_num)) { if (brp_i >= cortex_a->brp_num) {
LOG_DEBUG("Invalid BRP number in breakpoint"); LOG_DEBUG("Invalid BRP number in breakpoint");
return ERROR_OK; return ERROR_OK;
} }
@ -1533,12 +1533,12 @@ static int cortex_a_unset_breakpoint(struct target *target, struct breakpoint *b
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
breakpoint->linked_brp = 0; breakpoint->linked_brp = 0;
breakpoint->set = 0; breakpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} else { } else {
int brp_i = breakpoint->set - 1; int brp_i = breakpoint->number;
if ((brp_i < 0) || (brp_i >= cortex_a->brp_num)) { if (brp_i >= cortex_a->brp_num) {
LOG_DEBUG("Invalid BRP number in breakpoint"); LOG_DEBUG("Invalid BRP number in breakpoint");
return ERROR_OK; return ERROR_OK;
} }
@ -1557,7 +1557,7 @@ static int cortex_a_unset_breakpoint(struct target *target, struct breakpoint *b
brp_list[brp_i].value); brp_list[brp_i].value);
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
breakpoint->set = 0; breakpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
} else { } else {
@ -1589,7 +1589,7 @@ static int cortex_a_unset_breakpoint(struct target *target, struct breakpoint *b
armv7a_l1_i_cache_inval_virt(target, breakpoint->address, armv7a_l1_i_cache_inval_virt(target, breakpoint->address,
breakpoint->length); breakpoint->length);
} }
breakpoint->set = 0; breakpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
@ -1655,7 +1655,7 @@ static int cortex_a_remove_breakpoint(struct target *target, struct breakpoint *
} }
#endif #endif
if (breakpoint->set) { if (breakpoint->is_set) {
cortex_a_unset_breakpoint(target, breakpoint); cortex_a_unset_breakpoint(target, breakpoint);
if (breakpoint->type == BKPT_HARD) if (breakpoint->type == BKPT_HARD)
cortex_a->brp_num_available++; cortex_a->brp_num_available++;
@ -1688,7 +1688,7 @@ static int cortex_a_set_watchpoint(struct target *target, struct watchpoint *wat
struct armv7a_common *armv7a = &cortex_a->armv7a_common; struct armv7a_common *armv7a = &cortex_a->armv7a_common;
struct cortex_a_wrp *wrp_list = cortex_a->wrp_list; struct cortex_a_wrp *wrp_list = cortex_a->wrp_list;
if (watchpoint->set) { if (watchpoint->is_set) {
LOG_WARNING("watchpoint already set"); LOG_WARNING("watchpoint already set");
return retval; return retval;
} }
@ -1741,7 +1741,7 @@ static int cortex_a_set_watchpoint(struct target *target, struct watchpoint *wat
break; break;
} }
watchpoint->set = wrp_i + 1; watchpoint_set(watchpoint, wrp_i);
control = (address_mask << 24) | control = (address_mask << 24) |
(byte_address_select << 5) | (byte_address_select << 5) |
(load_store_access_control << 3) | (load_store_access_control << 3) |
@ -1784,13 +1784,13 @@ static int cortex_a_unset_watchpoint(struct target *target, struct watchpoint *w
struct armv7a_common *armv7a = &cortex_a->armv7a_common; struct armv7a_common *armv7a = &cortex_a->armv7a_common;
struct cortex_a_wrp *wrp_list = cortex_a->wrp_list; struct cortex_a_wrp *wrp_list = cortex_a->wrp_list;
if (!watchpoint->set) { if (!watchpoint->is_set) {
LOG_WARNING("watchpoint not set"); LOG_WARNING("watchpoint not set");
return ERROR_OK; return ERROR_OK;
} }
int wrp_i = watchpoint->set - 1; int wrp_i = watchpoint->number;
if (wrp_i < 0 || wrp_i >= cortex_a->wrp_num) { if (wrp_i >= cortex_a->wrp_num) {
LOG_DEBUG("Invalid WRP number in watchpoint"); LOG_DEBUG("Invalid WRP number in watchpoint");
return ERROR_OK; return ERROR_OK;
} }
@ -1809,7 +1809,7 @@ static int cortex_a_unset_watchpoint(struct target *target, struct watchpoint *w
wrp_list[wrp_i].value); wrp_list[wrp_i].value);
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
watchpoint->set = 0; watchpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
@ -1851,7 +1851,7 @@ static int cortex_a_remove_watchpoint(struct target *target, struct watchpoint *
{ {
struct cortex_a_common *cortex_a = target_to_cortex_a(target); struct cortex_a_common *cortex_a = target_to_cortex_a(target);
if (watchpoint->set) { if (watchpoint->is_set) {
cortex_a->wrp_num_available++; cortex_a->wrp_num_available++;
cortex_a_unset_watchpoint(target, watchpoint); cortex_a_unset_watchpoint(target, watchpoint);
} }

42
src/target/cortex_m.c
View File

@ -1090,7 +1090,7 @@ void cortex_m_enable_breakpoints(struct target *target)
/* set any pending breakpoints */ /* set any pending breakpoints */
while (breakpoint) { while (breakpoint) {
if (!breakpoint->set) if (!breakpoint->is_set)
cortex_m_set_breakpoint(target, breakpoint); cortex_m_set_breakpoint(target, breakpoint);
breakpoint = breakpoint->next; breakpoint = breakpoint->next;
} }
@ -1578,7 +1578,7 @@ int cortex_m_set_breakpoint(struct target *target, struct breakpoint *breakpoint
struct cortex_m_common *cortex_m = target_to_cm(target); struct cortex_m_common *cortex_m = target_to_cm(target);
struct cortex_m_fp_comparator *comparator_list = cortex_m->fp_comparator_list; struct cortex_m_fp_comparator *comparator_list = cortex_m->fp_comparator_list;
if (breakpoint->set) { if (breakpoint->is_set) {
LOG_TARGET_WARNING(target, "breakpoint (BPID: %" PRIu32 ") already set", breakpoint->unique_id); LOG_TARGET_WARNING(target, "breakpoint (BPID: %" PRIu32 ") already set", breakpoint->unique_id);
return ERROR_OK; return ERROR_OK;
} }
@ -1591,7 +1591,7 @@ int cortex_m_set_breakpoint(struct target *target, struct breakpoint *breakpoint
LOG_TARGET_ERROR(target, "Can not find free FPB Comparator!"); LOG_TARGET_ERROR(target, "Can not find free FPB Comparator!");
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
} }
breakpoint->set = fp_num + 1; breakpoint_hw_set(breakpoint, fp_num);
fpcr_value = breakpoint->address | 1; fpcr_value = breakpoint->address | 1;
if (cortex_m->fp_rev == 0) { if (cortex_m->fp_rev == 0) {
if (breakpoint->address > 0x1FFFFFFF) { if (breakpoint->address > 0x1FFFFFFF) {
@ -1643,15 +1643,15 @@ int cortex_m_set_breakpoint(struct target *target, struct breakpoint *breakpoint
code); code);
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
breakpoint->set = true; breakpoint->is_set = true;
} }
LOG_TARGET_DEBUG(target, "BPID: %" PRIu32 ", Type: %d, Address: " TARGET_ADDR_FMT " Length: %d (set=%d)", LOG_TARGET_DEBUG(target, "BPID: %" PRIu32 ", Type: %d, Address: " TARGET_ADDR_FMT " Length: %d (n=%u)",
breakpoint->unique_id, breakpoint->unique_id,
(int)(breakpoint->type), (int)(breakpoint->type),
breakpoint->address, breakpoint->address,
breakpoint->length, breakpoint->length,
breakpoint->set); (breakpoint->type == BKPT_SOFT) ? 0 : breakpoint->number);
return ERROR_OK; return ERROR_OK;
} }
@ -1662,20 +1662,20 @@ int cortex_m_unset_breakpoint(struct target *target, struct breakpoint *breakpoi
struct cortex_m_common *cortex_m = target_to_cm(target); struct cortex_m_common *cortex_m = target_to_cm(target);
struct cortex_m_fp_comparator *comparator_list = cortex_m->fp_comparator_list; struct cortex_m_fp_comparator *comparator_list = cortex_m->fp_comparator_list;
if (breakpoint->set <= 0) { if (!breakpoint->is_set) {
LOG_TARGET_WARNING(target, "breakpoint not set"); LOG_TARGET_WARNING(target, "breakpoint not set");
return ERROR_OK; return ERROR_OK;
} }
LOG_TARGET_DEBUG(target, "BPID: %" PRIu32 ", Type: %d, Address: " TARGET_ADDR_FMT " Length: %d (set=%d)", LOG_TARGET_DEBUG(target, "BPID: %" PRIu32 ", Type: %d, Address: " TARGET_ADDR_FMT " Length: %d (n=%u)",
breakpoint->unique_id, breakpoint->unique_id,
(int)(breakpoint->type), (int)(breakpoint->type),
breakpoint->address, breakpoint->address,
breakpoint->length, breakpoint->length,
breakpoint->set); (breakpoint->type == BKPT_SOFT) ? 0 : breakpoint->number);
if (breakpoint->type == BKPT_HARD) { if (breakpoint->type == BKPT_HARD) {
unsigned int fp_num = breakpoint->set - 1; unsigned int fp_num = breakpoint->number;
if (fp_num >= cortex_m->fp_num_code) { if (fp_num >= cortex_m->fp_num_code) {
LOG_TARGET_DEBUG(target, "Invalid FP Comparator number in breakpoint"); LOG_TARGET_DEBUG(target, "Invalid FP Comparator number in breakpoint");
return ERROR_OK; return ERROR_OK;
@ -1692,7 +1692,7 @@ int cortex_m_unset_breakpoint(struct target *target, struct breakpoint *breakpoi
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
} }
breakpoint->set = false; breakpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
@ -1714,7 +1714,7 @@ int cortex_m_add_breakpoint(struct target *target, struct breakpoint *breakpoint
int cortex_m_remove_breakpoint(struct target *target, struct breakpoint *breakpoint) int cortex_m_remove_breakpoint(struct target *target, struct breakpoint *breakpoint)
{ {
if (!breakpoint->set) if (!breakpoint->is_set)
return ERROR_OK; return ERROR_OK;
return cortex_m_unset_breakpoint(target, breakpoint); return cortex_m_unset_breakpoint(target, breakpoint);
@ -1741,7 +1741,7 @@ static int cortex_m_set_watchpoint(struct target *target, struct watchpoint *wat
return ERROR_FAIL; return ERROR_FAIL;
} }
comparator->used = true; comparator->used = true;
watchpoint->set = dwt_num + 1; watchpoint_set(watchpoint, dwt_num);
comparator->comp = watchpoint->address; comparator->comp = watchpoint->address;
target_write_u32(target, comparator->dwt_comparator_address + 0, target_write_u32(target, comparator->dwt_comparator_address + 0,
@ -1808,15 +1808,15 @@ static int cortex_m_unset_watchpoint(struct target *target, struct watchpoint *w
struct cortex_m_common *cortex_m = target_to_cm(target); struct cortex_m_common *cortex_m = target_to_cm(target);
struct cortex_m_dwt_comparator *comparator; struct cortex_m_dwt_comparator *comparator;
if (watchpoint->set <= 0) { if (!watchpoint->is_set) {
LOG_TARGET_WARNING(target, "watchpoint (wpid: %d) not set", LOG_TARGET_WARNING(target, "watchpoint (wpid: %d) not set",
watchpoint->unique_id); watchpoint->unique_id);
return ERROR_OK; return ERROR_OK;
} }
unsigned int dwt_num = watchpoint->set - 1; unsigned int dwt_num = watchpoint->number;
LOG_TARGET_DEBUG(target, "Watchpoint (ID %d) DWT%d address: 0x%08x clear", LOG_TARGET_DEBUG(target, "Watchpoint (ID %d) DWT%u address: 0x%08x clear",
watchpoint->unique_id, dwt_num, watchpoint->unique_id, dwt_num,
(unsigned) watchpoint->address); (unsigned) watchpoint->address);
@ -1831,7 +1831,7 @@ static int cortex_m_unset_watchpoint(struct target *target, struct watchpoint *w
target_write_u32(target, comparator->dwt_comparator_address + 8, target_write_u32(target, comparator->dwt_comparator_address + 8,
comparator->function); comparator->function);
watchpoint->set = false; watchpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
@ -1895,7 +1895,7 @@ int cortex_m_remove_watchpoint(struct target *target, struct watchpoint *watchpo
return ERROR_TARGET_NOT_HALTED; return ERROR_TARGET_NOT_HALTED;
} }
if (watchpoint->set) if (watchpoint->is_set)
cortex_m_unset_watchpoint(target, watchpoint); cortex_m_unset_watchpoint(target, watchpoint);
cortex_m->dwt_comp_available++; cortex_m->dwt_comp_available++;
@ -1912,10 +1912,10 @@ int cortex_m_hit_watchpoint(struct target *target, struct watchpoint **hit_watch
struct cortex_m_common *cortex_m = target_to_cm(target); struct cortex_m_common *cortex_m = target_to_cm(target);
for (struct watchpoint *wp = target->watchpoints; wp; wp = wp->next) { for (struct watchpoint *wp = target->watchpoints; wp; wp = wp->next) {
if (!wp->set) if (!wp->is_set)
continue; continue;
unsigned int dwt_num = wp->set - 1; unsigned int dwt_num = wp->number;
struct cortex_m_dwt_comparator *comparator = cortex_m->dwt_comparator_list + dwt_num; struct cortex_m_dwt_comparator *comparator = cortex_m->dwt_comparator_list + dwt_num;
uint32_t dwt_function; uint32_t dwt_function;
@ -1939,7 +1939,7 @@ void cortex_m_enable_watchpoints(struct target *target)
/* set any pending watchpoints */ /* set any pending watchpoints */
while (watchpoint) { while (watchpoint) {
if (!watchpoint->set) if (!watchpoint->is_set)
cortex_m_set_watchpoint(target, watchpoint); cortex_m_set_watchpoint(target, watchpoint);
watchpoint = watchpoint->next; watchpoint = watchpoint->next;
} }

16
src/target/esirisc.c
View File

@ -504,7 +504,7 @@ static int esirisc_add_breakpoint(struct target *target, struct breakpoint *brea
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
} }
breakpoint->set = bp_index + 1; breakpoint_hw_set(breakpoint, bp_index);
esirisc->breakpoints_p[bp_index] = breakpoint; esirisc->breakpoints_p[bp_index] = breakpoint;
/* specify instruction breakpoint address */ /* specify instruction breakpoint address */
@ -540,7 +540,7 @@ static int esirisc_add_breakpoints(struct target *target)
LOG_DEBUG("-"); LOG_DEBUG("-");
while (breakpoint) { while (breakpoint) {
if (breakpoint->set == 0) if (!breakpoint->is_set)
esirisc_add_breakpoint(target, breakpoint); esirisc_add_breakpoint(target, breakpoint);
breakpoint = breakpoint->next; breakpoint = breakpoint->next;
@ -553,7 +553,7 @@ static int esirisc_remove_breakpoint(struct target *target, struct breakpoint *b
{ {
struct esirisc_common *esirisc = target_to_esirisc(target); struct esirisc_common *esirisc = target_to_esirisc(target);
struct esirisc_jtag *jtag_info = &esirisc->jtag_info; struct esirisc_jtag *jtag_info = &esirisc->jtag_info;
int bp_index = breakpoint->set - 1; unsigned int bp_index = breakpoint->number;
uint32_t ibc; uint32_t ibc;
int retval; int retval;
@ -575,7 +575,7 @@ static int esirisc_remove_breakpoint(struct target *target, struct breakpoint *b
} }
esirisc->breakpoints_p[bp_index] = NULL; esirisc->breakpoints_p[bp_index] = NULL;
breakpoint->set = 0; breakpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
@ -630,7 +630,7 @@ static int esirisc_add_watchpoint(struct target *target, struct watchpoint *watc
return ERROR_FAIL; return ERROR_FAIL;
} }
watchpoint->set = wp_index + 1; watchpoint_set(watchpoint, wp_index);
esirisc->watchpoints_p[wp_index] = watchpoint; esirisc->watchpoints_p[wp_index] = watchpoint;
/* specify data breakpoint address */ /* specify data breakpoint address */
@ -724,7 +724,7 @@ static int esirisc_add_watchpoints(struct target *target)
LOG_DEBUG("-"); LOG_DEBUG("-");
while (watchpoint) { while (watchpoint) {
if (watchpoint->set == 0) if (!watchpoint->is_set)
esirisc_add_watchpoint(target, watchpoint); esirisc_add_watchpoint(target, watchpoint);
watchpoint = watchpoint->next; watchpoint = watchpoint->next;
@ -737,7 +737,7 @@ static int esirisc_remove_watchpoint(struct target *target, struct watchpoint *w
{ {
struct esirisc_common *esirisc = target_to_esirisc(target); struct esirisc_common *esirisc = target_to_esirisc(target);
struct esirisc_jtag *jtag_info = &esirisc->jtag_info; struct esirisc_jtag *jtag_info = &esirisc->jtag_info;
int wp_index = watchpoint->set - 1; unsigned int wp_index = watchpoint->number;
uint32_t dbc; uint32_t dbc;
int retval; int retval;
@ -759,7 +759,7 @@ static int esirisc_remove_watchpoint(struct target *target, struct watchpoint *w
} }
esirisc->watchpoints_p[wp_index] = NULL; esirisc->watchpoints_p[wp_index] = NULL;
watchpoint->set = 0; watchpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} }

4
src/target/lakemont.c
View File

@ -1024,10 +1024,10 @@ int lakemont_resume(struct target *t, int current, target_addr_t address,
/* if breakpoints are enabled, we need to redirect these into probe mode */ /* if breakpoints are enabled, we need to redirect these into probe mode */
struct breakpoint *activeswbp = t->breakpoints; struct breakpoint *activeswbp = t->breakpoints;
while (activeswbp && activeswbp->set == 0) while (activeswbp && !activeswbp->is_set)
activeswbp = activeswbp->next; activeswbp = activeswbp->next;
struct watchpoint *activehwbp = t->watchpoints; struct watchpoint *activehwbp = t->watchpoints;
while (activehwbp && activehwbp->set == 0) while (activehwbp && !activehwbp->is_set)
activehwbp = activehwbp->next; activehwbp = activehwbp->next;
if (activeswbp || activehwbp) if (activeswbp || activehwbp)
buf_set_u32(x86_32->cache->reg_list[PMCR].value, 0, 32, 1); buf_set_u32(x86_32->cache->reg_list[PMCR].value, 0, 32, 1);

34
src/target/mips_m4k.c
View File

@ -593,7 +593,7 @@ static void mips_m4k_enable_breakpoints(struct target *target)
/* set any pending breakpoints */ /* set any pending breakpoints */
while (breakpoint) { while (breakpoint) {
if (breakpoint->set == 0) if (!breakpoint->is_set)
mips_m4k_set_breakpoint(target, breakpoint); mips_m4k_set_breakpoint(target, breakpoint);
breakpoint = breakpoint->next; breakpoint = breakpoint->next;
} }
@ -607,7 +607,7 @@ static int mips_m4k_set_breakpoint(struct target *target,
struct mips32_comparator *comparator_list = mips32->inst_break_list; struct mips32_comparator *comparator_list = mips32->inst_break_list;
int retval; int retval;
if (breakpoint->set) { if (breakpoint->is_set) {
LOG_WARNING("breakpoint already set"); LOG_WARNING("breakpoint already set");
return ERROR_OK; return ERROR_OK;
} }
@ -622,7 +622,7 @@ static int mips_m4k_set_breakpoint(struct target *target,
breakpoint->unique_id); breakpoint->unique_id);
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
} }
breakpoint->set = bp_num + 1; breakpoint_hw_set(breakpoint, bp_num);
comparator_list[bp_num].used = 1; comparator_list[bp_num].used = 1;
comparator_list[bp_num].bp_value = breakpoint->address; comparator_list[bp_num].bp_value = breakpoint->address;
@ -724,7 +724,7 @@ static int mips_m4k_set_breakpoint(struct target *target,
} }
} }
breakpoint->set = 20; /* Any nice value but 0 */ breakpoint->is_set = true;
} }
return ERROR_OK; return ERROR_OK;
@ -739,14 +739,14 @@ static int mips_m4k_unset_breakpoint(struct target *target,
struct mips32_comparator *comparator_list = mips32->inst_break_list; struct mips32_comparator *comparator_list = mips32->inst_break_list;
int retval; int retval;
if (!breakpoint->set) { if (!breakpoint->is_set) {
LOG_WARNING("breakpoint not set"); LOG_WARNING("breakpoint not set");
return ERROR_OK; return ERROR_OK;
} }
if (breakpoint->type == BKPT_HARD) { if (breakpoint->type == BKPT_HARD) {
int bp_num = breakpoint->set - 1; int bp_num = breakpoint->number;
if ((bp_num < 0) || (bp_num >= mips32->num_inst_bpoints)) { if (bp_num >= mips32->num_inst_bpoints) {
LOG_DEBUG("Invalid FP Comparator number in breakpoint (bpid: %" PRIu32 ")", LOG_DEBUG("Invalid FP Comparator number in breakpoint (bpid: %" PRIu32 ")",
breakpoint->unique_id); breakpoint->unique_id);
return ERROR_OK; return ERROR_OK;
@ -813,7 +813,7 @@ static int mips_m4k_unset_breakpoint(struct target *target,
} }
} }
breakpoint->set = 0; breakpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
@ -851,7 +851,7 @@ static int mips_m4k_remove_breakpoint(struct target *target,
return ERROR_TARGET_NOT_HALTED; return ERROR_TARGET_NOT_HALTED;
} }
if (breakpoint->set) if (breakpoint->is_set)
mips_m4k_unset_breakpoint(target, breakpoint); mips_m4k_unset_breakpoint(target, breakpoint);
if (breakpoint->type == BKPT_HARD) if (breakpoint->type == BKPT_HARD)
@ -875,7 +875,7 @@ static int mips_m4k_set_watchpoint(struct target *target,
int enable = EJTAG_DBCN_NOSB | EJTAG_DBCN_NOLB | EJTAG_DBCN_BE | int enable = EJTAG_DBCN_NOSB | EJTAG_DBCN_NOLB | EJTAG_DBCN_BE |
(0xff << EJTAG_DBCN_BLM_SHIFT); (0xff << EJTAG_DBCN_BLM_SHIFT);
if (watchpoint->set) { if (watchpoint->is_set) {
LOG_WARNING("watchpoint already set"); LOG_WARNING("watchpoint already set");
return ERROR_OK; return ERROR_OK;
} }
@ -911,7 +911,7 @@ static int mips_m4k_set_watchpoint(struct target *target,
LOG_ERROR("BUG: watchpoint->rw neither read, write nor access"); LOG_ERROR("BUG: watchpoint->rw neither read, write nor access");
} }
watchpoint->set = wp_num + 1; watchpoint->number = wp_num;
comparator_list[wp_num].used = 1; comparator_list[wp_num].used = 1;
comparator_list[wp_num].bp_value = watchpoint->address; comparator_list[wp_num].bp_value = watchpoint->address;
@ -946,13 +946,13 @@ static int mips_m4k_unset_watchpoint(struct target *target,
struct mips_ejtag *ejtag_info = &mips32->ejtag_info; struct mips_ejtag *ejtag_info = &mips32->ejtag_info;
struct mips32_comparator *comparator_list = mips32->data_break_list; struct mips32_comparator *comparator_list = mips32->data_break_list;
if (!watchpoint->set) { if (!watchpoint->is_set) {
LOG_WARNING("watchpoint not set"); LOG_WARNING("watchpoint not set");
return ERROR_OK; return ERROR_OK;
} }
int wp_num = watchpoint->set - 1; int wp_num = watchpoint->number;
if ((wp_num < 0) || (wp_num >= mips32->num_data_bpoints)) { if (wp_num >= mips32->num_data_bpoints) {
LOG_DEBUG("Invalid FP Comparator number in watchpoint"); LOG_DEBUG("Invalid FP Comparator number in watchpoint");
return ERROR_OK; return ERROR_OK;
} }
@ -960,7 +960,7 @@ static int mips_m4k_unset_watchpoint(struct target *target,
comparator_list[wp_num].bp_value = 0; comparator_list[wp_num].bp_value = 0;
target_write_u32(target, comparator_list[wp_num].reg_address + target_write_u32(target, comparator_list[wp_num].reg_address +
ejtag_info->ejtag_dbc_offs, 0); ejtag_info->ejtag_dbc_offs, 0);
watchpoint->set = 0; watchpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
@ -991,7 +991,7 @@ static int mips_m4k_remove_watchpoint(struct target *target,
return ERROR_TARGET_NOT_HALTED; return ERROR_TARGET_NOT_HALTED;
} }
if (watchpoint->set) if (watchpoint->is_set)
mips_m4k_unset_watchpoint(target, watchpoint); mips_m4k_unset_watchpoint(target, watchpoint);
mips32->num_data_bpoints_avail++; mips32->num_data_bpoints_avail++;
@ -1005,7 +1005,7 @@ static void mips_m4k_enable_watchpoints(struct target *target)
/* set any pending watchpoints */ /* set any pending watchpoints */
while (watchpoint) { while (watchpoint) {
if (watchpoint->set == 0) if (!watchpoint->is_set)
mips_m4k_set_watchpoint(target, watchpoint); mips_m4k_set_watchpoint(target, watchpoint);
watchpoint = watchpoint->next; watchpoint = watchpoint->next;
} }

33
src/target/mips_mips64.c
View File

@ -346,7 +346,7 @@ static int mips_mips64_set_breakpoint(struct target *target,
{ {
int retval; int retval;
if (bp->set) { if (bp->is_set) {
LOG_WARNING("breakpoint already set"); LOG_WARNING("breakpoint already set");
return ERROR_OK; return ERROR_OK;
} }
@ -373,7 +373,7 @@ static int mips_mips64_set_breakpoint(struct target *target,
return retval; return retval;
} }
bp->set = true; bp->is_set = true;
return ERROR_OK; return ERROR_OK;
} }
@ -385,7 +385,7 @@ static int mips_mips64_enable_breakpoints(struct target *target)
/* set any pending breakpoints */ /* set any pending breakpoints */
while (bp) { while (bp) {
if (!bp->set) { if (!bp->is_set) {
retval = mips_mips64_set_breakpoint(target, bp); retval = mips_mips64_set_breakpoint(target, bp);
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
@ -413,7 +413,7 @@ static int mips_mips64_set_watchpoint(struct target *target,
int enable = EJTAG_DBCN_NOSB | EJTAG_DBCN_NOLB | EJTAG_DBCN_BE int enable = EJTAG_DBCN_NOSB | EJTAG_DBCN_NOLB | EJTAG_DBCN_BE
| (0xff << EJTAG_DBCN_BLM_SHIFT); | (0xff << EJTAG_DBCN_BLM_SHIFT);
if (watchpoint->set) { if (watchpoint->is_set) {
LOG_WARNING("watchpoint already set"); LOG_WARNING("watchpoint already set");
return ERROR_OK; return ERROR_OK;
} }
@ -451,7 +451,7 @@ static int mips_mips64_set_watchpoint(struct target *target,
} }
c = &cl[wp_num]; c = &cl[wp_num];
watchpoint->set = wp_num + 1; watchpoint_set(watchpoint, wp_num);
c->used = true; c->used = true;
c->bp_value = watchpoint->address; c->bp_value = watchpoint->address;
@ -491,7 +491,7 @@ static int mips_mips64_enable_watchpoints(struct target *target)
/* set any pending watchpoints */ /* set any pending watchpoints */
while (watchpoint) { while (watchpoint) {
if (watchpoint->set == 0) { if (!watchpoint->is_set) {
retval = mips_mips64_set_watchpoint(target, watchpoint); retval = mips_mips64_set_watchpoint(target, watchpoint);
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
@ -506,11 +506,10 @@ static int mips_mips64_unset_hwbp(struct target *target, struct breakpoint *bp)
{ {
struct mips64_common *mips64 = target->arch_info; struct mips64_common *mips64 = target->arch_info;
struct mips64_comparator *comparator_list = mips64->inst_break_list; struct mips64_comparator *comparator_list = mips64->inst_break_list;
int bp_num;
bp_num = bp->set - 1; int bp_num = bp->number;
if ((bp_num < 0) || (bp_num >= mips64->num_inst_bpoints)) { if (bp_num >= mips64->num_inst_bpoints) {
LOG_DEBUG("Invalid FP Comparator number in breakpoint (bpid: %" PRIu32 ")", LOG_DEBUG("Invalid FP Comparator number in breakpoint (bpid: %" PRIu32 ")",
bp->unique_id); bp->unique_id);
return ERROR_OK; return ERROR_OK;
@ -568,7 +567,7 @@ static int mips_mips64_unset_breakpoint(struct target *target,
/* get pointers to arch-specific information */ /* get pointers to arch-specific information */
int retval; int retval;
if (!bp->set) { if (!bp->is_set) {
LOG_WARNING("breakpoint not set"); LOG_WARNING("breakpoint not set");
return ERROR_OK; return ERROR_OK;
} }
@ -594,7 +593,7 @@ static int mips_mips64_unset_breakpoint(struct target *target,
return retval; return retval;
} }
bp->set = false; bp->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
@ -815,7 +814,7 @@ static int mips_mips64_remove_breakpoint(struct target *target,
return ERROR_TARGET_NOT_HALTED; return ERROR_TARGET_NOT_HALTED;
} }
if (bp->set) if (bp->is_set)
retval = mips_mips64_unset_breakpoint(target, bp); retval = mips_mips64_unset_breakpoint(target, bp);
if (bp->type == BKPT_HARD) if (bp->type == BKPT_HARD)
@ -831,20 +830,20 @@ static int mips_mips64_unset_watchpoint(struct target *target,
struct mips64_common *mips64 = target->arch_info; struct mips64_common *mips64 = target->arch_info;
struct mips64_comparator *comparator_list = mips64->data_break_list; struct mips64_comparator *comparator_list = mips64->data_break_list;
if (!watchpoint->set) { if (!watchpoint->is_set) {
LOG_WARNING("watchpoint not set"); LOG_WARNING("watchpoint not set");
return ERROR_OK; return ERROR_OK;
} }
int wp_num = watchpoint->set - 1; int wp_num = watchpoint->number;
if ((wp_num < 0) || (wp_num >= mips64->num_data_bpoints)) { if (wp_num >= mips64->num_data_bpoints) {
LOG_DEBUG("Invalid FP Comparator number in watchpoint"); LOG_DEBUG("Invalid FP Comparator number in watchpoint");
return ERROR_OK; return ERROR_OK;
} }
comparator_list[wp_num].used = false; comparator_list[wp_num].used = false;
comparator_list[wp_num].bp_value = 0; comparator_list[wp_num].bp_value = 0;
target_write_u64(target, comparator_list[wp_num].reg_address + 0x18, 0); target_write_u64(target, comparator_list[wp_num].reg_address + 0x18, 0);
watchpoint->set = 0; watchpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
@ -876,7 +875,7 @@ static int mips_mips64_remove_watchpoint(struct target *target,
return ERROR_TARGET_NOT_HALTED; return ERROR_TARGET_NOT_HALTED;
} }
if (watchpoint->set) if (watchpoint->is_set)
retval = mips_mips64_unset_watchpoint(target, watchpoint); retval = mips_mips64_unset_watchpoint(target, watchpoint);
mips64->num_data_bpoints_avail++; mips64->num_data_bpoints_avail++;

2
src/target/nds32.c
View File

@ -1653,7 +1653,7 @@ int nds32_init_arch_info(struct target *target, struct nds32 *nds32)
nds32->syscall_break.asid = 0; nds32->syscall_break.asid = 0;
nds32->syscall_break.length = 4; nds32->syscall_break.length = 4;
nds32->syscall_break.set = 0; nds32->syscall_break.is_set = false;
nds32->syscall_break.orig_instr = NULL; nds32->syscall_break.orig_instr = NULL;
nds32->syscall_break.next = NULL; nds32->syscall_break.next = NULL;
nds32->syscall_break.unique_id = 0x515CAll + target->target_number; nds32->syscall_break.unique_id = 0x515CAll + target->target_number;

6
src/target/nds32_v3_common.c
View File

@ -78,12 +78,12 @@ static int nds32_v3_debug_entry(struct nds32 *nds32, bool enable_watchpoint)
struct breakpoint *syscall_break = &(nds32->syscall_break); struct breakpoint *syscall_break = &(nds32->syscall_break);
if (nds32->virtual_hosting) { if (nds32->virtual_hosting) {
if (syscall_break->set) { if (syscall_break->is_set) {
/** disable virtual hosting */ /** disable virtual hosting */
/* remove breakpoint at syscall entry */ /* remove breakpoint at syscall entry */
target_remove_breakpoint(nds32->target, syscall_break); target_remove_breakpoint(nds32->target, syscall_break);
syscall_break->set = 0; syscall_break->is_set = false;
uint32_t value_pc; uint32_t value_pc;
nds32_get_mapped_reg(nds32, PC, &value_pc); nds32_get_mapped_reg(nds32, PC, &value_pc);
@ -209,7 +209,7 @@ static int nds32_v3_leave_debug_state(struct nds32 *nds32, bool enable_watchpoin
syscall_break->address = syscall_address; syscall_break->address = syscall_address;
syscall_break->type = BKPT_SOFT; syscall_break->type = BKPT_SOFT;
syscall_break->set = 1; syscall_break->is_set = true;
target_add_breakpoint(target, syscall_break); target_add_breakpoint(target, syscall_break);
} }

8
src/target/openrisc/or1k.c
View File

@ -923,9 +923,9 @@ static int or1k_add_breakpoint(struct target *target,
struct or1k_du *du_core = or1k_to_du(or1k); struct or1k_du *du_core = or1k_to_du(or1k);
uint8_t data; uint8_t data;
LOG_DEBUG("Adding breakpoint: addr 0x%08" TARGET_PRIxADDR ", len %d, type %d, set: %d, id: %" PRIu32, LOG_DEBUG("Adding breakpoint: addr 0x%08" TARGET_PRIxADDR ", len %d, type %d, id: %" PRIu32,
breakpoint->address, breakpoint->length, breakpoint->type, breakpoint->address, breakpoint->length, breakpoint->type,
breakpoint->set, breakpoint->unique_id); breakpoint->unique_id);
/* Only support SW breakpoints for now. */ /* Only support SW breakpoints for now. */
if (breakpoint->type == BKPT_HARD) if (breakpoint->type == BKPT_HARD)
@ -981,9 +981,9 @@ static int or1k_remove_breakpoint(struct target *target,
struct or1k_common *or1k = target_to_or1k(target); struct or1k_common *or1k = target_to_or1k(target);
struct or1k_du *du_core = or1k_to_du(or1k); struct or1k_du *du_core = or1k_to_du(or1k);
LOG_DEBUG("Removing breakpoint: addr 0x%08" TARGET_PRIxADDR ", len %d, type %d, set: %d, id: %" PRIu32, LOG_DEBUG("Removing breakpoint: addr 0x%08" TARGET_PRIxADDR ", len %d, type %d, id: %" PRIu32,
breakpoint->address, breakpoint->length, breakpoint->type, breakpoint->address, breakpoint->length, breakpoint->type,
breakpoint->set, breakpoint->unique_id); breakpoint->unique_id);
/* Only support SW breakpoints for now. */ /* Only support SW breakpoints for now. */
if (breakpoint->type == BKPT_HARD) if (breakpoint->type == BKPT_HARD)

14
src/target/riscv/riscv.c
View File

@ -903,7 +903,7 @@ int riscv_add_breakpoint(struct target *target, struct breakpoint *breakpoint)
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
} }
breakpoint->set = true; breakpoint->is_set = true;
return ERROR_OK; return ERROR_OK;
} }
@ -963,7 +963,7 @@ int riscv_remove_breakpoint(struct target *target,
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
} }
breakpoint->set = false; breakpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
@ -990,7 +990,7 @@ int riscv_add_watchpoint(struct target *target, struct watchpoint *watchpoint)
int result = add_trigger(target, &trigger); int result = add_trigger(target, &trigger);
if (result != ERROR_OK) if (result != ERROR_OK)
return result; return result;
watchpoint->set = true; watchpoint->is_set = true;
return ERROR_OK; return ERROR_OK;
} }
@ -1006,7 +1006,7 @@ int riscv_remove_watchpoint(struct target *target,
int result = remove_trigger(target, &trigger); int result = remove_trigger(target, &trigger);
if (result != ERROR_OK) if (result != ERROR_OK)
return result; return result;
watchpoint->set = false; watchpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
@ -1338,9 +1338,9 @@ static int disable_triggers(struct target *target, riscv_reg_t *state)
struct watchpoint *watchpoint = target->watchpoints; struct watchpoint *watchpoint = target->watchpoints;
int i = 0; int i = 0;
while (watchpoint) { while (watchpoint) {
LOG_DEBUG("watchpoint %d: set=%d", i, watchpoint->set); LOG_DEBUG("watchpoint %d: set=%d", i, watchpoint->is_set);
state[i] = watchpoint->set; state[i] = watchpoint->is_set;
if (watchpoint->set) { if (watchpoint->is_set) {
if (riscv_remove_watchpoint(target, watchpoint) != ERROR_OK) if (riscv_remove_watchpoint(target, watchpoint) != ERROR_OK)
return ERROR_FAIL; return ERROR_FAIL;
} }

34
src/target/stm8.c
View File

@ -1370,7 +1370,7 @@ static void stm8_enable_breakpoints(struct target *target)
/* set any pending breakpoints */ /* set any pending breakpoints */
while (breakpoint) { while (breakpoint) {
if (breakpoint->set == 0) if (!breakpoint->is_set)
stm8_set_breakpoint(target, breakpoint); stm8_set_breakpoint(target, breakpoint);
breakpoint = breakpoint->next; breakpoint = breakpoint->next;
} }
@ -1383,7 +1383,7 @@ static int stm8_set_breakpoint(struct target *target,
struct stm8_comparator *comparator_list = stm8->hw_break_list; struct stm8_comparator *comparator_list = stm8->hw_break_list;
int retval; int retval;
if (breakpoint->set) { if (breakpoint->is_set) {
LOG_WARNING("breakpoint already set"); LOG_WARNING("breakpoint already set");
return ERROR_OK; return ERROR_OK;
} }
@ -1398,7 +1398,7 @@ static int stm8_set_breakpoint(struct target *target,
breakpoint->unique_id); breakpoint->unique_id);
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
} }
breakpoint->set = bp_num + 1; breakpoint_hw_set(breakpoint, bp_num);
comparator_list[bp_num].used = true; comparator_list[bp_num].used = true;
comparator_list[bp_num].bp_value = breakpoint->address; comparator_list[bp_num].bp_value = breakpoint->address;
comparator_list[bp_num].type = HWBRK_EXEC; comparator_list[bp_num].type = HWBRK_EXEC;
@ -1435,7 +1435,7 @@ static int stm8_set_breakpoint(struct target *target,
} else { } else {
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
} }
breakpoint->set = 1; /* Any nice value but 0 */ breakpoint->is_set = true;
} }
return ERROR_OK; return ERROR_OK;
@ -1476,14 +1476,14 @@ static int stm8_unset_breakpoint(struct target *target,
struct stm8_comparator *comparator_list = stm8->hw_break_list; struct stm8_comparator *comparator_list = stm8->hw_break_list;
int retval; int retval;
if (!breakpoint->set) { if (!breakpoint->is_set) {
LOG_WARNING("breakpoint not set"); LOG_WARNING("breakpoint not set");
return ERROR_OK; return ERROR_OK;
} }
if (breakpoint->type == BKPT_HARD) { if (breakpoint->type == BKPT_HARD) {
int bp_num = breakpoint->set - 1; int bp_num = breakpoint->number;
if ((bp_num < 0) || (bp_num >= stm8->num_hw_bpoints)) { if (bp_num >= stm8->num_hw_bpoints) {
LOG_DEBUG("Invalid comparator number in breakpoint (bpid: %" PRIu32 ")", LOG_DEBUG("Invalid comparator number in breakpoint (bpid: %" PRIu32 ")",
breakpoint->unique_id); breakpoint->unique_id);
return ERROR_OK; return ERROR_OK;
@ -1517,7 +1517,7 @@ static int stm8_unset_breakpoint(struct target *target,
} else } else
return ERROR_FAIL; return ERROR_FAIL;
} }
breakpoint->set = 0; breakpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
@ -1533,7 +1533,7 @@ static int stm8_remove_breakpoint(struct target *target,
return ERROR_TARGET_NOT_HALTED; return ERROR_TARGET_NOT_HALTED;
} }
if (breakpoint->set) if (breakpoint->is_set)
stm8_unset_breakpoint(target, breakpoint); stm8_unset_breakpoint(target, breakpoint);
if (breakpoint->type == BKPT_HARD) if (breakpoint->type == BKPT_HARD)
@ -1550,7 +1550,7 @@ static int stm8_set_watchpoint(struct target *target,
int wp_num = 0; int wp_num = 0;
int ret; int ret;
if (watchpoint->set) { if (watchpoint->is_set) {
LOG_WARNING("watchpoint already set"); LOG_WARNING("watchpoint already set");
return ERROR_OK; return ERROR_OK;
} }
@ -1593,7 +1593,7 @@ static int stm8_set_watchpoint(struct target *target,
return ret; return ret;
} }
watchpoint->set = wp_num + 1; watchpoint_set(watchpoint, wp_num);
LOG_DEBUG("wp_num %i bp_value 0x%" PRIx32 "", LOG_DEBUG("wp_num %i bp_value 0x%" PRIx32 "",
wp_num, wp_num,
@ -1627,7 +1627,7 @@ static void stm8_enable_watchpoints(struct target *target)
/* set any pending watchpoints */ /* set any pending watchpoints */
while (watchpoint) { while (watchpoint) {
if (watchpoint->set == 0) if (!watchpoint->is_set)
stm8_set_watchpoint(target, watchpoint); stm8_set_watchpoint(target, watchpoint);
watchpoint = watchpoint->next; watchpoint = watchpoint->next;
} }
@ -1640,18 +1640,18 @@ static int stm8_unset_watchpoint(struct target *target,
struct stm8_common *stm8 = target_to_stm8(target); struct stm8_common *stm8 = target_to_stm8(target);
struct stm8_comparator *comparator_list = stm8->hw_break_list; struct stm8_comparator *comparator_list = stm8->hw_break_list;
if (!watchpoint->set) { if (!watchpoint->is_set) {
LOG_WARNING("watchpoint not set"); LOG_WARNING("watchpoint not set");
return ERROR_OK; return ERROR_OK;
} }
int wp_num = watchpoint->set - 1; int wp_num = watchpoint->number;
if ((wp_num < 0) || (wp_num >= stm8->num_hw_bpoints)) { if (wp_num >= stm8->num_hw_bpoints) {
LOG_DEBUG("Invalid hw comparator number in watchpoint"); LOG_DEBUG("Invalid hw comparator number in watchpoint");
return ERROR_OK; return ERROR_OK;
} }
comparator_list[wp_num].used = false; comparator_list[wp_num].used = false;
watchpoint->set = 0; watchpoint->is_set = false;
stm8_set_hwbreak(target, comparator_list); stm8_set_hwbreak(target, comparator_list);
@ -1669,7 +1669,7 @@ static int stm8_remove_watchpoint(struct target *target,
return ERROR_TARGET_NOT_HALTED; return ERROR_TARGET_NOT_HALTED;
} }
if (watchpoint->set) if (watchpoint->is_set)
stm8_unset_watchpoint(target, watchpoint); stm8_unset_watchpoint(target, watchpoint);
stm8->num_hw_bpoints_avail++; stm8->num_hw_bpoints_avail++;

16
src/target/target.c
View File

@ -3967,26 +3967,26 @@ static int handle_bp_command_list(struct command_invocation *cmd)
if (breakpoint->type == BKPT_SOFT) { if (breakpoint->type == BKPT_SOFT) {
char *buf = buf_to_hex_str(breakpoint->orig_instr, char *buf = buf_to_hex_str(breakpoint->orig_instr,
breakpoint->length); breakpoint->length);
command_print(cmd, "IVA breakpoint: " TARGET_ADDR_FMT ", 0x%x, %i, 0x%s", command_print(cmd, "IVA breakpoint: " TARGET_ADDR_FMT ", 0x%x, 0x%s",
breakpoint->address, breakpoint->address,
breakpoint->length, breakpoint->length,
breakpoint->set, buf); buf);
free(buf); free(buf);
} else { } else {
if ((breakpoint->address == 0) && (breakpoint->asid != 0)) if ((breakpoint->address == 0) && (breakpoint->asid != 0))
command_print(cmd, "Context breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i", command_print(cmd, "Context breakpoint: 0x%8.8" PRIx32 ", 0x%x, %u",
breakpoint->asid, breakpoint->asid,
breakpoint->length, breakpoint->set); breakpoint->length, breakpoint->number);
else if ((breakpoint->address != 0) && (breakpoint->asid != 0)) { else if ((breakpoint->address != 0) && (breakpoint->asid != 0)) {
command_print(cmd, "Hybrid breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i", command_print(cmd, "Hybrid breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %u",
breakpoint->address, breakpoint->address,
breakpoint->length, breakpoint->set); breakpoint->length, breakpoint->number);
command_print(cmd, "\t|--->linked with ContextID: 0x%8.8" PRIx32, command_print(cmd, "\t|--->linked with ContextID: 0x%8.8" PRIx32,
breakpoint->asid); breakpoint->asid);
} else } else
command_print(cmd, "Breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i", command_print(cmd, "Breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %u",
breakpoint->address, breakpoint->address,
breakpoint->length, breakpoint->set); breakpoint->length, breakpoint->number);
} }
breakpoint = breakpoint->next; breakpoint = breakpoint->next;

30
src/target/x86_32_common.c
View File

@ -862,7 +862,7 @@ int x86_32_common_remove_watchpoint(struct target *t, struct watchpoint *wp)
{ {
if (check_not_halted(t)) if (check_not_halted(t))
return ERROR_TARGET_NOT_HALTED; return ERROR_TARGET_NOT_HALTED;
if (wp->set) if (wp->is_set)
unset_watchpoint(t, wp); unset_watchpoint(t, wp);
return ERROR_OK; return ERROR_OK;
} }
@ -883,7 +883,7 @@ int x86_32_common_remove_breakpoint(struct target *t, struct breakpoint *bp)
LOG_DEBUG("type=%d, addr=" TARGET_ADDR_FMT, bp->type, bp->address); LOG_DEBUG("type=%d, addr=" TARGET_ADDR_FMT, bp->type, bp->address);
if (check_not_halted(t)) if (check_not_halted(t))
return ERROR_TARGET_NOT_HALTED; return ERROR_TARGET_NOT_HALTED;
if (bp->set) if (bp->is_set)
unset_breakpoint(t, bp); unset_breakpoint(t, bp);
return ERROR_OK; return ERROR_OK;
@ -995,7 +995,7 @@ static int set_hwbp(struct target *t, struct breakpoint *bp)
} }
if (set_debug_regs(t, bp->address, hwbp_num, DR7_BP_EXECUTE, 1) != ERROR_OK) if (set_debug_regs(t, bp->address, hwbp_num, DR7_BP_EXECUTE, 1) != ERROR_OK)
return ERROR_FAIL; return ERROR_FAIL;
bp->set = hwbp_num + 1; breakpoint_hw_set(bp, hwbp_num);
debug_reg_list[hwbp_num].used = 1; debug_reg_list[hwbp_num].used = 1;
debug_reg_list[hwbp_num].bp_value = bp->address; debug_reg_list[hwbp_num].bp_value = bp->address;
LOG_USER("%s hardware breakpoint %" PRIu32 " set at 0x%08" PRIx32 " (hwreg=%" PRIu8 ")", __func__, LOG_USER("%s hardware breakpoint %" PRIu32 " set at 0x%08" PRIx32 " (hwreg=%" PRIu8 ")", __func__,
@ -1007,9 +1007,9 @@ static int unset_hwbp(struct target *t, struct breakpoint *bp)
{ {
struct x86_32_common *x86_32 = target_to_x86_32(t); struct x86_32_common *x86_32 = target_to_x86_32(t);
struct x86_32_dbg_reg *debug_reg_list = x86_32->hw_break_list; struct x86_32_dbg_reg *debug_reg_list = x86_32->hw_break_list;
int hwbp_num = bp->set - 1; int hwbp_num = bp->number;
if ((hwbp_num < 0) || (hwbp_num >= x86_32->num_hw_bpoints)) { if (hwbp_num >= x86_32->num_hw_bpoints) {
LOG_ERROR("%s invalid breakpoint number=%d, bpid=%" PRIu32, LOG_ERROR("%s invalid breakpoint number=%d, bpid=%" PRIu32,
__func__, hwbp_num, bp->unique_id); __func__, hwbp_num, bp->unique_id);
return ERROR_OK; return ERROR_OK;
@ -1055,7 +1055,7 @@ static int set_swbp(struct target *t, struct breakpoint *bp)
__func__, readback, *bp->orig_instr); __func__, readback, *bp->orig_instr);
return ERROR_FAIL; return ERROR_FAIL;
} }
bp->set = SW_BP_OPCODE; /* just non 0 */ bp->is_set = true;
/* add the memory patch */ /* add the memory patch */
struct swbp_mem_patch *new_patch = malloc(sizeof(struct swbp_mem_patch)); struct swbp_mem_patch *new_patch = malloc(sizeof(struct swbp_mem_patch));
@ -1134,7 +1134,7 @@ static int set_breakpoint(struct target *t, struct breakpoint *bp)
int error = ERROR_OK; int error = ERROR_OK;
struct x86_32_common *x86_32 = target_to_x86_32(t); struct x86_32_common *x86_32 = target_to_x86_32(t);
LOG_DEBUG("type=%d, addr=" TARGET_ADDR_FMT, bp->type, bp->address); LOG_DEBUG("type=%d, addr=" TARGET_ADDR_FMT, bp->type, bp->address);
if (bp->set) { if (bp->is_set) {
LOG_ERROR("breakpoint already set"); LOG_ERROR("breakpoint already set");
return error; return error;
} }
@ -1164,7 +1164,7 @@ static int set_breakpoint(struct target *t, struct breakpoint *bp)
static int unset_breakpoint(struct target *t, struct breakpoint *bp) static int unset_breakpoint(struct target *t, struct breakpoint *bp)
{ {
LOG_DEBUG("type=%d, addr=" TARGET_ADDR_FMT, bp->type, bp->address); LOG_DEBUG("type=%d, addr=" TARGET_ADDR_FMT, bp->type, bp->address);
if (!bp->set) { if (!bp->is_set) {
LOG_WARNING("breakpoint not set"); LOG_WARNING("breakpoint not set");
return ERROR_OK; return ERROR_OK;
} }
@ -1182,7 +1182,7 @@ static int unset_breakpoint(struct target *t, struct breakpoint *bp)
return ERROR_FAIL; return ERROR_FAIL;
} }
} }
bp->set = 0; bp->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
@ -1193,7 +1193,7 @@ static int set_watchpoint(struct target *t, struct watchpoint *wp)
int wp_num = 0; int wp_num = 0;
LOG_DEBUG("type=%d, addr=" TARGET_ADDR_FMT, wp->rw, wp->address); LOG_DEBUG("type=%d, addr=" TARGET_ADDR_FMT, wp->rw, wp->address);
if (wp->set) { if (wp->is_set) {
LOG_ERROR("%s watchpoint already set", __func__); LOG_ERROR("%s watchpoint already set", __func__);
return ERROR_OK; return ERROR_OK;
} }
@ -1233,7 +1233,7 @@ static int set_watchpoint(struct target *t, struct watchpoint *wp)
LOG_ERROR("%s only 'access' or 'write' watchpoints are supported", __func__); LOG_ERROR("%s only 'access' or 'write' watchpoints are supported", __func__);
break; break;
} }
wp->set = wp_num + 1; watchpoint_set(wp, wp_num);
debug_reg_list[wp_num].used = 1; debug_reg_list[wp_num].used = 1;
debug_reg_list[wp_num].bp_value = wp->address; debug_reg_list[wp_num].bp_value = wp->address;
LOG_USER("'%s' watchpoint %d set at " TARGET_ADDR_FMT " with length %" PRIu32 " (hwreg=%d)", LOG_USER("'%s' watchpoint %d set at " TARGET_ADDR_FMT " with length %" PRIu32 " (hwreg=%d)",
@ -1248,13 +1248,13 @@ static int unset_watchpoint(struct target *t, struct watchpoint *wp)
struct x86_32_common *x86_32 = target_to_x86_32(t); struct x86_32_common *x86_32 = target_to_x86_32(t);
struct x86_32_dbg_reg *debug_reg_list = x86_32->hw_break_list; struct x86_32_dbg_reg *debug_reg_list = x86_32->hw_break_list;
LOG_DEBUG("type=%d, addr=" TARGET_ADDR_FMT, wp->rw, wp->address); LOG_DEBUG("type=%d, addr=" TARGET_ADDR_FMT, wp->rw, wp->address);
if (!wp->set) { if (!wp->is_set) {
LOG_WARNING("watchpoint not set"); LOG_WARNING("watchpoint not set");
return ERROR_OK; return ERROR_OK;
} }
int wp_num = wp->set - 1; int wp_num = wp->number;
if ((wp_num < 0) || (wp_num >= x86_32->num_hw_bpoints)) { if (wp_num >= x86_32->num_hw_bpoints) {
LOG_DEBUG("Invalid FP Comparator number in watchpoint"); LOG_DEBUG("Invalid FP Comparator number in watchpoint");
return ERROR_OK; return ERROR_OK;
} }
@ -1263,7 +1263,7 @@ static int unset_watchpoint(struct target *t, struct watchpoint *wp)
debug_reg_list[wp_num].used = 0; debug_reg_list[wp_num].used = 0;
debug_reg_list[wp_num].bp_value = 0; debug_reg_list[wp_num].bp_value = 0;
wp->set = 0; wp->is_set = false;
LOG_USER("'%s' watchpoint %d removed from " TARGET_ADDR_FMT " with length %" PRIu32 " (hwreg=%d)", LOG_USER("'%s' watchpoint %d removed from " TARGET_ADDR_FMT " with length %" PRIu32 " (hwreg=%d)",
wp->rw == WPT_READ ? "read" : wp->rw == WPT_WRITE ? wp->rw == WPT_READ ? "read" : wp->rw == WPT_WRITE ?

42
src/target/xscale.c
View File

@ -1087,7 +1087,7 @@ static void xscale_enable_watchpoints(struct target *target)
struct watchpoint *watchpoint = target->watchpoints; struct watchpoint *watchpoint = target->watchpoints;
while (watchpoint) { while (watchpoint) {
if (watchpoint->set == 0) if (!watchpoint->is_set)
xscale_set_watchpoint(target, watchpoint); xscale_set_watchpoint(target, watchpoint);
watchpoint = watchpoint->next; watchpoint = watchpoint->next;
} }
@ -1099,7 +1099,7 @@ static void xscale_enable_breakpoints(struct target *target)
/* set any pending breakpoints */ /* set any pending breakpoints */
while (breakpoint) { while (breakpoint) {
if (breakpoint->set == 0) if (!breakpoint->is_set)
xscale_set_breakpoint(target, breakpoint); xscale_set_breakpoint(target, breakpoint);
breakpoint = breakpoint->next; breakpoint = breakpoint->next;
} }
@ -1506,7 +1506,7 @@ static int xscale_deassert_reset(struct target *target)
/* mark all hardware breakpoints as unset */ /* mark all hardware breakpoints as unset */
while (breakpoint) { while (breakpoint) {
if (breakpoint->type == BKPT_HARD) if (breakpoint->type == BKPT_HARD)
breakpoint->set = 0; breakpoint->is_set = false;
breakpoint = breakpoint->next; breakpoint = breakpoint->next;
} }
@ -2088,7 +2088,7 @@ static int xscale_set_breakpoint(struct target *target,
return ERROR_TARGET_NOT_HALTED; return ERROR_TARGET_NOT_HALTED;
} }
if (breakpoint->set) { if (breakpoint->is_set) {
LOG_WARNING("breakpoint already set"); LOG_WARNING("breakpoint already set");
return ERROR_OK; return ERROR_OK;
} }
@ -2098,11 +2098,13 @@ static int xscale_set_breakpoint(struct target *target,
if (!xscale->ibcr0_used) { if (!xscale->ibcr0_used) {
xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_IBCR0], value); xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_IBCR0], value);
xscale->ibcr0_used = 1; xscale->ibcr0_used = 1;
breakpoint->set = 1; /* breakpoint set on first breakpoint register */ /* breakpoint set on first breakpoint register */
breakpoint_hw_set(breakpoint, 0);
} else if (!xscale->ibcr1_used) { } else if (!xscale->ibcr1_used) {
xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_IBCR1], value); xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_IBCR1], value);
xscale->ibcr1_used = 1; xscale->ibcr1_used = 1;
breakpoint->set = 2; /* breakpoint set on second breakpoint register */ /* breakpoint set on second breakpoint register */
breakpoint_hw_set(breakpoint, 1);
} else {/* bug: availability previously verified in xscale_add_breakpoint() */ } else {/* bug: availability previously verified in xscale_add_breakpoint() */
LOG_ERROR("BUG: no hardware comparator available"); LOG_ERROR("BUG: no hardware comparator available");
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
@ -2133,7 +2135,7 @@ static int xscale_set_breakpoint(struct target *target,
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
} }
breakpoint->set = 1; breakpoint->is_set = true;
xscale_send_u32(target, 0x50); /* clean dcache */ xscale_send_u32(target, 0x50); /* clean dcache */
xscale_send_u32(target, xscale->cache_clean_address); xscale_send_u32(target, xscale->cache_clean_address);
@ -2176,20 +2178,20 @@ static int xscale_unset_breakpoint(struct target *target,
return ERROR_TARGET_NOT_HALTED; return ERROR_TARGET_NOT_HALTED;
} }
if (!breakpoint->set) { if (!breakpoint->is_set) {
LOG_WARNING("breakpoint not set"); LOG_WARNING("breakpoint not set");
return ERROR_OK; return ERROR_OK;
} }
if (breakpoint->type == BKPT_HARD) { if (breakpoint->type == BKPT_HARD) {
if (breakpoint->set == 1) { if (breakpoint->number == 0) {
xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_IBCR0], 0x0); xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_IBCR0], 0x0);
xscale->ibcr0_used = 0; xscale->ibcr0_used = 0;
} else if (breakpoint->set == 2) { } else if (breakpoint->number == 1) {
xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_IBCR1], 0x0); xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_IBCR1], 0x0);
xscale->ibcr1_used = 0; xscale->ibcr1_used = 0;
} }
breakpoint->set = 0; breakpoint->is_set = false;
} else { } else {
/* restore original instruction (kept in target endianness) */ /* restore original instruction (kept in target endianness) */
if (breakpoint->length == 4) { if (breakpoint->length == 4) {
@ -2203,7 +2205,7 @@ static int xscale_unset_breakpoint(struct target *target,
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
} }
breakpoint->set = 0; breakpoint->is_set = false;
xscale_send_u32(target, 0x50); /* clean dcache */ xscale_send_u32(target, 0x50); /* clean dcache */
xscale_send_u32(target, xscale->cache_clean_address); xscale_send_u32(target, xscale->cache_clean_address);
@ -2223,7 +2225,7 @@ static int xscale_remove_breakpoint(struct target *target, struct breakpoint *br
return ERROR_TARGET_NOT_HALTED; return ERROR_TARGET_NOT_HALTED;
} }
if (breakpoint->set) if (breakpoint->is_set)
xscale_unset_breakpoint(target, breakpoint); xscale_unset_breakpoint(target, breakpoint);
if (breakpoint->type == BKPT_HARD) if (breakpoint->type == BKPT_HARD)
@ -2279,13 +2281,13 @@ static int xscale_set_watchpoint(struct target *target,
xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_DBR0], watchpoint->address); xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_DBR0], watchpoint->address);
dbcon_value |= enable; dbcon_value |= enable;
xscale_set_reg_u32(dbcon, dbcon_value); xscale_set_reg_u32(dbcon, dbcon_value);
watchpoint->set = 1; watchpoint_set(watchpoint, 0);
xscale->dbr0_used = 1; xscale->dbr0_used = 1;
} else if (!xscale->dbr1_used) { } else if (!xscale->dbr1_used) {
xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_DBR1], watchpoint->address); xscale_set_reg_u32(&xscale->reg_cache->reg_list[XSCALE_DBR1], watchpoint->address);
dbcon_value |= enable << 2; dbcon_value |= enable << 2;
xscale_set_reg_u32(dbcon, dbcon_value); xscale_set_reg_u32(dbcon, dbcon_value);
watchpoint->set = 2; watchpoint_set(watchpoint, 1);
xscale->dbr1_used = 1; xscale->dbr1_used = 1;
} else { } else {
LOG_ERROR("BUG: no hardware comparator available"); LOG_ERROR("BUG: no hardware comparator available");
@ -2349,12 +2351,12 @@ static int xscale_unset_watchpoint(struct target *target,
return ERROR_TARGET_NOT_HALTED; return ERROR_TARGET_NOT_HALTED;
} }
if (!watchpoint->set) { if (!watchpoint->is_set) {
LOG_WARNING("breakpoint not set"); LOG_WARNING("breakpoint not set");
return ERROR_OK; return ERROR_OK;
} }
if (watchpoint->set == 1) { if (watchpoint->number == 0) {
if (watchpoint->length > 4) { if (watchpoint->length > 4) {
dbcon_value &= ~0x103; /* clear DBCON[M] as well */ dbcon_value &= ~0x103; /* clear DBCON[M] as well */
xscale->dbr1_used = 0; /* DBR1 was used for mask */ xscale->dbr1_used = 0; /* DBR1 was used for mask */
@ -2363,12 +2365,12 @@ static int xscale_unset_watchpoint(struct target *target,
xscale_set_reg_u32(dbcon, dbcon_value); xscale_set_reg_u32(dbcon, dbcon_value);
xscale->dbr0_used = 0; xscale->dbr0_used = 0;
} else if (watchpoint->set == 2) { } else if (watchpoint->number == 1) {
dbcon_value &= ~0xc; dbcon_value &= ~0xc;
xscale_set_reg_u32(dbcon, dbcon_value); xscale_set_reg_u32(dbcon, dbcon_value);
xscale->dbr1_used = 0; xscale->dbr1_used = 0;
} }
watchpoint->set = 0; watchpoint->is_set = false;
return ERROR_OK; return ERROR_OK;
} }
@ -2382,7 +2384,7 @@ static int xscale_remove_watchpoint(struct target *target, struct watchpoint *wa
return ERROR_TARGET_NOT_HALTED; return ERROR_TARGET_NOT_HALTED;
} }
if (watchpoint->set) if (watchpoint->is_set)
xscale_unset_watchpoint(target, watchpoint); xscale_unset_watchpoint(target, watchpoint);
if (watchpoint->length > 4) if (watchpoint->length > 4)