1 /* PR tree-optimization/91183 - strlen of a strcpy result with a conditional
2 source not folded
3 Test to verify that strlen can determine string lengths from stores
4 involving PHI nodes with distinct strings of the same length of at
5 least 16 bytes.
6
7 { dg-do compile }
8 { dg-options "-O2 -fdump-tree-optimized" }
9 On strictly aligned targets the consecutive char assignments used
10 by the test aren't merged. When they involve multiple trailing nuls
11 these assignments then defeat the strlen optimization as a result of
12 pr83821. When the bug is resolved the directive below can be removed.
13 { dg-require-effective-target non_strict_align } */
14
15 #include "strlenopt.h"
16
17 #define CAT(x, y) x ## y
18 #define CONCAT(x, y) CAT (x, y)
19 #define FAILNAME(name) CONCAT (call_ ## name ##_on_line_, __LINE__)
20
21 #define FAIL(name) do { \
22 extern void FAILNAME (name) (void); \
23 FAILNAME (name)(); \
24 } while (0)
25
26 /* Macros to emit a call to function named
27 call_failed_to_be_eliminated_on_line_NNN()
28 for each call that's expected to be eliminated. The dg-final
29 scan-tree-dump-time directive at the bottom of the test verifies
30 that no such call appears in output. */
31 #define ELIM(expr) \
32 if ((expr)) FAIL (not_eliminated); else (void)0
33
34 #define T(expect, N, ncpy, cond) do { \
35 char CONCAT (arr_, __LINE__)[N]; \
36 char *pa = CONCAT (arr_, __LINE__); \
37 memcpy (pa, cond, ncpy); \
38 ELIM (!(expect strlen (pa))); \
39 sink (pa); \
40 } while (0)
41
42 void sink (void*);
43
44 const char a32[33] = "0123456789abcdef0123456789abcdef";
45 const char b32[33] = "fedcba9876543210fedcba9876543210";
46
47 const char a16[33] = "0123456789abcdef";
48 const char b16[33] = "fedcba9876543210";
49
50 int i0, i1, i2;
51
52 void test_copy_cond_equal_length (void)
53 {
54 // The test below is represented as this:
55 // # iftmp.0_3 = PHI <&b16(2), &a16(3)>
56 // MEM <unsigned char[17]> [(char * {ref-all})&a]
57 // = MEM <unsigned char[17]> [(char * {ref-all})iftmp.0_3];
58 // _2 = strlen (&a);
59 T (16 ==, 17, 17, i0 ? a16 : b16);
60 T (16 ==, 17, 17, i0 ? a16 : b16);
61 T (15 ==, 17, 16, (i0 ? a16 : b16) + 1);
62 T (14 ==, 17, 15, (i0 ? a16 : b16) + 2);
63 T ( 0 ==, 17, 1, (i0 ? a16 : b16) + 16);
64
65 T (31 ==, 33, 32, (i0 ? a32 : b32) + 1);
66 T (30 ==, 33, 31, (i0 ? a32 : b32) + 2);
67 T (29 ==, 33, 30, (i0 ? a32 : b32) + 3);
68 T ( 1 ==, 33, 2, (i0 ? a32 : b32) + 31);
69 T ( 0 ==, 33, 1, (i0 ? a32 : b32) + 32);
70 }
71
72 #if (defined(__i386__) && defined(__SSE__)) || defined(__x86_64__) || defined(__aarch64__) \
73 || defined(__s390__) || defined(__powerpc64__)
74
75 /* The following tests assume GCC transforms the memcpy calls into
76 long long assignments which it does only on targets that define
77 the MOVE_MAX macro to 8 or higher. Enable on a set of targets
78 known to do that. */
79
80 const char a4[16] = "0123";
81 const char b4[16] = "3210";
82
83 void test_copy_cond_unequal_length_i64 (void)
84 {
85 T (2 <, 16, 8, i0 ? a4 + 1 : b4 + 0);
86 T (1 <, 16, 8, i0 ? a4 + 1 : b4 + 2);
87 T (0 <, 16, 8, i0 ? a4 + 1 : b4 + 3);
88
89 T (1 <, 16, 8, i0 ? a4 + 2 : b4 + 0);
90 T (1 <, 16, 8, i0 ? a4 + 2 : b4 + 1);
91 T (0 <, 16, 8, i0 ? a4 + 2 : b4 + 3);
92 }
93
94 #endif
95
96
97 #if defined(__x86_64__) && __SIZEOF_INT128__ == 16
98
99 /* The following tests assume GCC transforms the memcpy calls into
100 int128_t assignments which it does only on targets that define
101 the MOVE_MAX macro to 16. That's only s390 and x86_64 with
102 int128_t support. */
103
104 const char a8[32] = "01234567";
105 const char b8[32] = "76543210";
106
107 void test_copy_cond_unequal_length_i128 (void)
108 {
109 T (6 <, 32, 16, i0 ? a8 + 1 : b8 + 0);
110 T (5 <, 32, 16, i0 ? a8 + 1 : b8 + 2);
111 T (4 <, 32, 16, i0 ? a8 + 1 : b8 + 3);
112 T (3 <, 32, 16, i0 ? a8 + 1 : b8 + 4);
113 T (2 <, 32, 16, i0 ? a8 + 1 : b8 + 5);
114 T (1 <, 32, 16, i0 ? a8 + 1 : b8 + 6);
115 T (0 <, 32, 16, i0 ? a8 + 1 : b8 + 7);
116
117 T (5 <, 32, 16, i0 ? a8 + 2 : b8 + 0);
118 T (5 <, 32, 16, i0 ? a8 + 2 : b8 + 1);
119 T (3 <, 32, 16, i0 ? a8 + 2 : b8 + 3);
120 T (2 <, 32, 16, i0 ? a8 + 2 : b8 + 4);
121 T (1 <, 32, 16, i0 ? a8 + 2 : b8 + 5);
122 T (0 <, 32, 16, i0 ? a8 + 2 : b8 + 6);
123
124 T (4 <, 32, 16, i0 ? a8 + 3 : b8 + 0);
125 T (4 <, 32, 16, i0 ? a8 + 3 : b8 + 1);
126 T (4 <, 32, 16, i0 ? a8 + 3 : b8 + 2);
127 T (3 <, 32, 16, i0 ? a8 + 3 : b8 + 4);
128 T (2 <, 32, 16, i0 ? a8 + 3 : b8 + 5);
129 T (1 <, 32, 16, i0 ? a8 + 3 : b8 + 6);
130 T (0 <, 32, 16, i0 ? a8 + 3 : b8 + 7);
131
132 T (3 <, 32, 16, i0 ? a8 + 4 : b8 + 0);
133 T (3 <, 32, 16, i0 ? a8 + 4 : b8 + 1);
134 T (3 <, 32, 16, i0 ? a8 + 4 : b8 + 2);
135 T (3 <, 32, 16, i0 ? a8 + 4 : b8 + 3);
136 T (2 <, 32, 16, i0 ? a8 + 4 : b8 + 5);
137 T (1 <, 32, 16, i0 ? a8 + 4 : b8 + 6);
138 T (0 <, 32, 16, i0 ? a8 + 4 : b8 + 7);
139 }
140
141 #endif /* Support for i128_t stores. */
142
143 /* { dg-final { scan-tree-dump-times "strlen" 0 "optimized" } }
144 { dg-final { scan-tree-dump-times "_not_eliminated_" 0 "optimized" } } */