delete ada-lang.c::move_bits, sharing and re-using copy_bitwise instead
This patch deletes ada-lang.c's move_bits function entirely, and
replaces all calls to it by calls to copy_bitwise instead. Because
the latter function was declared locally inside dwarf2loc.c, this
patch also move the function to a common area, and makes it non-static.
gdb/ChangeLog:
* ada-lang.c (move_bits): Delete. Update all callers to use
copy_bitwise instead.
* dwarf2loc.c (copy_bitwise, bits_to_str::bits_to_str)
(selftests::check_copy_bitwise, selftests::copy_bitwise_tests):
Move from here to utils.c.
(_initialize_dwarf2loc): Remove call to register copy_bitwise
selftests.
* utils.h (copy_bitwise): Add declaration.
* utils.c (copy_bitwise, bits_to_str::bits_to_str)
(selftests::check_copy_bitwise, selftests::copy_bitwise_tests):
Moved here from dwarf2loc.c.
(_initialize_utils): Register copy_bitwise selftests.
Tested on x86_64-linux, no regression. Also tested using AdaCore's
testsuite on a collection of small endian and big endian platforms.
This commit is contained in:
Joel Brobecker
parent
8b2d40cbba
commit
a99bc3d23c
5 changed files with 262 additions and 312 deletions
|
|
@ -1,3 +1,18 @@
|
|||
2018-11-14 Joel Brobecker <brobecker@adacore.com>
|
||||
|
||||
* ada-lang.c (move_bits): Delete. Update all callers to use
|
||||
copy_bitwise instead.
|
||||
* dwarf2loc.c (copy_bitwise, bits_to_str::bits_to_str)
|
||||
(selftests::check_copy_bitwise, selftests::copy_bitwise_tests):
|
||||
Move from here to utils.c.
|
||||
(_initialize_dwarf2loc): Remove call to register copy_bitwise
|
||||
selftests.
|
||||
* utils.h (copy_bitwise): Add declaration.
|
||||
* utils.c (copy_bitwise, bits_to_str::bits_to_str)
|
||||
(selftests::check_copy_bitwise, selftests::copy_bitwise_tests):
|
||||
Moved here from dwarf2loc.c.
|
||||
(_initialize_utils): Register copy_bitwise selftests.
|
||||
|
||||
2018-11-14 Jim Wilson <jimw@sifive.com>
|
||||
|
||||
* riscv-tdep.c (struct riscv_arg_info): New field is_unnamed.
|
||||
|
|
|
|||
|
|
@ -190,8 +190,6 @@ static int ada_is_unconstrained_packed_array_type (struct type *);
|
|||
static struct value *value_subscript_packed (struct value *, int,
|
||||
struct value **);
|
||||
|
||||
static void move_bits (gdb_byte *, int, const gdb_byte *, int, int, int);
|
||||
|
||||
static struct value *coerce_unspec_val_to_type (struct value *,
|
||||
struct type *);
|
||||
|
||||
|
|
@ -2669,72 +2667,6 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
|
|||
return v;
|
||||
}
|
||||
|
||||
/* Move N bits from SOURCE, starting at bit offset SRC_OFFSET to
|
||||
TARGET, starting at bit offset TARG_OFFSET. SOURCE and TARGET must
|
||||
not overlap. */
|
||||
static void
|
||||
move_bits (gdb_byte *target, int targ_offset, const gdb_byte *source,
|
||||
int src_offset, int n, int bits_big_endian_p)
|
||||
{
|
||||
unsigned int accum, mask;
|
||||
int accum_bits, chunk_size;
|
||||
|
||||
target += targ_offset / HOST_CHAR_BIT;
|
||||
targ_offset %= HOST_CHAR_BIT;
|
||||
source += src_offset / HOST_CHAR_BIT;
|
||||
src_offset %= HOST_CHAR_BIT;
|
||||
if (bits_big_endian_p)
|
||||
{
|
||||
accum = (unsigned char) *source;
|
||||
source += 1;
|
||||
accum_bits = HOST_CHAR_BIT - src_offset;
|
||||
|
||||
while (n > 0)
|
||||
{
|
||||
int unused_right;
|
||||
|
||||
accum = (accum << HOST_CHAR_BIT) + (unsigned char) *source;
|
||||
accum_bits += HOST_CHAR_BIT;
|
||||
source += 1;
|
||||
chunk_size = HOST_CHAR_BIT - targ_offset;
|
||||
if (chunk_size > n)
|
||||
chunk_size = n;
|
||||
unused_right = HOST_CHAR_BIT - (chunk_size + targ_offset);
|
||||
mask = ((1 << chunk_size) - 1) << unused_right;
|
||||
*target =
|
||||
(*target & ~mask)
|
||||
| ((accum >> (accum_bits - chunk_size - unused_right)) & mask);
|
||||
n -= chunk_size;
|
||||
accum_bits -= chunk_size;
|
||||
target += 1;
|
||||
targ_offset = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
accum = (unsigned char) *source >> src_offset;
|
||||
source += 1;
|
||||
accum_bits = HOST_CHAR_BIT - src_offset;
|
||||
|
||||
while (n > 0)
|
||||
{
|
||||
accum = accum + ((unsigned char) *source << accum_bits);
|
||||
accum_bits += HOST_CHAR_BIT;
|
||||
source += 1;
|
||||
chunk_size = HOST_CHAR_BIT - targ_offset;
|
||||
if (chunk_size > n)
|
||||
chunk_size = n;
|
||||
mask = ((1 << chunk_size) - 1) << targ_offset;
|
||||
*target = (*target & ~mask) | ((accum << targ_offset) & mask);
|
||||
n -= chunk_size;
|
||||
accum_bits -= chunk_size;
|
||||
accum >>= chunk_size;
|
||||
target += 1;
|
||||
targ_offset = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Store the contents of FROMVAL into the location of TOVAL.
|
||||
Return a new value with the location of TOVAL and contents of
|
||||
FROMVAL. Handles assignment into packed fields that have
|
||||
|
|
@ -2777,10 +2709,10 @@ ada_value_assign (struct value *toval, struct value *fromval)
|
|||
if (from_size == 0)
|
||||
from_size = TYPE_LENGTH (value_type (fromval)) * TARGET_CHAR_BIT;
|
||||
if (gdbarch_bits_big_endian (get_type_arch (type)))
|
||||
move_bits (buffer, value_bitpos (toval),
|
||||
copy_bitwise (buffer, value_bitpos (toval),
|
||||
value_contents (fromval), from_size - bits, bits, 1);
|
||||
else
|
||||
move_bits (buffer, value_bitpos (toval),
|
||||
copy_bitwise (buffer, value_bitpos (toval),
|
||||
value_contents (fromval), 0, bits, 0);
|
||||
write_memory_with_notification (to_addr, buffer, len);
|
||||
|
||||
|
|
@ -2833,12 +2765,12 @@ value_assign_to_component (struct value *container, struct value *component,
|
|||
= TYPE_LENGTH (value_type (component)) * TARGET_CHAR_BIT - bits;
|
||||
else
|
||||
src_offset = 0;
|
||||
move_bits (value_contents_writeable (container) + offset_in_container,
|
||||
copy_bitwise (value_contents_writeable (container) + offset_in_container,
|
||||
value_bitpos (container) + bit_offset_in_container,
|
||||
value_contents (val), src_offset, bits, 1);
|
||||
}
|
||||
else
|
||||
move_bits (value_contents_writeable (container) + offset_in_container,
|
||||
copy_bitwise (value_contents_writeable (container) + offset_in_container,
|
||||
value_bitpos (container) + bit_offset_in_container,
|
||||
value_contents (val), 0, bits, 0);
|
||||
}
|
||||
|
|
|
|||
234
gdb/dwarf2loc.c
234
gdb/dwarf2loc.c
|
|
@ -1555,236 +1555,6 @@ allocate_piece_closure (struct dwarf2_per_cu_data *per_cu,
|
|||
return c;
|
||||
}
|
||||
|
||||
/* Copy NBITS bits from SOURCE to DEST starting at the given bit
|
||||
offsets. Use the bit order as specified by BITS_BIG_ENDIAN.
|
||||
Source and destination buffers must not overlap. */
|
||||
|
||||
static void
|
||||
copy_bitwise (gdb_byte *dest, ULONGEST dest_offset,
|
||||
const gdb_byte *source, ULONGEST source_offset,
|
||||
ULONGEST nbits, int bits_big_endian)
|
||||
{
|
||||
unsigned int buf, avail;
|
||||
|
||||
if (nbits == 0)
|
||||
return;
|
||||
|
||||
if (bits_big_endian)
|
||||
{
|
||||
/* Start from the end, then work backwards. */
|
||||
dest_offset += nbits - 1;
|
||||
dest += dest_offset / 8;
|
||||
dest_offset = 7 - dest_offset % 8;
|
||||
source_offset += nbits - 1;
|
||||
source += source_offset / 8;
|
||||
source_offset = 7 - source_offset % 8;
|
||||
}
|
||||
else
|
||||
{
|
||||
dest += dest_offset / 8;
|
||||
dest_offset %= 8;
|
||||
source += source_offset / 8;
|
||||
source_offset %= 8;
|
||||
}
|
||||
|
||||
/* Fill BUF with DEST_OFFSET bits from the destination and 8 -
|
||||
SOURCE_OFFSET bits from the source. */
|
||||
buf = *(bits_big_endian ? source-- : source++) >> source_offset;
|
||||
buf <<= dest_offset;
|
||||
buf |= *dest & ((1 << dest_offset) - 1);
|
||||
|
||||
/* NBITS: bits yet to be written; AVAIL: BUF's fill level. */
|
||||
nbits += dest_offset;
|
||||
avail = dest_offset + 8 - source_offset;
|
||||
|
||||
/* Flush 8 bits from BUF, if appropriate. */
|
||||
if (nbits >= 8 && avail >= 8)
|
||||
{
|
||||
*(bits_big_endian ? dest-- : dest++) = buf;
|
||||
buf >>= 8;
|
||||
avail -= 8;
|
||||
nbits -= 8;
|
||||
}
|
||||
|
||||
/* Copy the middle part. */
|
||||
if (nbits >= 8)
|
||||
{
|
||||
size_t len = nbits / 8;
|
||||
|
||||
/* Use a faster method for byte-aligned copies. */
|
||||
if (avail == 0)
|
||||
{
|
||||
if (bits_big_endian)
|
||||
{
|
||||
dest -= len;
|
||||
source -= len;
|
||||
memcpy (dest + 1, source + 1, len);
|
||||
}
|
||||
else
|
||||
{
|
||||
memcpy (dest, source, len);
|
||||
dest += len;
|
||||
source += len;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (len--)
|
||||
{
|
||||
buf |= *(bits_big_endian ? source-- : source++) << avail;
|
||||
*(bits_big_endian ? dest-- : dest++) = buf;
|
||||
buf >>= 8;
|
||||
}
|
||||
}
|
||||
nbits %= 8;
|
||||
}
|
||||
|
||||
/* Write the last byte. */
|
||||
if (nbits)
|
||||
{
|
||||
if (avail < nbits)
|
||||
buf |= *source << avail;
|
||||
|
||||
buf &= (1 << nbits) - 1;
|
||||
*dest = (*dest & (~0 << nbits)) | buf;
|
||||
}
|
||||
}
|
||||
|
||||
#if GDB_SELF_TEST
|
||||
|
||||
namespace selftests {
|
||||
|
||||
/* Helper function for the unit test of copy_bitwise. Convert NBITS bits
|
||||
out of BITS, starting at OFFS, to the respective '0'/'1'-string. MSB0
|
||||
specifies whether to assume big endian bit numbering. Store the
|
||||
resulting (not null-terminated) string at STR. */
|
||||
|
||||
static void
|
||||
bits_to_str (char *str, const gdb_byte *bits, ULONGEST offs,
|
||||
ULONGEST nbits, int msb0)
|
||||
{
|
||||
unsigned int j;
|
||||
size_t i;
|
||||
|
||||
for (i = offs / 8, j = offs % 8; nbits; i++, j = 0)
|
||||
{
|
||||
unsigned int ch = bits[i];
|
||||
for (; j < 8 && nbits; j++, nbits--)
|
||||
*str++ = (ch & (msb0 ? (1 << (7 - j)) : (1 << j))) ? '1' : '0';
|
||||
}
|
||||
}
|
||||
|
||||
/* Check one invocation of copy_bitwise with the given parameters. */
|
||||
|
||||
static void
|
||||
check_copy_bitwise (const gdb_byte *dest, unsigned int dest_offset,
|
||||
const gdb_byte *source, unsigned int source_offset,
|
||||
unsigned int nbits, int msb0)
|
||||
{
|
||||
size_t len = align_up (dest_offset + nbits, 8);
|
||||
char *expected = (char *) alloca (len + 1);
|
||||
char *actual = (char *) alloca (len + 1);
|
||||
gdb_byte *buf = (gdb_byte *) alloca (len / 8);
|
||||
|
||||
/* Compose a '0'/'1'-string that represents the expected result of
|
||||
copy_bitwise below:
|
||||
Bits from [0, DEST_OFFSET) are filled from DEST.
|
||||
Bits from [DEST_OFFSET, DEST_OFFSET + NBITS) are filled from SOURCE.
|
||||
Bits from [DEST_OFFSET + NBITS, LEN) are filled from DEST.
|
||||
|
||||
E.g., with:
|
||||
dest_offset: 4
|
||||
nbits: 2
|
||||
len: 8
|
||||
dest: 00000000
|
||||
source: 11111111
|
||||
|
||||
We should end up with:
|
||||
buf: 00001100
|
||||
DDDDSSDD (D=dest, S=source)
|
||||
*/
|
||||
bits_to_str (expected, dest, 0, len, msb0);
|
||||
bits_to_str (expected + dest_offset, source, source_offset, nbits, msb0);
|
||||
|
||||
/* Fill BUF with data from DEST, apply copy_bitwise, and convert the
|
||||
result to a '0'/'1'-string. */
|
||||
memcpy (buf, dest, len / 8);
|
||||
copy_bitwise (buf, dest_offset, source, source_offset, nbits, msb0);
|
||||
bits_to_str (actual, buf, 0, len, msb0);
|
||||
|
||||
/* Compare the resulting strings. */
|
||||
expected[len] = actual[len] = '\0';
|
||||
if (strcmp (expected, actual) != 0)
|
||||
error (_("copy_bitwise %s != %s (%u+%u -> %u)"),
|
||||
expected, actual, source_offset, nbits, dest_offset);
|
||||
}
|
||||
|
||||
/* Unit test for copy_bitwise. */
|
||||
|
||||
static void
|
||||
copy_bitwise_tests (void)
|
||||
{
|
||||
/* Data to be used as both source and destination buffers. The two
|
||||
arrays below represent the lsb0- and msb0- encoded versions of the
|
||||
following bit string, respectively:
|
||||
00000000 00011111 11111111 01001000 10100101 11110010
|
||||
This pattern is chosen such that it contains:
|
||||
- constant 0- and 1- chunks of more than a full byte;
|
||||
- 0/1- and 1/0 transitions on all bit positions within a byte;
|
||||
- several sufficiently asymmetric bytes.
|
||||
*/
|
||||
static const gdb_byte data_lsb0[] = {
|
||||
0x00, 0xf8, 0xff, 0x12, 0xa5, 0x4f
|
||||
};
|
||||
static const gdb_byte data_msb0[] = {
|
||||
0x00, 0x1f, 0xff, 0x48, 0xa5, 0xf2
|
||||
};
|
||||
|
||||
constexpr size_t data_nbits = 8 * sizeof (data_lsb0);
|
||||
constexpr unsigned max_nbits = 24;
|
||||
|
||||
/* Try all combinations of:
|
||||
lsb0/msb0 bit order (using the respective data array)
|
||||
X [0, MAX_NBITS] copy bit width
|
||||
X feasible source offsets for the given copy bit width
|
||||
X feasible destination offsets
|
||||
*/
|
||||
for (int msb0 = 0; msb0 < 2; msb0++)
|
||||
{
|
||||
const gdb_byte *data = msb0 ? data_msb0 : data_lsb0;
|
||||
|
||||
for (unsigned int nbits = 1; nbits <= max_nbits; nbits++)
|
||||
{
|
||||
const unsigned int max_offset = data_nbits - nbits;
|
||||
|
||||
for (unsigned source_offset = 0;
|
||||
source_offset <= max_offset;
|
||||
source_offset++)
|
||||
{
|
||||
for (unsigned dest_offset = 0;
|
||||
dest_offset <= max_offset;
|
||||
dest_offset++)
|
||||
{
|
||||
check_copy_bitwise (data + dest_offset / 8,
|
||||
dest_offset % 8,
|
||||
data + source_offset / 8,
|
||||
source_offset % 8,
|
||||
nbits, msb0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Special cases: copy all, copy nothing. */
|
||||
check_copy_bitwise (data_lsb0, 0, data_msb0, 0, data_nbits, msb0);
|
||||
check_copy_bitwise (data_msb0, 0, data_lsb0, 0, data_nbits, msb0);
|
||||
check_copy_bitwise (data, data_nbits - 7, data, 9, 0, msb0);
|
||||
}
|
||||
}
|
||||
|
||||
} /* namespace selftests */
|
||||
|
||||
#endif /* GDB_SELF_TEST */
|
||||
|
||||
/* Return the number of bytes overlapping a contiguous chunk of N_BITS
|
||||
bits whose first bit is located at bit offset START. */
|
||||
|
||||
|
|
@ -4737,8 +4507,4 @@ _initialize_dwarf2loc (void)
|
|||
NULL,
|
||||
show_entry_values_debug,
|
||||
&setdebuglist, &showdebuglist);
|
||||
|
||||
#if GDB_SELF_TEST
|
||||
selftests::register_test ("copy_bitwise", selftests::copy_bitwise_tests);
|
||||
#endif
|
||||
}
|
||||
|
|
|
|||
229
gdb/utils.c
229
gdb/utils.c
|
|
@ -3219,6 +3219,234 @@ strip_leading_path_elements (const char *path, int n)
|
|||
return p;
|
||||
}
|
||||
|
||||
/* See utils.h. */
|
||||
|
||||
void
|
||||
copy_bitwise (gdb_byte *dest, ULONGEST dest_offset,
|
||||
const gdb_byte *source, ULONGEST source_offset,
|
||||
ULONGEST nbits, int bits_big_endian)
|
||||
{
|
||||
unsigned int buf, avail;
|
||||
|
||||
if (nbits == 0)
|
||||
return;
|
||||
|
||||
if (bits_big_endian)
|
||||
{
|
||||
/* Start from the end, then work backwards. */
|
||||
dest_offset += nbits - 1;
|
||||
dest += dest_offset / 8;
|
||||
dest_offset = 7 - dest_offset % 8;
|
||||
source_offset += nbits - 1;
|
||||
source += source_offset / 8;
|
||||
source_offset = 7 - source_offset % 8;
|
||||
}
|
||||
else
|
||||
{
|
||||
dest += dest_offset / 8;
|
||||
dest_offset %= 8;
|
||||
source += source_offset / 8;
|
||||
source_offset %= 8;
|
||||
}
|
||||
|
||||
/* Fill BUF with DEST_OFFSET bits from the destination and 8 -
|
||||
SOURCE_OFFSET bits from the source. */
|
||||
buf = *(bits_big_endian ? source-- : source++) >> source_offset;
|
||||
buf <<= dest_offset;
|
||||
buf |= *dest & ((1 << dest_offset) - 1);
|
||||
|
||||
/* NBITS: bits yet to be written; AVAIL: BUF's fill level. */
|
||||
nbits += dest_offset;
|
||||
avail = dest_offset + 8 - source_offset;
|
||||
|
||||
/* Flush 8 bits from BUF, if appropriate. */
|
||||
if (nbits >= 8 && avail >= 8)
|
||||
{
|
||||
*(bits_big_endian ? dest-- : dest++) = buf;
|
||||
buf >>= 8;
|
||||
avail -= 8;
|
||||
nbits -= 8;
|
||||
}
|
||||
|
||||
/* Copy the middle part. */
|
||||
if (nbits >= 8)
|
||||
{
|
||||
size_t len = nbits / 8;
|
||||
|
||||
/* Use a faster method for byte-aligned copies. */
|
||||
if (avail == 0)
|
||||
{
|
||||
if (bits_big_endian)
|
||||
{
|
||||
dest -= len;
|
||||
source -= len;
|
||||
memcpy (dest + 1, source + 1, len);
|
||||
}
|
||||
else
|
||||
{
|
||||
memcpy (dest, source, len);
|
||||
dest += len;
|
||||
source += len;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (len--)
|
||||
{
|
||||
buf |= *(bits_big_endian ? source-- : source++) << avail;
|
||||
*(bits_big_endian ? dest-- : dest++) = buf;
|
||||
buf >>= 8;
|
||||
}
|
||||
}
|
||||
nbits %= 8;
|
||||
}
|
||||
|
||||
/* Write the last byte. */
|
||||
if (nbits)
|
||||
{
|
||||
if (avail < nbits)
|
||||
buf |= *source << avail;
|
||||
|
||||
buf &= (1 << nbits) - 1;
|
||||
*dest = (*dest & (~0 << nbits)) | buf;
|
||||
}
|
||||
}
|
||||
|
||||
#if GDB_SELF_TEST
|
||||
|
||||
namespace selftests {
|
||||
|
||||
/* Helper function for the unit test of copy_bitwise. Convert NBITS bits
|
||||
out of BITS, starting at OFFS, to the respective '0'/'1'-string. MSB0
|
||||
specifies whether to assume big endian bit numbering. Store the
|
||||
resulting (not null-terminated) string at STR. */
|
||||
|
||||
static void
|
||||
bits_to_str (char *str, const gdb_byte *bits, ULONGEST offs,
|
||||
ULONGEST nbits, int msb0)
|
||||
{
|
||||
unsigned int j;
|
||||
size_t i;
|
||||
|
||||
for (i = offs / 8, j = offs % 8; nbits; i++, j = 0)
|
||||
{
|
||||
unsigned int ch = bits[i];
|
||||
for (; j < 8 && nbits; j++, nbits--)
|
||||
*str++ = (ch & (msb0 ? (1 << (7 - j)) : (1 << j))) ? '1' : '0';
|
||||
}
|
||||
}
|
||||
|
||||
/* Check one invocation of copy_bitwise with the given parameters. */
|
||||
|
||||
static void
|
||||
check_copy_bitwise (const gdb_byte *dest, unsigned int dest_offset,
|
||||
const gdb_byte *source, unsigned int source_offset,
|
||||
unsigned int nbits, int msb0)
|
||||
{
|
||||
size_t len = align_up (dest_offset + nbits, 8);
|
||||
char *expected = (char *) alloca (len + 1);
|
||||
char *actual = (char *) alloca (len + 1);
|
||||
gdb_byte *buf = (gdb_byte *) alloca (len / 8);
|
||||
|
||||
/* Compose a '0'/'1'-string that represents the expected result of
|
||||
copy_bitwise below:
|
||||
Bits from [0, DEST_OFFSET) are filled from DEST.
|
||||
Bits from [DEST_OFFSET, DEST_OFFSET + NBITS) are filled from SOURCE.
|
||||
Bits from [DEST_OFFSET + NBITS, LEN) are filled from DEST.
|
||||
|
||||
E.g., with:
|
||||
dest_offset: 4
|
||||
nbits: 2
|
||||
len: 8
|
||||
dest: 00000000
|
||||
source: 11111111
|
||||
|
||||
We should end up with:
|
||||
buf: 00001100
|
||||
DDDDSSDD (D=dest, S=source)
|
||||
*/
|
||||
bits_to_str (expected, dest, 0, len, msb0);
|
||||
bits_to_str (expected + dest_offset, source, source_offset, nbits, msb0);
|
||||
|
||||
/* Fill BUF with data from DEST, apply copy_bitwise, and convert the
|
||||
result to a '0'/'1'-string. */
|
||||
memcpy (buf, dest, len / 8);
|
||||
copy_bitwise (buf, dest_offset, source, source_offset, nbits, msb0);
|
||||
bits_to_str (actual, buf, 0, len, msb0);
|
||||
|
||||
/* Compare the resulting strings. */
|
||||
expected[len] = actual[len] = '\0';
|
||||
if (strcmp (expected, actual) != 0)
|
||||
error (_("copy_bitwise %s != %s (%u+%u -> %u)"),
|
||||
expected, actual, source_offset, nbits, dest_offset);
|
||||
}
|
||||
|
||||
/* Unit test for copy_bitwise. */
|
||||
|
||||
static void
|
||||
copy_bitwise_tests (void)
|
||||
{
|
||||
/* Data to be used as both source and destination buffers. The two
|
||||
arrays below represent the lsb0- and msb0- encoded versions of the
|
||||
following bit string, respectively:
|
||||
00000000 00011111 11111111 01001000 10100101 11110010
|
||||
This pattern is chosen such that it contains:
|
||||
- constant 0- and 1- chunks of more than a full byte;
|
||||
- 0/1- and 1/0 transitions on all bit positions within a byte;
|
||||
- several sufficiently asymmetric bytes.
|
||||
*/
|
||||
static const gdb_byte data_lsb0[] = {
|
||||
0x00, 0xf8, 0xff, 0x12, 0xa5, 0x4f
|
||||
};
|
||||
static const gdb_byte data_msb0[] = {
|
||||
0x00, 0x1f, 0xff, 0x48, 0xa5, 0xf2
|
||||
};
|
||||
|
||||
constexpr size_t data_nbits = 8 * sizeof (data_lsb0);
|
||||
constexpr unsigned max_nbits = 24;
|
||||
|
||||
/* Try all combinations of:
|
||||
lsb0/msb0 bit order (using the respective data array)
|
||||
X [0, MAX_NBITS] copy bit width
|
||||
X feasible source offsets for the given copy bit width
|
||||
X feasible destination offsets
|
||||
*/
|
||||
for (int msb0 = 0; msb0 < 2; msb0++)
|
||||
{
|
||||
const gdb_byte *data = msb0 ? data_msb0 : data_lsb0;
|
||||
|
||||
for (unsigned int nbits = 1; nbits <= max_nbits; nbits++)
|
||||
{
|
||||
const unsigned int max_offset = data_nbits - nbits;
|
||||
|
||||
for (unsigned source_offset = 0;
|
||||
source_offset <= max_offset;
|
||||
source_offset++)
|
||||
{
|
||||
for (unsigned dest_offset = 0;
|
||||
dest_offset <= max_offset;
|
||||
dest_offset++)
|
||||
{
|
||||
check_copy_bitwise (data + dest_offset / 8,
|
||||
dest_offset % 8,
|
||||
data + source_offset / 8,
|
||||
source_offset % 8,
|
||||
nbits, msb0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Special cases: copy all, copy nothing. */
|
||||
check_copy_bitwise (data_lsb0, 0, data_msb0, 0, data_nbits, msb0);
|
||||
check_copy_bitwise (data_msb0, 0, data_lsb0, 0, data_nbits, msb0);
|
||||
check_copy_bitwise (data, data_nbits - 7, data, 9, 0, msb0);
|
||||
}
|
||||
}
|
||||
|
||||
} /* namespace selftests */
|
||||
|
||||
#endif /* GDB_SELF_TEST */
|
||||
|
||||
void
|
||||
_initialize_utils (void)
|
||||
{
|
||||
|
|
@ -3228,5 +3456,6 @@ _initialize_utils (void)
|
|||
|
||||
#if GDB_SELF_TEST
|
||||
selftests::register_test ("gdb_realpath", gdb_realpath_tests);
|
||||
selftests::register_test ("copy_bitwise", selftests::copy_bitwise_tests);
|
||||
#endif
|
||||
}
|
||||
|
|
|
|||
|
|
@ -519,4 +519,12 @@ extern void dump_core (void);
|
|||
|
||||
extern char *make_hex_string (const gdb_byte *data, size_t length);
|
||||
|
||||
/* Copy NBITS bits from SOURCE to DEST starting at the given bit
|
||||
offsets. Use the bit order as specified by BITS_BIG_ENDIAN.
|
||||
Source and destination buffers must not overlap. */
|
||||
|
||||
extern void copy_bitwise (gdb_byte *dest, ULONGEST dest_offset,
|
||||
const gdb_byte *source, ULONGEST source_offset,
|
||||
ULONGEST nbits, int bits_big_endian);
|
||||
|
||||
#endif /* UTILS_H */
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue