gdb/unittests/copy_bitwise-selftests.c

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