Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
target: create/use register_cache_invalidate()
[openocd.git] / src / target / target.c
diff --git a/src/target/target.c b/src/target/target.c
index 6ecf16a1e887750fb08a35b3c1a62a0744d94612..70fd8f2b71c6a1b96092c0b0c5a190e1a0150f63 100644 (file)
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -36,6 +36,7 @@
 #include "target.h"
 #include "target_type.h"
 #include "target_request.h"
 #include "target.h"
 #include "target_type.h"
 #include "target_request.h"
+#include "breakpoints.h"
 #include "time_support.h"
 #include "register.h"
 #include "trace.h"
 #include "time_support.h"
 #include "register.h"
 #include "trace.h"
@@ -644,20 +645,13 @@ int target_run_algorithm(struct target *target,
                        entry_point, exit_point, timeout_ms, arch_info);
 }
 
                        entry_point, exit_point, timeout_ms, arch_info);
 }
 
-/// @returns @c true if the target has been examined.
-bool target_was_examined(struct target *target)
-{
-       return target->type->examined;
-}
-/// Sets the @c examined flag for the given target.
-void target_set_examined(struct target *target)
-{
-       target->type->examined = true;
-}
-// Reset the @c examined flag for the given target.
-void target_reset_examined(struct target *target)
+/**
+ * Reset the @c examined flag for the given target.
+ * Pure paranoia -- targets are zeroed on allocation.
+ */
+static void target_reset_examined(struct target *target)
 {
 {
-       target->type->examined = false;
+       target->examined = false;
 }
 
 
 }
 
 
@@ -1654,28 +1648,28 @@ COMMAND_HANDLER(handle_targets_command)
 {
        struct target *target = all_targets;
 
 {
        struct target *target = all_targets;
 
-       if (argc == 1)
+       if (CMD_ARGC == 1)
        {
        {
-               target = get_target(args[0]);
+               target = get_target(CMD_ARGV[0]);
                if (target == NULL) {
                if (target == NULL) {
-                       command_print(cmd_ctx,"Target: %s is unknown, try one of:\n", args[0]);
+                       command_print(CMD_CTX,"Target: %s is unknown, try one of:\n", CMD_ARGV[0]);
                        goto DumpTargets;
                }
                if (!target->tap->enabled) {
                        goto DumpTargets;
                }
                if (!target->tap->enabled) {
-                       command_print(cmd_ctx,"Target: TAP %s is disabled, "
+                       command_print(CMD_CTX,"Target: TAP %s is disabled, "
                                        "can't be the current target\n",
                                        target->tap->dotted_name);
                        return ERROR_FAIL;
                }
 
                                        "can't be the current target\n",
                                        target->tap->dotted_name);
                        return ERROR_FAIL;
                }
 
-               cmd_ctx->current_target = target->target_number;
+               CMD_CTX->current_target = target->target_number;
                return ERROR_OK;
        }
 DumpTargets:
 
        target = all_targets;
                return ERROR_OK;
        }
 DumpTargets:
 
        target = all_targets;
-       command_print(cmd_ctx, "    TargetName         Type       Endian TapName            State       ");
-       command_print(cmd_ctx, "--  ------------------ ---------- ------ ------------------ ------------");
+       command_print(CMD_CTX, "    TargetName         Type       Endian TapName            State       ");
+       command_print(CMD_CTX, "--  ------------------ ---------- ------ ------------------ ------------");
        while (target)
        {
                const char *state;
        while (target)
        {
                const char *state;
@@ -1686,11 +1680,11 @@ DumpTargets:
                else
                        state = "tap-disabled";
 
                else
                        state = "tap-disabled";
 
-               if (cmd_ctx->current_target == target->target_number)
+               if (CMD_CTX->current_target == target->target_number)
                        marker = '*';
 
                /* keep columns lined up to match the headers above */
                        marker = '*';
 
                /* keep columns lined up to match the headers above */
-               command_print(cmd_ctx, "%2d%c %-18s %-10s %-6s %-18s %s",
+               command_print(CMD_CTX, "%2d%c %-18s %-10s %-6s %-18s %s",
                                          target->target_number,
                                          marker,
                                          target->cmd_name,
                                          target->target_number,
                                          marker,
                                          target->cmd_name,
@@ -1866,24 +1860,24 @@ COMMAND_HANDLER(handle_reg_command)
 {
        struct target *target;
        struct reg *reg = NULL;
 {
        struct target *target;
        struct reg *reg = NULL;
-       int count = 0;
+       unsigned count = 0;
        char *value;
 
        LOG_DEBUG("-");
 
        char *value;
 
        LOG_DEBUG("-");
 
-       target = get_current_target(cmd_ctx);
+       target = get_current_target(CMD_CTX);
 
        /* list all available registers for the current target */
 
        /* list all available registers for the current target */
-       if (argc == 0)
+       if (CMD_ARGC == 0)
        {
                struct reg_cache *cache = target->reg_cache;
 
                count = 0;
                while (cache)
                {
        {
                struct reg_cache *cache = target->reg_cache;
 
                count = 0;
                while (cache)
                {
-                       int i;
+                       unsigned i;
 
 
-                       command_print(cmd_ctx, "===== %s", cache->name);
+                       command_print(CMD_CTX, "===== %s", cache->name);
 
                        for (i = 0, reg = cache->reg_list;
                                        i < cache->num_regs;
 
                        for (i = 0, reg = cache->reg_list;
                                        i < cache->num_regs;
@@ -1893,7 +1887,7 @@ COMMAND_HANDLER(handle_reg_command)
                                if (reg->valid) {
                                        value = buf_to_str(reg->value,
                                                        reg->size, 16);
                                if (reg->valid) {
                                        value = buf_to_str(reg->value,
                                                        reg->size, 16);
-                                       command_print(cmd_ctx,
+                                       command_print(CMD_CTX,
                                                        "(%i) %s (/%" PRIu32 "): 0x%s%s",
                                                        count, reg->name,
                                                        reg->size, value,
                                                        "(%i) %s (/%" PRIu32 "): 0x%s%s",
                                                        count, reg->name,
                                                        reg->size, value,
@@ -1902,7 +1896,7 @@ COMMAND_HANDLER(handle_reg_command)
                                                                : "");
                                        free(value);
                                } else {
                                                                : "");
                                        free(value);
                                } else {
-                                       command_print(cmd_ctx, "(%i) %s (/%" PRIu32 ")",
+                                       command_print(CMD_CTX, "(%i) %s (/%" PRIu32 ")",
                                                          count, reg->name,
                                                          reg->size) ;
                                }
                                                          count, reg->name,
                                                          reg->size) ;
                                }
@@ -1914,19 +1908,19 @@ COMMAND_HANDLER(handle_reg_command)
        }
 
        /* access a single register by its ordinal number */
        }
 
        /* access a single register by its ordinal number */
-       if ((args[0][0] >= '0') && (args[0][0] <= '9'))
+       if ((CMD_ARGV[0][0] >= '0') && (CMD_ARGV[0][0] <= '9'))
        {
                unsigned num;
        {
                unsigned num;
-               COMMAND_PARSE_NUMBER(uint, args[0], num);
+               COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
 
                struct reg_cache *cache = target->reg_cache;
                count = 0;
                while (cache)
                {
 
                struct reg_cache *cache = target->reg_cache;
                count = 0;
                while (cache)
                {
-                       int i;
+                       unsigned i;
                        for (i = 0; i < cache->num_regs; i++)
                        {
                        for (i = 0; i < cache->num_regs; i++)
                        {
-                               if (count++ == (int)num)
+                               if (count++ == num)
                                {
                                        reg = &cache->reg_list[i];
                                        break;
                                {
                                        reg = &cache->reg_list[i];
                                        break;
@@ -1939,48 +1933,46 @@ COMMAND_HANDLER(handle_reg_command)
 
                if (!reg)
                {
 
                if (!reg)
                {
-                       command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
+                       command_print(CMD_CTX, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1);
                        return ERROR_OK;
                }
        } else /* access a single register by its name */
        {
                        return ERROR_OK;
                }
        } else /* access a single register by its name */
        {
-               reg = register_get_by_name(target->reg_cache, args[0], 1);
+               reg = register_get_by_name(target->reg_cache, CMD_ARGV[0], 1);
 
                if (!reg)
                {
 
                if (!reg)
                {
-                       command_print(cmd_ctx, "register %s not found in current target", args[0]);
+                       command_print(CMD_CTX, "register %s not found in current target", CMD_ARGV[0]);
                        return ERROR_OK;
                }
        }
 
        /* display a register */
                        return ERROR_OK;
                }
        }
 
        /* display a register */
-       if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
+       if ((CMD_ARGC == 1) || ((CMD_ARGC == 2) && !((CMD_ARGV[1][0] >= '0') && (CMD_ARGV[1][0] <= '9'))))
        {
        {
-               if ((argc == 2) && (strcmp(args[1], "force") == 0))
+               if ((CMD_ARGC == 2) && (strcmp(CMD_ARGV[1], "force") == 0))
                        reg->valid = 0;
 
                if (reg->valid == 0)
                {
                        reg->valid = 0;
 
                if (reg->valid == 0)
                {
-                       struct reg_arch_type *arch_type = register_get_arch_type(reg->arch_type);
-                       arch_type->get(reg);
+                       reg->type->get(reg);
                }
                value = buf_to_str(reg->value, reg->size, 16);
                }
                value = buf_to_str(reg->value, reg->size, 16);
-               command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
+               command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
                free(value);
                return ERROR_OK;
        }
 
        /* set register value */
                free(value);
                return ERROR_OK;
        }
 
        /* set register value */
-       if (argc == 2)
+       if (CMD_ARGC == 2)
        {
        {
-               uint8_t *buf = malloc(CEIL(reg->size, 8));
-               str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
+               uint8_t *buf = malloc(DIV_ROUND_UP(reg->size, 8));
+               str_to_buf(CMD_ARGV[1], strlen(CMD_ARGV[1]), buf, reg->size, 0);
 
 
-               struct reg_arch_type *arch_type = register_get_arch_type(reg->arch_type);
-               arch_type->set(reg, buf);
+               reg->type->set(reg, buf);
 
                value = buf_to_str(reg->value, reg->size, 16);
 
                value = buf_to_str(reg->value, reg->size, 16);
-               command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
+               command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
                free(value);
 
                free(buf);
                free(value);
 
                free(buf);
@@ -1988,7 +1980,7 @@ COMMAND_HANDLER(handle_reg_command)
                return ERROR_OK;
        }
 
                return ERROR_OK;
        }
 
-       command_print(cmd_ctx, "usage: reg <#|name> [value]");
+       command_print(CMD_CTX, "usage: reg <#|name> [value]");
 
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
@@ -1996,13 +1988,13 @@ COMMAND_HANDLER(handle_reg_command)
 COMMAND_HANDLER(handle_poll_command)
 {
        int retval = ERROR_OK;
 COMMAND_HANDLER(handle_poll_command)
 {
        int retval = ERROR_OK;
-       struct target *target = get_current_target(cmd_ctx);
+       struct target *target = get_current_target(CMD_CTX);
 
 
-       if (argc == 0)
+       if (CMD_ARGC == 0)
        {
        {
-               command_print(cmd_ctx, "background polling: %s",
+               command_print(CMD_CTX, "background polling: %s",
                                jtag_poll_get_enabled() ? "on" : "off");
                                jtag_poll_get_enabled() ? "on" : "off");
-               command_print(cmd_ctx, "TAP: %s (%s)",
+               command_print(CMD_CTX, "TAP: %s (%s)",
                                target->tap->dotted_name,
                                target->tap->enabled ? "enabled" : "disabled");
                if (!target->tap->enabled)
                                target->tap->dotted_name,
                                target->tap->enabled ? "enabled" : "disabled");
                if (!target->tap->enabled)
@@ -2011,23 +2003,14 @@ COMMAND_HANDLER(handle_poll_command)
                        return retval;
                if ((retval = target_arch_state(target)) != ERROR_OK)
                        return retval;
                        return retval;
                if ((retval = target_arch_state(target)) != ERROR_OK)
                        return retval;
-
        }
        }
-       else if (argc == 1)
+       else if (CMD_ARGC == 1)
        {
        {
-               if (strcmp(args[0], "on") == 0)
-               {
-                       jtag_poll_set_enabled(true);
-               }
-               else if (strcmp(args[0], "off") == 0)
-               {
-                       jtag_poll_set_enabled(false);
-               }
-               else
-               {
-                       command_print(cmd_ctx, "arg is \"on\" or \"off\"");
-               }
-       } else
+               bool enable;
+               COMMAND_PARSE_ON_OFF(CMD_ARGV[0], enable);
+               jtag_poll_set_enabled(enable);
+       }
+       else
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
@@ -2037,23 +2020,23 @@ COMMAND_HANDLER(handle_poll_command)
 
 COMMAND_HANDLER(handle_wait_halt_command)
 {
 
 COMMAND_HANDLER(handle_wait_halt_command)
 {
-       if (argc > 1)
+       if (CMD_ARGC > 1)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        unsigned ms = 5000;
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        unsigned ms = 5000;
-       if (1 == argc)
+       if (1 == CMD_ARGC)
        {
        {
-               int retval = parse_uint(args[0], &ms);
+               int retval = parse_uint(CMD_ARGV[0], &ms);
                if (ERROR_OK != retval)
                {
                if (ERROR_OK != retval)
                {
-                       command_print(cmd_ctx, "usage: %s [seconds]", CMD_NAME);
+                       command_print(CMD_CTX, "usage: %s [seconds]", CMD_NAME);
                        return ERROR_COMMAND_SYNTAX_ERROR;
                }
                // convert seconds (given) to milliseconds (needed)
                ms *= 1000;
        }
 
                        return ERROR_COMMAND_SYNTAX_ERROR;
                }
                // convert seconds (given) to milliseconds (needed)
                ms *= 1000;
        }
 
-       struct target *target = get_current_target(cmd_ctx);
+       struct target *target = get_current_target(CMD_CTX);
        return target_wait_state(target, TARGET_HALTED, ms);
 }
 
        return target_wait_state(target, TARGET_HALTED, ms);
 }
 
@@ -2106,15 +2089,15 @@ COMMAND_HANDLER(handle_halt_command)
 {
        LOG_DEBUG("-");
 
 {
        LOG_DEBUG("-");
 
-       struct target *target = get_current_target(cmd_ctx);
+       struct target *target = get_current_target(CMD_CTX);
        int retval = target_halt(target);
        if (ERROR_OK != retval)
                return retval;
 
        int retval = target_halt(target);
        if (ERROR_OK != retval)
                return retval;
 
-       if (argc == 1)
+       if (CMD_ARGC == 1)
        {
                unsigned wait;
        {
                unsigned wait;
-               retval = parse_uint(args[0], &wait);
+               retval = parse_uint(CMD_ARGV[0], &wait);
                if (ERROR_OK != retval)
                        return ERROR_COMMAND_SYNTAX_ERROR;
                if (!wait)
                if (ERROR_OK != retval)
                        return ERROR_COMMAND_SYNTAX_ERROR;
                if (!wait)
@@ -2126,7 +2109,7 @@ COMMAND_HANDLER(handle_halt_command)
 
 COMMAND_HANDLER(handle_soft_reset_halt_command)
 {
 
 COMMAND_HANDLER(handle_soft_reset_halt_command)
 {
-       struct target *target = get_current_target(cmd_ctx);
+       struct target *target = get_current_target(CMD_CTX);
 
        LOG_USER("requesting target halt and executing a soft reset");
 
 
        LOG_USER("requesting target halt and executing a soft reset");
 
@@ -2137,14 +2120,14 @@ COMMAND_HANDLER(handle_soft_reset_halt_command)
 
 COMMAND_HANDLER(handle_reset_command)
 {
 
 COMMAND_HANDLER(handle_reset_command)
 {
-       if (argc > 1)
+       if (CMD_ARGC > 1)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        enum target_reset_mode reset_mode = RESET_RUN;
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        enum target_reset_mode reset_mode = RESET_RUN;
-       if (argc == 1)
+       if (CMD_ARGC == 1)
        {
                const Jim_Nvp *n;
        {
                const Jim_Nvp *n;
-               n = Jim_Nvp_name2value_simple(nvp_reset_modes, args[0]);
+               n = Jim_Nvp_name2value_simple(nvp_reset_modes, CMD_ARGV[0]);
                if ((n->name == NULL) || (n->value == RESET_UNKNOWN)) {
                        return ERROR_COMMAND_SYNTAX_ERROR;
                }
                if ((n->name == NULL) || (n->value == RESET_UNKNOWN)) {
                        return ERROR_COMMAND_SYNTAX_ERROR;
                }
@@ -2152,26 +2135,26 @@ COMMAND_HANDLER(handle_reset_command)
        }
 
        /* reset *all* targets */
        }
 
        /* reset *all* targets */
-       return target_process_reset(cmd_ctx, reset_mode);
+       return target_process_reset(CMD_CTX, reset_mode);
 }
 
 
 COMMAND_HANDLER(handle_resume_command)
 {
        int current = 1;
 }
 
 
 COMMAND_HANDLER(handle_resume_command)
 {
        int current = 1;
-       if (argc > 1)
+       if (CMD_ARGC > 1)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
                return ERROR_COMMAND_SYNTAX_ERROR;
 
-       struct target *target = get_current_target(cmd_ctx);
+       struct target *target = get_current_target(CMD_CTX);
        target_handle_event(target, TARGET_EVENT_OLD_pre_resume);
 
        target_handle_event(target, TARGET_EVENT_OLD_pre_resume);
 
-       /* with no args, resume from current pc, addr = 0,
-        * with one arguments, addr = args[0],
+       /* with no CMD_ARGV, resume from current pc, addr = 0,
+        * with one arguments, addr = CMD_ARGV[0],
         * handle breakpoints, not debugging */
        uint32_t addr = 0;
         * handle breakpoints, not debugging */
        uint32_t addr = 0;
-       if (argc == 1)
+       if (CMD_ARGC == 1)
        {
        {
-               COMMAND_PARSE_NUMBER(u32, args[0], addr);
+               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
                current = 0;
        }
 
                current = 0;
        }
 
@@ -2180,23 +2163,23 @@ COMMAND_HANDLER(handle_resume_command)
 
 COMMAND_HANDLER(handle_step_command)
 {
 
 COMMAND_HANDLER(handle_step_command)
 {
-       if (argc > 1)
+       if (CMD_ARGC > 1)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        LOG_DEBUG("-");
 
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        LOG_DEBUG("-");
 
-       /* with no args, step from current pc, addr = 0,
-        * with one argument addr = args[0],
+       /* with no CMD_ARGV, step from current pc, addr = 0,
+        * with one argument addr = CMD_ARGV[0],
         * handle breakpoints, debugging */
        uint32_t addr = 0;
        int current_pc = 1;
         * handle breakpoints, debugging */
        uint32_t addr = 0;
        int current_pc = 1;
-       if (argc == 1)
+       if (CMD_ARGC == 1)
        {
        {
-               COMMAND_PARSE_NUMBER(u32, args[0], addr);
+               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
                current_pc = 0;
        }
 
                current_pc = 0;
        }
 
-       struct target *target = get_current_target(cmd_ctx);
+       struct target *target = get_current_target(CMD_CTX);
 
        return target->type->step(target, current_pc, addr, 1);
 }
 
        return target->type->step(target, current_pc, addr, 1);
 }
@@ -2252,7 +2235,7 @@ static void handle_md_output(struct command_context *cmd_ctx,
 
 COMMAND_HANDLER(handle_md_command)
 {
 
 COMMAND_HANDLER(handle_md_command)
 {
-       if (argc < 1)
+       if (CMD_ARGC < 1)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        unsigned size = 0;
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        unsigned size = 0;
@@ -2263,36 +2246,36 @@ COMMAND_HANDLER(handle_md_command)
        default: return ERROR_COMMAND_SYNTAX_ERROR;
        }
 
        default: return ERROR_COMMAND_SYNTAX_ERROR;
        }
 
-       bool physical=strcmp(args[0], "phys")==0;
+       bool physical=strcmp(CMD_ARGV[0], "phys")==0;
        int (*fn)(struct target *target,
                        uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
        if (physical)
        {
        int (*fn)(struct target *target,
                        uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
        if (physical)
        {
-               argc--;
-               args++;
+               CMD_ARGC--;
+               CMD_ARGV++;
                fn=target_read_phys_memory;
        } else
        {
                fn=target_read_memory;
        }
                fn=target_read_phys_memory;
        } else
        {
                fn=target_read_memory;
        }
-       if ((argc < 1) || (argc > 2))
+       if ((CMD_ARGC < 1) || (CMD_ARGC > 2))
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
 
        uint32_t address;
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
 
        uint32_t address;
-       COMMAND_PARSE_NUMBER(u32, args[0], address);
+       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
 
        unsigned count = 1;
 
        unsigned count = 1;
-       if (argc == 2)
-               COMMAND_PARSE_NUMBER(uint, args[1], count);
+       if (CMD_ARGC == 2)
+               COMMAND_PARSE_NUMBER(uint, CMD_ARGV[1], count);
 
        uint8_t *buffer = calloc(count, size);
 
 
        uint8_t *buffer = calloc(count, size);
 
-       struct target *target = get_current_target(cmd_ctx);
+       struct target *target = get_current_target(CMD_CTX);
        int retval = fn(target, address, size, count, buffer);
        if (ERROR_OK == retval)
        int retval = fn(target, address, size, count, buffer);
        if (ERROR_OK == retval)
-               handle_md_output(cmd_ctx, target, address, size, count, buffer);
+               handle_md_output(CMD_CTX, target, address, size, count, buffer);
 
        free(buffer);
 
 
        free(buffer);
 
@@ -2301,40 +2284,39 @@ COMMAND_HANDLER(handle_md_command)
 
 COMMAND_HANDLER(handle_mw_command)
 {
 
 COMMAND_HANDLER(handle_mw_command)
 {
-       if (argc < 2)
+       if (CMD_ARGC < 2)
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
-       bool physical=strcmp(args[0], "phys")==0;
+       bool physical=strcmp(CMD_ARGV[0], "phys")==0;
        int (*fn)(struct target *target,
                        uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
        int (*fn)(struct target *target,
                        uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
-       const char *cmd_name = CMD_NAME;
        if (physical)
        {
        if (physical)
        {
-               argc--;
-               args++;
+               CMD_ARGC--;
+               CMD_ARGV++;
                fn=target_write_phys_memory;
        } else
        {
                fn=target_write_memory;
        }
                fn=target_write_phys_memory;
        } else
        {
                fn=target_write_memory;
        }
-       if ((argc < 2) || (argc > 3))
+       if ((CMD_ARGC < 2) || (CMD_ARGC > 3))
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        uint32_t address;
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        uint32_t address;
-       COMMAND_PARSE_NUMBER(u32, args[0], address);
+       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
 
        uint32_t value;
 
        uint32_t value;
-       COMMAND_PARSE_NUMBER(u32, args[1], value);
+       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
 
        unsigned count = 1;
 
        unsigned count = 1;
-       if (argc == 3)
-               COMMAND_PARSE_NUMBER(uint, args[2], count);
+       if (CMD_ARGC == 3)
+               COMMAND_PARSE_NUMBER(uint, CMD_ARGV[2], count);
 
 
-       struct target *target = get_current_target(cmd_ctx);
+       struct target *target = get_current_target(CMD_CTX);
        unsigned wordsize;
        uint8_t value_buf[4];
        unsigned wordsize;
        uint8_t value_buf[4];
-       switch (cmd_name[6])
+       switch (CMD_NAME[2])
        {
                case 'w':
                        wordsize = 4;
        {
                case 'w':
                        wordsize = 4;
@@ -2364,18 +2346,18 @@ COMMAND_HANDLER(handle_mw_command)
 
 }
 
 
 }
 
-static COMMAND_HELPER(parse_load_image_command_args, struct image *image,
+static COMMAND_HELPER(parse_load_image_command_CMD_ARGV, struct image *image,
                uint32_t *min_address, uint32_t *max_address)
 {
                uint32_t *min_address, uint32_t *max_address)
 {
-       if (argc < 1 || argc > 5)
+       if (CMD_ARGC < 1 || CMD_ARGC > 5)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        /* a base address isn't always necessary,
         * default to 0x0 (i.e. don't relocate) */
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        /* a base address isn't always necessary,
         * default to 0x0 (i.e. don't relocate) */
-       if (argc >= 2)
+       if (CMD_ARGC >= 2)
        {
                uint32_t addr;
        {
                uint32_t addr;
-               COMMAND_PARSE_NUMBER(u32, args[1], addr);
+               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], addr);
                image->base_address = addr;
                image->base_address_set = 1;
        }
                image->base_address = addr;
                image->base_address_set = 1;
        }
@@ -2384,13 +2366,13 @@ static COMMAND_HELPER(parse_load_image_command_args, struct image *image,
 
        image->start_address_set = 0;
 
 
        image->start_address_set = 0;
 
-       if (argc >= 4)
+       if (CMD_ARGC >= 4)
        {
        {
-               COMMAND_PARSE_NUMBER(u32, args[3], *min_address);
+               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], *min_address);
        }
        }
-       if (argc == 5)
+       if (CMD_ARGC == 5)
        {
        {
-               COMMAND_PARSE_NUMBER(u32, args[4], *max_address);
+               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[4], *max_address);
                // use size (given) to find max (required)
                *max_address += *min_address;
        }
                // use size (given) to find max (required)
                *max_address += *min_address;
        }
@@ -2404,24 +2386,24 @@ static COMMAND_HELPER(parse_load_image_command_args, struct image *image,
 COMMAND_HANDLER(handle_load_image_command)
 {
        uint8_t *buffer;
 COMMAND_HANDLER(handle_load_image_command)
 {
        uint8_t *buffer;
-       uint32_t buf_cnt;
+       size_t buf_cnt;
        uint32_t image_size;
        uint32_t min_address = 0;
        uint32_t max_address = 0xffffffff;
        int i;
        struct image image;
 
        uint32_t image_size;
        uint32_t min_address = 0;
        uint32_t max_address = 0xffffffff;
        int i;
        struct image image;
 
-       int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args,
+       int retval = CALL_COMMAND_HANDLER(parse_load_image_command_CMD_ARGV,
                        &image, &min_address, &max_address);
        if (ERROR_OK != retval)
                return retval;
 
                        &image, &min_address, &max_address);
        if (ERROR_OK != retval)
                return retval;
 
-       struct target *target = get_current_target(cmd_ctx);
+       struct target *target = get_current_target(CMD_CTX);
 
        struct duration bench;
        duration_start(&bench);
 
 
        struct duration bench;
        duration_start(&bench);
 
-       if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
+       if (image_open(&image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL) != ERROR_OK)
        {
                return ERROR_OK;
        }
        {
                return ERROR_OK;
        }
@@ -2433,7 +2415,7 @@ COMMAND_HANDLER(handle_load_image_command)
                buffer = malloc(image.sections[i].size);
                if (buffer == NULL)
                {
                buffer = malloc(image.sections[i].size);
                if (buffer == NULL)
                {
-                       command_print(cmd_ctx,
+                       command_print(CMD_CTX,
                                                  "error allocating buffer for section (%d bytes)",
                                                  (int)(image.sections[i].size));
                        break;
                                                  "error allocating buffer for section (%d bytes)",
                                                  (int)(image.sections[i].size));
                        break;
@@ -2471,7 +2453,7 @@ COMMAND_HANDLER(handle_load_image_command)
                                break;
                        }
                        image_size += length;
                                break;
                        }
                        image_size += length;
-                       command_print(cmd_ctx, "%u bytes written at address 0x%8.8" PRIx32 "",
+                       command_print(CMD_CTX, "%u bytes written at address 0x%8.8" PRIx32 "",
                                                  (unsigned int)length,
                                                  image.sections[i].base_address + offset);
                }
                                                  (unsigned int)length,
                                                  image.sections[i].base_address + offset);
                }
@@ -2481,7 +2463,7 @@ COMMAND_HANDLER(handle_load_image_command)
 
        if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
        {
 
        if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
        {
-               command_print(cmd_ctx, "downloaded %" PRIu32 " bytes "
+               command_print(CMD_CTX, "downloaded %" PRIu32 " bytes "
                                "in %fs (%0.3f kb/s)", image_size,
                                duration_elapsed(&bench), duration_kbps(&bench, image_size));
        }
                                "in %fs (%0.3f kb/s)", image_size,
                                duration_elapsed(&bench), duration_kbps(&bench, image_size));
        }
@@ -2500,20 +2482,20 @@ COMMAND_HANDLER(handle_dump_image_command)
        int retvaltemp;
 
 
        int retvaltemp;
 
 
-       struct target *target = get_current_target(cmd_ctx);
+       struct target *target = get_current_target(CMD_CTX);
 
 
-       if (argc != 3)
+       if (CMD_ARGC != 3)
        {
        {
-               command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
+               command_print(CMD_CTX, "usage: dump_image <filename> <address> <size>");
                return ERROR_OK;
        }
 
        uint32_t address;
                return ERROR_OK;
        }
 
        uint32_t address;
-       COMMAND_PARSE_NUMBER(u32, args[1], address);
+       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], address);
        uint32_t size;
        uint32_t size;
-       COMMAND_PARSE_NUMBER(u32, args[2], size);
+       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], size);
 
 
-       if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
+       if (fileio_open(&fileio, CMD_ARGV[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK)
        {
                return ERROR_OK;
        }
        {
                return ERROR_OK;
        }
@@ -2524,7 +2506,7 @@ COMMAND_HANDLER(handle_dump_image_command)
        int retval = ERROR_OK;
        while (size > 0)
        {
        int retval = ERROR_OK;
        while (size > 0)
        {
-               uint32_t size_written;
+               size_t size_written;
                uint32_t this_run_size = (size > 560) ? 560 : size;
                retval = target_read_buffer(target, address, this_run_size, buffer);
                if (retval != ERROR_OK)
                uint32_t this_run_size = (size > 560) ? 560 : size;
                retval = target_read_buffer(target, address, this_run_size, buffer);
                if (retval != ERROR_OK)
@@ -2547,8 +2529,8 @@ COMMAND_HANDLER(handle_dump_image_command)
 
        if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
        {
 
        if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
        {
-               command_print(cmd_ctx,
-                               "dumped %lld bytes in %fs (%0.3f kb/s)", fileio.size,
+               command_print(CMD_CTX,
+                               "dumped %zu bytes in %fs (%0.3f kb/s)", fileio.size,
                                duration_elapsed(&bench), duration_kbps(&bench, fileio.size));
        }
 
                                duration_elapsed(&bench), duration_kbps(&bench, fileio.size));
        }
 
@@ -2558,7 +2540,7 @@ COMMAND_HANDLER(handle_dump_image_command)
 static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
 {
        uint8_t *buffer;
 static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
 {
        uint8_t *buffer;
-       uint32_t buf_cnt;
+       size_t buf_cnt;
        uint32_t image_size;
        int i;
        int retval;
        uint32_t image_size;
        int i;
        int retval;
@@ -2567,9 +2549,9 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
 
        struct image image;
 
 
        struct image image;
 
-       struct target *target = get_current_target(cmd_ctx);
+       struct target *target = get_current_target(CMD_CTX);
 
 
-       if (argc < 1)
+       if (CMD_ARGC < 1)
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
@@ -2583,10 +2565,10 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
        struct duration bench;
        duration_start(&bench);
 
        struct duration bench;
        duration_start(&bench);
 
-       if (argc >= 2)
+       if (CMD_ARGC >= 2)
        {
                uint32_t addr;
        {
                uint32_t addr;
-               COMMAND_PARSE_NUMBER(u32, args[1], addr);
+               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], addr);
                image.base_address = addr;
                image.base_address_set = 1;
        }
                image.base_address = addr;
                image.base_address_set = 1;
        }
@@ -2598,7 +2580,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
 
        image.start_address_set = 0;
 
 
        image.start_address_set = 0;
 
-       if ((retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
+       if ((retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC == 3) ? CMD_ARGV[2] : NULL)) != ERROR_OK)
        {
                return retval;
        }
        {
                return retval;
        }
@@ -2610,7 +2592,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
                buffer = malloc(image.sections[i].size);
                if (buffer == NULL)
                {
                buffer = malloc(image.sections[i].size);
                if (buffer == NULL)
                {
-                       command_print(cmd_ctx,
+                       command_print(CMD_CTX,
                                                  "error allocating buffer for section (%d bytes)",
                                                  (int)(image.sections[i].size));
                        break;
                                                  "error allocating buffer for section (%d bytes)",
                                                  (int)(image.sections[i].size));
                        break;
@@ -2638,7 +2620,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
                                /* failed crc checksum, fall back to a binary compare */
                                uint8_t *data;
 
                                /* failed crc checksum, fall back to a binary compare */
                                uint8_t *data;
 
-                               command_print(cmd_ctx, "checksum mismatch - attempting binary compare");
+                               command_print(CMD_CTX, "checksum mismatch - attempting binary compare");
 
                                data = (uint8_t*)malloc(buf_cnt);
 
 
                                data = (uint8_t*)malloc(buf_cnt);
 
@@ -2658,7 +2640,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
                                        {
                                                if (data[t] != buffer[t])
                                                {
                                        {
                                                if (data[t] != buffer[t])
                                                {
-                                                       command_print(cmd_ctx,
+                                                       command_print(CMD_CTX,
                                                                                  "Verify operation failed address 0x%08x. Was 0x%02x instead of 0x%02x\n",
                                                                                  (unsigned)(t + image.sections[i].base_address),
                                                                                  data[t],
                                                                                  "Verify operation failed address 0x%08x. Was 0x%02x instead of 0x%02x\n",
                                                                                  (unsigned)(t + image.sections[i].base_address),
                                                                                  data[t],
@@ -2679,7 +2661,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
                        }
                } else
                {
                        }
                } else
                {
-                       command_print(cmd_ctx, "address 0x%08" PRIx32 " length 0x%08" PRIx32 "",
+                       command_print(CMD_CTX, "address 0x%08" PRIx32 " length 0x%08zx",
                                                  image.sections[i].base_address,
                                                  buf_cnt);
                }
                                                  image.sections[i].base_address,
                                                  buf_cnt);
                }
@@ -2690,7 +2672,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
 done:
        if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
        {
 done:
        if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
        {
-               command_print(cmd_ctx, "verified %" PRIu32 " bytes "
+               command_print(CMD_CTX, "verified %" PRIu32 " bytes "
                                "in %fs (%0.3f kb/s)", image_size,
                                duration_elapsed(&bench), duration_kbps(&bench, image_size));
        }
                                "in %fs (%0.3f kb/s)", image_size,
                                duration_elapsed(&bench), duration_kbps(&bench, image_size));
        }
@@ -2752,41 +2734,41 @@ static int handle_bp_command_set(struct command_context *cmd_ctx,
 
 COMMAND_HANDLER(handle_bp_command)
 {
 
 COMMAND_HANDLER(handle_bp_command)
 {
-       if (argc == 0)
-               return handle_bp_command_list(cmd_ctx);
+       if (CMD_ARGC == 0)
+               return handle_bp_command_list(CMD_CTX);
 
 
-       if (argc < 2 || argc > 3)
+       if (CMD_ARGC < 2 || CMD_ARGC > 3)
        {
        {
-               command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
+               command_print(CMD_CTX, "usage: bp <address> <length> ['hw']");
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
 
        uint32_t addr;
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
 
        uint32_t addr;
-       COMMAND_PARSE_NUMBER(u32, args[0], addr);
+       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
        uint32_t length;
        uint32_t length;
-       COMMAND_PARSE_NUMBER(u32, args[1], length);
+       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
 
        int hw = BKPT_SOFT;
 
        int hw = BKPT_SOFT;
-       if (argc == 3)
+       if (CMD_ARGC == 3)
        {
        {
-               if (strcmp(args[2], "hw") == 0)
+               if (strcmp(CMD_ARGV[2], "hw") == 0)
                        hw = BKPT_HARD;
                else
                        return ERROR_COMMAND_SYNTAX_ERROR;
        }
 
                        hw = BKPT_HARD;
                else
                        return ERROR_COMMAND_SYNTAX_ERROR;
        }
 
-       return handle_bp_command_set(cmd_ctx, addr, length, hw);
+       return handle_bp_command_set(CMD_CTX, addr, length, hw);
 }
 
 COMMAND_HANDLER(handle_rbp_command)
 {
 }
 
 COMMAND_HANDLER(handle_rbp_command)
 {
-       if (argc != 1)
+       if (CMD_ARGC != 1)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        uint32_t addr;
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        uint32_t addr;
-       COMMAND_PARSE_NUMBER(u32, args[0], addr);
+       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
 
 
-       struct target *target = get_current_target(cmd_ctx);
+       struct target *target = get_current_target(CMD_CTX);
        breakpoint_remove(target, addr);
 
        return ERROR_OK;
        breakpoint_remove(target, addr);
 
        return ERROR_OK;
@@ -2794,15 +2776,15 @@ COMMAND_HANDLER(handle_rbp_command)
 
 COMMAND_HANDLER(handle_wp_command)
 {
 
 COMMAND_HANDLER(handle_wp_command)
 {
-       struct target *target = get_current_target(cmd_ctx);
+       struct target *target = get_current_target(CMD_CTX);
 
 
-       if (argc == 0)
+       if (CMD_ARGC == 0)
        {
                struct watchpoint *watchpoint = target->watchpoints;
 
                while (watchpoint)
                {
        {
                struct watchpoint *watchpoint = target->watchpoints;
 
                while (watchpoint)
                {
-                       command_print(cmd_ctx, "address: 0x%8.8" PRIx32
+                       command_print(CMD_CTX, "address: 0x%8.8" PRIx32
                                        ", len: 0x%8.8" PRIx32
                                        ", r/w/a: %i, value: 0x%8.8" PRIx32
                                        ", mask: 0x%8.8" PRIx32,
                                        ", len: 0x%8.8" PRIx32
                                        ", r/w/a: %i, value: 0x%8.8" PRIx32
                                        ", mask: 0x%8.8" PRIx32,
@@ -2822,16 +2804,16 @@ COMMAND_HANDLER(handle_wp_command)
        uint32_t data_value = 0x0;
        uint32_t data_mask = 0xffffffff;
 
        uint32_t data_value = 0x0;
        uint32_t data_mask = 0xffffffff;
 
-       switch (argc)
+       switch (CMD_ARGC)
        {
        case 5:
        {
        case 5:
-               COMMAND_PARSE_NUMBER(u32, args[4], data_mask);
+               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[4], data_mask);
                // fall through
        case 4:
                // fall through
        case 4:
-               COMMAND_PARSE_NUMBER(u32, args[3], data_value);
+               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], data_value);
                // fall through
        case 3:
                // fall through
        case 3:
-               switch (args[2][0])
+               switch (CMD_ARGV[2][0])
                {
                case 'r':
                        type = WPT_READ;
                {
                case 'r':
                        type = WPT_READ;
@@ -2843,17 +2825,17 @@ COMMAND_HANDLER(handle_wp_command)
                        type = WPT_ACCESS;
                        break;
                default:
                        type = WPT_ACCESS;
                        break;
                default:
-                       LOG_ERROR("invalid watchpoint mode ('%c')", args[2][0]);
+                       LOG_ERROR("invalid watchpoint mode ('%c')", CMD_ARGV[2][0]);
                        return ERROR_COMMAND_SYNTAX_ERROR;
                }
                // fall through
        case 2:
                        return ERROR_COMMAND_SYNTAX_ERROR;
                }
                // fall through
        case 2:
-               COMMAND_PARSE_NUMBER(u32, args[1], length);
-               COMMAND_PARSE_NUMBER(u32, args[0], addr);
+               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
+               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
                break;
 
        default:
                break;
 
        default:
-               command_print(cmd_ctx, "usage: wp [address length "
+               command_print(CMD_CTX, "usage: wp [address length "
                                "[(r|w|a) [value [mask]]]]");
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
                                "[(r|w|a) [value [mask]]]]");
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
@@ -2868,13 +2850,13 @@ COMMAND_HANDLER(handle_wp_command)
 
 COMMAND_HANDLER(handle_rwp_command)
 {
 
 COMMAND_HANDLER(handle_rwp_command)
 {
-       if (argc != 1)
+       if (CMD_ARGC != 1)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        uint32_t addr;
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        uint32_t addr;
-       COMMAND_PARSE_NUMBER(u32, args[0], addr);
+       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
 
 
-       struct target *target = get_current_target(cmd_ctx);
+       struct target *target = get_current_target(CMD_CTX);
        watchpoint_remove(target, addr);
 
        return ERROR_OK;
        watchpoint_remove(target, addr);
 
        return ERROR_OK;
@@ -2889,17 +2871,17 @@ COMMAND_HANDLER(handle_rwp_command)
  */
 COMMAND_HANDLER(handle_virt2phys_command)
 {
  */
 COMMAND_HANDLER(handle_virt2phys_command)
 {
-       if (argc != 1)
+       if (CMD_ARGC != 1)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        uint32_t va;
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        uint32_t va;
-       COMMAND_PARSE_NUMBER(u32, args[0], va);
+       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], va);
        uint32_t pa;
 
        uint32_t pa;
 
-       struct target *target = get_current_target(cmd_ctx);
+       struct target *target = get_current_target(CMD_CTX);
        int retval = target->type->virt2phys(target, va, &pa);
        if (retval == ERROR_OK)
        int retval = target->type->virt2phys(target, va, &pa);
        if (retval == ERROR_OK)
-               command_print(cmd_ctx, "Physical address 0x%08" PRIx32 "", pa);
+               command_print(CMD_CTX, "Physical address 0x%08" PRIx32 "", pa);
 
        return retval;
 }
 
        return retval;
 }
@@ -3023,20 +3005,20 @@ static void writeGmon(uint32_t *samples, uint32_t sampleNum, const char *filenam
 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
 COMMAND_HANDLER(handle_profile_command)
 {
 /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */
 COMMAND_HANDLER(handle_profile_command)
 {
-       struct target *target = get_current_target(cmd_ctx);
+       struct target *target = get_current_target(CMD_CTX);
        struct timeval timeout, now;
 
        gettimeofday(&timeout, NULL);
        struct timeval timeout, now;
 
        gettimeofday(&timeout, NULL);
-       if (argc != 2)
+       if (CMD_ARGC != 2)
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
        unsigned offset;
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
        unsigned offset;
-       COMMAND_PARSE_NUMBER(uint, args[0], offset);
+       COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], offset);
 
        timeval_add_time(&timeout, offset, 0);
 
 
        timeval_add_time(&timeout, offset, 0);
 
-       command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
+       command_print(CMD_CTX, "Starting profiling. Halting and resuming the target as often as we can...");
 
        static const int maxSample = 10000;
        uint32_t *samples = malloc(sizeof(uint32_t)*maxSample);
 
        static const int maxSample = 10000;
        uint32_t *samples = malloc(sizeof(uint32_t)*maxSample);
@@ -3068,7 +3050,7 @@ COMMAND_HANDLER(handle_profile_command)
                        }
                } else
                {
                        }
                } else
                {
-                       command_print(cmd_ctx, "Target not halted or running");
+                       command_print(CMD_CTX, "Target not halted or running");
                        retval = ERROR_OK;
                        break;
                }
                        retval = ERROR_OK;
                        break;
                }
@@ -3080,7 +3062,7 @@ COMMAND_HANDLER(handle_profile_command)
                gettimeofday(&now, NULL);
                if ((numSamples >= maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
                {
                gettimeofday(&now, NULL);
                if ((numSamples >= maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec)))
                {
-                       command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples);
+                       command_print(CMD_CTX, "Profiling completed. %d samples.", numSamples);
                        if ((retval = target_poll(target)) != ERROR_OK)
                        {
                                free(samples);
                        if ((retval = target_poll(target)) != ERROR_OK)
                        {
                                free(samples);
@@ -3095,8 +3077,8 @@ COMMAND_HANDLER(handle_profile_command)
                                free(samples);
                                return retval;
                        }
                                free(samples);
                                return retval;
                        }
-                       writeGmon(samples, numSamples, args[1]);
-                       command_print(cmd_ctx, "Wrote %s", args[1]);
+                       writeGmon(samples, numSamples, CMD_ARGV[1]);
+                       command_print(CMD_CTX, "Wrote %s", CMD_ARGV[1]);
                        break;
                }
        }
                        break;
                }
        }
@@ -4542,7 +4524,7 @@ static void free_fastload(void)
 COMMAND_HANDLER(handle_fast_load_image_command)
 {
        uint8_t *buffer;
 COMMAND_HANDLER(handle_fast_load_image_command)
 {
        uint8_t *buffer;
-       uint32_t buf_cnt;
+       size_t buf_cnt;
        uint32_t image_size;
        uint32_t min_address = 0;
        uint32_t max_address = 0xffffffff;
        uint32_t image_size;
        uint32_t min_address = 0;
        uint32_t max_address = 0xffffffff;
@@ -4550,7 +4532,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 
        struct image image;
 
 
        struct image image;
 
-       int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args,
+       int retval = CALL_COMMAND_HANDLER(parse_load_image_command_CMD_ARGV,
                        &image, &min_address, &max_address);
        if (ERROR_OK != retval)
                return retval;
                        &image, &min_address, &max_address);
        if (ERROR_OK != retval)
                return retval;
@@ -4558,7 +4540,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
        struct duration bench;
        duration_start(&bench);
 
        struct duration bench;
        duration_start(&bench);
 
-       if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
+       if (image_open(&image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL) != ERROR_OK)
        {
                return ERROR_OK;
        }
        {
                return ERROR_OK;
        }
@@ -4578,7 +4560,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
                buffer = malloc(image.sections[i].size);
                if (buffer == NULL)
                {
                buffer = malloc(image.sections[i].size);
                if (buffer == NULL)
                {
-                       command_print(cmd_ctx, "error allocating buffer for section (%d bytes)",
+                       command_print(CMD_CTX, "error allocating buffer for section (%d bytes)",
                                                  (int)(image.sections[i].size));
                        break;
                }
                                                  (int)(image.sections[i].size));
                        break;
                }
@@ -4621,7 +4603,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
                        fastload[i].length = length;
 
                        image_size += length;
                        fastload[i].length = length;
 
                        image_size += length;
-                       command_print(cmd_ctx, "%u bytes written at address 0x%8.8x",
+                       command_print(CMD_CTX, "%u bytes written at address 0x%8.8x",
                                                  (unsigned int)length,
                                                  ((unsigned int)(image.sections[i].base_address + offset)));
                }
                                                  (unsigned int)length,
                                                  ((unsigned int)(image.sections[i].base_address + offset)));
                }
@@ -4631,11 +4613,11 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 
        if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
        {
 
        if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
        {
-               command_print(cmd_ctx, "Loaded %" PRIu32 " bytes "
+               command_print(CMD_CTX, "Loaded %" PRIu32 " bytes "
                                "in %fs (%0.3f kb/s)", image_size, 
                                duration_elapsed(&bench), duration_kbps(&bench, image_size));
 
                                "in %fs (%0.3f kb/s)", image_size, 
                                duration_elapsed(&bench), duration_kbps(&bench, image_size));
 
-               command_print(cmd_ctx,
+               command_print(CMD_CTX,
                                "WARNING: image has not been loaded to target!"
                                "You can issue a 'fast_load' to finish loading.");
        }
                                "WARNING: image has not been loaded to target!"
                                "You can issue a 'fast_load' to finish loading.");
        }
@@ -4652,7 +4634,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 
 COMMAND_HANDLER(handle_fast_load_command)
 {
 
 COMMAND_HANDLER(handle_fast_load_command)
 {
-       if (argc > 0)
+       if (CMD_ARGC > 0)
                return ERROR_COMMAND_SYNTAX_ERROR;
        if (fastload == NULL)
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        if (fastload == NULL)
        {
@@ -4665,8 +4647,8 @@ COMMAND_HANDLER(handle_fast_load_command)
        int retval = ERROR_OK;
        for (i = 0; i < fastload_num;i++)
        {
        int retval = ERROR_OK;
        for (i = 0; i < fastload_num;i++)
        {
-               struct target *target = get_current_target(cmd_ctx);
-               command_print(cmd_ctx, "Write to 0x%08x, length 0x%08x",
+               struct target *target = get_current_target(CMD_CTX);
+               command_print(CMD_CTX, "Write to 0x%08x, length 0x%08x",
                                          (unsigned int)(fastload[i].address),
                                          (unsigned int)(fastload[i].length));
                if (retval == ERROR_OK)
                                          (unsigned int)(fastload[i].address),
                                          (unsigned int)(fastload[i].length));
                if (retval == ERROR_OK)
@@ -4676,7 +4658,7 @@ COMMAND_HANDLER(handle_fast_load_command)
                size += fastload[i].length;
        }
        int after = timeval_ms();
                size += fastload[i].length;
        }
        int after = timeval_ms();
-       command_print(cmd_ctx, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
+       command_print(CMD_CTX, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
        return retval;
 }
 
        return retval;
 }
 
@@ -4802,7 +4784,7 @@ int target_register_user_commands(struct command_context *cmd_ctx)
 
        register_command(cmd_ctx, NULL, "fast_load_image",
                        handle_fast_load_image_command, COMMAND_ANY,
 
        register_command(cmd_ctx, NULL, "fast_load_image",
                        handle_fast_load_image_command, COMMAND_ANY,
-                       "same args as load_image, image stored in memory "
+                       "same CMD_ARGV as load_image, image stored in memory "
                        "- mainly for profiling purposes");
 
        register_command(cmd_ctx, NULL, "fast_load",
                        "- mainly for profiling purposes");
 
        register_command(cmd_ctx, NULL, "fast_load",
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)