+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.
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 *);
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
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),
- value_contents (fromval), from_size - bits, bits, 1);
+ copy_bitwise (buffer, value_bitpos (toval),
+ value_contents (fromval), from_size - bits, bits, 1);
else
- move_bits (buffer, value_bitpos (toval),
- value_contents (fromval), 0, bits, 0);
+ copy_bitwise (buffer, value_bitpos (toval),
+ value_contents (fromval), 0, bits, 0);
write_memory_with_notification (to_addr, buffer, len);
val = value_copy (toval);
= TYPE_LENGTH (value_type (component)) * TARGET_CHAR_BIT - bits;
else
src_offset = 0;
- move_bits (value_contents_writeable (container) + offset_in_container,
- value_bitpos (container) + bit_offset_in_container,
- value_contents (val), src_offset, bits, 1);
+ 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,
- value_bitpos (container) + bit_offset_in_container,
- value_contents (val), 0, bits, 0);
+ copy_bitwise (value_contents_writeable (container) + offset_in_container,
+ value_bitpos (container) + bit_offset_in_container,
+ value_contents (val), 0, bits, 0);
}
/* Determine if TYPE is an access to an unconstrained array. */
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. */
NULL,
show_entry_values_debug,
&setdebuglist, &showdebuglist);
-
-#if GDB_SELF_TEST
- selftests::register_test ("copy_bitwise", selftests::copy_bitwise_tests);
-#endif
}
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)
{
#if GDB_SELF_TEST
selftests::register_test ("gdb_realpath", gdb_realpath_tests);
+ selftests::register_test ("copy_bitwise", selftests::copy_bitwise_tests);
#endif
}
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 */
projects / platform / upstream / binutils.git / commitdiff