openocd: properly use jim data types

[openocd.git] / src / target / target.c

diff --git a/src/target/target.c b/src/target/target.c
index 4b4aec83c32080d18c88a5719ee5326111740767..c0953a3f1ca666eebc4deec6bf75f6eb0308579a 100644 (file)
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -94,6 +94,7 @@ extern struct target_type cortexr4_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;
@@ -110,6 +111,7 @@ 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,
@@ -145,9 +147,9 @@ static struct target_type *target_types[] = {
        &riscv_target,
        &mem_ap_target,
        &esirisc_target,
-#if BUILD_TARGET64
+       &arcv2_target,
        &aarch64_target,
-#endif
+       &mips_mips64_target,
        NULL,
 };
 
@@ -201,6 +203,8 @@ static const Jim_Nvp nvp_target_event[] = {
        { .value = TARGET_EVENT_RESUMED, .name = "resumed" },
        { .value = TARGET_EVENT_RESUME_START, .name = "resume-start" },
        { .value = TARGET_EVENT_RESUME_END, .name = "resume-end" },
+       { .value = TARGET_EVENT_STEP_START, .name = "step-start" },
+       { .value = TARGET_EVENT_STEP_END, .name = "step-end" },
 
        { .name = "gdb-start", .value = TARGET_EVENT_GDB_START },
        { .name = "gdb-end", .value = TARGET_EVENT_GDB_END },
@@ -215,6 +219,7 @@ static const Jim_Nvp nvp_target_event[] = {
        { .value = TARGET_EVENT_RESET_END,           .name = "reset-end" },
 
        { .value = TARGET_EVENT_EXAMINE_START, .name = "examine-start" },
+       { .value = TARGET_EVENT_EXAMINE_FAIL, .name = "examine-fail" },
        { .value = TARGET_EVENT_EXAMINE_END, .name = "examine-end" },
 
        { .value = TARGET_EVENT_DEBUG_HALTED, .name = "debug-halted" },
@@ -375,12 +380,6 @@ uint16_t target_buffer_get_u16(struct target *target, const uint8_t *buffer)
                return be_to_h_u16(buffer);
 }
 
-/* read a uint8_t from a buffer in target memory endianness */
-static __attribute__((unused)) uint8_t target_buffer_get_u8(struct target *target, const uint8_t *buffer)
-{
-       return *buffer & 0x0ff;
-}
-
 /* write a uint64_t to a buffer in target memory endianness */
 void target_buffer_set_u64(struct target *target, uint8_t *buffer, uint64_t value)
 {
@@ -710,13 +709,17 @@ static int default_check_reset(struct target *target)
        return ERROR_OK;
 }
 
+/* Equvivalent Tcl code arp_examine_one is in src/target/startup.tcl
+ * Keep in sync */
 int target_examine_one(struct target *target)
 {
        target_call_event_callbacks(target, TARGET_EVENT_EXAMINE_START);
 
        int retval = target->type->examine(target);
-       if (retval != ERROR_OK)
+       if (retval != ERROR_OK) {
+               target_call_event_callbacks(target, TARGET_EVENT_EXAMINE_FAIL);
                return retval;
+       }
 
        target_call_event_callbacks(target, TARGET_EVENT_EXAMINE_END);
 
@@ -1221,7 +1224,24 @@ int target_get_gdb_reg_list(struct target *target,
                struct reg **reg_list[], int *reg_list_size,
                enum target_register_class reg_class)
 {
-       return target->type->get_gdb_reg_list(target, reg_list, reg_list_size, reg_class);
+       int result = target->type->get_gdb_reg_list(target, reg_list,
+                       reg_list_size, reg_class);
+       if (result != ERROR_OK) {
+               *reg_list = NULL;
+               *reg_list_size = 0;
+       }
+       return result;
+}
+
+int target_get_gdb_reg_list_noread(struct target *target,
+               struct reg **reg_list[], int *reg_list_size,
+               enum target_register_class reg_class)
+{
+       if (target->type->get_gdb_reg_list_noread &&
+                       target->type->get_gdb_reg_list_noread(target, reg_list,
+                               reg_list_size, reg_class) == ERROR_OK)
+               return ERROR_OK;
+       return target_get_gdb_reg_list(target, reg_list, reg_list_size, reg_class);
 }
 
 bool target_supports_gdb_connection(struct target *target)
@@ -1236,7 +1256,17 @@ bool target_supports_gdb_connection(struct target *target)
 int target_step(struct target *target,
                int current, target_addr_t address, int handle_breakpoints)
 {
-       return target->type->step(target, current, address, handle_breakpoints);
+       int retval;
+
+       target_call_event_callbacks(target, TARGET_EVENT_STEP_START);
+
+       retval = target->type->step(target, current, address, handle_breakpoints);
+       if (retval != ERROR_OK)
+               return retval;
+
+       target_call_event_callbacks(target, TARGET_EVENT_STEP_END);
+
+       return retval;
 }
 
 int target_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fileio_info)
@@ -1593,8 +1623,9 @@ int target_call_event_callbacks(struct target *target, enum target_event event)
                target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
        }
 
-       LOG_DEBUG("target event %i (%s)", event,
-                       Jim_Nvp_value2name_simple(nvp_target_event, event)->name);
+       LOG_DEBUG("target event %i (%s) for core %s", event,
+                       Jim_Nvp_value2name_simple(nvp_target_event, event)->name,
+                       target_name(target));
 
        target_handle_event(target, event);
 
@@ -1668,7 +1699,7 @@ static int target_call_timer_callbacks_check_time(int checktime)
         * next item; initially, that's a standalone "root of the
         * list" variable. */
        struct target_timer_callback **callback = &target_timer_callbacks;
-       while (*callback) {
+       while (callback && *callback) {
                if ((*callback)->removed) {
                        struct target_timer_callback *p = *callback;
                        *callback = (*callback)->next;
@@ -2028,6 +2059,8 @@ static void target_destroy(struct target *target)
                target->smp = 0;
        }
 
+       rtos_destroy(target);
+
        free(target->gdb_port_override);
        free(target->type);
        free(target->trace_info);
@@ -2267,7 +2300,7 @@ static int target_read_buffer_default(struct target *target, target_addr_t addre
        return ERROR_OK;
 }
 
-int target_checksum_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t* crc)
+int target_checksum_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t *crc)
 {
        uint8_t *buffer;
        int retval;
@@ -3122,10 +3155,10 @@ COMMAND_HANDLER(handle_step_command)
 
        struct target *target = get_current_target(CMD_CTX);
 
-       return target->type->step(target, current_pc, addr, 1);
+       return target_step(target, current_pc, addr, 1);
 }
 
-static void handle_md_output(struct command_invocation *cmd,
+void target_handle_md_output(struct command_invocation *cmd,
                struct target *target, target_addr_t address, unsigned size,
                unsigned count, const uint8_t *buffer)
 {
@@ -3240,7 +3273,7 @@ COMMAND_HANDLER(handle_md_command)
        struct target *target = get_current_target(CMD_CTX);
        int retval = fn(target, address, size, count, buffer);
        if (ERROR_OK == retval)
-               handle_md_output(CMD, target, address, size, count, buffer);
+               target_handle_md_output(CMD, target, address, size, count, buffer);
 
        free(buffer);
 
@@ -3324,8 +3357,8 @@ COMMAND_HANDLER(handle_mw_command)
        target_addr_t address;
        COMMAND_PARSE_ADDRESS(CMD_ARGV[0], address);
 
-       target_addr_t value;
-       COMMAND_PARSE_ADDRESS(CMD_ARGV[1], value);
+       uint64_t value;
+       COMMAND_PARSE_NUMBER(u64, CMD_ARGV[1], value);
 
        unsigned count = 1;
        if (CMD_ARGC == 3)
@@ -3624,14 +3657,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, enum verify_mode ver
 
                                data = malloc(buf_cnt);
 
-                               /* Can we use 32bit word accesses? */
-                               int size = 1;
-                               int count = buf_cnt;
-                               if ((count % 4) == 0) {
-                                       size *= 4;
-                                       count /= 4;
-                               }
-                               retval = target_read_memory(target, image.sections[i].base_address, size, count, data);
+                               retval = target_read_buffer(target, image.sections[i].base_address, buf_cnt, data);
                                if (retval == ERROR_OK) {
                                        uint32_t t;
                                        for (t = 0; t < buf_cnt; t++) {
@@ -3813,11 +3839,16 @@ COMMAND_HANDLER(handle_rbp_command)
        if (CMD_ARGC != 1)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
-       target_addr_t addr;
-       COMMAND_PARSE_ADDRESS(CMD_ARGV[0], addr);
-
        struct target *target = get_current_target(CMD_CTX);
-       breakpoint_remove(target, addr);
+
+       if (!strcmp(CMD_ARGV[0], "all")) {
+               breakpoint_remove_all(target);
+       } else {
+               target_addr_t addr;
+               COMMAND_PARSE_ADDRESS(CMD_ARGV[0], addr);
+
+               breakpoint_remove(target, addr);
+       }
 
        return ERROR_OK;
 }
@@ -4532,6 +4563,7 @@ static int target_array2mem(Jim_Interp *interp, struct target *target,
 void target_handle_event(struct target *target, enum target_event e)
 {
        struct target_event_action *teap;
+       int retval;
 
        for (teap = target->event_action; teap != NULL; teap = teap->next) {
                if (teap->event == e) {
@@ -4550,8 +4582,12 @@ void target_handle_event(struct target *target, enum target_event e)
                        struct command_context *cmd_ctx = current_command_context(teap->interp);
                        struct target *saved_target_override = cmd_ctx->current_target_override;
                        cmd_ctx->current_target_override = target;
+                       retval = Jim_EvalObj(teap->interp, teap->body);
 
-                       if (Jim_EvalObj(teap->interp, teap->body) != JIM_OK) {
+                       if (retval == JIM_RETURN)
+                               retval = teap->interp->returnCode;
+
+                       if (retval != JIM_OK) {
                                Jim_MakeErrorMessage(teap->interp);
                                LOG_USER("Error executing event %s on target %s:\n%s",
                                                  Jim_Nvp_value2name_simple(nvp_target_event, e)->name,
@@ -4899,6 +4935,12 @@ no_params:
 
                case TCFG_GDB_PORT:
                        if (goi->isconfigure) {
+                               struct command_context *cmd_ctx = current_command_context(goi->interp);
+                               if (cmd_ctx->mode != COMMAND_CONFIG) {
+                                       Jim_SetResultString(goi->interp, "-gdb-port must be configured before 'init'", -1);
+                                       return JIM_ERR;
+                               }
+
                                const char *s;
                                e = Jim_GetOpt_String(goi, &s, NULL);
                                if (e != JIM_OK)
@@ -4969,7 +5011,7 @@ static int jim_target_examine(Jim_Interp *interp, int argc, Jim_Obj *const *argv
        if (goi.argc > 0 &&
            strcmp(Jim_GetString(argv[1], NULL), "allow-defer") == 0) {
                /* consume it */
-               struct Jim_Obj *obj;
+               Jim_Obj *obj;
                int e = Jim_GetOpt_Obj(&goi, &obj);
                if (e != JIM_OK)
                        return e;
@@ -5139,7 +5181,6 @@ static int jim_target_wait_state(Jim_Interp *interp, int argc, Jim_Obj *const *a
                                "target: %s wait %s fails (%#s) %s",
                                target_name(target), n->name,
                                eObj, target_strerror_safe(e));
-               Jim_FreeNewObj(interp, eObj);
                return JIM_ERR;
        }
        return JIM_OK;
@@ -5200,7 +5241,7 @@ static int jim_target_invoke_event(Jim_Interp *interp, int argc, Jim_Obj *const
 static const struct command_registration target_instance_command_handlers[] = {
        {
                .name = "configure",
-               .mode = COMMAND_CONFIG,
+               .mode = COMMAND_ANY,
                .jim_handler = jim_target_configure,
                .help  = "configure a new target for use",
                .usage = "[target_attribute ...]",
@@ -6191,7 +6232,7 @@ static const struct command_registration target_exec_command_handlers[] = {
                .name = "halt",
                .handler = handle_halt_command,
                .mode = COMMAND_EXEC,
-               .help = "request target to halt, then wait up to the specified"
+               .help = "request target to halt, then wait up to the specified "
                        "number of milliseconds (default 5000) for it to complete",
                .usage = "[milliseconds]",
        },
@@ -6207,7 +6248,7 @@ static const struct command_registration target_exec_command_handlers[] = {
                .handler = handle_reset_command,
                .mode = COMMAND_EXEC,
                .usage = "[run|halt|init]",
-               .help = "Reset all targets into the specified mode."
+               .help = "Reset all targets into the specified mode. "
                        "Default reset mode is run, if not given.",
        },
        {
@@ -6285,14 +6326,14 @@ 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> [<asid>] <length> ['hw'|'hw_ctx']",
+               .usage = "[<address> [<asid>] <length> ['hw'|'hw_ctx']]",
        },
        {
                .name = "rbp",
                .handler = handle_rbp_command,
                .mode = COMMAND_EXEC,
                .help = "remove breakpoint",
-               .usage = "address",
+               .usage = "'all' | address",
        },
        {
                .name = "wp",