target: Deprecate 'array2mem' and 'mem2array''

Replace 'mem2array' and 'array2mem' with a Tcl wrapper that
internally uses 'read_memory' and 'write_memory'.

The target-specific 'mem2array' and 'array2mem' functions
remain for now.

Change-Id: If24c22a76ac72d4c26916a95f7f17902b41b6d9e
Signed-off-by: Marc Schink <dev@zapb.de>
Reviewed-on: https://review.openocd.org/c/openocd/+/6308
Tested-by: jenkins
Reviewed-by: Antonio Borneo <borneo.antonio@gmail.com>

diff --git a/doc/openocd.texi b/doc/openocd.texi
index f9acedf69cd24ba3953a3caba473619b9743d82e..0cd9621ff4b02bbc5fc63c59217a364cdb75d298 100644 (file)
--- a/doc/openocd.texi
+++ b/doc/openocd.texi
@@ -4980,29 +4980,6 @@ use these to deal with specific reset cases.
 They are not otherwise documented here.
 @end deffn
 
-@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, 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.
-
-The efficiency comes from enabling the use of
-bulk JTAG data transfer operations.
-The script orientation comes from working with data
-values that are packaged for use by TCL scripts;
-@command{mdw} type primitives only print data they retrieve,
-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/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
-@end deffn
-
 @deffn {Command} {$target_name set_reg} dict
 Set register values of the target.
 
@@ -5142,8 +5119,8 @@ When the current target has an MMU which is present and active,
 Otherwise, or if the optional @var{phys} flag is specified,
 @var{addr} is interpreted as a physical address.
 If @var{count} is specified, displays that many units.
-(If you want to manipulate the data instead of displaying it,
-see the @code{mem2array} primitives.)
+(If you want to process the data instead of displaying it,
+see the @code{read_memory} primitives.)
 @end deffn
 
 @deffn {Command} {$target_name mwd} [phys] addr doubleword [count]
@@ -8772,8 +8749,8 @@ When the current target has an MMU which is present and active,
 Otherwise, or if the optional @var{phys} flag is specified,
 @var{addr} is interpreted as a physical address.
 If @var{count} is specified, displays that many units.
-(If you want to manipulate the data instead of displaying it,
-see the @code{mem2array} primitives.)
+(If you want to process the data instead of displaying it,
+see the @code{read_memory} primitives.)
 @end deffn
 
 @deffn {Command} {mwd} [phys] addr doubleword [count]
@@ -11681,13 +11658,7 @@ should be passed in to the proc in question.
 By "low-level", we mean commands that a human would typically not
 invoke directly.
 
-@itemize @bullet
-@item @b{mem2array} <@var{varname}> <@var{width}> <@var{addr}> <@var{nelems}>
-
-Read memory and return as a Tcl array for script processing
-@item @b{array2mem} <@var{varname}> <@var{width}> <@var{addr}> <@var{nelems}>
-
-Convert a Tcl array to memory locations and write the values
+@itemize
 @item @b{flash banks} <@var{driver}> <@var{base}> <@var{size}> <@var{chip_width}> <@var{bus_width}> <@var{target}> [@option{driver options} ...]
 
 Return information about the flash banks

diff --git a/src/target/startup.tcl b/src/target/startup.tcl
index cd98d68e44356d47d432ff173794ec63e7a17797..0e46992b748d7f8324cf04ff50b784d06371353a 100644 (file)
--- a/src/target/startup.tcl
+++ b/src/target/startup.tcl
@@ -206,6 +206,32 @@ proc init_target_events {} {
 proc init_board {} {
 }
 
+proc mem2array {arrayname bitwidth address count {phys ""}} {
+       echo "DEPRECATED! use 'read_memory' not 'mem2array'"
+
+       upvar $arrayname $arrayname
+       set $arrayname ""
+       set i 0
+
+       foreach elem [read_memory $address $bitwidth $count {*}$phys] {
+               set ${arrayname}($i) $elem
+               incr i
+       }
+}
+
+proc array2mem {arrayname bitwidth address count {phys ""}} {
+       echo "DEPRECATED! use 'write_memory' not 'array2mem'"
+
+       upvar $arrayname $arrayname
+       set data ""
+
+       for {set i 0} {$i < $count} {incr i} {
+               lappend data [expr $${arrayname}($i)]
+       }
+
+       write_memory $address $bitwidth $data {*}$phys
+}
+
 # smp_on/smp_off were already DEPRECATED in v0.11.0 through http://openocd.zylin.com/4615
 lappend _telnet_autocomplete_skip "aarch64 smp_on"
 proc "aarch64 smp_on" {args} {

diff --git a/src/target/target.c b/src/target/target.c
index 473538ab7747cc9484c91c11a2c72ec5caaed5a7..7b8271339ce5ad1e7df0d46f535361ee6b7c020c 100644 (file)
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -4431,27 +4431,12 @@ static int new_u64_array_element(Jim_Interp *interp, const char *varname, int id
        return result;
 }
 
-static int jim_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-       struct command_context *context;
-       struct target *target;
-
-       context = current_command_context(interp);
-       assert(context);
-
-       target = get_current_target(context);
-       if (!target) {
-               LOG_ERROR("mem2array: no current target");
-               return JIM_ERR;
-       }
-
-       return target_mem2array(interp, target, argc - 1, argv + 1);
-}
-
 static int target_mem2array(Jim_Interp *interp, struct target *target, int argc, Jim_Obj *const *argv)
 {
        int e;
 
+       LOG_WARNING("DEPRECATED! use 'read_memory' not 'mem2array'");
+
        /* argv[0] = name of array to receive the data
         * argv[1] = desired element width in bits
         * argv[2] = memory address
@@ -4784,28 +4769,13 @@ static int get_u64_array_element(Jim_Interp *interp, const char *varname, size_t
        return result;
 }
 
-static int jim_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
-{
-       struct command_context *context;
-       struct target *target;
-
-       context = current_command_context(interp);
-       assert(context);
-
-       target = get_current_target(context);
-       if (!target) {
-               LOG_ERROR("array2mem: no current target");
-               return JIM_ERR;
-       }
-
-       return target_array2mem(interp, target, argc-1, argv + 1);
-}
-
 static int target_array2mem(Jim_Interp *interp, struct target *target,
                int argc, Jim_Obj *const *argv)
 {
        int e;
 
+       LOG_WARNING("DEPRECATED! use 'write_memory' not 'array2mem'");
+
        /* argv[0] = name of array from which to read the data
         * argv[1] = desired element width in bits
         * argv[2] = memory address
@@ -7170,22 +7140,6 @@ static const struct command_registration target_exec_command_handlers[] = {
                .mode = COMMAND_EXEC,
                .usage = "filename [offset [type]]",
        },
-       {
-               .name = "mem2array",
-               .mode = COMMAND_EXEC,
-               .jim_handler = jim_mem2array,
-               .help = "read 8/16/32 bit memory and return as a TCL array "
-                       "for script processing",
-               .usage = "arrayname bitwidth address count",
-       },
-       {
-               .name = "array2mem",
-               .mode = COMMAND_EXEC,
-               .jim_handler = jim_array2mem,
-               .help = "convert a TCL array to memory locations "
-                       "and write the 8/16/32 bit values",
-               .usage = "arrayname bitwidth address count",
-       },
        {
                .name = "get_reg",
                .mode = COMMAND_EXEC,