modernc.org/ccgo/v3@v3.16.14/lib/testdata/gcc-9.1.0/gcc/testsuite/gcc.c-torture/execute/memchr-1.c (about)

     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  #if 4 == __WCHAR_WIDTH__
   110  
   111  static const wchar_t wc = L'1';
   112  static const wchar_t ws1[] = L"1";
   113  static const wchar_t ws4[] = L"\x00123456\x12005678\x12340078\x12345600";
   114  
   115  void test_wide (void)
   116  {
   117    int i0 = 0;
   118    int i1 = i0 + 1;
   119    int i2 = i1 + 1;
   120    int i3 = i2 + 1;
   121    int i4 = i3 + 1;
   122  
   123    A (memchr (L"" + 1, 0, 0) == 0);
   124    A (memchr (&wc + 1, 0, 0) == 0);
   125    A (memchr (L"\x12345678", 0, sizeof (wchar_t)) == 0);
   126  
   127    const size_t nb = sizeof ws4;
   128    const size_t nwb = sizeof (wchar_t);
   129  
   130    const char *pws1 = (const char*)ws1;
   131    const char *pws4 = (const char*)ws4;
   132  
   133  #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
   134    A (memchr (ws1, 0, sizeof ws1) == pws1 + 1);
   135  
   136    A (memchr (&ws4[0], 0, nb) == pws4 + 3);
   137    A (memchr (&ws4[1], 0, nb - 1 * nwb) == pws4 + 1 * nwb + 2);
   138    A (memchr (&ws4[2], 0, nb - 2 * nwb) == pws4 + 2 * nwb + 1);
   139    A (memchr (&ws4[3], 0, nb - 3 * nwb) == pws4 + 3 * nwb + 0);
   140  #else
   141    A (memchr (ws1, 0, sizeof ws1) == pws1 + 0);
   142  
   143    A (memchr (&ws4[0], 0, nb) == pws4 + 0);
   144    A (memchr (&ws4[1], 0, nb - 1 * nwb) == pws4 + 1 * nwb + 1);
   145    A (memchr (&ws4[2], 0, nb - 2 * nwb) == pws4 + 2 * nwb + 2);
   146    A (memchr (&ws4[3], 0, nb - 3 * nwb) == pws4 + 3 * nwb + 3);
   147  #endif
   148  }
   149  
   150  #elif 2 == __WCHAR_WIDTH__
   151  
   152  static const wchar_t wc = L'1';
   153  static const wchar_t ws1[] = L"1";
   154  static const wchar_t ws2[2] = L"\x1234\x5678";   /* no terminating nul */
   155  static const wchar_t ws4[] = L"\x0012\x1200\x1234";
   156  
   157  void test_wide (void)
   158  {
   159    int i0 = 0;
   160    int i1 = i0 + 1;
   161    int i2 = i1 + 1;
   162  
   163    A (sizeof (wchar_t) == 2);
   164  
   165    A (memchr (L"" + 1, 0, 0) == 0);
   166    A (memchr (&wc + 1, 0, 0) == 0);
   167    A (memchr (L"\x1234", 0, sizeof (wchar_t)) == 0);
   168  
   169    A (memchr (L"" + i1, i0, i0) == 0);
   170    A (memchr (&wc + i1, i0, i0) == 0);
   171    A (memchr (L"\x1234", i0, sizeof (wchar_t)) == 0);
   172  
   173    A (memchr (ws2, 0, sizeof ws2) == 0);
   174    A (memchr (ws2, i0, sizeof ws2) == 0);
   175  
   176    const size_t nb = sizeof ws4;
   177    const size_t nwb = sizeof (wchar_t);
   178  
   179    const char *pws1 = (const char*)ws1;
   180    const char *pws4 = (const char*)ws4;
   181  
   182  #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
   183    A (memchr (ws1, i0, sizeof ws1) == pws1 + 1);
   184  
   185    A (memchr (&ws4[0], i0, nb) == pws4 + i1);
   186    A (memchr (&ws4[1], i0, nb - i1 * nwb) == pws4 + i1 * nwb);
   187    A (memchr (&ws4[2], i0, nb - i2 * nwb) == pws4 + i2 * nwb + i2);
   188  #else
   189    A (memchr (ws1, i0, sizeof ws1) == pws1 + 0);
   190  
   191    A (memchr (&ws4[0], i0, nb) == pws4 + 0);
   192    A (memchr (&ws4[1], i0, nb - i1 * nwb) == pws4 + i1 * nwb + i1);
   193    A (memchr (&ws4[2], i0, nb - i2 * nwb) == pws4 + i2 * nwb + i2);
   194  #endif
   195  }
   196  
   197  #else
   198  
   199  void test_wide (void) { }
   200  
   201  #endif
   202  
   203  int main ()
   204  {
   205    test_narrow ();
   206    test_wide ();
   207  }