From c8926d14579528bfcead1e179baf7cb846513db4 Mon Sep 17 00:00:00 2001 From: Heythem Bouhaja Date: Mon, 9 May 2011 10:40:35 +0200 Subject: [PATCH] cortex_a hybrid & context breakpoints --- src/target/breakpoints.c | 162 ++++++++++++++++++++++++++++- src/target/breakpoints.h | 8 +- src/target/cortex_a.c | 266 +++++++++++++++++++++++++++++++++++++++++++---- src/target/target.c | 137 +++++++++++++++++++----- src/target/target.h | 15 +++ src/target/target_type.h | 2 + 6 files changed, 542 insertions(+), 48 deletions(-) diff --git a/src/target/breakpoints.c b/src/target/breakpoints.c index e6eb67389..5a0fc401f 100644 --- a/src/target/breakpoints.c +++ b/src/target/breakpoints.c @@ -72,6 +72,7 @@ int breakpoint_add_internal(struct target *target, uint32_t address, uint32_t le (*breakpoint_p) = malloc(sizeof(struct breakpoint)); (*breakpoint_p)->address = address; + (*breakpoint_p)->asid = 0; (*breakpoint_p)->length = length; (*breakpoint_p)->type = type; (*breakpoint_p)->set = 0; @@ -107,6 +108,117 @@ fail: return ERROR_OK; } +int context_breakpoint_add_internal(struct target *target, uint32_t asid, uint32_t length, enum breakpoint_type type) +{ + struct breakpoint *breakpoint = target->breakpoints; + struct breakpoint **breakpoint_p = &target->breakpoints; + int retval; + int n; + + n = 0; + while (breakpoint) + { + n++; + if (breakpoint->asid == asid) + { + /* FIXME don't assume "same address" means "same + * breakpoint" ... check all the parameters before + * succeeding. + */ + LOG_DEBUG("Duplicate Breakpoint asid: 0x%08" PRIx32 " (BP %d)", + asid, breakpoint->unique_id ); + return -1; + } + breakpoint_p = &breakpoint->next; + breakpoint = breakpoint->next; + } + + (*breakpoint_p) = malloc(sizeof(struct breakpoint)); + (*breakpoint_p)->address = 0; + (*breakpoint_p)->asid = asid; + (*breakpoint_p)->length = length; + (*breakpoint_p)->type = type; + (*breakpoint_p)->set = 0; + (*breakpoint_p)->orig_instr = malloc(length); + (*breakpoint_p)->next = NULL; + (*breakpoint_p)->unique_id = bpwp_unique_id++; + retval = target_add_context_breakpoint(target, *breakpoint_p); + if (retval != ERROR_OK) + { + LOG_ERROR("could not add breakpoint"); + free((*breakpoint_p)->orig_instr); + free(*breakpoint_p); + *breakpoint_p = NULL; + return retval; + } + + LOG_DEBUG("added %s Context breakpoint at 0x%8.8" PRIx32 " of length 0x%8.8x, (BPID: %d)", + breakpoint_type_strings[(*breakpoint_p)->type], + (*breakpoint_p)->asid, (*breakpoint_p)->length, + (*breakpoint_p)->unique_id ); + + return ERROR_OK; +} + +int hybrid_breakpoint_add_internal(struct target *target, uint32_t address, uint32_t asid, uint32_t length, enum breakpoint_type type) +{ + struct breakpoint *breakpoint = target->breakpoints; + struct breakpoint **breakpoint_p = &target->breakpoints; + int retval; + int n; + n = 0; + while (breakpoint) + { + n++; + if ((breakpoint->asid == asid) && (breakpoint->address == address)) { + /* FIXME don't assume "same address" means "same + * breakpoint" ... check all the parameters before + * succeeding. + */ + LOG_DEBUG("Duplicate Hybrid Breakpoint asid: 0x%08" PRIx32 " (BP %d)", + asid, breakpoint->unique_id ); + return -1; + } + else if ((breakpoint->address == address) && (breakpoint->asid == 0)) + { + LOG_DEBUG("Duplicate Breakpoint IVA: 0x%08" PRIx32 " (BP %d)", + address, breakpoint->unique_id ); + return -1; + + } + breakpoint_p = &breakpoint->next; + breakpoint = breakpoint->next; + } + (*breakpoint_p) = malloc(sizeof(struct breakpoint)); + (*breakpoint_p)->address = address; + (*breakpoint_p)->asid = asid; + (*breakpoint_p)->length = length; + (*breakpoint_p)->type = type; + (*breakpoint_p)->set = 0; + (*breakpoint_p)->orig_instr = malloc(length); + (*breakpoint_p)->next = NULL; + (*breakpoint_p)->unique_id = bpwp_unique_id++; + + + retval = target_add_hybrid_breakpoint(target, *breakpoint_p); + if (retval != ERROR_OK) + { + LOG_ERROR("could not add breakpoint"); + free((*breakpoint_p)->orig_instr); + free(*breakpoint_p); + *breakpoint_p = NULL; + return retval; + } + LOG_DEBUG("added %s Hybrid breakpoint at address 0x%8.8" PRIx32 " of length 0x%8.8x, (BPID: %d)", + breakpoint_type_strings[(*breakpoint_p)->type], + (*breakpoint_p)->address, (*breakpoint_p)->length, + (*breakpoint_p)->unique_id ); + + return ERROR_OK; +} + + + int breakpoint_add(struct target *target, uint32_t address, uint32_t length, enum breakpoint_type type) { @@ -129,6 +241,50 @@ int retval = ERROR_OK; return(breakpoint_add_internal(target, address, length, type)); } +int context_breakpoint_add(struct target *target, uint32_t asid, uint32_t length, enum breakpoint_type type) +{ + +int retval = ERROR_OK; + if (target->smp) + { + struct target_list *head; + struct target *curr; + head = target->head; + while(head != (struct target_list*)NULL) + { + curr = head->target; + retval = context_breakpoint_add_internal(curr, asid,length, type); + if (retval != ERROR_OK) return retval; + head = head->next; + } + return retval; + } + else + return(context_breakpoint_add_internal(target, asid, length, type)); + +} +int hybrid_breakpoint_add(struct target *target, uint32_t address, uint32_t asid, uint32_t length, enum breakpoint_type type) +{ + +int retval = ERROR_OK; + if (target->smp) + { + struct target_list *head; + struct target *curr; + head = target->head; + while(head != (struct target_list*)NULL) + { + curr = head->target; + retval = hybrid_breakpoint_add_internal(curr, address, asid, length, type); + if (retval != ERROR_OK) return retval; + head = head->next; + } + return retval; + } + else + return(hybrid_breakpoint_add_internal(target, address, asid, length, type)); + +} /* free up a breakpoint */ static void breakpoint_free(struct target *target, struct breakpoint *breakpoint_to_remove) @@ -162,7 +318,11 @@ void breakpoint_remove_internal(struct target *target, uint32_t address) while (breakpoint) { - if (breakpoint->address == address) + if ((breakpoint->address == address) && (breakpoint->asid == 0)) + break; + else if ((breakpoint->address == 0) && (breakpoint->asid == address)) + break; + else if ((breakpoint->address == address) && (breakpoint->asid != 0)) break; breakpoint = breakpoint->next; } diff --git a/src/target/breakpoints.h b/src/target/breakpoints.h index ee4d9d135..912117fc4 100644 --- a/src/target/breakpoints.h +++ b/src/target/breakpoints.h @@ -38,12 +38,14 @@ enum watchpoint_rw struct breakpoint { uint32_t address; + uint32_t asid; int length; enum breakpoint_type type; int set; uint8_t *orig_instr; struct breakpoint *next; - int unique_id; + uint32_t unique_id; + int linked_BRP; }; struct watchpoint @@ -61,6 +63,10 @@ struct watchpoint void breakpoint_clear_target(struct target *target); int breakpoint_add(struct target *target, uint32_t address, uint32_t length, enum breakpoint_type type); +int context_breakpoint_add(struct target *target, + uint32_t asid, uint32_t length, enum breakpoint_type type); +int hybrid_breakpoint_add(struct target *target, + uint32_t address, uint32_t asid, uint32_t length, enum breakpoint_type type); void breakpoint_remove(struct target *target, uint32_t address); struct breakpoint* breakpoint_find(struct target *target, uint32_t address); diff --git a/src/target/cortex_a.c b/src/target/cortex_a.c index 9b8ba4166..39f1b9e1a 100755 --- a/src/target/cortex_a.c +++ b/src/target/cortex_a.c @@ -53,6 +53,10 @@ static int cortex_a8_debug_entry(struct target *target); static int cortex_a8_restore_context(struct target *target, bool bpwp); static int cortex_a8_set_breakpoint(struct target *target, struct breakpoint *breakpoint, uint8_t matchmode); +static int cortex_a8_set_context_breakpoint(struct target *target, + struct breakpoint *breakpoint, uint8_t matchmode); +static int cortex_a8_set_hybrid_breakpoint(struct target *target, + struct breakpoint *breakpoint); static int cortex_a8_unset_breakpoint(struct target *target, struct breakpoint *breakpoint); static int cortex_a8_dap_read_coreregister_u32(struct target *target, @@ -1422,6 +1426,141 @@ static int cortex_a8_set_breakpoint(struct target *target, return ERROR_OK; } +static int cortex_a8_set_context_breakpoint(struct target *target, + struct breakpoint *breakpoint, uint8_t matchmode) +{ + int retval = ERROR_FAIL; + int brp_i=0; + uint32_t control; + uint8_t byte_addr_select = 0x0F; + struct cortex_a8_common *cortex_a8 = target_to_cortex_a8(target); + struct armv7a_common *armv7a = &cortex_a8->armv7a_common; + struct cortex_a8_brp * brp_list = cortex_a8->brp_list; + + if (breakpoint->set) + { + LOG_WARNING("breakpoint already set"); + return retval ; + } + /*check available context BRPs*/ + while ((brp_list[brp_i].used || (brp_list[brp_i].type!=BRP_CONTEXT)) && (brp_i < cortex_a8->brp_num)) + brp_i++ ; + + if (brp_i >= cortex_a8->brp_num) + { + LOG_ERROR("ERROR Can not find free Breakpoint Register Pair"); + return ERROR_FAIL; + } + + breakpoint->set = brp_i + 1; + control = ((matchmode & 0x7) << 20) + | (byte_addr_select << 5) + | (3 << 1) | 1; + brp_list[brp_i].used = 1; + brp_list[brp_i].value = (breakpoint->asid); + brp_list[brp_i].control = control; + retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base + + CPUDBG_BVR_BASE + 4 * brp_list[brp_i].BRPn, + brp_list[brp_i].value); + if(retval != ERROR_OK) + return retval; + retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base + + CPUDBG_BCR_BASE + 4 * brp_list[brp_i].BRPn, + brp_list[brp_i].control); + if(retval != ERROR_OK) + return retval; + LOG_DEBUG("brp %i control 0x%0" PRIx32 " value 0x%0" PRIx32, brp_i, + brp_list[brp_i].control, + brp_list[brp_i].value); + return ERROR_OK; + +} + +static int cortex_a8_set_hybrid_breakpoint(struct target *target, struct breakpoint *breakpoint) +{ + int retval = ERROR_FAIL; + int brp_1=0; //holds the contextID pair + int brp_2=0; // holds the IVA pair + uint32_t control_CTX, control_IVA; + uint8_t CTX_byte_addr_select = 0x0F; + uint8_t IVA_byte_addr_select = 0x0F; + uint8_t CTX_machmode = 0x03; + uint8_t IVA_machmode = 0x01; + struct cortex_a8_common *cortex_a8 = target_to_cortex_a8(target); + struct armv7a_common *armv7a = &cortex_a8->armv7a_common; + struct cortex_a8_brp * brp_list = cortex_a8->brp_list; + + + + if (breakpoint->set) + { + LOG_WARNING("breakpoint already set"); + return retval ; + } + /*check available context BRPs*/ + while ((brp_list[brp_1].used || (brp_list[brp_1].type!=BRP_CONTEXT)) && (brp_1 < cortex_a8->brp_num)) + brp_1++ ; + + printf("brp(CTX) found num: %d \n",brp_1); + if (brp_1 >= cortex_a8->brp_num) + { + LOG_ERROR("ERROR Can not find free Breakpoint Register Pair"); + return ERROR_FAIL; + } + + while ((brp_list[brp_2].used || (brp_list[brp_2].type!=BRP_NORMAL)) && (brp_2 < cortex_a8->brp_num)) + brp_2++ ; + + printf("brp(IVA) found num: %d \n",brp_2); + if (brp_2 >= cortex_a8->brp_num) + { + LOG_ERROR("ERROR Can not find free Breakpoint Register Pair"); + return ERROR_FAIL; + } + + breakpoint->set = brp_1 + 1; + breakpoint->linked_BRP= brp_2; + control_CTX = ((CTX_machmode & 0x7) << 20) + | (brp_2 << 16) + | (0 << 14) + | (CTX_byte_addr_select << 5) + | (3 << 1) | 1; + brp_list[brp_1].used = 1; + brp_list[brp_1].value = (breakpoint->asid); + brp_list[brp_1].control = control_CTX; + retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base + + CPUDBG_BVR_BASE + 4 * brp_list[brp_1].BRPn, + brp_list[brp_1].value); + if (retval != ERROR_OK) + return retval; + retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base + + CPUDBG_BCR_BASE + 4 * brp_list[brp_1].BRPn, + brp_list[brp_1].control); + if( retval != ERROR_OK ) + return retval; + + control_IVA = ((IVA_machmode & 0x7) << 20) + | (brp_1 << 16) + | (IVA_byte_addr_select << 5) + | (3 << 1) | 1; + brp_list[brp_2].used = 1; + brp_list[brp_2].value = (breakpoint->address & 0xFFFFFFFC); + brp_list[brp_2].control = control_IVA; + retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base + + CPUDBG_BVR_BASE + 4 * brp_list[brp_2].BRPn, + brp_list[brp_2].value); + if (retval != ERROR_OK) + return retval; + retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base + + CPUDBG_BCR_BASE + 4 * brp_list[brp_2].BRPn, + brp_list[brp_2].control); + if (retval != ERROR_OK ) + return retval; + + return ERROR_OK; +} + + static int cortex_a8_unset_breakpoint(struct target *target, struct breakpoint *breakpoint) { int retval; @@ -1437,27 +1576,81 @@ static int cortex_a8_unset_breakpoint(struct target *target, struct breakpoint * if (breakpoint->type == BKPT_HARD) { - int brp_i = breakpoint->set - 1; - if ((brp_i < 0) || (brp_i >= cortex_a8->brp_num)) + if ((breakpoint->address != 0) && (breakpoint->asid != 0)) { - LOG_DEBUG("Invalid BRP number in breakpoint"); + int brp_i = breakpoint->set - 1; + int brp_j = breakpoint->linked_BRP; + if ((brp_i < 0) || (brp_i >= cortex_a8->brp_num)) + { + LOG_DEBUG("Invalid BRP number in breakpoint"); + return ERROR_OK; + } + LOG_DEBUG("rbp %i control 0x%0" PRIx32 " value 0x%0" PRIx32, brp_i, + brp_list[brp_i].control, brp_list[brp_i].value); + brp_list[brp_i].used = 0; + brp_list[brp_i].value = 0; + brp_list[brp_i].control = 0; + retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base + + CPUDBG_BCR_BASE + 4 * brp_list[brp_i].BRPn, + brp_list[brp_i].control); + if (retval != ERROR_OK) + return retval; + retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base + + CPUDBG_BVR_BASE + 4 * brp_list[brp_i].BRPn, + brp_list[brp_i].value); + if (retval != ERROR_OK) + return retval; + if ((brp_j < 0) || (brp_j >= cortex_a8->brp_num)) + { + LOG_DEBUG("Invalid BRP number in breakpoint"); + return ERROR_OK; + } + LOG_DEBUG("rbp %i control 0x%0" PRIx32 " value 0x%0" PRIx32, brp_j, + brp_list[brp_j].control, brp_list[brp_j].value); + brp_list[brp_j].used = 0; + brp_list[brp_j].value = 0; + brp_list[brp_j].control = 0; + retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base + + CPUDBG_BCR_BASE + 4 * brp_list[brp_j].BRPn, + brp_list[brp_j].control); + if (retval != ERROR_OK) + return retval; + retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base + + CPUDBG_BVR_BASE + 4 * brp_list[brp_j].BRPn, + brp_list[brp_j].value); + if (retval != ERROR_OK) + return retval; + breakpoint->linked_BRP = 0; + breakpoint->set = 0; return ERROR_OK; + } - LOG_DEBUG("rbp %i control 0x%0" PRIx32 " value 0x%0" PRIx32, brp_i, - brp_list[brp_i].control, brp_list[brp_i].value); - brp_list[brp_i].used = 0; - brp_list[brp_i].value = 0; - brp_list[brp_i].control = 0; - retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base - + CPUDBG_BCR_BASE + 4 * brp_list[brp_i].BRPn, - brp_list[brp_i].control); - if (retval != ERROR_OK) - return retval; - retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base - + CPUDBG_BVR_BASE + 4 * brp_list[brp_i].BRPn, - brp_list[brp_i].value); - if (retval != ERROR_OK) - return retval; + else + { + int brp_i = breakpoint->set - 1; + if ((brp_i < 0) || (brp_i >= cortex_a8->brp_num)) + { + LOG_DEBUG("Invalid BRP number in breakpoint"); + return ERROR_OK; + } + LOG_DEBUG("rbp %i control 0x%0" PRIx32 " value 0x%0" PRIx32, brp_i, + brp_list[brp_i].control, brp_list[brp_i].value); + brp_list[brp_i].used = 0; + brp_list[brp_i].value = 0; + brp_list[brp_i].control = 0; + retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base + + CPUDBG_BCR_BASE + 4 * brp_list[brp_i].BRPn, + brp_list[brp_i].control); + if (retval != ERROR_OK) + return retval; + retval = cortex_a8_dap_write_memap_register_u32(target, armv7a->debug_base + + CPUDBG_BVR_BASE + 4 * brp_list[brp_i].BRPn, + brp_list[brp_i].value); + if (retval != ERROR_OK) + return retval; + breakpoint->set = 0; + return ERROR_OK; + } } else { @@ -1501,6 +1694,41 @@ static int cortex_a8_add_breakpoint(struct target *target, return cortex_a8_set_breakpoint(target, breakpoint, 0x00); /* Exact match */ } +static int cortex_a8_add_context_breakpoint(struct target *target, + struct breakpoint *breakpoint) +{ + struct cortex_a8_common *cortex_a8 = target_to_cortex_a8(target); + + if ((breakpoint->type == BKPT_HARD) && (cortex_a8->brp_num_available < 1)) + { + LOG_INFO("no hardware breakpoint available"); + return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; + } + + if (breakpoint->type == BKPT_HARD) + cortex_a8->brp_num_available--; + + return cortex_a8_set_context_breakpoint(target, breakpoint, 0x02); /* asid match */ +} + +static int cortex_a8_add_hybrid_breakpoint(struct target *target, + struct breakpoint *breakpoint) +{ + struct cortex_a8_common *cortex_a8 = target_to_cortex_a8(target); + + if ((breakpoint->type == BKPT_HARD) && (cortex_a8->brp_num_available < 1)) + { + LOG_INFO("no hardware breakpoint available"); + return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; + } + + if (breakpoint->type == BKPT_HARD) + cortex_a8->brp_num_available--; + + return cortex_a8_set_hybrid_breakpoint(target, breakpoint); /* ??? */ +} + + static int cortex_a8_remove_breakpoint(struct target *target, struct breakpoint *breakpoint) { struct cortex_a8_common *cortex_a8 = target_to_cortex_a8(target); @@ -2546,6 +2774,8 @@ struct target_type cortexa8_target = { .run_algorithm = armv4_5_run_algorithm, .add_breakpoint = cortex_a8_add_breakpoint, + .add_context_breakpoint = cortex_a8_add_context_breakpoint, + .add_hybrid_breakpoint = cortex_a8_add_hybrid_breakpoint, .remove_breakpoint = cortex_a8_remove_breakpoint, .add_watchpoint = NULL, .remove_watchpoint = NULL, diff --git a/src/target/target.c b/src/target/target.c index b71d83936..be9742f5c 100644 --- a/src/target/target.c +++ b/src/target/target.c @@ -772,6 +772,27 @@ int target_add_breakpoint(struct target *target, } return target->type->add_breakpoint(target, breakpoint); } + +int target_add_context_breakpoint(struct target *target, + struct breakpoint *breakpoint) +{ + if (target->state != TARGET_HALTED) { + LOG_WARNING("target %s is not halted", target->cmd_name); + return ERROR_TARGET_NOT_HALTED; + } + return target->type->add_context_breakpoint(target, breakpoint); +} + +int target_add_hybrid_breakpoint(struct target *target, + struct breakpoint *breakpoint) +{ + if (target->state != TARGET_HALTED) { + LOG_WARNING("target %s is not halted", target->cmd_name); + return ERROR_TARGET_NOT_HALTED; + } + return target->type->add_hybrid_breakpoint(target, breakpoint); +} + int target_remove_breakpoint(struct target *target, struct breakpoint *breakpoint) { @@ -2919,7 +2940,7 @@ static int handle_bp_command_list(struct command_context *cmd_ctx) { char* buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16); - command_print(cmd_ctx, "0x%8.8" PRIx32 ", 0x%x, %i, 0x%s", + command_print(cmd_ctx, "IVA breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf); @@ -2927,9 +2948,22 @@ static int handle_bp_command_list(struct command_context *cmd_ctx) } else { - command_print(cmd_ctx, "0x%8.8" PRIx32 ", 0x%x, %i", - breakpoint->address, - breakpoint->length, breakpoint->set); + if ((breakpoint->address == 0) && (breakpoint->asid != 0)) + command_print(cmd_ctx, "Context breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i", + breakpoint->asid, + breakpoint->length, breakpoint->set); + else if ((breakpoint->address != 0) && (breakpoint->asid != 0)) + { + command_print(cmd_ctx, "Hybrid breakpoint(IVA): 0x%8.8" PRIx32 ", 0x%x, %i", + breakpoint->address, + breakpoint->length, breakpoint->set); + command_print(cmd_ctx, "\t|--->linked with ContextID: 0x%8.8" PRIx32, + breakpoint->asid); + } + else + command_print(cmd_ctx, "Breakpoint(IVA): 0x%8.8" PRIx32 ", 0x%x, %i", + breakpoint->address, + breakpoint->length, breakpoint->set); } breakpoint = breakpoint->next; @@ -2938,43 +2972,90 @@ static int handle_bp_command_list(struct command_context *cmd_ctx) } static int handle_bp_command_set(struct command_context *cmd_ctx, - uint32_t addr, uint32_t length, int hw) + uint32_t addr, uint32_t asid, uint32_t length, int hw) { struct target *target = get_current_target(cmd_ctx); - int retval = breakpoint_add(target, addr, length, hw); - if (ERROR_OK == retval) - command_print(cmd_ctx, "breakpoint set at 0x%8.8" PRIx32 "", addr); - else - LOG_ERROR("Failure setting breakpoint"); - return retval; + + if (asid == 0) + { int retval = breakpoint_add(target, addr, length, hw); + if (ERROR_OK == retval) + command_print(cmd_ctx, "breakpoint set at 0x%8.8" PRIx32 "", addr); + else + { + LOG_ERROR("Failure setting breakpoint, the same address(IVA) is already used"); + return retval; + } + } + else if (addr == 0) + { + int retval = context_breakpoint_add(target, asid, length, hw); + if (ERROR_OK == retval) + command_print(cmd_ctx, "Context breakpoint set at 0x%8.8" PRIx32 "", asid); + else + { + LOG_ERROR("Failure setting breakpoint, the same address(CONTEXTID) is already used"); + return retval; + } + } + else + { + int retval = hybrid_breakpoint_add(target, addr, asid, length, hw); + if(ERROR_OK == retval) + command_print(cmd_ctx, "Hybrid breakpoint set at 0x%8.8" PRIx32 "", asid); + else + { + LOG_ERROR("Failure setting breakpoint, the same address is already used"); + return retval; + } + } + return ERROR_OK; + + } COMMAND_HANDLER(handle_bp_command) { - if (CMD_ARGC == 0) - return handle_bp_command_list(CMD_CTX); - - if (CMD_ARGC < 2 || CMD_ARGC > 3) - { - command_print(CMD_CTX, "usage: bp
['hw']"); - return ERROR_COMMAND_SYNTAX_ERROR; - } - uint32_t addr; - COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr); + uint32_t asid; uint32_t length; - COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length); - int hw = BKPT_SOFT; - if (CMD_ARGC == 3) + switch(CMD_ARGC) { - if (strcmp(CMD_ARGV[2], "hw") == 0) + case 0: + return handle_bp_command_list(CMD_CTX); + case 3: + + if(strcmp(CMD_ARGV[2], "hw") == 0) + { + hw = BKPT_HARD; + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr); + + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length); + + asid = 0; + return handle_bp_command_set(CMD_CTX, addr, asid, length, hw); + } + else if(strcmp(CMD_ARGV[2], "hw_ctx") == 0) + { + hw = BKPT_HARD; + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], asid); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length); + addr = 0; + return handle_bp_command_set(CMD_CTX, addr, asid, length, hw); + } + + case 4: hw = BKPT_HARD; - else + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], asid); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], length); + return handle_bp_command_set(CMD_CTX, addr, asid, length, hw); + default: + command_print(CMD_CTX, "usage: bp
[] ['hw'|'hw_ctx']"); return ERROR_COMMAND_SYNTAX_ERROR; } - return handle_bp_command_set(CMD_CTX, addr, length, hw); + } COMMAND_HANDLER(handle_rbp_command) @@ -5467,7 +5548,7 @@ static const struct command_registration target_exec_command_handlers[] = { .handler = handle_bp_command, .mode = COMMAND_EXEC, .help = "list or set hardware or software breakpoint", - .usage = "[address length ['hw']]", + .usage = "usage: bp
[] ['hw'|'hw_ctx']", }, { .name = "rbp", diff --git a/src/target/target.h b/src/target/target.h index 1b5730f2f..5248d69ed 100644 --- a/src/target/target.h +++ b/src/target/target.h @@ -369,10 +369,25 @@ static inline void target_set_examined(struct target *target) int target_add_breakpoint(struct target *target, struct breakpoint *breakpoint); /** + * Add the @a ContextID breakpoint for @a target. + * + * This routine is a wrapper for target->type->add_context_breakpoint. + */ +int target_add_context_breakpoint(struct target *target, + struct breakpoint *breakpoint); +/** + * Add the @a ContextID & IVA breakpoint for @a target. + * + * This routine is a wrapper for target->type->add_hybrid_breakpoint. + */ +int target_add_hybrid_breakpoint(struct target *target, + struct breakpoint *breakpoint); +/** * Remove the @a breakpoint for @a target. * * This routine is a wrapper for target->type->remove_breakpoint. */ + int target_remove_breakpoint(struct target *target, struct breakpoint *breakpoint); /** diff --git a/src/target/target_type.h b/src/target/target_type.h index 6059c403d..fc062dabd 100644 --- a/src/target/target_type.h +++ b/src/target/target_type.h @@ -148,6 +148,8 @@ struct target_type * Upon GDB connection all breakpoints/watchpoints are cleared. */ int (*add_breakpoint)(struct target *target, struct breakpoint *breakpoint); + int (*add_context_breakpoint)(struct target *target, struct breakpoint *breakpoint); + int (*add_hybrid_breakpoint)(struct target *target, struct breakpoint *breakpoint); /* remove breakpoint. hw will only be updated if the target * is currently halted. -- 2.11.4.GIT