OSDN Git Service

2007-01-07 Manuel Lopez-Ibanez <manu@gcc.gnu.org>
[pf3gnuchains/gcc-fork.git] / gcc / testsuite / g++.dg / warn / overflow-warn-3.C
1 /* Test for diagnostics for constant overflow.  Test with -pedantic.  */
2 /* Origin: Joseph Myers <joseph@codesourcery.com> */
3 /* { dg-do compile } */
4 /* { dg-options "-fpermissive -pedantic" } */
5
6 #include <limits.h>
7
8 enum e {
9   E0 = INT_MAX,
10   /* Unsigned overflow wraps around.  */
11   E1 = UINT_MAX + 1,
12   /* Overflow in an unevaluated part of an expression is OK (example
13      in the standard).  */
14   E2 = 2 || 1 / 0, /* { dg-bogus "warning: division by zero" "" { xfail *-*-* } 14 } */
15   E3 = 1 / 0, /* { dg-warning "warning: division by zero" } */
16   /* { dg-error "error: enumerator value for 'E3' is not an integer constant" "enum error" { target *-*-* } 15 } */
17   /* But as in DR#031, the 1/0 in an evaluated subexpression means the
18      whole expression violates the constraints.  */
19   E4 = 0 * (1 / 0), /* { dg-warning "warning: division by zero" } */
20   /* { dg-error "error: enumerator value for 'E4' is not an integer constant" "enum error" { xfail *-*-* } 19 } */
21   E5 = INT_MAX + 1, /* { dg-warning "warning: integer overflow in expression" } */
22   /* { dg-warning "warning: overflow in constant expression" "constant" { target *-*-* } 21 } */
23   /* Again, overflow in evaluated subexpression.  */
24   E6 = 0 * (INT_MAX + 1), /* { dg-warning "warning: integer overflow in expression" } */
25   /* { dg-warning "warning: overflow in constant expression" "constant" { target *-*-* } 24 } */
26   /* A cast does not constitute overflow in conversion.  */
27   E7 = (char) INT_MAX
28 };
29
30 struct s {
31   int a;
32   int : 0 * (1 / 0); /* { dg-warning "warning: division by zero" } */
33   int : 0 * (INT_MAX + 1); /* { dg-warning "warning: integer overflow in expression" } */
34   /* { dg-warning "warning: overflow in constant expression" "constant" { target *-*-* } 33 } */
35 };
36
37 void
38 f (void)
39 {
40   /* This expression is not required to be a constant expression, so
41      it should just involve undefined behavior at runtime.  */
42   int c = INT_MAX + 1; /* { dg-warning "warning: integer overflow in expression" } */
43
44 }
45
46 /* This expression is neither required to be constant.  */
47 static int sc = INT_MAX + 1; /* { dg-warning "warning: integer overflow in expression" } */
48
49
50 // Test for overflow in null pointer constant.  
51 void *n = 0;
52 /* The first two of these involve overflow, so are not null pointer
53    constants.  The third has the overflow in an unevaluated
54    subexpression, so is a null pointer constant.  */
55 void *p = 0 * (INT_MAX + 1); /* { dg-warning "warning: integer overflow in expression" } */
56 /* { dg-error "invalid conversion from 'int' to 'void" "null" { target *-*-* } 55 } */
57
58 void *q = 0 * (1 / 0); /* { dg-warning "warning: division by zero" } */
59 /* { dg-error "invalid conversion from 'int' to 'void*'" "null" { xfail *-*-* } 58 } */
60 void *r = (1 ? 0 : INT_MAX+1); /* { dg-bogus "integer overflow in expression" "" { xfail *-*-* } 60 } */
61
62 void
63 g (int i)
64 {
65   switch (i)
66     {
67     case 0 * (1/0): /* { dg-warning "warning: division by zero" } */
68       ;
69     case 1 + 0 * (INT_MAX + 1): /* { dg-warning "warning: integer overflow in expression" } */
70       /* { dg-warning "warning: overflow in constant expression" "constant" { target *-*-* } 69 } */
71       ;
72     }
73 }
74
75 int
76 h (void)
77 {
78   return INT_MAX + 1; /* { dg-warning "warning: integer overflow in expression" } */
79 }
80
81 int
82 h1 (void)
83 {
84   return INT_MAX + 1 - INT_MAX; /* { dg-warning "warning: integer overflow in expression" } */
85 }
86
87 void fuc (unsigned char);
88 void fsc (signed char);
89
90 void
91 h2 (void)
92 {
93   fsc (SCHAR_MAX + 1); /* { dg-warning "warning: overflow in implicit constant conversion" } */
94   fsc (SCHAR_MIN - 1); /* { dg-warning "warning: overflow in implicit constant conversion" } */
95   fsc (UCHAR_MAX); /* { dg-warning "warning: overflow in implicit constant conversion" } */
96   fsc (UCHAR_MAX + 1); /* { dg-warning "warning: overflow in implicit constant conversion" } */
97   fuc (-1);
98   fuc (UCHAR_MAX + 1); /* { dg-warning "warning: large integer implicitly truncated to unsigned type" } */
99   fuc (SCHAR_MIN);
100   fuc (SCHAR_MIN - 1); /* { dg-warning "warning: large integer implicitly truncated to unsigned type" } */
101   fuc (-UCHAR_MAX); /* { dg-warning "warning: large integer implicitly truncated to unsigned type" } */
102 }
103
104 void fui (unsigned int);
105 void fsi (signed int);
106
107 int si;
108 unsigned ui;
109
110 void
111 h2i (int x)
112 {
113   /* For some reason, we only give certain warnings for implicit
114      conversions among values of the same precision with -Wconversion,
115      while we don't give others at all.  */
116   fsi ((unsigned)INT_MAX + 1);
117   si = (unsigned)INT_MAX + 1;
118   si = x ? (unsigned)INT_MAX + 1 : 1;
119   fsi ((unsigned)INT_MAX + 2);
120   si = (unsigned)INT_MAX + 2;
121   si = x ? (unsigned)INT_MAX + 2 : 1;
122   fsi (UINT_MAX);
123   si = UINT_MAX;
124   fui (-1);
125   ui = -1;
126   ui = x ? -1 : 1U;
127   fui (INT_MIN);
128   ui = INT_MIN;
129   ui = x ? INT_MIN : 1U;
130 }
131 /* Test for diagnostics for constant overflow.  Test with -pedantic.  */
132 /* Origin: Joseph Myers <joseph@codesourcery.com> */
133 /* { dg-do compile } */
134 /* { dg-options "-fpermissive -pedantic" } */
135
136 #include <limits.h>
137
138 enum e {
139   E0 = INT_MAX,
140   /* Unsigned overflow wraps around.  */
141   E1 = UINT_MAX + 1,
142   /* Overflow in an unevaluated part of an expression is OK (example
143      in the standard).  */
144   E2 = 2 || 1 / 0, /* { dg-bogus "warning: division by zero" "" { xfail *-*-* } 14 } */
145   E3 = 1 / 0, /* { dg-warning "warning: division by zero" } */
146   /* { dg-error "error: enumerator value for 'E3' is not an integer constant" "enum error" { target *-*-* } 15 } */
147   /* But as in DR#031, the 1/0 in an evaluated subexpression means the
148      whole expression violates the constraints.  */
149   E4 = 0 * (1 / 0), /* { dg-warning "warning: division by zero" } */
150   /* { dg-error "error: enumerator value for 'E4' is not an integer constant" "enum error" { xfail *-*-* } 19 } */
151   E5 = INT_MAX + 1, /* { dg-warning "warning: integer overflow in expression" } */
152   /* { dg-warning "warning: overflow in constant expression" "constant" { target *-*-* } 21 } */
153   /* Again, overflow in evaluated subexpression.  */
154   E6 = 0 * (INT_MAX + 1), /* { dg-warning "warning: integer overflow in expression" } */
155   /* { dg-warning "warning: overflow in constant expression" "constant" { target *-*-* } 24 } */
156   /* A cast does not constitute overflow in conversion.  */
157   E7 = (char) INT_MAX
158 };
159
160 struct s {
161   int a;
162   int : 0 * (1 / 0); /* { dg-warning "warning: division by zero" } */
163   int : 0 * (INT_MAX + 1); /* { dg-warning "warning: integer overflow in expression" } */
164   /* { dg-warning "warning: overflow in constant expression" "constant" { target *-*-* } 33 } */
165 };
166
167 void
168 f (void)
169 {
170   /* This expression is not required to be a constant expression, so
171      it should just involve undefined behavior at runtime.  */
172   int c = INT_MAX + 1; /* { dg-warning "warning: integer overflow in expression" } */
173
174 }
175
176 /* But this expression does need to be constant (in C++ ???).  */
177 static int sc = INT_MAX + 1; /* { dg-warning "warning: integer overflow in expression" } */
178 /* { dg-warning "warning: overflow in constant expression" "constant" { xfail *-*-* } 47 } */
179
180 /* The first two of these involve overflow, so are not null pointer
181    constants.  The third has the overflow in an unevaluated
182    subexpression, so is a null pointer constant.  */
183 void *p = 0 * (INT_MAX + 1); /* { dg-warning "warning: integer overflow in expression" } */
184 /* { dg-error "invalid conversion from 'int' to 'void" "null" { target *-*-* } 53 } */
185
186 void *q = 0 * (1 / 0); /* { dg-warning "warning: division by zero" } */
187 /* { dg-error "invalid conversion from 'int' to 'void*'" "null" { xfail *-*-* } 56 } */
188 void *r = (1 ? 0 : INT_MAX+1); /* { dg-bogus "integer overflow in expression" "" { xfail *-*-* } 58 } */
189
190 void
191 g (int i)
192 {
193   switch (i)
194     {
195     case 0 * (1/0): /* { dg-warning "warning: division by zero" } */
196       ;
197     case 1 + 0 * (INT_MAX + 1): /* { dg-warning "warning: integer overflow in expression" } */
198       /* { dg-warning "warning: overflow in constant expression" "constant" { target *-*-* } 67 } */
199       ;
200     }
201 }
202
203 int
204 h (void)
205 {
206   return INT_MAX + 1; /* { dg-warning "warning: integer overflow in expression" } */
207 }
208
209 int
210 h1 (void)
211 {
212   return INT_MAX + 1 - INT_MAX; /* { dg-warning "warning: integer overflow in expression" } */
213 }
214
215 void fuc (unsigned char);
216 void fsc (signed char);
217
218 void
219 h2 (void)
220 {
221   fsc (SCHAR_MAX + 1); /* { dg-warning "warning: overflow in implicit constant conversion" } */
222   fsc (SCHAR_MIN - 1); /* { dg-warning "warning: overflow in implicit constant conversion" } */
223   fsc (UCHAR_MAX); /* { dg-warning "warning: overflow in implicit constant conversion" } */
224   fsc (UCHAR_MAX + 1); /* { dg-warning "warning: overflow in implicit constant conversion" } */
225   fuc (-1);
226   fuc (UCHAR_MAX + 1); /* { dg-warning "warning: large integer implicitly truncated to unsigned type" } */
227   fuc (SCHAR_MIN);
228   fuc (SCHAR_MIN - 1); /* { dg-warning "warning: large integer implicitly truncated to unsigned type" } */
229   fuc (-UCHAR_MAX); /* { dg-warning "warning: large integer implicitly truncated to unsigned type" } */
230 }
231
232 void fui (unsigned int);
233 void fsi (signed int);
234
235 int si;
236 unsigned ui;
237
238 void
239 h2i (int x)
240 {
241   /* For some reason, we only give certain warnings for implicit
242      conversions among values of the same precision with -Wconversion,
243      while we don't give others at all.  */
244   fsi ((unsigned)INT_MAX + 1);
245   si = (unsigned)INT_MAX + 1;
246   si = x ? (unsigned)INT_MAX + 1 : 1;
247   fsi ((unsigned)INT_MAX + 2);
248   si = (unsigned)INT_MAX + 2;
249   si = x ? (unsigned)INT_MAX + 2 : 1;
250   fsi (UINT_MAX);
251   si = UINT_MAX;
252   fui (-1);
253   ui = -1;
254   ui = x ? -1 : 1U;
255   fui (INT_MIN);
256   ui = INT_MIN;
257   ui = x ? INT_MIN : 1U;
258 }
259 /* Test for diagnostics for constant overflow.  Test with -pedantic.  */
260 /* Origin: Joseph Myers <joseph@codesourcery.com> */
261 /* { dg-do compile } */
262 /* { dg-options "-fpermissive -pedantic" } */
263
264 #include <limits.h>
265
266 enum e {
267   E0 = INT_MAX,
268   /* Unsigned overflow wraps around.  */
269   E1 = UINT_MAX + 1,
270   /* Overflow in an unevaluated part of an expression is OK (example
271      in the standard).  */
272   E2 = 2 || 1 / 0, /* { dg-bogus "warning: division by zero" "" { xfail *-*-* } 14 } */
273   E3 = 1 / 0, /* { dg-warning "warning: division by zero" } */
274   /* { dg-error "error: enumerator value for 'E3' is not an integer constant" "enum error" { target *-*-* } 15 } */
275   /* But as in DR#031, the 1/0 in an evaluated subexpression means the
276      whole expression violates the constraints.  */
277   E4 = 0 * (1 / 0), /* { dg-warning "warning: division by zero" } */
278   /* { dg-error "error: enumerator value for 'E4' is not an integer constant" "enum error" { xfail *-*-* } 19 } */
279   E5 = INT_MAX + 1, /* { dg-warning "warning: integer overflow in expression" } */
280   /* { dg-warning "warning: overflow in constant expression" "constant" { target *-*-* } 21 } */
281   /* Again, overflow in evaluated subexpression.  */
282   E6 = 0 * (INT_MAX + 1), /* { dg-warning "warning: integer overflow in expression" } */
283   /* { dg-warning "warning: overflow in constant expression" "constant" { target *-*-* } 24 } */
284   /* A cast does not constitute overflow in conversion.  */
285   E7 = (char) INT_MAX
286 };
287
288 struct s {
289   int a;
290   int : 0 * (1 / 0); /* { dg-warning "warning: division by zero" } */
291   int : 0 * (INT_MAX + 1); /* { dg-warning "warning: integer overflow in expression" } */
292   /* { dg-warning "warning: overflow in constant expression" "constant" { target *-*-* } 33 } */
293 };
294
295 void
296 f (void)
297 {
298   /* This expression is not required to be a constant expression, so
299      it should just involve undefined behavior at runtime.  */
300   int c = INT_MAX + 1; /* { dg-warning "warning: integer overflow in expression" } */
301
302 }
303
304 /* This expression is neither required to be constant.  */
305 static int sc = INT_MAX + 1; /* { dg-warning "warning: integer overflow in expression" } */
306
307
308 // Test for overflow in null pointer constant.  
309 void *n = 0;
310 /* The first two of these involve overflow, so are not null pointer
311    constants.  The third has the overflow in an unevaluated
312    subexpression, so is a null pointer constant.  */
313 void *p = 0 * (INT_MAX + 1); /* { dg-warning "warning: integer overflow in expression" } */
314 /* { dg-error "invalid conversion from 'int' to 'void" "null" { target *-*-* } 55 } */
315
316 void *q = 0 * (1 / 0); /* { dg-warning "warning: division by zero" } */
317 /* { dg-error "invalid conversion from 'int' to 'void*'" "null" { xfail *-*-* } 58 } */
318 void *r = (1 ? 0 : INT_MAX+1); /* { dg-bogus "integer overflow in expression" "" { xfail *-*-* } 60 } */
319
320 void
321 g (int i)
322 {
323   switch (i)
324     {
325     case 0 * (1/0): /* { dg-warning "warning: division by zero" } */
326       ;
327     case 1 + 0 * (INT_MAX + 1): /* { dg-warning "warning: integer overflow in expression" } */
328       /* { dg-warning "warning: overflow in constant expression" "constant" { target *-*-* } 69 } */
329       ;
330     }
331 }
332
333 int
334 h (void)
335 {
336   return INT_MAX + 1; /* { dg-warning "warning: integer overflow in expression" } */
337 }
338
339 int
340 h1 (void)
341 {
342   return INT_MAX + 1 - INT_MAX; /* { dg-warning "warning: integer overflow in expression" } */
343 }
344
345 void fuc (unsigned char);
346 void fsc (signed char);
347
348 void
349 h2 (void)
350 {
351   fsc (SCHAR_MAX + 1); /* { dg-warning "warning: overflow in implicit constant conversion" } */
352   fsc (SCHAR_MIN - 1); /* { dg-warning "warning: overflow in implicit constant conversion" } */
353   fsc (UCHAR_MAX); /* { dg-warning "warning: overflow in implicit constant conversion" } */
354   fsc (UCHAR_MAX + 1); /* { dg-warning "warning: overflow in implicit constant conversion" } */
355   fuc (-1);
356   fuc (UCHAR_MAX + 1); /* { dg-warning "warning: large integer implicitly truncated to unsigned type" } */
357   fuc (SCHAR_MIN);
358   fuc (SCHAR_MIN - 1); /* { dg-warning "warning: large integer implicitly truncated to unsigned type" } */
359   fuc (-UCHAR_MAX); /* { dg-warning "warning: large integer implicitly truncated to unsigned type" } */
360 }
361
362 void fui (unsigned int);
363 void fsi (signed int);
364
365 int si;
366 unsigned ui;
367
368 void
369 h2i (int x)
370 {
371   /* For some reason, we only give certain warnings for implicit
372      conversions among values of the same precision with -Wconversion,
373      while we don't give others at all.  */
374   fsi ((unsigned)INT_MAX + 1);
375   si = (unsigned)INT_MAX + 1;
376   si = x ? (unsigned)INT_MAX + 1 : 1;
377   fsi ((unsigned)INT_MAX + 2);
378   si = (unsigned)INT_MAX + 2;
379   si = x ? (unsigned)INT_MAX + 2 : 1;
380   fsi (UINT_MAX);
381   si = UINT_MAX;
382   fui (-1);
383   ui = -1;
384   ui = x ? -1 : 1U;
385   fui (INT_MIN);
386   ui = INT_MIN;
387   ui = x ? INT_MIN : 1U;
388 }