gcc/testsuite/gcc.c-torture/execute/memchr-1.c

   1 /* PR tree-optimization/86711 - wrong folding of memchr
   2
   3    Verify that memchr() of arrays initialized with string literals
   4    where the nul doesn't fit in the array doesn't find the nul.  */
   5 typedef __SIZE_TYPE__  size_t;
   6 typedef __WCHAR_TYPE__ wchar_t;
   7
   8 extern void* memchr (const void*, int, size_t);
   9
  10 #define A(expr)                                                 \
  11   ((expr)                                                       \
  12    ? (void)0                                                    \
  13    : (__builtin_printf ("assertion failed on line %i: %s\n",    \
  14                         __LINE__, #expr),                       \
  15       __builtin_abort ()))
  16
  17 static const char c = '1';
  18 static const char s1[1] = "1";
  19 static const char s4[4] = "1234";
  20
  21 static const char s4_2[2][4] = { "1234", "5678" };
  22 static const char s5_3[3][5] = { "12345", "6789", "01234" };
  23
  24 volatile int v0 = 0;
  25 volatile int v1 = 1;
  26 volatile int v2 = 2;
  27 volatile int v3 = 3;
  28 volatile int v4 = 3;
  29
  30 void test_narrow (void)
  31 {
  32   int i0 = 0;
  33   int i1 = i0 + 1;
  34   int i2 = i1 + 1;
  35   int i3 = i2 + 1;
  36   int i4 = i3 + 1;
  37
  38   A (memchr ("" + 1, 0, 0) == 0);
  39
  40   A (memchr (&c, 0, sizeof c) == 0);
  41   A (memchr (&c + 1, 0, sizeof c - 1) == 0);
  42   A (memchr (&c + i1, 0, sizeof c - i1) == 0);
  43   A (memchr (&c + v1, 0, sizeof c - v1) == 0);
  44
  45   A (memchr (s1, 0, sizeof s1) == 0);
  46   A (memchr (s1 + 1, 0, sizeof s1 - 1) == 0);
  47   A (memchr (s1 + i1, 0, sizeof s1 - i1) == 0);
  48   A (memchr (s1 + v1, 0, sizeof s1 - v1) == 0);
  49
  50   A (memchr (&s1, 0, sizeof s1) == 0);
  51   A (memchr (&s1 + 1, 0, sizeof s1 - 1) == 0);
  52   A (memchr (&s1 + i1, 0, sizeof s1 - i1) == 0);
  53   A (memchr (&s1 + v1, 0, sizeof s1 - v1) == 0);
  54
  55   A (memchr (&s1[0], 0, sizeof s1) == 0);
  56   A (memchr (&s1[0] + 1, 0, sizeof s1 - 1) == 0);
  57   A (memchr (&s1[0] + i1, 0, sizeof s1 - i1) == 0);
  58   A (memchr (&s1[0] + v1, 0, sizeof s1 - v1) == 0);
  59
  60   A (memchr (&s1[i0], 0, sizeof s1) == 0);
  61   A (memchr (&s1[i0] + 1, 0, sizeof s1 - 1) == 0);
  62   A (memchr (&s1[i0] + i1, 0, sizeof s1 - i1) == 0);
  63   A (memchr (&s1[i0] + v1, 0, sizeof s1 - v1) == 0);
  64
  65   A (memchr (&s1[v0], 0, sizeof s1) == 0);
  66   A (memchr (&s1[v0] + 1, 0, sizeof s1 - 1) == 0);
  67   A (memchr (&s1[v0] + i1, 0, sizeof s1 - i1) == 0);
  68   A (memchr (&s1[v0] + v1, 0, sizeof s1 - v1) == 0);
  69
  70
  71   A (memchr (s4 + i0, 0, sizeof s4 - i0) == 0);
  72   A (memchr (s4 + i1, 0, sizeof s4 - i1) == 0);
  73   A (memchr (s4 + i2, 0, sizeof s4 - i2) == 0);
  74   A (memchr (s4 + i3, 0, sizeof s4 - i3) == 0);
  75   A (memchr (s4 + i4, 0, sizeof s4 - i4) == 0);
  76
  77   A (memchr (s4 + v0, 0, sizeof s4 - v0) == 0);
  78   A (memchr (s4 + v1, 0, sizeof s4 - v1) == 0);
  79   A (memchr (s4 + v2, 0, sizeof s4 - v2) == 0);
  80   A (memchr (s4 + v3, 0, sizeof s4 - v3) == 0);
  81   A (memchr (s4 + v4, 0, sizeof s4 - v4) == 0);
  82
  83
  84   A (memchr (s4_2, 0, sizeof s4_2) == 0);
  85
  86   A (memchr (s4_2[0], 0, sizeof s4_2[0]) == 0);
  87   A (memchr (s4_2[1], 0, sizeof s4_2[1]) == 0);
  88
  89   A (memchr (s4_2[0] + 1, 0, sizeof s4_2[0] - 1) == 0);
  90   A (memchr (s4_2[1] + 2, 0, sizeof s4_2[1] - 2) == 0);
  91   A (memchr (s4_2[1] + 3, 0, sizeof s4_2[1] - 3) == 0);
  92
  93   A (memchr (s4_2[v0], 0, sizeof s4_2[v0]) == 0);
  94   A (memchr (s4_2[v0] + 1, 0, sizeof s4_2[v0] - 1) == 0);
  95
  96
  97   /* The following calls must find the nul.  */
  98   A (memchr ("", 0, 1) != 0);
  99   A (memchr (s5_3, 0, sizeof s5_3) == &s5_3[1][4]);
 100
 101   A (memchr (&s5_3[0][0] + i0, 0, sizeof s5_3 - i0) == &s5_3[1][4]);
 102   A (memchr (&s5_3[0][0] + i1, 0, sizeof s5_3 - i1) == &s5_3[1][4]);
 103   A (memchr (&s5_3[0][0] + i2, 0, sizeof s5_3 - i2) == &s5_3[1][4]);
 104   A (memchr (&s5_3[0][0] + i4, 0, sizeof s5_3 - i4) == &s5_3[1][4]);
 105
 106   A (memchr (&s5_3[1][i0], 0, sizeof s5_3[1] - i0) == &s5_3[1][4]);
 107 }
 108
 109 static const wchar_t wc = L'1';
 110 static const wchar_t ws1[] = L"1";
 111 static const wchar_t ws4[] = L"\x00123456\x12005678\x12340078\x12345600";
 112
 113 void test_wide (void)
 114 {
 115   int i0 = 0;
 116   int i1 = i0 + 1;
 117   int i2 = i1 + 1;
 118   int i3 = i2 + 1;
 119   int i4 = i3 + 1;
 120
 121   A (memchr (L"" + 1, 0, 0) == 0);
 122   A (memchr (&wc + 1, 0, 0) == 0);
 123   A (memchr (L"\x12345678", 0, sizeof (wchar_t)) == 0);
 124
 125   const size_t nb = sizeof ws4;
 126   const size_t nwb = sizeof (wchar_t);
 127
 128   const char *pws1 = (const char*)ws1;
 129   const char *pws4 = (const char*)ws4;
 130
 131 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 132   A (memchr (ws1, 0, sizeof ws1) == pws1 + 1);
 133
 134   A (memchr (&ws4[0], 0, nb) == pws4 + 3);
 135   A (memchr (&ws4[1], 0, nb - 1 * nwb) == pws4 + 1 * nwb + 2);
 136   A (memchr (&ws4[2], 0, nb - 2 * nwb) == pws4 + 2 * nwb + 1);
 137   A (memchr (&ws4[3], 0, nb - 3 * nwb) == pws4 + 3 * nwb + 0);
 138 #else
 139   A (memchr (ws1, 0, sizeof ws1) == pws1 + 0);
 140
 141   A (memchr (&ws4[0], 0, nb) == pws4 + 0);
 142   A (memchr (&ws4[1], 0, nb - 1 * nwb) == pws4 + 1 * nwb + 1);
 143   A (memchr (&ws4[2], 0, nb - 2 * nwb) == pws4 + 2 * nwb + 2);
 144   A (memchr (&ws4[3], 0, nb - 3 * nwb) == pws4 + 3 * nwb + 3);
 145 #endif
 146 }
 147
 148
 149 int main ()
 150 {
 151   test_narrow ();
 152   test_wide ();
 153 }