Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
target: Unify the output of "bp" command
[openocd.git] / src / target / target.c
diff --git a/src/target/target.c b/src/target/target.c
index 73fba0da7744929152d606ae9e6c330f2712b1a5..1219743750ae707e111670143031c120f9b1f0a5 100644 (file)
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -66,46 +66,6 @@ static int target_get_gdb_fileio_info_default(struct target *target,
 static int target_gdb_fileio_end_default(struct target *target, int retcode,
                int fileio_errno, bool ctrl_c);
 
-/* targets */
-extern struct target_type arm7tdmi_target;
-extern struct target_type arm720t_target;
-extern struct target_type arm9tdmi_target;
-extern struct target_type arm920t_target;
-extern struct target_type arm966e_target;
-extern struct target_type arm946e_target;
-extern struct target_type arm926ejs_target;
-extern struct target_type fa526_target;
-extern struct target_type feroceon_target;
-extern struct target_type dragonite_target;
-extern struct target_type xscale_target;
-extern struct target_type xtensa_chip_target;
-extern struct target_type cortexm_target;
-extern struct target_type cortexa_target;
-extern struct target_type aarch64_target;
-extern struct target_type cortexr4_target;
-extern struct target_type armv8r_target;
-extern struct target_type arm11_target;
-extern struct target_type ls1_sap_target;
-extern struct target_type mips_m4k_target;
-extern struct target_type mips_mips64_target;
-extern struct target_type avr_target;
-extern struct target_type dsp563xx_target;
-extern struct target_type dsp5680xx_target;
-extern struct target_type testee_target;
-extern struct target_type avr32_ap7k_target;
-extern struct target_type hla_target;
-extern struct target_type esp32_target;
-extern struct target_type esp32s2_target;
-extern struct target_type esp32s3_target;
-extern struct target_type or1k_target;
-extern struct target_type quark_x10xx_target;
-extern struct target_type quark_d20xx_target;
-extern struct target_type stm8_target;
-extern struct target_type riscv_target;
-extern struct target_type mem_ap_target;
-extern struct target_type esirisc_target;
-extern struct target_type arcv2_target;
-
 static struct target_type *target_types[] = {
        &arm7tdmi_target,
        &arm9tdmi_target,
@@ -250,7 +210,7 @@ static const struct jim_nvp nvp_target_event[] = {
        { .name = NULL, .value = -1 }
 };
 
-static const struct jim_nvp nvp_target_state[] = {
+static const struct nvp nvp_target_state[] = {
        { .name = "unknown", .value = TARGET_UNKNOWN },
        { .name = "running", .value = TARGET_RUNNING },
        { .name = "halted",  .value = TARGET_HALTED },
@@ -304,7 +264,7 @@ const char *debug_reason_name(struct target *t)
 const char *target_state_name(struct target *t)
 {
        const char *cp;
-       cp = jim_nvp_value2name_simple(nvp_target_state, t->state)->name;
+       cp = nvp_value2name(nvp_target_state, t->state)->name;
        if (!cp) {
                LOG_ERROR("Invalid target state: %d", (int)(t->state));
                cp = "(*BUG*unknown*BUG*)";
@@ -849,7 +809,7 @@ int target_run_algorithm(struct target *target,
                int num_mem_params, struct mem_param *mem_params,
                int num_reg_params, struct reg_param *reg_param,
                target_addr_t entry_point, target_addr_t exit_point,
-               int timeout_ms, void *arch_info)
+               unsigned int timeout_ms, void *arch_info)
 {
        int retval = ERROR_FAIL;
 
@@ -933,7 +893,7 @@ done:
 int target_wait_algorithm(struct target *target,
                int num_mem_params, struct mem_param *mem_params,
                int num_reg_params, struct reg_param *reg_params,
-               target_addr_t exit_point, int timeout_ms,
+               target_addr_t exit_point, unsigned int timeout_ms,
                void *arch_info)
 {
        int retval = ERROR_FAIL;
@@ -1365,7 +1325,7 @@ int target_add_breakpoint(struct target *target,
                struct breakpoint *breakpoint)
 {
        if ((target->state != TARGET_HALTED) && (breakpoint->type != BKPT_HARD)) {
-               LOG_WARNING("target %s is not halted (add breakpoint)", target_name(target));
+               LOG_TARGET_ERROR(target, "not halted (add breakpoint)");
                return ERROR_TARGET_NOT_HALTED;
        }
        return target->type->add_breakpoint(target, breakpoint);
@@ -1375,7 +1335,7 @@ int target_add_context_breakpoint(struct target *target,
                struct breakpoint *breakpoint)
 {
        if (target->state != TARGET_HALTED) {
-               LOG_WARNING("target %s is not halted (add context breakpoint)", target_name(target));
+               LOG_TARGET_ERROR(target, "not halted (add context breakpoint)");
                return ERROR_TARGET_NOT_HALTED;
        }
        return target->type->add_context_breakpoint(target, breakpoint);
@@ -1385,7 +1345,7 @@ int target_add_hybrid_breakpoint(struct target *target,
                struct breakpoint *breakpoint)
 {
        if (target->state != TARGET_HALTED) {
-               LOG_WARNING("target %s is not halted (add hybrid breakpoint)", target_name(target));
+               LOG_TARGET_ERROR(target, "not halted (add hybrid breakpoint)");
                return ERROR_TARGET_NOT_HALTED;
        }
        return target->type->add_hybrid_breakpoint(target, breakpoint);
@@ -1401,7 +1361,7 @@ int target_add_watchpoint(struct target *target,
                struct watchpoint *watchpoint)
 {
        if (target->state != TARGET_HALTED) {
-               LOG_WARNING("target %s is not halted (add watchpoint)", target_name(target));
+               LOG_TARGET_ERROR(target, "not halted (add watchpoint)");
                return ERROR_TARGET_NOT_HALTED;
        }
        return target->type->add_watchpoint(target, watchpoint);
@@ -1415,7 +1375,7 @@ int target_hit_watchpoint(struct target *target,
                struct watchpoint **hit_watchpoint)
 {
        if (target->state != TARGET_HALTED) {
-               LOG_WARNING("target %s is not halted (hit watchpoint)", target->cmd_name);
+               LOG_TARGET_ERROR(target, "not halted (hit watchpoint)");
                return ERROR_TARGET_NOT_HALTED;
        }
 
@@ -1497,7 +1457,7 @@ int target_step(struct target *target,
 int target_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fileio_info)
 {
        if (target->state != TARGET_HALTED) {
-               LOG_WARNING("target %s is not halted (gdb fileio)", target->cmd_name);
+               LOG_TARGET_ERROR(target, "not halted (gdb fileio)");
                return ERROR_TARGET_NOT_HALTED;
        }
        return target->type->get_gdb_fileio_info(target, fileio_info);
@@ -1506,7 +1466,7 @@ int target_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fi
 int target_gdb_fileio_end(struct target *target, int retcode, int fileio_errno, bool ctrl_c)
 {
        if (target->state != TARGET_HALTED) {
-               LOG_WARNING("target %s is not halted (gdb fileio end)", target->cmd_name);
+               LOG_TARGET_ERROR(target, "not halted (gdb fileio end)");
                return ERROR_TARGET_NOT_HALTED;
        }
        return target->type->gdb_fileio_end(target, retcode, fileio_errno, ctrl_c);
@@ -3269,7 +3229,7 @@ COMMAND_HANDLER(handle_wait_halt_command)
  *
  * After 500ms, keep_alive() is invoked
  */
-int target_wait_state(struct target *target, enum target_state state, int ms)
+int target_wait_state(struct target *target, enum target_state state, unsigned int ms)
 {
        int retval;
        int64_t then = 0, cur;
@@ -3286,7 +3246,7 @@ int target_wait_state(struct target *target, enum target_state state, int ms)
                        once = false;
                        then = timeval_ms();
                        LOG_DEBUG("waiting for target %s...",
-                               jim_nvp_value2name_simple(nvp_target_state, state)->name);
+                               nvp_value2name(nvp_target_state, state)->name);
                }
 
                if (cur-then > 500)
@@ -3294,7 +3254,7 @@ int target_wait_state(struct target *target, enum target_state state, int ms)
 
                if ((cur-then) > ms) {
                        LOG_ERROR("timed out while waiting for target %s",
-                               jim_nvp_value2name_simple(nvp_target_state, state)->name);
+                               nvp_value2name(nvp_target_state, state)->name);
                        return ERROR_FAIL;
                }
        }
@@ -3966,24 +3926,24 @@ static int handle_bp_command_list(struct command_invocation *cmd)
                if (breakpoint->type == BKPT_SOFT) {
                        char *buf = buf_to_hex_str(breakpoint->orig_instr,
                                        breakpoint->length);
-                       command_print(cmd, "IVA breakpoint: " TARGET_ADDR_FMT ", 0x%x, 0x%s",
+                       command_print(cmd, "Software breakpoint(IVA): addr=" TARGET_ADDR_FMT ", len=0x%x, orig_instr=0x%s",
                                        breakpoint->address,
                                        breakpoint->length,
                                        buf);
                        free(buf);
                } else {
                        if ((breakpoint->address == 0) && (breakpoint->asid != 0))
-                               command_print(cmd, "Context breakpoint: 0x%8.8" PRIx32 ", 0x%x, %u",
+                               command_print(cmd, "Context breakpoint: asid=0x%8.8" PRIx32 ", len=0x%x, num=%u",
                                                        breakpoint->asid,
                                                        breakpoint->length, breakpoint->number);
                        else if ((breakpoint->address != 0) && (breakpoint->asid != 0)) {
-                               command_print(cmd, "Hybrid breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %u",
+                               command_print(cmd, "Hybrid breakpoint(IVA): addr=" TARGET_ADDR_FMT ", len=0x%x, num=%u",
                                                        breakpoint->address,
                                                        breakpoint->length, breakpoint->number);
                                command_print(cmd, "\t|--->linked with ContextID: 0x%8.8" PRIx32,
                                                        breakpoint->asid);
                        } else
-                               command_print(cmd, "Breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %u",
+                               command_print(cmd, "Hardware breakpoint(IVA): addr=" TARGET_ADDR_FMT ", len=0x%x, num=%u",
                                                        breakpoint->address,
                                                        breakpoint->length, breakpoint->number);
                }
@@ -4074,21 +4034,31 @@ COMMAND_HANDLER(handle_bp_command)
 
 COMMAND_HANDLER(handle_rbp_command)
 {
+       int retval;
+
        if (CMD_ARGC != 1)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        struct target *target = get_current_target(CMD_CTX);
 
        if (!strcmp(CMD_ARGV[0], "all")) {
-               breakpoint_remove_all(target);
+               retval = breakpoint_remove_all(target);
+
+               if (retval != ERROR_OK) {
+                       command_print(CMD, "Error encountered during removal of all breakpoints.");
+                       command_print(CMD, "Some breakpoints may have remained set.");
+               }
        } else {
                target_addr_t addr;
                COMMAND_PARSE_ADDRESS(CMD_ARGV[0], addr);
 
-               breakpoint_remove(target, addr);
+               retval = breakpoint_remove(target, addr);
+
+               if (retval != ERROR_OK)
+                       command_print(CMD, "Error during removal of breakpoint at address " TARGET_ADDR_FMT, addr);
        }
 
-       return ERROR_OK;
+       return retval;
 }
 
 COMMAND_HANDLER(handle_wp_command)
@@ -4101,8 +4071,8 @@ COMMAND_HANDLER(handle_wp_command)
                while (watchpoint) {
                        command_print(CMD, "address: " TARGET_ADDR_FMT
                                        ", len: 0x%8.8" PRIx32
-                                       ", r/w/a: %i, value: 0x%8.8" PRIx32
-                                       ", mask: 0x%8.8" PRIx32,
+                                       ", r/w/a: %i, value: 0x%8.8" PRIx64
+                                       ", mask: 0x%8.8" PRIx64,
                                        watchpoint->address,
                                        watchpoint->length,
                                        (int)watchpoint->rw,
@@ -4116,15 +4086,20 @@ COMMAND_HANDLER(handle_wp_command)
        enum watchpoint_rw type = WPT_ACCESS;
        target_addr_t addr = 0;
        uint32_t length = 0;
-       uint32_t data_value = 0x0;
-       uint32_t data_mask = 0xffffffff;
+       uint64_t data_value = 0x0;
+       uint64_t data_mask = WATCHPOINT_IGNORE_DATA_VALUE_MASK;
+       bool mask_specified = false;
 
        switch (CMD_ARGC) {
        case 5:
-               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[4], data_mask);
+               COMMAND_PARSE_NUMBER(u64, CMD_ARGV[4], data_mask);
+               mask_specified = true;
                /* fall through */
        case 4:
-               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], data_value);
+               COMMAND_PARSE_NUMBER(u64, CMD_ARGV[3], data_value);
+               // if user specified only data value without mask - the mask should be 0
+               if (!mask_specified)
+                       data_mask = 0;
                /* fall through */
        case 3:
                switch (CMD_ARGV[2][0]) {
@@ -4168,9 +4143,12 @@ COMMAND_HANDLER(handle_rwp_command)
        COMMAND_PARSE_ADDRESS(CMD_ARGV[0], addr);
 
        struct target *target = get_current_target(CMD_CTX);
-       watchpoint_remove(target, addr);
+       int retval = watchpoint_remove(target, addr);
 
-       return ERROR_OK;
+       if (retval != ERROR_OK)
+               command_print(CMD, "Error during removal of watchpoint at address " TARGET_ADDR_FMT, addr);
+
+       return retval;
 }
 
 /**
@@ -5673,55 +5651,40 @@ static int jim_target_array2mem(Jim_Interp *interp,
        return target_array2mem(interp, target, argc - 1, argv + 1);
 }
 
-static int jim_target_tap_disabled(Jim_Interp *interp)
-{
-       Jim_SetResultFormatted(interp, "[TAP is disabled]");
-       return JIM_ERR;
-}
-
-static int jim_target_examine(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+COMMAND_HANDLER(handle_target_examine)
 {
        bool allow_defer = false;
 
-       struct jim_getopt_info goi;
-       jim_getopt_setup(&goi, interp, argc - 1, argv + 1);
-       if (goi.argc > 1) {
-               const char *cmd_name = Jim_GetString(argv[0], NULL);
-               Jim_SetResultFormatted(goi.interp,
-                               "usage: %s ['allow-defer']", cmd_name);
-               return JIM_ERR;
-       }
-       if (goi.argc > 0 &&
-           strcmp(Jim_GetString(argv[1], NULL), "allow-defer") == 0) {
-               /* consume it */
-               Jim_Obj *obj;
-               int e = jim_getopt_obj(&goi, &obj);
-               if (e != JIM_OK)
-                       return e;
+       if (CMD_ARGC > 1)
+               return ERROR_COMMAND_SYNTAX_ERROR;
+
+       if (CMD_ARGC == 1) {
+               if (strcmp(CMD_ARGV[0], "allow-defer"))
+                       return ERROR_COMMAND_ARGUMENT_INVALID;
                allow_defer = true;
        }
 
-       struct command_context *cmd_ctx = current_command_context(interp);
-       assert(cmd_ctx);
-       struct target *target = get_current_target(cmd_ctx);
-       if (!target->tap->enabled)
-               return jim_target_tap_disabled(interp);
+       struct target *target = get_current_target(CMD_CTX);
+       if (!target->tap->enabled) {
+               command_print(CMD, "[TAP is disabled]");
+               return ERROR_FAIL;
+       }
 
        if (allow_defer && target->defer_examine) {
                LOG_INFO("Deferring arp_examine of %s", target_name(target));
                LOG_INFO("Use arp_examine command to examine it manually!");
-               return JIM_OK;
+               return ERROR_OK;
        }
 
-       int e = target->type->examine(target);
-       if (e != ERROR_OK) {
+       int retval = target->type->examine(target);
+       if (retval != ERROR_OK) {
                target_reset_examined(target);
-               return JIM_ERR;
+               return retval;
        }
 
        target_set_examined(target);
 
-       return JIM_OK;
+       return ERROR_OK;
 }
 
 COMMAND_HANDLER(handle_target_was_examined)
@@ -5829,45 +5792,35 @@ COMMAND_HANDLER(handle_target_halt)
        return target->type->halt(target);
 }
 
-static int jim_target_wait_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+COMMAND_HANDLER(handle_target_wait_state)
 {
-       struct jim_getopt_info goi;
-       jim_getopt_setup(&goi, interp, argc - 1, argv + 1);
+       if (CMD_ARGC != 2)
+               return ERROR_COMMAND_SYNTAX_ERROR;
 
-       /* params:  <name>  statename timeoutmsecs */
-       if (goi.argc != 2) {
-               const char *cmd_name = Jim_GetString(argv[0], NULL);
-               Jim_SetResultFormatted(goi.interp,
-                               "%s <state_name> <timeout_in_msec>", cmd_name);
-               return JIM_ERR;
+       const struct nvp *n = nvp_name2value(nvp_target_state, CMD_ARGV[0]);
+       if (!n->name) {
+               nvp_unknown_command_print(CMD, nvp_target_state, NULL, CMD_ARGV[0]);
+               return ERROR_COMMAND_ARGUMENT_INVALID;
        }
 
-       struct jim_nvp *n;
-       int e = jim_getopt_nvp(&goi, nvp_target_state, &n);
-       if (e != JIM_OK) {
-               jim_getopt_nvp_unknown(&goi, nvp_target_state, 1);
-               return e;
+       unsigned int a;
+       COMMAND_PARSE_NUMBER(uint, CMD_ARGV[1], a);
+
+       struct target *target = get_current_target(CMD_CTX);
+       if (!target->tap->enabled) {
+               command_print(CMD, "[TAP is disabled]");
+               return ERROR_FAIL;
        }
-       jim_wide a;
-       e = jim_getopt_wide(&goi, &a);
-       if (e != JIM_OK)
-               return e;
-       struct command_context *cmd_ctx = current_command_context(interp);
-       assert(cmd_ctx);
-       struct target *target = get_current_target(cmd_ctx);
-       if (!target->tap->enabled)
-               return jim_target_tap_disabled(interp);
 
-       e = target_wait_state(target, n->value, a);
-       if (e != ERROR_OK) {
-               Jim_Obj *obj = Jim_NewIntObj(interp, e);
-               Jim_SetResultFormatted(goi.interp,
-                               "target: %s wait %s fails (%#s) %s",
+       int retval = target_wait_state(target, n->value, a);
+       if (retval != ERROR_OK) {
+               command_print(CMD,
+                               "target: %s wait %s fails (%d) %s",
                                target_name(target), n->name,
-                               obj, target_strerror_safe(e));
-               return JIM_ERR;
+                               retval, target_strerror_safe(retval));
+               return retval;
        }
-       return JIM_OK;
+       return ERROR_OK;
 }
 /* List for human, Events defined for this target.
  * scripts/programs should use 'name cget -event NAME'
@@ -6059,7 +6012,7 @@ static const struct command_registration target_instance_command_handlers[] = {
        {
                .name = "arp_examine",
                .mode = COMMAND_EXEC,
-               .jim_handler = jim_target_examine,
+               .handler = handle_target_examine,
                .help = "used internally for reset processing",
                .usage = "['allow-defer']",
        },
@@ -6108,8 +6061,9 @@ static const struct command_registration target_instance_command_handlers[] = {
        {
                .name = "arp_waitstate",
                .mode = COMMAND_EXEC,
-               .jim_handler = jim_target_wait_state,
+               .handler = handle_target_wait_state,
                .help = "used internally for reset processing",
+               .usage = "statename timeoutmsecs",
        },
        {
                .name = "invoke-event",
@@ -6730,8 +6684,8 @@ COMMAND_HANDLER(handle_ps_command)
        struct target *target = get_current_target(CMD_CTX);
        char *display;
        if (target->state != TARGET_HALTED) {
-               LOG_INFO("target not halted !!");
-               return ERROR_OK;
+               command_print(CMD, "Error: [%s] not halted", target_name(target));
+               return ERROR_TARGET_NOT_HALTED;
        }
 
        if ((target->rtos) && (target->rtos->type)
@@ -6762,8 +6716,8 @@ COMMAND_HANDLER(handle_test_mem_access_command)
        int retval = ERROR_OK;
 
        if (target->state != TARGET_HALTED) {
-               LOG_INFO("target not halted !!");
-               return ERROR_FAIL;
+               command_print(CMD, "Error: [%s] not halted", target_name(target));
+               return ERROR_TARGET_NOT_HALTED;
        }
 
        if (CMD_ARGC != 1)
@@ -7211,3 +7165,29 @@ static int target_register_user_commands(struct command_context *cmd_ctx)
 
        return register_commands(cmd_ctx, NULL, target_exec_command_handlers);
 }
+
+const char *target_debug_reason_str(enum target_debug_reason reason)
+{
+       switch (reason) {
+               case DBG_REASON_DBGRQ:
+                       return "DBGRQ";
+               case DBG_REASON_BREAKPOINT:
+                       return "BREAKPOINT";
+               case DBG_REASON_WATCHPOINT:
+                       return "WATCHPOINT";
+               case DBG_REASON_WPTANDBKPT:
+                       return "WPTANDBKPT";
+               case DBG_REASON_SINGLESTEP:
+                       return "SINGLESTEP";
+               case DBG_REASON_NOTHALTED:
+                       return "NOTHALTED";
+               case DBG_REASON_EXIT:
+                       return "EXIT";
+               case DBG_REASON_EXC_CATCH:
+                       return "EXC_CATCH";
+               case DBG_REASON_UNDEFINED:
+                       return "UNDEFINED";
+               default:
+                       return "UNKNOWN!";
+       }
+}
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)