ARC: Remove JTAG test function

This is a custom function that seems to be redundant nowdays as it
doesn't server any purpose from user-perspective.

Signed-off-by: Anton Kolesov <anton.kolesov@synopsys.com>
ARC: Optimize JTAG layer

OpenOCD used to be painfully slow when communicating with ARC. This was
caused by two reasons.

1) Functions to write memory used to ignore JTAG write_bulk functions
and were writing 4-bytes one by one. This was mostly affecting GDB's
"load" command, as in other cases writes are usually limited to 4 bytes.
This was increasing amount of JTAG traffic dramatically for "load".

2) Main reason that was affecting every GDB command, was that our JTAG
interface used to execute queue of JTAG commands after adding each
command to the queue. Bonus of that is that if there is an error then it
is clear what caused it, however the performance price was just too big.
Constant flushing of command queue causes unnecessary communication over
USB with the debug cable, instead of small amount of big packets, our
JTAG layer used to send hordes of small ones. USB is quite terrible at
small packets, so bigger packets are better. In fact much-much better.
As a consequence OpenOCD was spending most of the execution time waiting
for USB packets to travel between debug host and debug cable.

To fix this internal functions that are called by high-level JTAG
functions should not execute queue, they should just add commands to the
queue. Execution of queue is performed once per high-level function, at
the end. In case if write operations this is a "enqueue and forget"
approach, as no response is expected. It is a bit more complex in case
of reading, as the data returned from target should be parsed
appropriately. This can be done only after queue execution. So for
example to read registers, first it is required to add commands to
queue, then execute, then convert returned data to host representation.

I've also change API of JTAG layer significantly. Now "bulk" functions
are first-class citizens and the only choice for memory and code
register operations. Functions for AUX registers provide small
convenience wrapper to deal with operations on one register, which are
common throughout ARC OpenOCD code. In other cases if caller wants to
operate on one register/memory word, it should call function with
"count" equal to 1.

Functions for memory and core register support only sequential
addresses, if sequence is broken, two calls are required. AUX registers
functions accept an array of addresses to operate on, thus allowing to
deal with all AUX registers in one call, at the price of more complex
function API. This wasn't applied to memory and core register functions
because non-sequential request there are less common and simpler API was
chosen. This might change for core registers with the advent of proper
support for extension core registers and reduced core register set.

JTAG layer is the lowest level of ARC stack in OpenOCD and I've tried to
make it already acceptable for upstreaming.

Some numbers on performance:

1) Small application debugged with following sequence of GDB commands:
load, b main, b exit, si, c, s, c. Before patch this test was taking
around 20 seconds to finish, after the patch it takes around 1 seconds
(floats between 0.8-1.3 seconds).

2) Test suite consisting of 20 small application, was taking around 8:30
minutes to finish, but after the patch it reduced to 40 seconds.
Interesting that before patch OpenOCD used to spent 40 second in kernel
mode (probably cooking USB packets), while after the patch this time
reduced to 2.5 seconds.

Signed-off-by: Anton Kolesov <anton.kolesov@synopsys.com>