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 }