gcc/testsuite/gcc.dg/strcmpopt_7.c

   1 /* PR tree-optimization/92501 - strncmp with constant unterminated arrays
   2    not folded
   3    { dg-do compile }
   4    { dg-options "-O1 -Wall -fdump-tree-forwprop1" } */
   5
   6 /* Unterminated arrays of the size encoded in name.  */
   7 const char a1[] = { '1' };
   8 const char a12[] = { '1', '2' };
   9 const char a112[] = { '1', '1', '2' };
  10 const char a123[] = { '1', '2', '3' };
  11
  12 /* Nul-terminated strings of the length encoded in name.  */
  13 const char s[] = "";
  14 const char s1[] = "1";
  15 const char s12[] = "12";
  16 const char s112[] = "112";
  17 const char s123[] = "123";
  18
  19 extern void failure_on_line (int);
  20
  21 /* Verify that the test in 'if (EQL strncmp (S, T, N))' is folded.  */
  22 #define T(eql, s, t, n) do {                    \
  23     if (!(eql __builtin_strncmp (s, t, n)))     \
  24       failure_on_line (__LINE__);               \
  25   } while (0)
  26
  27
  28 void test (void)
  29 {
  30   /* Mixed array and string.  */
  31   T (0 ==, a1, "", 0);
  32   T (0 ==, a1, s, 0);
  33   T (0 !=, a1, "", 1);
  34   T (0 !=, a1, s, 1);
  35
  36   /* The following two are safe to fold because while strncmp compares
  37      at most N bytes it doesn't compare any bytes past the first nul.  */
  38   T (0 !=, a1, "", 9);
  39   T (0 !=, a1, s, 9);
  40
  41   T (0 ==, a1, "1", 0);
  42   T (0 ==, a1, s1, 0);
  43   T (0 ==, a1, "1", 1);
  44   T (0 ==, a1, s1, 1);
  45   T (0 ==, a1, "12", 1);
  46   T (0 ==, a1, s12, 1);
  47
  48      /* As above, the following three are also safe to fold.  */
  49   T (0 !=, a1, s12 + 1, 1);
  50   T (0 !=, a1, s12 + 1, 2);
  51   T (0 !=, a1, s12 + 1, 9);
  52
  53   T (0 ==, a12, s, 0);
  54   T (0 ==, a12, "", 0);
  55   T (0 ==, a12, s1, 0);
  56   T (0 ==, a12, "1", 0);
  57   T (0 ==, a12, s1, 1);
  58   T (0 ==, a12, "1", 1);
  59   T (0 !=, a12, s1, 2);
  60   T (0 !=, a12, "1", 2);
  61   T (0 ==, a12, s12, 0);
  62   T (0 ==, a12, "12", 0);
  63   T (0 ==, a12, s12, 1);
  64   T (0 ==, a12, "12", 1);
  65   T (0 ==, a12, s12, 2);
  66   T (0 ==, a12, "12", 2);
  67   T (0 ==, a12, s123, 2);
  68   T (0 ==, a12, "123", 2);
  69
  70   T (0 ==, a12 + 0, s123 + 1, 0);
  71   T (0 !=, a12 + 0, s123 + 1, 1);
  72   T (0 !=, a12 + 0, s123 + 1, 2);
  73   T (0 ==, a12 + 1, s123 + 0, 0);
  74   T (0 !=, a12 + 1, s123 + 0, 1);
  75   T (0 !=, a12 + 1, s123 + 0, 2);
  76   T (0 ==, a12 + 1, s123 + 1, 1);
  77   T (0 !=, a12 + 1, s123 + 2, 1);
  78   T (0 !=, a12 + 1, s123 + 3, 1);
  79
  80   T (0 ==, a12 + 1, "123" + 1, 1);
  81   T (0 !=, a12 + 1, "123" + 2, 1);
  82   T (0 !=, a12 + 1, "123" + 3, 1);
  83   T (0 !=, a12 + 1, "123" + 3, 9);
  84
  85   /* Both arguments arrays.  */
  86   T (0 ==, a112 + 0, a1, 1);
  87   T (0 ==, a112 + 1, a1, 1);
  88   T (0 !=, a112 + 2, a1, 1);
  89
  90   T (0 ==, a1, a112 + 0, 1);
  91   T (0 ==, a1, a112 + 1, 1);
  92   T (0 !=, a1, a112 + 2, 1);
  93
  94   T (0 ==, a112 + 0, a12, 0);
  95   T (0 ==, a112 + 0, a12, 1);
  96   T (0 !=, a112 + 0, a12, 2);
  97
  98   T (0 ==, a112 + 1, a12, 2);
  99   T (0 !=, a112 + 1, a12 + 1, 1);
 100   T (0 ==, a112 + 2, a12 + 1, 1);
 101
 102   /* Mixed array and string.  */
 103   T (0 ==, s112 + 0, a12, 0);
 104   T (0 ==, s112 + 0, a12, 1);
 105   T (0 !=, s112 + 0, a12, 2);
 106
 107   T (0 ==, s112 + 1, a12, 0);
 108   T (0 ==, s112 + 1, a12, 1);
 109   T (0 ==, s112 + 1, a12, 2);
 110   T (0 !=, s112 + 2, a12, 2);
 111
 112   T (0 ==, a112 + 0, s1, 1);
 113   T (0 ==, a112 + 1, s1, 1);
 114   T (0 !=, a112 + 2, s1, 1);
 115 }
 116
 117 /* { dg-final { scan-tree-dump-not "strcmp" "forwprop1" } }
 118    { dg-final { scan-tree-dump-not "strncmp" "forwprop1" } }
 119    { dg-final { scan-tree-dump-not "failure_on_line_" "forwprop1" } } */