Menu
▾
▴
[OpenOCD-commit] Main OpenOCD repository branch, master, updated. v0.11.0-259-g65c9653cc
|
From: OpenOCD-Gerrit <ope...@us...> - 2021-07-10 14:32:39
|
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "Main OpenOCD repository".
The branch, master has been updated
via 65c9653cc768f77a5e8cf2af73e0f40d614bdec2 (commit)
from c819444e9665888a45fcdaf6691737329a380d00 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 65c9653cc768f77a5e8cf2af73e0f40d614bdec2
Author: Jan Matyas <ma...@co...>
Date: Thu Jun 3 16:26:37 2021 +0200
target: add support for 64bit data in mem2array and array2mem
- Added support for reading and writing 64-bit data items
using TCL commands "mem2array" and "array2mem". Until now,
data items only up to 32 bits were supportd.
- Cleaned up functions target_array2mem() and
target_mem2array(), especially data types of variables
and variable declarations (scope).
Change-Id: Ia0ba427804f8fd8d7568f12714ab36984d6d5e24
Signed-off-by: Jan Matyas <ma...@co...>
Reviewed-on: http://openocd.zylin.com/6286
Tested-by: jenkins
Reviewed-by: Marc Schink <de...@za...>
Reviewed-by: Antonio Borneo <bor...@gm...>
diff --git a/doc/openocd.texi b/doc/openocd.texi
index daf0a6aa1..1eebe1425 100644
--- a/doc/openocd.texi
+++ b/doc/openocd.texi
@@ -4821,8 +4821,8 @@ They are not otherwise documented here.
@deffn {Command} {$target_name array2mem} arrayname width address count
@deffnx {Command} {$target_name mem2array} arrayname width address count
These provide an efficient script-oriented interface to memory.
-The @code{array2mem} primitive writes bytes, halfwords, or words;
-while @code{mem2array} reads them.
+The @code{array2mem} primitive writes bytes, halfwords, words
+or double-words; while @code{mem2array} reads them.
In both cases, the TCL side uses an array, and
the target side uses raw memory.
@@ -4835,7 +4835,7 @@ and neither store nor return those values.
@itemize
@item @var{arrayname} ... is the name of an array variable
-@item @var{width} ... is 8/16/32 - indicating the memory access size
+@item @var{width} ... is 8/16/32/64 - indicating the memory access size
@item @var{address} ... is the target memory address
@item @var{count} ... is the number of elements to process
@end itemize
diff --git a/src/target/target.c b/src/target/target.c
index 6b53ebd98..3772f8e3e 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -4372,7 +4372,7 @@ COMMAND_HANDLER(handle_profile_command)
return retval;
}
-static int new_int_array_element(Jim_Interp *interp, const char *varname, int idx, uint32_t val)
+static int new_u64_array_element(Jim_Interp *interp, const char *varname, int idx, uint64_t val)
{
char *namebuf;
Jim_Obj *nameObjPtr, *valObjPtr;
@@ -4383,7 +4383,8 @@ static int new_int_array_element(Jim_Interp *interp, const char *varname, int id
return JIM_ERR;
nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
- valObjPtr = Jim_NewIntObj(interp, val);
+ jim_wide wide_val = val;
+ valObjPtr = Jim_NewWideObj(interp, wide_val);
if (!nameObjPtr || !valObjPtr) {
free(namebuf);
return JIM_ERR;
@@ -4418,68 +4419,65 @@ static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
static int target_mem2array(Jim_Interp *interp, struct target *target, int argc, Jim_Obj *const *argv)
{
- long l;
- jim_wide wide_addr;
- uint32_t width;
- int len;
- target_addr_t addr;
- uint32_t count;
- uint32_t v;
- const char *varname;
- const char *phys;
- bool is_phys;
- int n, e, retval;
- uint32_t i;
+ int e;
- /* argv[1] = name of array to receive the data
- * argv[2] = desired width
- * argv[3] = memory address
- * argv[4] = count of times to read
+ /* argv[0] = name of array to receive the data
+ * argv[1] = desired element width in bits
+ * argv[2] = memory address
+ * argv[3] = count of times to read
+ * argv[4] = optional "phys"
*/
-
if (argc < 4 || argc > 5) {
Jim_WrongNumArgs(interp, 0, argv, "varname width addr nelems [phys]");
return JIM_ERR;
}
- varname = Jim_GetString(argv[0], &len);
- /* given "foo" get space for worse case "foo(%d)" .. add 20 */
+ /* Arg 0: Name of the array variable */
+ const char *varname = Jim_GetString(argv[0], NULL);
+
+ /* Arg 1: Bit width of one element */
+ long l;
e = Jim_GetLong(interp, argv[1], &l);
- width = l;
if (e != JIM_OK)
return e;
+ const unsigned int width_bits = l;
+
+ if (width_bits != 8 &&
+ width_bits != 16 &&
+ width_bits != 32 &&
+ width_bits != 64) {
+ Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+ Jim_AppendStrings(interp, Jim_GetResult(interp),
+ "Invalid width param. Must be one of: 8, 16, 32 or 64.", NULL);
+ return JIM_ERR;
+ }
+ const unsigned int width = width_bits / 8;
+ /* Arg 2: Memory address */
+ jim_wide wide_addr;
e = Jim_GetWide(interp, argv[2], &wide_addr);
- addr = (target_addr_t)wide_addr;
if (e != JIM_OK)
return e;
+ target_addr_t addr = (target_addr_t)wide_addr;
+
+ /* Arg 3: Number of elements to read */
e = Jim_GetLong(interp, argv[3], &l);
- len = l;
if (e != JIM_OK)
return e;
- is_phys = false;
+ size_t len = l;
+
+ /* Arg 4: phys */
+ bool is_phys = false;
if (argc > 4) {
- phys = Jim_GetString(argv[4], &n);
- if (!strncmp(phys, "phys", n))
+ int str_len = 0;
+ const char *phys = Jim_GetString(argv[4], &str_len);
+ if (!strncmp(phys, "phys", str_len))
is_phys = true;
else
return JIM_ERR;
}
- switch (width) {
- case 8:
- width = 1;
- break;
- case 16:
- width = 2;
- break;
- case 32:
- width = 4;
- break;
- default:
- Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
- Jim_AppendStrings(interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL);
- return JIM_ERR;
- }
+
+ /* Argument checks */
if (len == 0) {
Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: zero width read?", NULL);
@@ -4490,17 +4488,18 @@ static int target_mem2array(Jim_Interp *interp, struct target *target, int argc,
Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: addr + len - wraps to zero?", NULL);
return JIM_ERR;
}
- /* absurd transfer size? */
if (len > 65536) {
Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
- Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: absurd > 64K item request", NULL);
+ Jim_AppendStrings(interp, Jim_GetResult(interp),
+ "mem2array: too large read request, exceeds 64K items", NULL);
return JIM_ERR;
}
if ((width == 1) ||
((width == 2) && ((addr & 1) == 0)) ||
- ((width == 4) && ((addr & 3) == 0))) {
- /* all is well */
+ ((width == 4) && ((addr & 3) == 0)) ||
+ ((width == 8) && ((addr & 7) == 0))) {
+ /* alignment correct */
} else {
char buf[100];
Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
@@ -4514,9 +4513,9 @@ static int target_mem2array(Jim_Interp *interp, struct target *target, int argc,
/* Transfer loop */
/* index counter */
- n = 0;
+ size_t idx = 0;
- size_t buffersize = 4096;
+ const size_t buffersize = 4096;
uint8_t *buffer = malloc(buffersize);
if (buffer == NULL)
return JIM_ERR;
@@ -4525,29 +4524,31 @@ static int target_mem2array(Jim_Interp *interp, struct target *target, int argc,
e = JIM_OK;
while (len) {
/* Slurp... in buffer size chunks */
+ const unsigned int max_chunk_len = buffersize / width;
+ const size_t chunk_len = MIN(len, max_chunk_len); /* in elements.. */
- count = len; /* in objects.. */
- if (count > (buffersize / width))
- count = (buffersize / width);
-
+ int retval;
if (is_phys)
- retval = target_read_phys_memory(target, addr, width, count, buffer);
+ retval = target_read_phys_memory(target, addr, width, chunk_len, buffer);
else
- retval = target_read_memory(target, addr, width, count, buffer);
+ retval = target_read_memory(target, addr, width, chunk_len, buffer);
if (retval != ERROR_OK) {
/* BOO !*/
- LOG_ERROR("mem2array: Read @ " TARGET_ADDR_FMT ", w=%" PRIu32 ", cnt=%" PRIu32 ", failed",
+ LOG_ERROR("mem2array: Read @ " TARGET_ADDR_FMT ", w=%u, cnt=%zu, failed",
addr,
width,
- count);
+ chunk_len);
Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL);
e = JIM_ERR;
break;
} else {
- v = 0; /* shut up gcc */
- for (i = 0; i < count ; i++, n++) {
+ for (size_t i = 0; i < chunk_len ; i++, idx++) {
+ uint64_t v = 0;
switch (width) {
+ case 8:
+ v = target_buffer_get_u64(target, &buffer[i*width]);
+ break;
case 4:
v = target_buffer_get_u32(target, &buffer[i*width]);
break;
@@ -4558,10 +4559,10 @@ static int target_mem2array(Jim_Interp *interp, struct target *target, int argc,
v = buffer[i] & 0x0ff;
break;
}
- new_int_array_element(interp, varname, n, v);
+ new_u64_array_element(interp, varname, idx, v);
}
- len -= count;
- addr += count * width;
+ len -= chunk_len;
+ addr += chunk_len * width;
}
}
@@ -4572,33 +4573,28 @@ static int target_mem2array(Jim_Interp *interp, struct target *target, int argc,
return e;
}
-static int get_int_array_element(Jim_Interp *interp, const char *varname, int idx, uint32_t *val)
+static int get_u64_array_element(Jim_Interp *interp, const char *varname, size_t idx, uint64_t *val)
{
- char *namebuf;
- Jim_Obj *nameObjPtr, *valObjPtr;
- int result;
- long l;
-
- namebuf = alloc_printf("%s(%d)", varname, idx);
+ char *namebuf = alloc_printf("%s(%zu)", varname, idx);
if (!namebuf)
return JIM_ERR;
- nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
+ Jim_Obj *nameObjPtr = Jim_NewStringObj(interp, namebuf, -1);
if (!nameObjPtr) {
free(namebuf);
return JIM_ERR;
}
Jim_IncrRefCount(nameObjPtr);
- valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG);
+ Jim_Obj *valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG);
Jim_DecrRefCount(interp, nameObjPtr);
free(namebuf);
if (valObjPtr == NULL)
return JIM_ERR;
- result = Jim_GetLong(interp, valObjPtr, &l);
- /* printf("%s(%d) => 0%08x\n", varname, idx, val); */
- *val = l;
+ jim_wide wide_val;
+ int result = Jim_GetWide(interp, valObjPtr, &wide_val);
+ *val = wide_val;
return result;
}
@@ -4622,92 +4618,91 @@ static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
static int target_array2mem(Jim_Interp *interp, struct target *target,
int argc, Jim_Obj *const *argv)
{
- long l;
- jim_wide wide_addr;
- uint32_t width;
- int len;
- target_addr_t addr;
- uint32_t count;
- uint32_t v;
- const char *varname;
- const char *phys;
- bool is_phys;
- int n, e, retval;
- uint32_t i;
+ int e;
- /* argv[1] = name of array to get the data
- * argv[2] = desired width
- * argv[3] = memory address
- * argv[4] = count to write
+ /* argv[0] = name of array from which to read the data
+ * argv[1] = desired element width in bits
+ * argv[2] = memory address
+ * argv[3] = number of elements to write
+ * argv[4] = optional "phys"
*/
if (argc < 4 || argc > 5) {
Jim_WrongNumArgs(interp, 0, argv, "varname width addr nelems [phys]");
return JIM_ERR;
}
- varname = Jim_GetString(argv[0], &len);
- /* given "foo" get space for worse case "foo(%d)" .. add 20 */
+ /* Arg 0: Name of the array variable */
+ const char *varname = Jim_GetString(argv[0], NULL);
+
+ /* Arg 1: Bit width of one element */
+ long l;
e = Jim_GetLong(interp, argv[1], &l);
- width = l;
if (e != JIM_OK)
return e;
+ const unsigned int width_bits = l;
+
+ if (width_bits != 8 &&
+ width_bits != 16 &&
+ width_bits != 32 &&
+ width_bits != 64) {
+ Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
+ Jim_AppendStrings(interp, Jim_GetResult(interp),
+ "Invalid width param. Must be one of: 8, 16, 32 or 64.", NULL);
+ return JIM_ERR;
+ }
+ const unsigned int width = width_bits / 8;
+ /* Arg 2: Memory address */
+ jim_wide wide_addr;
e = Jim_GetWide(interp, argv[2], &wide_addr);
- addr = (target_addr_t)wide_addr;
if (e != JIM_OK)
return e;
+ target_addr_t addr = (target_addr_t)wide_addr;
+
+ /* Arg 3: Number of elements to write */
e = Jim_GetLong(interp, argv[3], &l);
- len = l;
if (e != JIM_OK)
return e;
- is_phys = false;
+ size_t len = l;
+
+ /* Arg 4: Phys */
+ bool is_phys = false;
if (argc > 4) {
- phys = Jim_GetString(argv[4], &n);
- if (!strncmp(phys, "phys", n))
+ int str_len = 0;
+ const char *phys = Jim_GetString(argv[4], &str_len);
+ if (!strncmp(phys, "phys", str_len))
is_phys = true;
else
return JIM_ERR;
}
- switch (width) {
- case 8:
- width = 1;
- break;
- case 16:
- width = 2;
- break;
- case 32:
- width = 4;
- break;
- default:
- Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
- Jim_AppendStrings(interp, Jim_GetResult(interp),
- "Invalid width param, must be 8/16/32", NULL);
- return JIM_ERR;
- }
+
+ /* Argument checks */
if (len == 0) {
Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
Jim_AppendStrings(interp, Jim_GetResult(interp),
"array2mem: zero width read?", NULL);
return JIM_ERR;
}
+
if ((addr + (len * width)) < addr) {
Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
Jim_AppendStrings(interp, Jim_GetResult(interp),
"array2mem: addr + len - wraps to zero?", NULL);
return JIM_ERR;
}
- /* absurd transfer size? */
+
if (len > 65536) {
Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
Jim_AppendStrings(interp, Jim_GetResult(interp),
- "array2mem: absurd > 64K item request", NULL);
+ "array2mem: too large memory write request, exceeds 64K items", NULL);
return JIM_ERR;
}
if ((width == 1) ||
((width == 2) && ((addr & 1) == 0)) ||
- ((width == 4) && ((addr & 3) == 0))) {
- /* all is well */
+ ((width == 4) && ((addr & 3) == 0)) ||
+ ((width == 8) && ((addr & 7) == 0))) {
+ /* alignment correct */
} else {
char buf[100];
Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
@@ -4720,27 +4715,34 @@ static int target_array2mem(Jim_Interp *interp, struct target *target,
/* Transfer loop */
- /* index counter */
- n = 0;
/* assume ok */
e = JIM_OK;
- size_t buffersize = 4096;
+ const size_t buffersize = 4096;
uint8_t *buffer = malloc(buffersize);
if (buffer == NULL)
return JIM_ERR;
+ /* index counter */
+ size_t idx = 0;
+
while (len) {
/* Slurp... in buffer size chunks */
+ const unsigned int max_chunk_len = buffersize / width;
- count = len; /* in objects.. */
- if (count > (buffersize / width))
- count = (buffersize / width);
+ const size_t chunk_len = MIN(len, max_chunk_len); /* in elements.. */
- v = 0; /* shut up gcc */
- for (i = 0; i < count; i++, n++) {
- get_int_array_element(interp, varname, n, &v);
+ /* Fill the buffer */
+ for (size_t i = 0; i < chunk_len; i++, idx++) {
+ uint64_t v = 0;
+ if (get_u64_array_element(interp, varname, idx, &v) != JIM_OK) {
+ free(buffer);
+ return JIM_ERR;
+ }
switch (width) {
+ case 8:
+ target_buffer_set_u64(target, &buffer[i * width], v);
+ break;
case 4:
target_buffer_set_u32(target, &buffer[i * width], v);
break;
@@ -4752,24 +4754,26 @@ static int target_array2mem(Jim_Interp *interp, struct target *target,
break;
}
}
- len -= count;
+ len -= chunk_len;
+ /* Write the buffer to memory */
+ int retval;
if (is_phys)
- retval = target_write_phys_memory(target, addr, width, count, buffer);
+ retval = target_write_phys_memory(target, addr, width, chunk_len, buffer);
else
- retval = target_write_memory(target, addr, width, count, buffer);
+ retval = target_write_memory(target, addr, width, chunk_len, buffer);
if (retval != ERROR_OK) {
/* BOO !*/
- LOG_ERROR("array2mem: Write @ " TARGET_ADDR_FMT ", w=%" PRIu32 ", cnt=%" PRIu32 ", failed",
+ LOG_ERROR("array2mem: Write @ " TARGET_ADDR_FMT ", w=%u, cnt=%zu, failed",
addr,
width,
- count);
+ chunk_len);
Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: cannot read memory", NULL);
e = JIM_ERR;
break;
}
- addr += count * width;
+ addr += chunk_len * width;
}
free(buffer);
-----------------------------------------------------------------------
Summary of changes:
doc/openocd.texi | 6 +-
src/target/target.c | 268 ++++++++++++++++++++++++++--------------------------
2 files changed, 139 insertions(+), 135 deletions(-)
hooks/post-receive
--
Main OpenOCD repository
|
