gdb/unittests/copy_bitwise-selftests.c

   1 /* Self tests of the copy_bitwise routine for GDB, the GNU debugger.
   2
   3    Copyright (C) 2018-2024 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "gdbsupport/selftest.h"
  21 #include "utils.h"
  22
  23 namespace selftests {
  24
  25 /* Helper function for the unit test of copy_bitwise.  Convert NBITS bits
  26    out of BITS, starting at OFFS, to the respective '0'/'1'-string.  MSB0
  27    specifies whether to assume big endian bit numbering.  Store the
  28    resulting (not null-terminated) string at STR.  */
  29
  30 static void
  31 bits_to_str (char *str, const gdb_byte *bits, ULONGEST offs,
  32              ULONGEST nbits, int msb0)
  33 {
  34   unsigned int j;
  35   size_t i;
  36
  37   for (i = offs / 8, j = offs % 8; nbits; i++, j = 0)
  38     {
  39       unsigned int ch = bits[i];
  40       for (; j < 8 && nbits; j++, nbits--)
  41         *str++ = (ch & (msb0 ? (1 << (7 - j)) : (1 << j))) ? '1' : '0';
  42     }
  43 }
  44
  45 /* Check one invocation of copy_bitwise with the given parameters.  */
  46
  47 static void
  48 check_copy_bitwise (const gdb_byte *dest, unsigned int dest_offset,
  49                     const gdb_byte *source, unsigned int source_offset,
  50                     unsigned int nbits, int msb0)
  51 {
  52   size_t len = align_up (dest_offset + nbits, 8);
  53   char *expected = (char *) alloca (len + 1);
  54   char *actual = (char *) alloca (len + 1);
  55   gdb_byte *buf = (gdb_byte *) alloca (len / 8);
  56
  57   /* Compose a '0'/'1'-string that represents the expected result of
  58      copy_bitwise below:
  59       Bits from [0, DEST_OFFSET) are filled from DEST.
  60       Bits from [DEST_OFFSET, DEST_OFFSET + NBITS) are filled from SOURCE.
  61       Bits from [DEST_OFFSET + NBITS, LEN) are filled from DEST.
  62
  63      E.g., with:
  64       dest_offset: 4
  65       nbits:       2
  66       len:         8
  67       dest:        00000000
  68       source:      11111111
  69
  70      We should end up with:
  71       buf:         00001100
  72                    DDDDSSDD (D=dest, S=source)
  73   */
  74   bits_to_str (expected, dest, 0, len, msb0);
  75   bits_to_str (expected + dest_offset, source, source_offset, nbits, msb0);
  76
  77   /* Fill BUF with data from DEST, apply copy_bitwise, and convert the
  78      result to a '0'/'1'-string.  */
  79   memcpy (buf, dest, len / 8);
  80   copy_bitwise (buf, dest_offset, source, source_offset, nbits, msb0);
  81   bits_to_str (actual, buf, 0, len, msb0);
  82
  83   /* Compare the resulting strings.  */
  84   expected[len] = actual[len] = '\0';
  85   if (strcmp (expected, actual) != 0)
  86     error (_("copy_bitwise %s != %s (%u+%u -> %u)"),
  87            expected, actual, source_offset, nbits, dest_offset);
  88 }
  89
  90 /* Unit test for copy_bitwise.  */
  91
  92 static void
  93 copy_bitwise_tests (void)
  94 {
  95   /* Data to be used as both source and destination buffers.  The two
  96      arrays below represent the lsb0- and msb0- encoded versions of the
  97      following bit string, respectively:
  98        00000000 00011111 11111111 01001000 10100101 11110010
  99      This pattern is chosen such that it contains:
 100      - constant 0- and 1- chunks of more than a full byte;
 101      - 0/1- and 1/0 transitions on all bit positions within a byte;
 102      - several sufficiently asymmetric bytes.
 103   */
 104   static const gdb_byte data_lsb0[] = {
 105     0x00, 0xf8, 0xff, 0x12, 0xa5, 0x4f
 106   };
 107   static const gdb_byte data_msb0[] = {
 108     0x00, 0x1f, 0xff, 0x48, 0xa5, 0xf2
 109   };
 110
 111   constexpr size_t data_nbits = 8 * sizeof (data_lsb0);
 112   constexpr unsigned max_nbits = 24;
 113
 114   /* Try all combinations of:
 115       lsb0/msb0 bit order (using the respective data array)
 116        X [0, MAX_NBITS] copy bit width
 117        X feasible source offsets for the given copy bit width
 118        X feasible destination offsets
 119   */
 120   for (int msb0 = 0; msb0 < 2; msb0++)
 121     {
 122       const gdb_byte *data = msb0 ? data_msb0 : data_lsb0;
 123
 124       for (unsigned int nbits = 1; nbits <= max_nbits; nbits++)
 125         {
 126           const unsigned int max_offset = data_nbits - nbits;
 127
 128           for (unsigned source_offset = 0;
 129                source_offset <= max_offset;
 130                source_offset++)
 131             {
 132               for (unsigned dest_offset = 0;
 133                    dest_offset <= max_offset;
 134                    dest_offset++)
 135                 {
 136                   check_copy_bitwise (data + dest_offset / 8,
 137                                       dest_offset % 8,
 138                                       data + source_offset / 8,
 139                                       source_offset % 8,
 140                                       nbits, msb0);
 141                 }
 142             }
 143         }
 144
 145       /* Special cases: copy all, copy nothing.  */
 146       check_copy_bitwise (data_lsb0, 0, data_msb0, 0, data_nbits, msb0);
 147       check_copy_bitwise (data_msb0, 0, data_lsb0, 0, data_nbits, msb0);
 148       check_copy_bitwise (data, data_nbits - 7, data, 9, 0, msb0);
 149     }
 150 }
 151
 152 } /* namespace selftests */
 153
 154 void _initialize_copy_bitwise_utils_selftests ();
 155 void
 156 _initialize_copy_bitwise_utils_selftests ()
 157 {
 158   selftests::register_test ("copy_bitwise", selftests::copy_bitwise_tests);
 159 }