1/* Build expressions with type checking for C compiler.
2 Copyright (C) 1987, 88, 91-97, 1998 Free Software Foundation, Inc.
3
4This file is part of GNU CC.
5
6GNU CC is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2, or (at your option)
9any later version.
10
11GNU CC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GNU CC; see the file COPYING. If not, write to
18the Free Software Foundation, 59 Temple Place - Suite 330,
19Boston, MA 02111-1307, USA. */
20
21
22/* This file is part of the C front end.
23 It contains routines to build C expressions given their operands,
24 including computing the types of the result, C-specific error checks,
25 and some optimization.
26
27 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
28 and to process initializations in declarations (since they work
29 like a strange sort of assignment). */
30
31#include "config.h"
32#include "system.h"
33#include "tree.h"
34#include "c-tree.h"
35#include "flags.h"
36#include "output.h"
37#include "rtl.h"
38#include "expr.h"
39#include "toplev.h"
| 1/* Build expressions with type checking for C compiler.
2 Copyright (C) 1987, 88, 91-97, 1998 Free Software Foundation, Inc.
3
4This file is part of GNU CC.
5
6GNU CC is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2, or (at your option)
9any later version.
10
11GNU CC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GNU CC; see the file COPYING. If not, write to
18the Free Software Foundation, 59 Temple Place - Suite 330,
19Boston, MA 02111-1307, USA. */
20
21
22/* This file is part of the C front end.
23 It contains routines to build C expressions given their operands,
24 including computing the types of the result, C-specific error checks,
25 and some optimization.
26
27 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
28 and to process initializations in declarations (since they work
29 like a strange sort of assignment). */
30
31#include "config.h"
32#include "system.h"
33#include "tree.h"
34#include "c-tree.h"
35#include "flags.h"
36#include "output.h"
37#include "rtl.h"
38#include "expr.h"
39#include "toplev.h"
|
| 40#include "intl.h"
|
40
41/* Nonzero if we've already printed a "missing braces around initializer"
42 message within this initializer. */
43static int missing_braces_mentioned;
44
45static tree qualify_type PROTO((tree, tree));
46static int comp_target_types PROTO((tree, tree));
47static int function_types_compatible_p PROTO((tree, tree));
48static int type_lists_compatible_p PROTO((tree, tree));
49static int self_promoting_type_p PROTO((tree));
50static tree decl_constant_value PROTO((tree));
51static tree lookup_field PROTO((tree, tree, tree *));
52static tree convert_arguments PROTO((tree, tree, tree, tree));
53static tree pointer_int_sum PROTO((enum tree_code, tree, tree));
54static tree pointer_diff PROTO((tree, tree));
55static tree unary_complex_lvalue PROTO((enum tree_code, tree));
56static void pedantic_lvalue_warning PROTO((enum tree_code));
57static tree internal_build_compound_expr PROTO((tree, int));
| 41
42/* Nonzero if we've already printed a "missing braces around initializer"
43 message within this initializer. */
44static int missing_braces_mentioned;
45
46static tree qualify_type PROTO((tree, tree));
47static int comp_target_types PROTO((tree, tree));
48static int function_types_compatible_p PROTO((tree, tree));
49static int type_lists_compatible_p PROTO((tree, tree));
50static int self_promoting_type_p PROTO((tree));
51static tree decl_constant_value PROTO((tree));
52static tree lookup_field PROTO((tree, tree, tree *));
53static tree convert_arguments PROTO((tree, tree, tree, tree));
54static tree pointer_int_sum PROTO((enum tree_code, tree, tree));
55static tree pointer_diff PROTO((tree, tree));
56static tree unary_complex_lvalue PROTO((enum tree_code, tree));
57static void pedantic_lvalue_warning PROTO((enum tree_code));
58static tree internal_build_compound_expr PROTO((tree, int));
|
58static tree convert_for_assignment PROTO((tree, tree, char *, tree,
| 59static tree convert_for_assignment PROTO((tree, tree, const char *, tree,
|
59 tree, int));
| 60 tree, int));
|
60static void warn_for_assignment PROTO((char *, char *, tree, int));
| 61static void warn_for_assignment PROTO((const char *, const char *,
62 tree, int));
|
61static tree valid_compound_expr_initializer PROTO((tree, tree));
| 63static tree valid_compound_expr_initializer PROTO((tree, tree));
|
62static void push_string PROTO((char *));
| 64static void push_string PROTO((const char *));
|
63static void push_member_name PROTO((tree));
64static void push_array_bounds PROTO((int));
65static int spelling_length PROTO((void));
66static char *print_spelling PROTO((char *));
| 65static void push_member_name PROTO((tree));
66static void push_array_bounds PROTO((int));
67static int spelling_length PROTO((void));
68static char *print_spelling PROTO((char *));
|
67static char *get_spelling PROTO((char *));
68static void warning_init PROTO((char *, char *,
69 char *));
| 69static void warning_init PROTO((const char *));
|
70static tree digest_init PROTO((tree, tree, int, int));
71static void check_init_type_bitfields PROTO((tree));
72static void output_init_element PROTO((tree, tree, tree, int));
73static void output_pending_init_elements PROTO((int));
74static void add_pending_init PROTO((tree, tree));
75static int pending_init_member PROTO((tree));
76
77/* Do `exp = require_complete_type (exp);' to make sure exp
78 does not have an incomplete type. (That includes void types.) */
79
80tree
81require_complete_type (value)
82 tree value;
83{
84 tree type = TREE_TYPE (value);
85
| 70static tree digest_init PROTO((tree, tree, int, int));
71static void check_init_type_bitfields PROTO((tree));
72static void output_init_element PROTO((tree, tree, tree, int));
73static void output_pending_init_elements PROTO((int));
74static void add_pending_init PROTO((tree, tree));
75static int pending_init_member PROTO((tree));
76
77/* Do `exp = require_complete_type (exp);' to make sure exp
78 does not have an incomplete type. (That includes void types.) */
79
80tree
81require_complete_type (value)
82 tree value;
83{
84 tree type = TREE_TYPE (value);
85
|
| 86 if (TREE_CODE (value) == ERROR_MARK)
87 return error_mark_node;
88
|
86 /* First, detect a valid value with a complete type. */
87 if (TYPE_SIZE (type) != 0
88 && type != void_type_node)
89 return value;
90
91 incomplete_type_error (value, type);
92 return error_mark_node;
93}
94
95/* Print an error message for invalid use of an incomplete type.
96 VALUE is the expression that was used (or 0 if that isn't known)
97 and TYPE is the type that was invalid. */
98
99void
100incomplete_type_error (value, type)
101 tree value;
102 tree type;
103{
| 89 /* First, detect a valid value with a complete type. */
90 if (TYPE_SIZE (type) != 0
91 && type != void_type_node)
92 return value;
93
94 incomplete_type_error (value, type);
95 return error_mark_node;
96}
97
98/* Print an error message for invalid use of an incomplete type.
99 VALUE is the expression that was used (or 0 if that isn't known)
100 and TYPE is the type that was invalid. */
101
102void
103incomplete_type_error (value, type)
104 tree value;
105 tree type;
106{
|
104 char *errmsg;
| 107 const char *type_code_string;
|
105
106 /* Avoid duplicate error message. */
107 if (TREE_CODE (type) == ERROR_MARK)
108 return;
109
110 if (value != 0 && (TREE_CODE (value) == VAR_DECL
111 || TREE_CODE (value) == PARM_DECL))
112 error ("`%s' has an incomplete type",
113 IDENTIFIER_POINTER (DECL_NAME (value)));
114 else
115 {
116 retry:
117 /* We must print an error message. Be clever about what it says. */
118
119 switch (TREE_CODE (type))
120 {
121 case RECORD_TYPE:
| 108
109 /* Avoid duplicate error message. */
110 if (TREE_CODE (type) == ERROR_MARK)
111 return;
112
113 if (value != 0 && (TREE_CODE (value) == VAR_DECL
114 || TREE_CODE (value) == PARM_DECL))
115 error ("`%s' has an incomplete type",
116 IDENTIFIER_POINTER (DECL_NAME (value)));
117 else
118 {
119 retry:
120 /* We must print an error message. Be clever about what it says. */
121
122 switch (TREE_CODE (type))
123 {
124 case RECORD_TYPE:
|
122 errmsg = "invalid use of undefined type `struct %s'";
| 125 type_code_string = "struct";
|
123 break;
124
125 case UNION_TYPE:
| 126 break;
127
128 case UNION_TYPE:
|
126 errmsg = "invalid use of undefined type `union %s'";
| 129 type_code_string = "union";
|
127 break;
128
129 case ENUMERAL_TYPE:
| 130 break;
131
132 case ENUMERAL_TYPE:
|
130 errmsg = "invalid use of undefined type `enum %s'";
| 133 type_code_string = "enum";
|
131 break;
132
133 case VOID_TYPE:
134 error ("invalid use of void expression");
135 return;
136
137 case ARRAY_TYPE:
138 if (TYPE_DOMAIN (type))
139 {
140 type = TREE_TYPE (type);
141 goto retry;
142 }
143 error ("invalid use of array with unspecified bounds");
144 return;
145
146 default:
147 abort ();
148 }
149
150 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
| 134 break;
135
136 case VOID_TYPE:
137 error ("invalid use of void expression");
138 return;
139
140 case ARRAY_TYPE:
141 if (TYPE_DOMAIN (type))
142 {
143 type = TREE_TYPE (type);
144 goto retry;
145 }
146 error ("invalid use of array with unspecified bounds");
147 return;
148
149 default:
150 abort ();
151 }
152
153 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
|
151 error (errmsg, IDENTIFIER_POINTER (TYPE_NAME (type)));
| 154 error ("invalid use of undefined type `%s %s'",
155 type_code_string, IDENTIFIER_POINTER (TYPE_NAME (type)));
|
152 else
153 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
154 error ("invalid use of incomplete typedef `%s'",
155 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
156 }
157}
158
159/* Return a variant of TYPE which has all the type qualifiers of LIKE
160 as well as those of TYPE. */
161
162static tree
163qualify_type (type, like)
164 tree type, like;
165{
| 156 else
157 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
158 error ("invalid use of incomplete typedef `%s'",
159 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
160 }
161}
162
163/* Return a variant of TYPE which has all the type qualifiers of LIKE
164 as well as those of TYPE. */
165
166static tree
167qualify_type (type, like)
168 tree type, like;
169{
|
166 int constflag = TYPE_READONLY (type) || TYPE_READONLY (like);
167 int volflag = TYPE_VOLATILE (type) || TYPE_VOLATILE (like);
168 return c_build_type_variant (type, constflag, volflag);
| 170 return c_build_qualified_type (type, TYPE_QUALS (like));
|
169}
170
171/* Return the common type of two types.
172 We assume that comptypes has already been done and returned 1;
173 if that isn't so, this may crash. In particular, we assume that qualifiers
174 match.
175
176 This is the type for the result of most arithmetic operations
177 if the operands have the given two types. */
178
179tree
180common_type (t1, t2)
181 tree t1, t2;
182{
183 register enum tree_code code1;
184 register enum tree_code code2;
185 tree attributes;
186
187 /* Save time if the two types are the same. */
188
189 if (t1 == t2) return t1;
190
191 /* If one type is nonsense, use the other. */
192 if (t1 == error_mark_node)
193 return t2;
194 if (t2 == error_mark_node)
195 return t1;
196
197 /* Merge the attributes. */
198 attributes = merge_machine_type_attributes (t1, t2);
199
200 /* Treat an enum type as the unsigned integer type of the same width. */
201
202 if (TREE_CODE (t1) == ENUMERAL_TYPE)
203 t1 = type_for_size (TYPE_PRECISION (t1), 1);
204 if (TREE_CODE (t2) == ENUMERAL_TYPE)
205 t2 = type_for_size (TYPE_PRECISION (t2), 1);
206
207 code1 = TREE_CODE (t1);
208 code2 = TREE_CODE (t2);
209
210 /* If one type is complex, form the common type of the non-complex
211 components, then make that complex. Use T1 or T2 if it is the
212 required type. */
213 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
214 {
215 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
216 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
217 tree subtype = common_type (subtype1, subtype2);
218
219 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
220 return build_type_attribute_variant (t1, attributes);
221 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
222 return build_type_attribute_variant (t2, attributes);
223 else
224 return build_type_attribute_variant (build_complex_type (subtype),
225 attributes);
226 }
227
228 switch (code1)
229 {
230 case INTEGER_TYPE:
231 case REAL_TYPE:
232 /* If only one is real, use it as the result. */
233
234 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
235 return build_type_attribute_variant (t1, attributes);
236
237 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
238 return build_type_attribute_variant (t2, attributes);
239
240 /* Both real or both integers; use the one with greater precision. */
241
242 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
243 return build_type_attribute_variant (t1, attributes);
244 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
245 return build_type_attribute_variant (t2, attributes);
246
247 /* Same precision. Prefer longs to ints even when same size. */
248
249 if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
250 || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
251 return build_type_attribute_variant (long_unsigned_type_node,
252 attributes);
253
254 if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
255 || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
256 {
257 /* But preserve unsignedness from the other type,
258 since long cannot hold all the values of an unsigned int. */
259 if (TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
260 t1 = long_unsigned_type_node;
261 else
262 t1 = long_integer_type_node;
263 return build_type_attribute_variant (t1, attributes);
264 }
265
266 /* Likewise, prefer long double to double even if same size. */
267 if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
268 || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
269 return build_type_attribute_variant (long_double_type_node,
270 attributes);
271
272 /* Otherwise prefer the unsigned one. */
273
274 if (TREE_UNSIGNED (t1))
275 return build_type_attribute_variant (t1, attributes);
276 else
277 return build_type_attribute_variant (t2, attributes);
278
279 case POINTER_TYPE:
280 /* For two pointers, do this recursively on the target type,
281 and combine the qualifiers of the two types' targets. */
282 /* This code was turned off; I don't know why.
283 But ANSI C specifies doing this with the qualifiers.
284 So I turned it on again. */
285 {
| 171}
172
173/* Return the common type of two types.
174 We assume that comptypes has already been done and returned 1;
175 if that isn't so, this may crash. In particular, we assume that qualifiers
176 match.
177
178 This is the type for the result of most arithmetic operations
179 if the operands have the given two types. */
180
181tree
182common_type (t1, t2)
183 tree t1, t2;
184{
185 register enum tree_code code1;
186 register enum tree_code code2;
187 tree attributes;
188
189 /* Save time if the two types are the same. */
190
191 if (t1 == t2) return t1;
192
193 /* If one type is nonsense, use the other. */
194 if (t1 == error_mark_node)
195 return t2;
196 if (t2 == error_mark_node)
197 return t1;
198
199 /* Merge the attributes. */
200 attributes = merge_machine_type_attributes (t1, t2);
201
202 /* Treat an enum type as the unsigned integer type of the same width. */
203
204 if (TREE_CODE (t1) == ENUMERAL_TYPE)
205 t1 = type_for_size (TYPE_PRECISION (t1), 1);
206 if (TREE_CODE (t2) == ENUMERAL_TYPE)
207 t2 = type_for_size (TYPE_PRECISION (t2), 1);
208
209 code1 = TREE_CODE (t1);
210 code2 = TREE_CODE (t2);
211
212 /* If one type is complex, form the common type of the non-complex
213 components, then make that complex. Use T1 or T2 if it is the
214 required type. */
215 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
216 {
217 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
218 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
219 tree subtype = common_type (subtype1, subtype2);
220
221 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
222 return build_type_attribute_variant (t1, attributes);
223 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
224 return build_type_attribute_variant (t2, attributes);
225 else
226 return build_type_attribute_variant (build_complex_type (subtype),
227 attributes);
228 }
229
230 switch (code1)
231 {
232 case INTEGER_TYPE:
233 case REAL_TYPE:
234 /* If only one is real, use it as the result. */
235
236 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
237 return build_type_attribute_variant (t1, attributes);
238
239 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
240 return build_type_attribute_variant (t2, attributes);
241
242 /* Both real or both integers; use the one with greater precision. */
243
244 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
245 return build_type_attribute_variant (t1, attributes);
246 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
247 return build_type_attribute_variant (t2, attributes);
248
249 /* Same precision. Prefer longs to ints even when same size. */
250
251 if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
252 || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
253 return build_type_attribute_variant (long_unsigned_type_node,
254 attributes);
255
256 if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
257 || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
258 {
259 /* But preserve unsignedness from the other type,
260 since long cannot hold all the values of an unsigned int. */
261 if (TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
262 t1 = long_unsigned_type_node;
263 else
264 t1 = long_integer_type_node;
265 return build_type_attribute_variant (t1, attributes);
266 }
267
268 /* Likewise, prefer long double to double even if same size. */
269 if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
270 || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
271 return build_type_attribute_variant (long_double_type_node,
272 attributes);
273
274 /* Otherwise prefer the unsigned one. */
275
276 if (TREE_UNSIGNED (t1))
277 return build_type_attribute_variant (t1, attributes);
278 else
279 return build_type_attribute_variant (t2, attributes);
280
281 case POINTER_TYPE:
282 /* For two pointers, do this recursively on the target type,
283 and combine the qualifiers of the two types' targets. */
284 /* This code was turned off; I don't know why.
285 But ANSI C specifies doing this with the qualifiers.
286 So I turned it on again. */
287 {
|
286 tree target = common_type (TYPE_MAIN_VARIANT (TREE_TYPE (t1)),
287 TYPE_MAIN_VARIANT (TREE_TYPE (t2)));
288 int constp
289 = TYPE_READONLY (TREE_TYPE (t1)) || TYPE_READONLY (TREE_TYPE (t2));
290 int volatilep
291 = TYPE_VOLATILE (TREE_TYPE (t1)) || TYPE_VOLATILE (TREE_TYPE (t2));
292 t1 = build_pointer_type (c_build_type_variant (target, constp,
293 volatilep));
| 288 tree pointed_to_1 = TREE_TYPE (t1);
289 tree pointed_to_2 = TREE_TYPE (t2);
290 tree target = common_type (TYPE_MAIN_VARIANT (pointed_to_1),
291 TYPE_MAIN_VARIANT (pointed_to_2));
292 t1 = build_pointer_type (c_build_qualified_type
293 (target,
294 TYPE_QUALS (pointed_to_1) |
295 TYPE_QUALS (pointed_to_2)));
|
294 return build_type_attribute_variant (t1, attributes);
295 }
296#if 0
297 t1 = build_pointer_type (common_type (TREE_TYPE (t1), TREE_TYPE (t2)));
298 return build_type_attribute_variant (t1, attributes);
299#endif
300
301 case ARRAY_TYPE:
302 {
303 tree elt = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
304 /* Save space: see if the result is identical to one of the args. */
305 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
306 return build_type_attribute_variant (t1, attributes);
307 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
308 return build_type_attribute_variant (t2, attributes);
309 /* Merge the element types, and have a size if either arg has one. */
310 t1 = build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
311 return build_type_attribute_variant (t1, attributes);
312 }
313
314 case FUNCTION_TYPE:
315 /* Function types: prefer the one that specified arg types.
316 If both do, merge the arg types. Also merge the return types. */
317 {
318 tree valtype = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
319 tree p1 = TYPE_ARG_TYPES (t1);
320 tree p2 = TYPE_ARG_TYPES (t2);
321 int len;
322 tree newargs, n;
323 int i;
324
325 /* Save space: see if the result is identical to one of the args. */
326 if (valtype == TREE_TYPE (t1) && ! TYPE_ARG_TYPES (t2))
327 return build_type_attribute_variant (t1, attributes);
328 if (valtype == TREE_TYPE (t2) && ! TYPE_ARG_TYPES (t1))
329 return build_type_attribute_variant (t2, attributes);
330
331 /* Simple way if one arg fails to specify argument types. */
332 if (TYPE_ARG_TYPES (t1) == 0)
333 {
334 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
335 return build_type_attribute_variant (t1, attributes);
336 }
337 if (TYPE_ARG_TYPES (t2) == 0)
338 {
339 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
340 return build_type_attribute_variant (t1, attributes);
341 }
342
343 /* If both args specify argument types, we must merge the two
344 lists, argument by argument. */
345
346 len = list_length (p1);
347 newargs = 0;
348
349 for (i = 0; i < len; i++)
350 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
351
352 n = newargs;
353
354 for (; p1;
355 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
356 {
357 /* A null type means arg type is not specified.
358 Take whatever the other function type has. */
359 if (TREE_VALUE (p1) == 0)
360 {
361 TREE_VALUE (n) = TREE_VALUE (p2);
362 goto parm_done;
363 }
364 if (TREE_VALUE (p2) == 0)
365 {
366 TREE_VALUE (n) = TREE_VALUE (p1);
367 goto parm_done;
368 }
369
370 /* Given wait (union {union wait *u; int *i} *)
371 and wait (union wait *),
372 prefer union wait * as type of parm. */
373 if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
374 && TREE_VALUE (p1) != TREE_VALUE (p2))
375 {
376 tree memb;
377 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
378 memb; memb = TREE_CHAIN (memb))
379 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2)))
380 {
381 TREE_VALUE (n) = TREE_VALUE (p2);
382 if (pedantic)
383 pedwarn ("function types not truly compatible in ANSI C");
384 goto parm_done;
385 }
386 }
387 if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
388 && TREE_VALUE (p2) != TREE_VALUE (p1))
389 {
390 tree memb;
391 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
392 memb; memb = TREE_CHAIN (memb))
393 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1)))
394 {
395 TREE_VALUE (n) = TREE_VALUE (p1);
396 if (pedantic)
397 pedwarn ("function types not truly compatible in ANSI C");
398 goto parm_done;
399 }
400 }
401 TREE_VALUE (n) = common_type (TREE_VALUE (p1), TREE_VALUE (p2));
402 parm_done: ;
403 }
404
405 t1 = build_function_type (valtype, newargs);
406 /* ... falls through ... */
407 }
408
409 default:
410 return build_type_attribute_variant (t1, attributes);
411 }
412
413}
414
415/* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
416 or various other operations. Return 2 if they are compatible
417 but a warning may be needed if you use them together. */
418
419int
420comptypes (type1, type2)
421 tree type1, type2;
422{
423 register tree t1 = type1;
424 register tree t2 = type2;
425 int attrval, val;
426
427 /* Suppress errors caused by previously reported errors. */
428
429 if (t1 == t2 || !t1 || !t2
430 || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
431 return 1;
432
433 /* Treat an enum type as the integer type of the same width and
434 signedness. */
435
436 if (TREE_CODE (t1) == ENUMERAL_TYPE)
437 t1 = type_for_size (TYPE_PRECISION (t1), TREE_UNSIGNED (t1));
438 if (TREE_CODE (t2) == ENUMERAL_TYPE)
439 t2 = type_for_size (TYPE_PRECISION (t2), TREE_UNSIGNED (t2));
440
441 if (t1 == t2)
442 return 1;
443
444 /* Different classes of types can't be compatible. */
445
446 if (TREE_CODE (t1) != TREE_CODE (t2)) return 0;
447
448 /* Qualifiers must match. */
449
| 296 return build_type_attribute_variant (t1, attributes);
297 }
298#if 0
299 t1 = build_pointer_type (common_type (TREE_TYPE (t1), TREE_TYPE (t2)));
300 return build_type_attribute_variant (t1, attributes);
301#endif
302
303 case ARRAY_TYPE:
304 {
305 tree elt = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
306 /* Save space: see if the result is identical to one of the args. */
307 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
308 return build_type_attribute_variant (t1, attributes);
309 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
310 return build_type_attribute_variant (t2, attributes);
311 /* Merge the element types, and have a size if either arg has one. */
312 t1 = build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
313 return build_type_attribute_variant (t1, attributes);
314 }
315
316 case FUNCTION_TYPE:
317 /* Function types: prefer the one that specified arg types.
318 If both do, merge the arg types. Also merge the return types. */
319 {
320 tree valtype = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
321 tree p1 = TYPE_ARG_TYPES (t1);
322 tree p2 = TYPE_ARG_TYPES (t2);
323 int len;
324 tree newargs, n;
325 int i;
326
327 /* Save space: see if the result is identical to one of the args. */
328 if (valtype == TREE_TYPE (t1) && ! TYPE_ARG_TYPES (t2))
329 return build_type_attribute_variant (t1, attributes);
330 if (valtype == TREE_TYPE (t2) && ! TYPE_ARG_TYPES (t1))
331 return build_type_attribute_variant (t2, attributes);
332
333 /* Simple way if one arg fails to specify argument types. */
334 if (TYPE_ARG_TYPES (t1) == 0)
335 {
336 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
337 return build_type_attribute_variant (t1, attributes);
338 }
339 if (TYPE_ARG_TYPES (t2) == 0)
340 {
341 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
342 return build_type_attribute_variant (t1, attributes);
343 }
344
345 /* If both args specify argument types, we must merge the two
346 lists, argument by argument. */
347
348 len = list_length (p1);
349 newargs = 0;
350
351 for (i = 0; i < len; i++)
352 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
353
354 n = newargs;
355
356 for (; p1;
357 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
358 {
359 /* A null type means arg type is not specified.
360 Take whatever the other function type has. */
361 if (TREE_VALUE (p1) == 0)
362 {
363 TREE_VALUE (n) = TREE_VALUE (p2);
364 goto parm_done;
365 }
366 if (TREE_VALUE (p2) == 0)
367 {
368 TREE_VALUE (n) = TREE_VALUE (p1);
369 goto parm_done;
370 }
371
372 /* Given wait (union {union wait *u; int *i} *)
373 and wait (union wait *),
374 prefer union wait * as type of parm. */
375 if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
376 && TREE_VALUE (p1) != TREE_VALUE (p2))
377 {
378 tree memb;
379 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
380 memb; memb = TREE_CHAIN (memb))
381 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2)))
382 {
383 TREE_VALUE (n) = TREE_VALUE (p2);
384 if (pedantic)
385 pedwarn ("function types not truly compatible in ANSI C");
386 goto parm_done;
387 }
388 }
389 if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
390 && TREE_VALUE (p2) != TREE_VALUE (p1))
391 {
392 tree memb;
393 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
394 memb; memb = TREE_CHAIN (memb))
395 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1)))
396 {
397 TREE_VALUE (n) = TREE_VALUE (p1);
398 if (pedantic)
399 pedwarn ("function types not truly compatible in ANSI C");
400 goto parm_done;
401 }
402 }
403 TREE_VALUE (n) = common_type (TREE_VALUE (p1), TREE_VALUE (p2));
404 parm_done: ;
405 }
406
407 t1 = build_function_type (valtype, newargs);
408 /* ... falls through ... */
409 }
410
411 default:
412 return build_type_attribute_variant (t1, attributes);
413 }
414
415}
416
417/* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
418 or various other operations. Return 2 if they are compatible
419 but a warning may be needed if you use them together. */
420
421int
422comptypes (type1, type2)
423 tree type1, type2;
424{
425 register tree t1 = type1;
426 register tree t2 = type2;
427 int attrval, val;
428
429 /* Suppress errors caused by previously reported errors. */
430
431 if (t1 == t2 || !t1 || !t2
432 || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
433 return 1;
434
435 /* Treat an enum type as the integer type of the same width and
436 signedness. */
437
438 if (TREE_CODE (t1) == ENUMERAL_TYPE)
439 t1 = type_for_size (TYPE_PRECISION (t1), TREE_UNSIGNED (t1));
440 if (TREE_CODE (t2) == ENUMERAL_TYPE)
441 t2 = type_for_size (TYPE_PRECISION (t2), TREE_UNSIGNED (t2));
442
443 if (t1 == t2)
444 return 1;
445
446 /* Different classes of types can't be compatible. */
447
448 if (TREE_CODE (t1) != TREE_CODE (t2)) return 0;
449
450 /* Qualifiers must match. */
451
|
450 if (TYPE_READONLY (t1) != TYPE_READONLY (t2))
| 452 if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
|
451 return 0;
| 453 return 0;
|
452 if (TYPE_VOLATILE (t1) != TYPE_VOLATILE (t2))
453 return 0;
| |
454
455 /* Allow for two different type nodes which have essentially the same
456 definition. Note that we already checked for equality of the type
457 qualifiers (just above). */
458
459 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
460 return 1;
461
462#ifndef COMP_TYPE_ATTRIBUTES
463#define COMP_TYPE_ATTRIBUTES(t1,t2) 1
464#endif
465
466 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
467 if (! (attrval = COMP_TYPE_ATTRIBUTES (t1, t2)))
468 return 0;
469
470 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
471 val = 0;
472
473 switch (TREE_CODE (t1))
474 {
475 case POINTER_TYPE:
476 val = (TREE_TYPE (t1) == TREE_TYPE (t2)
477 ? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2)));
478 break;
479
480 case FUNCTION_TYPE:
481 val = function_types_compatible_p (t1, t2);
482 break;
483
484 case ARRAY_TYPE:
485 {
486 tree d1 = TYPE_DOMAIN (t1);
487 tree d2 = TYPE_DOMAIN (t2);
488 val = 1;
489
490 /* Target types must match incl. qualifiers. */
491 if (TREE_TYPE (t1) != TREE_TYPE (t2)
492 && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2))))
493 return 0;
494
495 /* Sizes must match unless one is missing or variable. */
496 if (d1 == 0 || d2 == 0 || d1 == d2
497 || TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
498 || TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
499 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST
500 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)
501 break;
502
503 if (! ((TREE_INT_CST_LOW (TYPE_MIN_VALUE (d1))
504 == TREE_INT_CST_LOW (TYPE_MIN_VALUE (d2)))
505 && (TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d1))
506 == TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d2)))
507 && (TREE_INT_CST_LOW (TYPE_MAX_VALUE (d1))
508 == TREE_INT_CST_LOW (TYPE_MAX_VALUE (d2)))
509 && (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d1))
510 == TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d2)))))
511 val = 0;
512 break;
513 }
514
515 case RECORD_TYPE:
516 if (maybe_objc_comptypes (t1, t2, 0) == 1)
517 val = 1;
518 break;
519
520 default:
521 break;
522 }
523 return attrval == 2 && val == 1 ? 2 : val;
524}
525
526/* Return 1 if TTL and TTR are pointers to types that are equivalent,
527 ignoring their qualifiers. */
528
529static int
530comp_target_types (ttl, ttr)
531 tree ttl, ttr;
532{
533 int val;
534
535 /* Give maybe_objc_comptypes a crack at letting these types through. */
536 if ((val = maybe_objc_comptypes (ttl, ttr, 1)) >= 0)
537 return val;
538
539 val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)),
540 TYPE_MAIN_VARIANT (TREE_TYPE (ttr)));
541
542 if (val == 2 && pedantic)
543 pedwarn ("types are not quite compatible");
544 return val;
545}
546
547/* Subroutines of `comptypes'. */
548
549/* Return 1 if two function types F1 and F2 are compatible.
550 If either type specifies no argument types,
551 the other must specify a fixed number of self-promoting arg types.
552 Otherwise, if one type specifies only the number of arguments,
553 the other must specify that number of self-promoting arg types.
554 Otherwise, the argument types must match. */
555
556static int
557function_types_compatible_p (f1, f2)
558 tree f1, f2;
559{
560 tree args1, args2;
561 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
562 int val = 1;
563 int val1;
564
565 if (!(TREE_TYPE (f1) == TREE_TYPE (f2)
566 || (val = comptypes (TREE_TYPE (f1), TREE_TYPE (f2)))))
567 return 0;
568
569 args1 = TYPE_ARG_TYPES (f1);
570 args2 = TYPE_ARG_TYPES (f2);
571
572 /* An unspecified parmlist matches any specified parmlist
573 whose argument types don't need default promotions. */
574
575 if (args1 == 0)
576 {
577 if (!self_promoting_args_p (args2))
578 return 0;
579 /* If one of these types comes from a non-prototype fn definition,
580 compare that with the other type's arglist.
581 If they don't match, ask for a warning (but no error). */
582 if (TYPE_ACTUAL_ARG_TYPES (f1)
583 && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
584 val = 2;
585 return val;
586 }
587 if (args2 == 0)
588 {
589 if (!self_promoting_args_p (args1))
590 return 0;
591 if (TYPE_ACTUAL_ARG_TYPES (f2)
592 && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
593 val = 2;
594 return val;
595 }
596
597 /* Both types have argument lists: compare them and propagate results. */
598 val1 = type_lists_compatible_p (args1, args2);
599 return val1 != 1 ? val1 : val;
600}
601
602/* Check two lists of types for compatibility,
603 returning 0 for incompatible, 1 for compatible,
604 or 2 for compatible with warning. */
605
606static int
607type_lists_compatible_p (args1, args2)
608 tree args1, args2;
609{
610 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
611 int val = 1;
612 int newval = 0;
613
614 while (1)
615 {
616 if (args1 == 0 && args2 == 0)
617 return val;
618 /* If one list is shorter than the other,
619 they fail to match. */
620 if (args1 == 0 || args2 == 0)
621 return 0;
622 /* A null pointer instead of a type
623 means there is supposed to be an argument
624 but nothing is specified about what type it has.
625 So match anything that self-promotes. */
626 if (TREE_VALUE (args1) == 0)
627 {
628 if (! self_promoting_type_p (TREE_VALUE (args2)))
629 return 0;
630 }
631 else if (TREE_VALUE (args2) == 0)
632 {
633 if (! self_promoting_type_p (TREE_VALUE (args1)))
634 return 0;
635 }
636 else if (! (newval = comptypes (TREE_VALUE (args1), TREE_VALUE (args2))))
637 {
638 /* Allow wait (union {union wait *u; int *i} *)
639 and wait (union wait *) to be compatible. */
640 if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE
641 && (TYPE_NAME (TREE_VALUE (args1)) == 0
642 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1)))
643 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST
644 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)),
645 TYPE_SIZE (TREE_VALUE (args2))))
646 {
647 tree memb;
648 for (memb = TYPE_FIELDS (TREE_VALUE (args1));
649 memb; memb = TREE_CHAIN (memb))
650 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2)))
651 break;
652 if (memb == 0)
653 return 0;
654 }
655 else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE
656 && (TYPE_NAME (TREE_VALUE (args2)) == 0
657 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2)))
658 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST
659 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)),
660 TYPE_SIZE (TREE_VALUE (args1))))
661 {
662 tree memb;
663 for (memb = TYPE_FIELDS (TREE_VALUE (args2));
664 memb; memb = TREE_CHAIN (memb))
665 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1)))
666 break;
667 if (memb == 0)
668 return 0;
669 }
670 else
671 return 0;
672 }
673
674 /* comptypes said ok, but record if it said to warn. */
675 if (newval > val)
676 val = newval;
677
678 args1 = TREE_CHAIN (args1);
679 args2 = TREE_CHAIN (args2);
680 }
681}
682
683/* Return 1 if PARMS specifies a fixed number of parameters
684 and none of their types is affected by default promotions. */
685
686int
687self_promoting_args_p (parms)
688 tree parms;
689{
690 register tree t;
691 for (t = parms; t; t = TREE_CHAIN (t))
692 {
693 register tree type = TREE_VALUE (t);
694
695 if (TREE_CHAIN (t) == 0 && type != void_type_node)
696 return 0;
697
698 if (type == 0)
699 return 0;
700
701 if (TYPE_MAIN_VARIANT (type) == float_type_node)
702 return 0;
703
704 if (C_PROMOTING_INTEGER_TYPE_P (type))
705 return 0;
706 }
707 return 1;
708}
709
710/* Return 1 if TYPE is not affected by default promotions. */
711
712static int
713self_promoting_type_p (type)
714 tree type;
715{
716 if (TYPE_MAIN_VARIANT (type) == float_type_node)
717 return 0;
718
719 if (C_PROMOTING_INTEGER_TYPE_P (type))
720 return 0;
721
722 return 1;
723}
724
725/* Return an unsigned type the same as TYPE in other respects. */
726
727tree
728unsigned_type (type)
729 tree type;
730{
731 tree type1 = TYPE_MAIN_VARIANT (type);
732 if (type1 == signed_char_type_node || type1 == char_type_node)
733 return unsigned_char_type_node;
734 if (type1 == integer_type_node)
735 return unsigned_type_node;
736 if (type1 == short_integer_type_node)
737 return short_unsigned_type_node;
738 if (type1 == long_integer_type_node)
739 return long_unsigned_type_node;
740 if (type1 == long_long_integer_type_node)
741 return long_long_unsigned_type_node;
742 if (type1 == intDI_type_node)
743 return unsigned_intDI_type_node;
744 if (type1 == intSI_type_node)
745 return unsigned_intSI_type_node;
746 if (type1 == intHI_type_node)
747 return unsigned_intHI_type_node;
748 if (type1 == intQI_type_node)
749 return unsigned_intQI_type_node;
750
751 return signed_or_unsigned_type (1, type);
752}
753
754/* Return a signed type the same as TYPE in other respects. */
755
756tree
757signed_type (type)
758 tree type;
759{
760 tree type1 = TYPE_MAIN_VARIANT (type);
761 if (type1 == unsigned_char_type_node || type1 == char_type_node)
762 return signed_char_type_node;
763 if (type1 == unsigned_type_node)
764 return integer_type_node;
765 if (type1 == short_unsigned_type_node)
766 return short_integer_type_node;
767 if (type1 == long_unsigned_type_node)
768 return long_integer_type_node;
769 if (type1 == long_long_unsigned_type_node)
770 return long_long_integer_type_node;
771 if (type1 == unsigned_intDI_type_node)
772 return intDI_type_node;
773 if (type1 == unsigned_intSI_type_node)
774 return intSI_type_node;
775 if (type1 == unsigned_intHI_type_node)
776 return intHI_type_node;
777 if (type1 == unsigned_intQI_type_node)
778 return intQI_type_node;
779
780 return signed_or_unsigned_type (0, type);
781}
782
783/* Return a type the same as TYPE except unsigned or
784 signed according to UNSIGNEDP. */
785
786tree
787signed_or_unsigned_type (unsignedp, type)
788 int unsignedp;
789 tree type;
790{
791 if ((! INTEGRAL_TYPE_P (type) && ! POINTER_TYPE_P (type))
792 || TREE_UNSIGNED (type) == unsignedp)
793 return type;
794 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
795 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
796 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
797 return unsignedp ? unsigned_type_node : integer_type_node;
798 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
799 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
800 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
801 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
802 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
803 return (unsignedp ? long_long_unsigned_type_node
804 : long_long_integer_type_node);
805 return type;
806}
807
808/* Compute the value of the `sizeof' operator. */
809
810tree
811c_sizeof (type)
812 tree type;
813{
814 enum tree_code code = TREE_CODE (type);
815 tree t;
816
817 if (code == FUNCTION_TYPE)
818 {
819 if (pedantic || warn_pointer_arith)
820 pedwarn ("sizeof applied to a function type");
821 return size_int (1);
822 }
823 if (code == VOID_TYPE)
824 {
825 if (pedantic || warn_pointer_arith)
826 pedwarn ("sizeof applied to a void type");
827 return size_int (1);
828 }
829 if (code == ERROR_MARK)
830 return size_int (1);
831 if (TYPE_SIZE (type) == 0)
832 {
833 error ("sizeof applied to an incomplete type");
834 return size_int (0);
835 }
836
837 /* Convert in case a char is more than one unit. */
838 t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
839 size_int (TYPE_PRECISION (char_type_node)));
840 t = convert (sizetype, t);
841 /* size_binop does not put the constant in range, so do it now. */
842 if (TREE_CODE (t) == INTEGER_CST && force_fit_type (t, 0))
843 TREE_CONSTANT_OVERFLOW (t) = TREE_OVERFLOW (t) = 1;
844 return t;
845}
846
847tree
848c_sizeof_nowarn (type)
849 tree type;
850{
851 enum tree_code code = TREE_CODE (type);
852 tree t;
853
854 if (code == FUNCTION_TYPE
855 || code == VOID_TYPE
856 || code == ERROR_MARK)
857 return size_int (1);
858 if (TYPE_SIZE (type) == 0)
859 return size_int (0);
860
861 /* Convert in case a char is more than one unit. */
862 t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
863 size_int (TYPE_PRECISION (char_type_node)));
864 t = convert (sizetype, t);
865 force_fit_type (t, 0);
866 return t;
867}
868
869/* Compute the size to increment a pointer by. */
870
871tree
872c_size_in_bytes (type)
873 tree type;
874{
875 enum tree_code code = TREE_CODE (type);
876 tree t;
877
878 if (code == FUNCTION_TYPE)
879 return size_int (1);
880 if (code == VOID_TYPE)
881 return size_int (1);
882 if (code == ERROR_MARK)
883 return size_int (1);
884 if (TYPE_SIZE (type) == 0)
885 {
886 error ("arithmetic on pointer to an incomplete type");
887 return size_int (1);
888 }
889
890 /* Convert in case a char is more than one unit. */
891 t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
892 size_int (BITS_PER_UNIT));
893 t = convert (sizetype, t);
894 force_fit_type (t, 0);
895 return t;
896}
897
898/* Implement the __alignof keyword: Return the minimum required
899 alignment of TYPE, measured in bytes. */
900
901tree
902c_alignof (type)
903 tree type;
904{
905 enum tree_code code = TREE_CODE (type);
906
907 if (code == FUNCTION_TYPE)
908 return size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
909
910 if (code == VOID_TYPE || code == ERROR_MARK)
911 return size_int (1);
912
913 return size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
914}
915
916/* Implement the __alignof keyword: Return the minimum required
917 alignment of EXPR, measured in bytes. For VAR_DECL's and
918 FIELD_DECL's return DECL_ALIGN (which can be set from an
919 "aligned" __attribute__ specification). */
920
921tree
922c_alignof_expr (expr)
923 tree expr;
924{
925 if (TREE_CODE (expr) == VAR_DECL)
926 return size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
927
928 if (TREE_CODE (expr) == COMPONENT_REF
929 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
930 {
931 error ("`__alignof' applied to a bit-field");
932 return size_int (1);
933 }
934 else if (TREE_CODE (expr) == COMPONENT_REF
935 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
936 return size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
937
938 if (TREE_CODE (expr) == INDIRECT_REF)
939 {
940 tree t = TREE_OPERAND (expr, 0);
941 tree best = t;
942 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
943
944 while (TREE_CODE (t) == NOP_EXPR
945 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
946 {
947 int thisalign;
948
949 t = TREE_OPERAND (t, 0);
950 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
951 if (thisalign > bestalign)
952 best = t, bestalign = thisalign;
953 }
954 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
955 }
956 else
957 return c_alignof (TREE_TYPE (expr));
958}
959
960/* Return either DECL or its known constant value (if it has one). */
961
962static tree
963decl_constant_value (decl)
964 tree decl;
965{
966 if (/* Don't change a variable array bound or initial value to a constant
967 in a place where a variable is invalid. */
968 current_function_decl != 0
969 && ! pedantic
970 && ! TREE_THIS_VOLATILE (decl)
971 && TREE_READONLY (decl) && ! ITERATOR_P (decl)
972 && DECL_INITIAL (decl) != 0
973 && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
974 /* This is invalid if initial value is not constant.
975 If it has either a function call, a memory reference,
976 or a variable, then re-evaluating it could give different results. */
977 && TREE_CONSTANT (DECL_INITIAL (decl))
978 /* Check for cases where this is sub-optimal, even though valid. */
979 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR
980 && DECL_MODE (decl) != BLKmode)
981 return DECL_INITIAL (decl);
982 return decl;
983}
984
985/* Perform default promotions for C data used in expressions.
986 Arrays and functions are converted to pointers;
987 enumeral types or short or char, to int.
988 In addition, manifest constants symbols are replaced by their values. */
989
990tree
991default_conversion (exp)
992 tree exp;
993{
994 register tree type = TREE_TYPE (exp);
995 register enum tree_code code = TREE_CODE (type);
996
997 /* Constants can be used directly unless they're not loadable. */
998 if (TREE_CODE (exp) == CONST_DECL)
999 exp = DECL_INITIAL (exp);
1000
1001 /* Replace a nonvolatile const static variable with its value unless
1002 it is an array, in which case we must be sure that taking the
1003 address of the array produces consistent results. */
1004 else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
1005 {
1006 exp = decl_constant_value (exp);
1007 type = TREE_TYPE (exp);
1008 }
1009
1010 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1011 an lvalue. */
1012 /* Do not use STRIP_NOPS here! It will remove conversions from pointer
1013 to integer and cause infinite recursion. */
1014 while (TREE_CODE (exp) == NON_LVALUE_EXPR
1015 || (TREE_CODE (exp) == NOP_EXPR
1016 && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
1017 exp = TREE_OPERAND (exp, 0);
1018
1019 /* Normally convert enums to int,
1020 but convert wide enums to something wider. */
1021 if (code == ENUMERAL_TYPE)
1022 {
1023 type = type_for_size (MAX (TYPE_PRECISION (type),
1024 TYPE_PRECISION (integer_type_node)),
1025 ((flag_traditional
1026 || (TYPE_PRECISION (type)
1027 >= TYPE_PRECISION (integer_type_node)))
1028 && TREE_UNSIGNED (type)));
1029 return convert (type, exp);
1030 }
1031
1032 if (TREE_CODE (exp) == COMPONENT_REF
1033 && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1)))
1034 {
1035 tree width = DECL_SIZE (TREE_OPERAND (exp, 1));
1036 HOST_WIDE_INT low = TREE_INT_CST_LOW (width);
1037
1038 /* If it's thinner than an int, promote it like a
1039 C_PROMOTING_INTEGER_TYPE_P, otherwise leave it alone. */
1040
1041 if (low < TYPE_PRECISION (integer_type_node))
1042 {
1043 if (flag_traditional && TREE_UNSIGNED (type))
1044 return convert (unsigned_type_node, exp);
1045 else
1046 return convert (integer_type_node, exp);
1047 }
1048 }
1049
1050 if (C_PROMOTING_INTEGER_TYPE_P (type))
1051 {
1052 /* Traditionally, unsignedness is preserved in default promotions.
1053 Also preserve unsignedness if not really getting any wider. */
1054 if (TREE_UNSIGNED (type)
1055 && (flag_traditional
1056 || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
1057 return convert (unsigned_type_node, exp);
1058 return convert (integer_type_node, exp);
1059 }
1060 if (flag_traditional && !flag_allow_single_precision
1061 && TYPE_MAIN_VARIANT (type) == float_type_node)
1062 return convert (double_type_node, exp);
1063 if (code == VOID_TYPE)
1064 {
1065 error ("void value not ignored as it ought to be");
1066 return error_mark_node;
1067 }
1068 if (code == FUNCTION_TYPE)
1069 {
1070 return build_unary_op (ADDR_EXPR, exp, 0);
1071 }
1072 if (code == ARRAY_TYPE)
1073 {
1074 register tree adr;
1075 tree restype = TREE_TYPE (type);
1076 tree ptrtype;
1077 int constp = 0;
1078 int volatilep = 0;
1079
1080 if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'r'
1081 || TREE_CODE_CLASS (TREE_CODE (exp)) == 'd')
1082 {
1083 constp = TREE_READONLY (exp);
1084 volatilep = TREE_THIS_VOLATILE (exp);
1085 }
1086
| 454
455 /* Allow for two different type nodes which have essentially the same
456 definition. Note that we already checked for equality of the type
457 qualifiers (just above). */
458
459 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
460 return 1;
461
462#ifndef COMP_TYPE_ATTRIBUTES
463#define COMP_TYPE_ATTRIBUTES(t1,t2) 1
464#endif
465
466 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
467 if (! (attrval = COMP_TYPE_ATTRIBUTES (t1, t2)))
468 return 0;
469
470 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
471 val = 0;
472
473 switch (TREE_CODE (t1))
474 {
475 case POINTER_TYPE:
476 val = (TREE_TYPE (t1) == TREE_TYPE (t2)
477 ? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2)));
478 break;
479
480 case FUNCTION_TYPE:
481 val = function_types_compatible_p (t1, t2);
482 break;
483
484 case ARRAY_TYPE:
485 {
486 tree d1 = TYPE_DOMAIN (t1);
487 tree d2 = TYPE_DOMAIN (t2);
488 val = 1;
489
490 /* Target types must match incl. qualifiers. */
491 if (TREE_TYPE (t1) != TREE_TYPE (t2)
492 && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2))))
493 return 0;
494
495 /* Sizes must match unless one is missing or variable. */
496 if (d1 == 0 || d2 == 0 || d1 == d2
497 || TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
498 || TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
499 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST
500 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)
501 break;
502
503 if (! ((TREE_INT_CST_LOW (TYPE_MIN_VALUE (d1))
504 == TREE_INT_CST_LOW (TYPE_MIN_VALUE (d2)))
505 && (TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d1))
506 == TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d2)))
507 && (TREE_INT_CST_LOW (TYPE_MAX_VALUE (d1))
508 == TREE_INT_CST_LOW (TYPE_MAX_VALUE (d2)))
509 && (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d1))
510 == TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d2)))))
511 val = 0;
512 break;
513 }
514
515 case RECORD_TYPE:
516 if (maybe_objc_comptypes (t1, t2, 0) == 1)
517 val = 1;
518 break;
519
520 default:
521 break;
522 }
523 return attrval == 2 && val == 1 ? 2 : val;
524}
525
526/* Return 1 if TTL and TTR are pointers to types that are equivalent,
527 ignoring their qualifiers. */
528
529static int
530comp_target_types (ttl, ttr)
531 tree ttl, ttr;
532{
533 int val;
534
535 /* Give maybe_objc_comptypes a crack at letting these types through. */
536 if ((val = maybe_objc_comptypes (ttl, ttr, 1)) >= 0)
537 return val;
538
539 val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)),
540 TYPE_MAIN_VARIANT (TREE_TYPE (ttr)));
541
542 if (val == 2 && pedantic)
543 pedwarn ("types are not quite compatible");
544 return val;
545}
546
547/* Subroutines of `comptypes'. */
548
549/* Return 1 if two function types F1 and F2 are compatible.
550 If either type specifies no argument types,
551 the other must specify a fixed number of self-promoting arg types.
552 Otherwise, if one type specifies only the number of arguments,
553 the other must specify that number of self-promoting arg types.
554 Otherwise, the argument types must match. */
555
556static int
557function_types_compatible_p (f1, f2)
558 tree f1, f2;
559{
560 tree args1, args2;
561 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
562 int val = 1;
563 int val1;
564
565 if (!(TREE_TYPE (f1) == TREE_TYPE (f2)
566 || (val = comptypes (TREE_TYPE (f1), TREE_TYPE (f2)))))
567 return 0;
568
569 args1 = TYPE_ARG_TYPES (f1);
570 args2 = TYPE_ARG_TYPES (f2);
571
572 /* An unspecified parmlist matches any specified parmlist
573 whose argument types don't need default promotions. */
574
575 if (args1 == 0)
576 {
577 if (!self_promoting_args_p (args2))
578 return 0;
579 /* If one of these types comes from a non-prototype fn definition,
580 compare that with the other type's arglist.
581 If they don't match, ask for a warning (but no error). */
582 if (TYPE_ACTUAL_ARG_TYPES (f1)
583 && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
584 val = 2;
585 return val;
586 }
587 if (args2 == 0)
588 {
589 if (!self_promoting_args_p (args1))
590 return 0;
591 if (TYPE_ACTUAL_ARG_TYPES (f2)
592 && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
593 val = 2;
594 return val;
595 }
596
597 /* Both types have argument lists: compare them and propagate results. */
598 val1 = type_lists_compatible_p (args1, args2);
599 return val1 != 1 ? val1 : val;
600}
601
602/* Check two lists of types for compatibility,
603 returning 0 for incompatible, 1 for compatible,
604 or 2 for compatible with warning. */
605
606static int
607type_lists_compatible_p (args1, args2)
608 tree args1, args2;
609{
610 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
611 int val = 1;
612 int newval = 0;
613
614 while (1)
615 {
616 if (args1 == 0 && args2 == 0)
617 return val;
618 /* If one list is shorter than the other,
619 they fail to match. */
620 if (args1 == 0 || args2 == 0)
621 return 0;
622 /* A null pointer instead of a type
623 means there is supposed to be an argument
624 but nothing is specified about what type it has.
625 So match anything that self-promotes. */
626 if (TREE_VALUE (args1) == 0)
627 {
628 if (! self_promoting_type_p (TREE_VALUE (args2)))
629 return 0;
630 }
631 else if (TREE_VALUE (args2) == 0)
632 {
633 if (! self_promoting_type_p (TREE_VALUE (args1)))
634 return 0;
635 }
636 else if (! (newval = comptypes (TREE_VALUE (args1), TREE_VALUE (args2))))
637 {
638 /* Allow wait (union {union wait *u; int *i} *)
639 and wait (union wait *) to be compatible. */
640 if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE
641 && (TYPE_NAME (TREE_VALUE (args1)) == 0
642 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1)))
643 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST
644 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)),
645 TYPE_SIZE (TREE_VALUE (args2))))
646 {
647 tree memb;
648 for (memb = TYPE_FIELDS (TREE_VALUE (args1));
649 memb; memb = TREE_CHAIN (memb))
650 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2)))
651 break;
652 if (memb == 0)
653 return 0;
654 }
655 else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE
656 && (TYPE_NAME (TREE_VALUE (args2)) == 0
657 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2)))
658 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST
659 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)),
660 TYPE_SIZE (TREE_VALUE (args1))))
661 {
662 tree memb;
663 for (memb = TYPE_FIELDS (TREE_VALUE (args2));
664 memb; memb = TREE_CHAIN (memb))
665 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1)))
666 break;
667 if (memb == 0)
668 return 0;
669 }
670 else
671 return 0;
672 }
673
674 /* comptypes said ok, but record if it said to warn. */
675 if (newval > val)
676 val = newval;
677
678 args1 = TREE_CHAIN (args1);
679 args2 = TREE_CHAIN (args2);
680 }
681}
682
683/* Return 1 if PARMS specifies a fixed number of parameters
684 and none of their types is affected by default promotions. */
685
686int
687self_promoting_args_p (parms)
688 tree parms;
689{
690 register tree t;
691 for (t = parms; t; t = TREE_CHAIN (t))
692 {
693 register tree type = TREE_VALUE (t);
694
695 if (TREE_CHAIN (t) == 0 && type != void_type_node)
696 return 0;
697
698 if (type == 0)
699 return 0;
700
701 if (TYPE_MAIN_VARIANT (type) == float_type_node)
702 return 0;
703
704 if (C_PROMOTING_INTEGER_TYPE_P (type))
705 return 0;
706 }
707 return 1;
708}
709
710/* Return 1 if TYPE is not affected by default promotions. */
711
712static int
713self_promoting_type_p (type)
714 tree type;
715{
716 if (TYPE_MAIN_VARIANT (type) == float_type_node)
717 return 0;
718
719 if (C_PROMOTING_INTEGER_TYPE_P (type))
720 return 0;
721
722 return 1;
723}
724
725/* Return an unsigned type the same as TYPE in other respects. */
726
727tree
728unsigned_type (type)
729 tree type;
730{
731 tree type1 = TYPE_MAIN_VARIANT (type);
732 if (type1 == signed_char_type_node || type1 == char_type_node)
733 return unsigned_char_type_node;
734 if (type1 == integer_type_node)
735 return unsigned_type_node;
736 if (type1 == short_integer_type_node)
737 return short_unsigned_type_node;
738 if (type1 == long_integer_type_node)
739 return long_unsigned_type_node;
740 if (type1 == long_long_integer_type_node)
741 return long_long_unsigned_type_node;
742 if (type1 == intDI_type_node)
743 return unsigned_intDI_type_node;
744 if (type1 == intSI_type_node)
745 return unsigned_intSI_type_node;
746 if (type1 == intHI_type_node)
747 return unsigned_intHI_type_node;
748 if (type1 == intQI_type_node)
749 return unsigned_intQI_type_node;
750
751 return signed_or_unsigned_type (1, type);
752}
753
754/* Return a signed type the same as TYPE in other respects. */
755
756tree
757signed_type (type)
758 tree type;
759{
760 tree type1 = TYPE_MAIN_VARIANT (type);
761 if (type1 == unsigned_char_type_node || type1 == char_type_node)
762 return signed_char_type_node;
763 if (type1 == unsigned_type_node)
764 return integer_type_node;
765 if (type1 == short_unsigned_type_node)
766 return short_integer_type_node;
767 if (type1 == long_unsigned_type_node)
768 return long_integer_type_node;
769 if (type1 == long_long_unsigned_type_node)
770 return long_long_integer_type_node;
771 if (type1 == unsigned_intDI_type_node)
772 return intDI_type_node;
773 if (type1 == unsigned_intSI_type_node)
774 return intSI_type_node;
775 if (type1 == unsigned_intHI_type_node)
776 return intHI_type_node;
777 if (type1 == unsigned_intQI_type_node)
778 return intQI_type_node;
779
780 return signed_or_unsigned_type (0, type);
781}
782
783/* Return a type the same as TYPE except unsigned or
784 signed according to UNSIGNEDP. */
785
786tree
787signed_or_unsigned_type (unsignedp, type)
788 int unsignedp;
789 tree type;
790{
791 if ((! INTEGRAL_TYPE_P (type) && ! POINTER_TYPE_P (type))
792 || TREE_UNSIGNED (type) == unsignedp)
793 return type;
794 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
795 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
796 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
797 return unsignedp ? unsigned_type_node : integer_type_node;
798 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
799 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
800 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
801 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
802 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
803 return (unsignedp ? long_long_unsigned_type_node
804 : long_long_integer_type_node);
805 return type;
806}
807
808/* Compute the value of the `sizeof' operator. */
809
810tree
811c_sizeof (type)
812 tree type;
813{
814 enum tree_code code = TREE_CODE (type);
815 tree t;
816
817 if (code == FUNCTION_TYPE)
818 {
819 if (pedantic || warn_pointer_arith)
820 pedwarn ("sizeof applied to a function type");
821 return size_int (1);
822 }
823 if (code == VOID_TYPE)
824 {
825 if (pedantic || warn_pointer_arith)
826 pedwarn ("sizeof applied to a void type");
827 return size_int (1);
828 }
829 if (code == ERROR_MARK)
830 return size_int (1);
831 if (TYPE_SIZE (type) == 0)
832 {
833 error ("sizeof applied to an incomplete type");
834 return size_int (0);
835 }
836
837 /* Convert in case a char is more than one unit. */
838 t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
839 size_int (TYPE_PRECISION (char_type_node)));
840 t = convert (sizetype, t);
841 /* size_binop does not put the constant in range, so do it now. */
842 if (TREE_CODE (t) == INTEGER_CST && force_fit_type (t, 0))
843 TREE_CONSTANT_OVERFLOW (t) = TREE_OVERFLOW (t) = 1;
844 return t;
845}
846
847tree
848c_sizeof_nowarn (type)
849 tree type;
850{
851 enum tree_code code = TREE_CODE (type);
852 tree t;
853
854 if (code == FUNCTION_TYPE
855 || code == VOID_TYPE
856 || code == ERROR_MARK)
857 return size_int (1);
858 if (TYPE_SIZE (type) == 0)
859 return size_int (0);
860
861 /* Convert in case a char is more than one unit. */
862 t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
863 size_int (TYPE_PRECISION (char_type_node)));
864 t = convert (sizetype, t);
865 force_fit_type (t, 0);
866 return t;
867}
868
869/* Compute the size to increment a pointer by. */
870
871tree
872c_size_in_bytes (type)
873 tree type;
874{
875 enum tree_code code = TREE_CODE (type);
876 tree t;
877
878 if (code == FUNCTION_TYPE)
879 return size_int (1);
880 if (code == VOID_TYPE)
881 return size_int (1);
882 if (code == ERROR_MARK)
883 return size_int (1);
884 if (TYPE_SIZE (type) == 0)
885 {
886 error ("arithmetic on pointer to an incomplete type");
887 return size_int (1);
888 }
889
890 /* Convert in case a char is more than one unit. */
891 t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
892 size_int (BITS_PER_UNIT));
893 t = convert (sizetype, t);
894 force_fit_type (t, 0);
895 return t;
896}
897
898/* Implement the __alignof keyword: Return the minimum required
899 alignment of TYPE, measured in bytes. */
900
901tree
902c_alignof (type)
903 tree type;
904{
905 enum tree_code code = TREE_CODE (type);
906
907 if (code == FUNCTION_TYPE)
908 return size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
909
910 if (code == VOID_TYPE || code == ERROR_MARK)
911 return size_int (1);
912
913 return size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
914}
915
916/* Implement the __alignof keyword: Return the minimum required
917 alignment of EXPR, measured in bytes. For VAR_DECL's and
918 FIELD_DECL's return DECL_ALIGN (which can be set from an
919 "aligned" __attribute__ specification). */
920
921tree
922c_alignof_expr (expr)
923 tree expr;
924{
925 if (TREE_CODE (expr) == VAR_DECL)
926 return size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
927
928 if (TREE_CODE (expr) == COMPONENT_REF
929 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
930 {
931 error ("`__alignof' applied to a bit-field");
932 return size_int (1);
933 }
934 else if (TREE_CODE (expr) == COMPONENT_REF
935 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
936 return size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
937
938 if (TREE_CODE (expr) == INDIRECT_REF)
939 {
940 tree t = TREE_OPERAND (expr, 0);
941 tree best = t;
942 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
943
944 while (TREE_CODE (t) == NOP_EXPR
945 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
946 {
947 int thisalign;
948
949 t = TREE_OPERAND (t, 0);
950 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
951 if (thisalign > bestalign)
952 best = t, bestalign = thisalign;
953 }
954 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
955 }
956 else
957 return c_alignof (TREE_TYPE (expr));
958}
959
960/* Return either DECL or its known constant value (if it has one). */
961
962static tree
963decl_constant_value (decl)
964 tree decl;
965{
966 if (/* Don't change a variable array bound or initial value to a constant
967 in a place where a variable is invalid. */
968 current_function_decl != 0
969 && ! pedantic
970 && ! TREE_THIS_VOLATILE (decl)
971 && TREE_READONLY (decl) && ! ITERATOR_P (decl)
972 && DECL_INITIAL (decl) != 0
973 && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
974 /* This is invalid if initial value is not constant.
975 If it has either a function call, a memory reference,
976 or a variable, then re-evaluating it could give different results. */
977 && TREE_CONSTANT (DECL_INITIAL (decl))
978 /* Check for cases where this is sub-optimal, even though valid. */
979 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR
980 && DECL_MODE (decl) != BLKmode)
981 return DECL_INITIAL (decl);
982 return decl;
983}
984
985/* Perform default promotions for C data used in expressions.
986 Arrays and functions are converted to pointers;
987 enumeral types or short or char, to int.
988 In addition, manifest constants symbols are replaced by their values. */
989
990tree
991default_conversion (exp)
992 tree exp;
993{
994 register tree type = TREE_TYPE (exp);
995 register enum tree_code code = TREE_CODE (type);
996
997 /* Constants can be used directly unless they're not loadable. */
998 if (TREE_CODE (exp) == CONST_DECL)
999 exp = DECL_INITIAL (exp);
1000
1001 /* Replace a nonvolatile const static variable with its value unless
1002 it is an array, in which case we must be sure that taking the
1003 address of the array produces consistent results. */
1004 else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
1005 {
1006 exp = decl_constant_value (exp);
1007 type = TREE_TYPE (exp);
1008 }
1009
1010 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1011 an lvalue. */
1012 /* Do not use STRIP_NOPS here! It will remove conversions from pointer
1013 to integer and cause infinite recursion. */
1014 while (TREE_CODE (exp) == NON_LVALUE_EXPR
1015 || (TREE_CODE (exp) == NOP_EXPR
1016 && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
1017 exp = TREE_OPERAND (exp, 0);
1018
1019 /* Normally convert enums to int,
1020 but convert wide enums to something wider. */
1021 if (code == ENUMERAL_TYPE)
1022 {
1023 type = type_for_size (MAX (TYPE_PRECISION (type),
1024 TYPE_PRECISION (integer_type_node)),
1025 ((flag_traditional
1026 || (TYPE_PRECISION (type)
1027 >= TYPE_PRECISION (integer_type_node)))
1028 && TREE_UNSIGNED (type)));
1029 return convert (type, exp);
1030 }
1031
1032 if (TREE_CODE (exp) == COMPONENT_REF
1033 && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1)))
1034 {
1035 tree width = DECL_SIZE (TREE_OPERAND (exp, 1));
1036 HOST_WIDE_INT low = TREE_INT_CST_LOW (width);
1037
1038 /* If it's thinner than an int, promote it like a
1039 C_PROMOTING_INTEGER_TYPE_P, otherwise leave it alone. */
1040
1041 if (low < TYPE_PRECISION (integer_type_node))
1042 {
1043 if (flag_traditional && TREE_UNSIGNED (type))
1044 return convert (unsigned_type_node, exp);
1045 else
1046 return convert (integer_type_node, exp);
1047 }
1048 }
1049
1050 if (C_PROMOTING_INTEGER_TYPE_P (type))
1051 {
1052 /* Traditionally, unsignedness is preserved in default promotions.
1053 Also preserve unsignedness if not really getting any wider. */
1054 if (TREE_UNSIGNED (type)
1055 && (flag_traditional
1056 || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
1057 return convert (unsigned_type_node, exp);
1058 return convert (integer_type_node, exp);
1059 }
1060 if (flag_traditional && !flag_allow_single_precision
1061 && TYPE_MAIN_VARIANT (type) == float_type_node)
1062 return convert (double_type_node, exp);
1063 if (code == VOID_TYPE)
1064 {
1065 error ("void value not ignored as it ought to be");
1066 return error_mark_node;
1067 }
1068 if (code == FUNCTION_TYPE)
1069 {
1070 return build_unary_op (ADDR_EXPR, exp, 0);
1071 }
1072 if (code == ARRAY_TYPE)
1073 {
1074 register tree adr;
1075 tree restype = TREE_TYPE (type);
1076 tree ptrtype;
1077 int constp = 0;
1078 int volatilep = 0;
1079
1080 if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'r'
1081 || TREE_CODE_CLASS (TREE_CODE (exp)) == 'd')
1082 {
1083 constp = TREE_READONLY (exp);
1084 volatilep = TREE_THIS_VOLATILE (exp);
1085 }
1086
|
1087 if (TYPE_READONLY (type) || TYPE_VOLATILE (type)
1088 || constp || volatilep)
1089 restype = c_build_type_variant (restype,
1090 TYPE_READONLY (type) || constp,
1091 TYPE_VOLATILE (type) || volatilep);
| 1087 if (TYPE_QUALS (type) || constp || volatilep)
1088 restype
1089 = c_build_qualified_type (restype,
1090 TYPE_QUALS (type)
1091 | (constp * TYPE_QUAL_CONST)
1092 | (volatilep * TYPE_QUAL_VOLATILE));
|
1092
1093 if (TREE_CODE (exp) == INDIRECT_REF)
1094 return convert (TYPE_POINTER_TO (restype),
1095 TREE_OPERAND (exp, 0));
1096
1097 if (TREE_CODE (exp) == COMPOUND_EXPR)
1098 {
1099 tree op1 = default_conversion (TREE_OPERAND (exp, 1));
1100 return build (COMPOUND_EXPR, TREE_TYPE (op1),
1101 TREE_OPERAND (exp, 0), op1);
1102 }
1103
1104 if (! lvalue_p (exp)
1105 && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1106 {
1107 error ("invalid use of non-lvalue array");
1108 return error_mark_node;
1109 }
1110
1111 ptrtype = build_pointer_type (restype);
1112
1113 if (TREE_CODE (exp) == VAR_DECL)
1114 {
1115 /* ??? This is not really quite correct
1116 in that the type of the operand of ADDR_EXPR
1117 is not the target type of the type of the ADDR_EXPR itself.
1118 Question is, can this lossage be avoided? */
1119 adr = build1 (ADDR_EXPR, ptrtype, exp);
1120 if (mark_addressable (exp) == 0)
1121 return error_mark_node;
1122 TREE_CONSTANT (adr) = staticp (exp);
1123 TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */
1124 return adr;
1125 }
1126 /* This way is better for a COMPONENT_REF since it can
1127 simplify the offset for a component. */
1128 adr = build_unary_op (ADDR_EXPR, exp, 1);
1129 return convert (ptrtype, adr);
1130 }
1131 return exp;
1132}
1133
1134/* Look up component name in the structure type definition.
1135
1136 If this component name is found indirectly within an anonymous union,
1137 store in *INDIRECT the component which directly contains
1138 that anonymous union. Otherwise, set *INDIRECT to 0. */
1139
1140static tree
1141lookup_field (type, component, indirect)
1142 tree type, component;
1143 tree *indirect;
1144{
1145 tree field;
1146
1147 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1148 to the field elements. Use a binary search on this array to quickly
1149 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
1150 will always be set for structures which have many elements. */
1151
1152 if (TYPE_LANG_SPECIFIC (type))
1153 {
1154 int bot, top, half;
1155 tree *field_array = &TYPE_LANG_SPECIFIC (type)->elts[0];
1156
1157 field = TYPE_FIELDS (type);
1158 bot = 0;
1159 top = TYPE_LANG_SPECIFIC (type)->len;
1160 while (top - bot > 1)
1161 {
1162 half = (top - bot + 1) >> 1;
1163 field = field_array[bot+half];
1164
1165 if (DECL_NAME (field) == NULL_TREE)
1166 {
1167 /* Step through all anon unions in linear fashion. */
1168 while (DECL_NAME (field_array[bot]) == NULL_TREE)
1169 {
1170 tree anon = 0, junk;
1171
1172 field = field_array[bot++];
1173 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1174 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1175 anon = lookup_field (TREE_TYPE (field), component, &junk);
1176
1177 if (anon != NULL_TREE)
1178 {
1179 *indirect = field;
1180 return anon;
1181 }
1182 }
1183
1184 /* Entire record is only anon unions. */
1185 if (bot > top)
1186 return NULL_TREE;
1187
1188 /* Restart the binary search, with new lower bound. */
1189 continue;
1190 }
1191
1192 if (DECL_NAME (field) == component)
1193 break;
1194 if (DECL_NAME (field) < component)
1195 bot += half;
1196 else
1197 top = bot + half;
1198 }
1199
1200 if (DECL_NAME (field_array[bot]) == component)
1201 field = field_array[bot];
1202 else if (DECL_NAME (field) != component)
1203 field = 0;
1204 }
1205 else
1206 {
1207 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1208 {
1209 if (DECL_NAME (field) == NULL_TREE)
1210 {
1211 tree junk;
1212 tree anon = 0;
1213
1214 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1215 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1216 anon = lookup_field (TREE_TYPE (field), component, &junk);
1217
1218 if (anon != NULL_TREE)
1219 {
1220 *indirect = field;
1221 return anon;
1222 }
1223 }
1224
1225 if (DECL_NAME (field) == component)
1226 break;
1227 }
1228 }
1229
1230 *indirect = NULL_TREE;
1231 return field;
1232}
1233
1234/* Make an expression to refer to the COMPONENT field of
1235 structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */
1236
1237tree
1238build_component_ref (datum, component)
1239 tree datum, component;
1240{
1241 register tree type = TREE_TYPE (datum);
1242 register enum tree_code code = TREE_CODE (type);
1243 register tree field = NULL;
1244 register tree ref;
1245
1246 /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference inside it
1247 unless we are not to support things not strictly ANSI. */
1248 switch (TREE_CODE (datum))
1249 {
1250 case COMPOUND_EXPR:
1251 {
1252 tree value = build_component_ref (TREE_OPERAND (datum, 1), component);
1253 return build (COMPOUND_EXPR, TREE_TYPE (value),
1254 TREE_OPERAND (datum, 0), value);
1255 }
1256 case COND_EXPR:
1257 return build_conditional_expr
1258 (TREE_OPERAND (datum, 0),
1259 build_component_ref (TREE_OPERAND (datum, 1), component),
1260 build_component_ref (TREE_OPERAND (datum, 2), component));
1261
1262 default:
1263 break;
1264 }
1265
1266 /* See if there is a field or component with name COMPONENT. */
1267
1268 if (code == RECORD_TYPE || code == UNION_TYPE)
1269 {
1270 tree indirect = 0;
1271
1272 if (TYPE_SIZE (type) == 0)
1273 {
1274 incomplete_type_error (NULL_TREE, type);
1275 return error_mark_node;
1276 }
1277
1278 field = lookup_field (type, component, &indirect);
1279
1280 if (!field)
1281 {
1282 error (code == RECORD_TYPE
1283 ? "structure has no member named `%s'"
1284 : "union has no member named `%s'",
1285 IDENTIFIER_POINTER (component));
1286 return error_mark_node;
1287 }
1288 if (TREE_TYPE (field) == error_mark_node)
1289 return error_mark_node;
1290
1291 /* If FIELD was found buried within an anonymous union,
1292 make one COMPONENT_REF to get that anonymous union,
1293 then fall thru to make a second COMPONENT_REF to get FIELD. */
1294 if (indirect != 0)
1295 {
1296 ref = build (COMPONENT_REF, TREE_TYPE (indirect), datum, indirect);
1297 if (TREE_READONLY (datum) || TREE_READONLY (indirect))
1298 TREE_READONLY (ref) = 1;
1299 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (indirect))
1300 TREE_THIS_VOLATILE (ref) = 1;
1301 datum = ref;
1302 }
1303
1304 ref = build (COMPONENT_REF, TREE_TYPE (field), datum, field);
1305
1306 if (TREE_READONLY (datum) || TREE_READONLY (field))
1307 TREE_READONLY (ref) = 1;
1308 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (field))
1309 TREE_THIS_VOLATILE (ref) = 1;
1310
1311 return ref;
1312 }
1313 else if (code != ERROR_MARK)
1314 error ("request for member `%s' in something not a structure or union",
1315 IDENTIFIER_POINTER (component));
1316
1317 return error_mark_node;
1318}
1319
1320/* Given an expression PTR for a pointer, return an expression
1321 for the value pointed to.
1322 ERRORSTRING is the name of the operator to appear in error messages. */
1323
1324tree
1325build_indirect_ref (ptr, errorstring)
1326 tree ptr;
| 1093
1094 if (TREE_CODE (exp) == INDIRECT_REF)
1095 return convert (TYPE_POINTER_TO (restype),
1096 TREE_OPERAND (exp, 0));
1097
1098 if (TREE_CODE (exp) == COMPOUND_EXPR)
1099 {
1100 tree op1 = default_conversion (TREE_OPERAND (exp, 1));
1101 return build (COMPOUND_EXPR, TREE_TYPE (op1),
1102 TREE_OPERAND (exp, 0), op1);
1103 }
1104
1105 if (! lvalue_p (exp)
1106 && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
1107 {
1108 error ("invalid use of non-lvalue array");
1109 return error_mark_node;
1110 }
1111
1112 ptrtype = build_pointer_type (restype);
1113
1114 if (TREE_CODE (exp) == VAR_DECL)
1115 {
1116 /* ??? This is not really quite correct
1117 in that the type of the operand of ADDR_EXPR
1118 is not the target type of the type of the ADDR_EXPR itself.
1119 Question is, can this lossage be avoided? */
1120 adr = build1 (ADDR_EXPR, ptrtype, exp);
1121 if (mark_addressable (exp) == 0)
1122 return error_mark_node;
1123 TREE_CONSTANT (adr) = staticp (exp);
1124 TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */
1125 return adr;
1126 }
1127 /* This way is better for a COMPONENT_REF since it can
1128 simplify the offset for a component. */
1129 adr = build_unary_op (ADDR_EXPR, exp, 1);
1130 return convert (ptrtype, adr);
1131 }
1132 return exp;
1133}
1134
1135/* Look up component name in the structure type definition.
1136
1137 If this component name is found indirectly within an anonymous union,
1138 store in *INDIRECT the component which directly contains
1139 that anonymous union. Otherwise, set *INDIRECT to 0. */
1140
1141static tree
1142lookup_field (type, component, indirect)
1143 tree type, component;
1144 tree *indirect;
1145{
1146 tree field;
1147
1148 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1149 to the field elements. Use a binary search on this array to quickly
1150 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
1151 will always be set for structures which have many elements. */
1152
1153 if (TYPE_LANG_SPECIFIC (type))
1154 {
1155 int bot, top, half;
1156 tree *field_array = &TYPE_LANG_SPECIFIC (type)->elts[0];
1157
1158 field = TYPE_FIELDS (type);
1159 bot = 0;
1160 top = TYPE_LANG_SPECIFIC (type)->len;
1161 while (top - bot > 1)
1162 {
1163 half = (top - bot + 1) >> 1;
1164 field = field_array[bot+half];
1165
1166 if (DECL_NAME (field) == NULL_TREE)
1167 {
1168 /* Step through all anon unions in linear fashion. */
1169 while (DECL_NAME (field_array[bot]) == NULL_TREE)
1170 {
1171 tree anon = 0, junk;
1172
1173 field = field_array[bot++];
1174 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1175 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1176 anon = lookup_field (TREE_TYPE (field), component, &junk);
1177
1178 if (anon != NULL_TREE)
1179 {
1180 *indirect = field;
1181 return anon;
1182 }
1183 }
1184
1185 /* Entire record is only anon unions. */
1186 if (bot > top)
1187 return NULL_TREE;
1188
1189 /* Restart the binary search, with new lower bound. */
1190 continue;
1191 }
1192
1193 if (DECL_NAME (field) == component)
1194 break;
1195 if (DECL_NAME (field) < component)
1196 bot += half;
1197 else
1198 top = bot + half;
1199 }
1200
1201 if (DECL_NAME (field_array[bot]) == component)
1202 field = field_array[bot];
1203 else if (DECL_NAME (field) != component)
1204 field = 0;
1205 }
1206 else
1207 {
1208 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1209 {
1210 if (DECL_NAME (field) == NULL_TREE)
1211 {
1212 tree junk;
1213 tree anon = 0;
1214
1215 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1216 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1217 anon = lookup_field (TREE_TYPE (field), component, &junk);
1218
1219 if (anon != NULL_TREE)
1220 {
1221 *indirect = field;
1222 return anon;
1223 }
1224 }
1225
1226 if (DECL_NAME (field) == component)
1227 break;
1228 }
1229 }
1230
1231 *indirect = NULL_TREE;
1232 return field;
1233}
1234
1235/* Make an expression to refer to the COMPONENT field of
1236 structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */
1237
1238tree
1239build_component_ref (datum, component)
1240 tree datum, component;
1241{
1242 register tree type = TREE_TYPE (datum);
1243 register enum tree_code code = TREE_CODE (type);
1244 register tree field = NULL;
1245 register tree ref;
1246
1247 /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference inside it
1248 unless we are not to support things not strictly ANSI. */
1249 switch (TREE_CODE (datum))
1250 {
1251 case COMPOUND_EXPR:
1252 {
1253 tree value = build_component_ref (TREE_OPERAND (datum, 1), component);
1254 return build (COMPOUND_EXPR, TREE_TYPE (value),
1255 TREE_OPERAND (datum, 0), value);
1256 }
1257 case COND_EXPR:
1258 return build_conditional_expr
1259 (TREE_OPERAND (datum, 0),
1260 build_component_ref (TREE_OPERAND (datum, 1), component),
1261 build_component_ref (TREE_OPERAND (datum, 2), component));
1262
1263 default:
1264 break;
1265 }
1266
1267 /* See if there is a field or component with name COMPONENT. */
1268
1269 if (code == RECORD_TYPE || code == UNION_TYPE)
1270 {
1271 tree indirect = 0;
1272
1273 if (TYPE_SIZE (type) == 0)
1274 {
1275 incomplete_type_error (NULL_TREE, type);
1276 return error_mark_node;
1277 }
1278
1279 field = lookup_field (type, component, &indirect);
1280
1281 if (!field)
1282 {
1283 error (code == RECORD_TYPE
1284 ? "structure has no member named `%s'"
1285 : "union has no member named `%s'",
1286 IDENTIFIER_POINTER (component));
1287 return error_mark_node;
1288 }
1289 if (TREE_TYPE (field) == error_mark_node)
1290 return error_mark_node;
1291
1292 /* If FIELD was found buried within an anonymous union,
1293 make one COMPONENT_REF to get that anonymous union,
1294 then fall thru to make a second COMPONENT_REF to get FIELD. */
1295 if (indirect != 0)
1296 {
1297 ref = build (COMPONENT_REF, TREE_TYPE (indirect), datum, indirect);
1298 if (TREE_READONLY (datum) || TREE_READONLY (indirect))
1299 TREE_READONLY (ref) = 1;
1300 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (indirect))
1301 TREE_THIS_VOLATILE (ref) = 1;
1302 datum = ref;
1303 }
1304
1305 ref = build (COMPONENT_REF, TREE_TYPE (field), datum, field);
1306
1307 if (TREE_READONLY (datum) || TREE_READONLY (field))
1308 TREE_READONLY (ref) = 1;
1309 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (field))
1310 TREE_THIS_VOLATILE (ref) = 1;
1311
1312 return ref;
1313 }
1314 else if (code != ERROR_MARK)
1315 error ("request for member `%s' in something not a structure or union",
1316 IDENTIFIER_POINTER (component));
1317
1318 return error_mark_node;
1319}
1320
1321/* Given an expression PTR for a pointer, return an expression
1322 for the value pointed to.
1323 ERRORSTRING is the name of the operator to appear in error messages. */
1324
1325tree
1326build_indirect_ref (ptr, errorstring)
1327 tree ptr;
|
1327 char *errorstring;
| 1328 const char *errorstring;
|
1328{
1329 register tree pointer = default_conversion (ptr);
1330 register tree type = TREE_TYPE (pointer);
1331
1332 if (TREE_CODE (type) == POINTER_TYPE)
1333 {
1334 if (TREE_CODE (pointer) == ADDR_EXPR
1335 && !flag_volatile
1336 && (TREE_TYPE (TREE_OPERAND (pointer, 0))
1337 == TREE_TYPE (type)))
1338 return TREE_OPERAND (pointer, 0);
1339 else
1340 {
1341 tree t = TREE_TYPE (type);
1342 register tree ref = build1 (INDIRECT_REF,
1343 TYPE_MAIN_VARIANT (t), pointer);
1344
1345 if (TYPE_SIZE (t) == 0 && TREE_CODE (t) != ARRAY_TYPE)
1346 {
1347 error ("dereferencing pointer to incomplete type");
1348 return error_mark_node;
1349 }
1350 if (TREE_CODE (t) == VOID_TYPE && skip_evaluation == 0)
1351 warning ("dereferencing `void *' pointer");
1352
1353 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1354 so that we get the proper error message if the result is used
1355 to assign to. Also, &* is supposed to be a no-op.
1356 And ANSI C seems to specify that the type of the result
1357 should be the const type. */
1358 /* A de-reference of a pointer to const is not a const. It is valid
1359 to change it via some other pointer. */
1360 TREE_READONLY (ref) = TYPE_READONLY (t);
1361 TREE_SIDE_EFFECTS (ref)
1362 = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer) || flag_volatile;
1363 TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
1364 return ref;
1365 }
1366 }
1367 else if (TREE_CODE (pointer) != ERROR_MARK)
1368 error ("invalid type argument of `%s'", errorstring);
1369 return error_mark_node;
1370}
1371
1372/* This handles expressions of the form "a[i]", which denotes
1373 an array reference.
1374
1375 This is logically equivalent in C to *(a+i), but we may do it differently.
1376 If A is a variable or a member, we generate a primitive ARRAY_REF.
1377 This avoids forcing the array out of registers, and can work on
1378 arrays that are not lvalues (for example, members of structures returned
1379 by functions). */
1380
1381tree
1382build_array_ref (array, index)
1383 tree array, index;
1384{
1385 if (index == 0)
1386 {
1387 error ("subscript missing in array reference");
1388 return error_mark_node;
1389 }
1390
1391 if (TREE_TYPE (array) == error_mark_node
1392 || TREE_TYPE (index) == error_mark_node)
1393 return error_mark_node;
1394
1395 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
1396 && TREE_CODE (array) != INDIRECT_REF)
1397 {
1398 tree rval, type;
1399
1400 /* Subscripting with type char is likely to lose
1401 on a machine where chars are signed.
1402 So warn on any machine, but optionally.
1403 Don't warn for unsigned char since that type is safe.
1404 Don't warn for signed char because anyone who uses that
1405 must have done so deliberately. */
1406 if (warn_char_subscripts
1407 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1408 warning ("array subscript has type `char'");
1409
1410 /* Apply default promotions *after* noticing character types. */
1411 index = default_conversion (index);
1412
1413 /* Require integer *after* promotion, for sake of enums. */
1414 if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE)
1415 {
1416 error ("array subscript is not an integer");
1417 return error_mark_node;
1418 }
1419
1420 /* An array that is indexed by a non-constant
1421 cannot be stored in a register; we must be able to do
1422 address arithmetic on its address.
1423 Likewise an array of elements of variable size. */
1424 if (TREE_CODE (index) != INTEGER_CST
1425 || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))) != 0
1426 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
1427 {
1428 if (mark_addressable (array) == 0)
1429 return error_mark_node;
1430 }
1431 /* An array that is indexed by a constant value which is not within
1432 the array bounds cannot be stored in a register either; because we
1433 would get a crash in store_bit_field/extract_bit_field when trying
1434 to access a non-existent part of the register. */
1435 if (TREE_CODE (index) == INTEGER_CST
1436 && TYPE_VALUES (TREE_TYPE (array))
1437 && ! int_fits_type_p (index, TYPE_VALUES (TREE_TYPE (array))))
1438 {
1439 if (mark_addressable (array) == 0)
1440 return error_mark_node;
1441 }
1442
1443 if (pedantic && !lvalue_p (array))
1444 {
1445 if (DECL_REGISTER (array))
1446 pedwarn ("ANSI C forbids subscripting `register' array");
1447 else
1448 pedwarn ("ANSI C forbids subscripting non-lvalue array");
1449 }
1450
1451 if (pedantic)
1452 {
1453 tree foo = array;
1454 while (TREE_CODE (foo) == COMPONENT_REF)
1455 foo = TREE_OPERAND (foo, 0);
1456 if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
1457 pedwarn ("ANSI C forbids subscripting non-lvalue array");
1458 }
1459
1460 type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
1461 rval = build (ARRAY_REF, type, array, index);
1462 /* Array ref is const/volatile if the array elements are
1463 or if the array is. */
1464 TREE_READONLY (rval)
1465 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
1466 | TREE_READONLY (array));
1467 TREE_SIDE_EFFECTS (rval)
1468 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1469 | TREE_SIDE_EFFECTS (array));
1470 TREE_THIS_VOLATILE (rval)
1471 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1472 /* This was added by rms on 16 Nov 91.
1473 It fixes vol struct foo *a; a->elts[1]
1474 in an inline function.
1475 Hope it doesn't break something else. */
1476 | TREE_THIS_VOLATILE (array));
1477 return require_complete_type (fold (rval));
1478 }
1479
1480 {
1481 tree ar = default_conversion (array);
1482 tree ind = default_conversion (index);
1483
1484 /* Do the same warning check as above, but only on the part that's
1485 syntactically the index and only if it is also semantically
1486 the index. */
1487 if (warn_char_subscripts
1488 && TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE
1489 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1490 warning ("subscript has type `char'");
1491
1492 /* Put the integer in IND to simplify error checking. */
1493 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
1494 {
1495 tree temp = ar;
1496 ar = ind;
1497 ind = temp;
1498 }
1499
1500 if (ar == error_mark_node)
1501 return ar;
1502
1503 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE
1504 || TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) == FUNCTION_TYPE)
1505 {
1506 error ("subscripted value is neither array nor pointer");
1507 return error_mark_node;
1508 }
1509 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
1510 {
1511 error ("array subscript is not an integer");
1512 return error_mark_node;
1513 }
1514
1515 return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind, 0),
1516 "array indexing");
1517 }
1518}
1519
1520/* Build a function call to function FUNCTION with parameters PARAMS.
1521 PARAMS is a list--a chain of TREE_LIST nodes--in which the
1522 TREE_VALUE of each node is a parameter-expression.
1523 FUNCTION's data type may be a function type or a pointer-to-function. */
1524
1525tree
1526build_function_call (function, params)
1527 tree function, params;
1528{
1529 register tree fntype, fundecl = 0;
1530 register tree coerced_params;
1531 tree name = NULL_TREE, assembler_name = NULL_TREE;
1532
1533 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1534 STRIP_TYPE_NOPS (function);
1535
1536 /* Convert anything with function type to a pointer-to-function. */
1537 if (TREE_CODE (function) == FUNCTION_DECL)
1538 {
1539 name = DECL_NAME (function);
1540 assembler_name = DECL_ASSEMBLER_NAME (function);
1541
1542 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1543 (because calling an inline function does not mean the function
1544 needs to be separately compiled). */
1545 fntype = build_type_variant (TREE_TYPE (function),
1546 TREE_READONLY (function),
1547 TREE_THIS_VOLATILE (function));
1548 fundecl = function;
1549 function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
1550 }
1551 else
1552 function = default_conversion (function);
1553
1554 fntype = TREE_TYPE (function);
1555
1556 if (TREE_CODE (fntype) == ERROR_MARK)
1557 return error_mark_node;
1558
1559 if (!(TREE_CODE (fntype) == POINTER_TYPE
1560 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
1561 {
1562 error ("called object is not a function");
1563 return error_mark_node;
1564 }
1565
1566 /* fntype now gets the type of function pointed to. */
1567 fntype = TREE_TYPE (fntype);
1568
1569 /* Convert the parameters to the types declared in the
1570 function prototype, or apply default promotions. */
1571
1572 coerced_params
1573 = convert_arguments (TYPE_ARG_TYPES (fntype), params, name, fundecl);
1574
1575 /* Check for errors in format strings. */
1576
1577 if (warn_format && (name || assembler_name))
1578 check_function_format (name, assembler_name, coerced_params);
1579
1580 /* Recognize certain built-in functions so we can make tree-codes
1581 other than CALL_EXPR. We do this when it enables fold-const.c
1582 to do something useful. */
1583
1584 if (TREE_CODE (function) == ADDR_EXPR
1585 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
1586 && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
1587 switch (DECL_FUNCTION_CODE (TREE_OPERAND (function, 0)))
1588 {
1589 case BUILT_IN_ABS:
1590 case BUILT_IN_LABS:
1591 case BUILT_IN_FABS:
1592 if (coerced_params == 0)
1593 return integer_zero_node;
1594 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
1595 default:
1596 break;
1597 }
1598
1599 {
1600 register tree result
1601 = build (CALL_EXPR, TREE_TYPE (fntype),
1602 function, coerced_params, NULL_TREE);
1603
1604 TREE_SIDE_EFFECTS (result) = 1;
1605 if (TREE_TYPE (result) == void_type_node)
1606 return result;
1607 return require_complete_type (result);
1608 }
1609}
1610
1611/* Convert the argument expressions in the list VALUES
1612 to the types in the list TYPELIST. The result is a list of converted
1613 argument expressions.
1614
1615 If TYPELIST is exhausted, or when an element has NULL as its type,
1616 perform the default conversions.
1617
1618 PARMLIST is the chain of parm decls for the function being called.
1619 It may be 0, if that info is not available.
1620 It is used only for generating error messages.
1621
1622 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
1623
1624 This is also where warnings about wrong number of args are generated.
1625
1626 Both VALUES and the returned value are chains of TREE_LIST nodes
1627 with the elements of the list in the TREE_VALUE slots of those nodes. */
1628
1629static tree
1630convert_arguments (typelist, values, name, fundecl)
1631 tree typelist, values, name, fundecl;
1632{
1633 register tree typetail, valtail;
1634 register tree result = NULL;
1635 int parmnum;
1636
1637 /* Scan the given expressions and types, producing individual
1638 converted arguments and pushing them on RESULT in reverse order. */
1639
1640 for (valtail = values, typetail = typelist, parmnum = 0;
1641 valtail;
1642 valtail = TREE_CHAIN (valtail), parmnum++)
1643 {
1644 register tree type = typetail ? TREE_VALUE (typetail) : 0;
1645 register tree val = TREE_VALUE (valtail);
1646
1647 if (type == void_type_node)
1648 {
1649 if (name)
1650 error ("too many arguments to function `%s'",
1651 IDENTIFIER_POINTER (name));
1652 else
1653 error ("too many arguments to function");
1654 break;
1655 }
1656
1657 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1658 /* Do not use STRIP_NOPS here! We do not want an enumerator with value 0
1659 to convert automatically to a pointer. */
1660 if (TREE_CODE (val) == NON_LVALUE_EXPR)
1661 val = TREE_OPERAND (val, 0);
1662
1663 if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
1664 || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE)
1665 val = default_conversion (val);
1666
1667 val = require_complete_type (val);
1668
1669 if (type != 0)
1670 {
1671 /* Formal parm type is specified by a function prototype. */
1672 tree parmval;
1673
1674 if (TYPE_SIZE (type) == 0)
1675 {
1676 error ("type of formal parameter %d is incomplete", parmnum + 1);
1677 parmval = val;
1678 }
1679 else
1680 {
1681 /* Optionally warn about conversions that
1682 differ from the default conversions. */
1683 if (warn_conversion)
1684 {
1685 int formal_prec = TYPE_PRECISION (type);
1686
1687 if (INTEGRAL_TYPE_P (type)
1688 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1689 warn_for_assignment ("%s as integer rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1690 else if (TREE_CODE (type) == COMPLEX_TYPE
1691 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1692 warn_for_assignment ("%s as complex rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1693 else if (TREE_CODE (type) == REAL_TYPE
1694 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1695 warn_for_assignment ("%s as floating rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1696 else if (TREE_CODE (type) == REAL_TYPE
1697 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1698 warn_for_assignment ("%s as floating rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1699 /* ??? At some point, messages should be written about
1700 conversions between complex types, but that's too messy
1701 to do now. */
1702 else if (TREE_CODE (type) == REAL_TYPE
1703 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1704 {
1705 /* Warn if any argument is passed as `float',
1706 since without a prototype it would be `double'. */
1707 if (formal_prec == TYPE_PRECISION (float_type_node))
1708 warn_for_assignment ("%s as `float' rather than `double' due to prototype", (char *) 0, name, parmnum + 1);
1709 }
1710 /* Detect integer changing in width or signedness. */
1711 else if (INTEGRAL_TYPE_P (type)
1712 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1713 {
1714 tree would_have_been = default_conversion (val);
1715 tree type1 = TREE_TYPE (would_have_been);
1716
1717 if (TREE_CODE (type) == ENUMERAL_TYPE
1718 && type == TREE_TYPE (val))
1719 /* No warning if function asks for enum
1720 and the actual arg is that enum type. */
1721 ;
1722 else if (formal_prec != TYPE_PRECISION (type1))
1723 warn_for_assignment ("%s with different width due to prototype", (char *) 0, name, parmnum + 1);
1724 else if (TREE_UNSIGNED (type) == TREE_UNSIGNED (type1))
1725 ;
1726 /* Don't complain if the formal parameter type
1727 is an enum, because we can't tell now whether
1728 the value was an enum--even the same enum. */
1729 else if (TREE_CODE (type) == ENUMERAL_TYPE)
1730 ;
1731 else if (TREE_CODE (val) == INTEGER_CST
1732 && int_fits_type_p (val, type))
1733 /* Change in signedness doesn't matter
1734 if a constant value is unaffected. */
1735 ;
1736 /* Likewise for a constant in a NOP_EXPR. */
1737 else if (TREE_CODE (val) == NOP_EXPR
1738 && TREE_CODE (TREE_OPERAND (val, 0)) == INTEGER_CST
1739 && int_fits_type_p (TREE_OPERAND (val, 0), type))
1740 ;
1741#if 0 /* We never get such tree structure here. */
1742 else if (TREE_CODE (TREE_TYPE (val)) == ENUMERAL_TYPE
1743 && int_fits_type_p (TYPE_MIN_VALUE (TREE_TYPE (val)), type)
1744 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (val)), type))
1745 /* Change in signedness doesn't matter
1746 if an enum value is unaffected. */
1747 ;
1748#endif
1749 /* If the value is extended from a narrower
1750 unsigned type, it doesn't matter whether we
1751 pass it as signed or unsigned; the value
1752 certainly is the same either way. */
1753 else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
1754 && TREE_UNSIGNED (TREE_TYPE (val)))
1755 ;
1756 else if (TREE_UNSIGNED (type))
1757 warn_for_assignment ("%s as unsigned due to prototype", (char *) 0, name, parmnum + 1);
1758 else
1759 warn_for_assignment ("%s as signed due to prototype", (char *) 0, name, parmnum + 1);
1760 }
1761 }
1762
1763 parmval = convert_for_assignment (type, val,
1764 (char *) 0, /* arg passing */
1765 fundecl, name, parmnum + 1);
1766
1767#ifdef PROMOTE_PROTOTYPES
1768 if ((TREE_CODE (type) == INTEGER_TYPE
1769 || TREE_CODE (type) == ENUMERAL_TYPE)
1770 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
1771 parmval = default_conversion (parmval);
1772#endif
1773 }
1774 result = tree_cons (NULL_TREE, parmval, result);
1775 }
1776 else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
1777 && (TYPE_PRECISION (TREE_TYPE (val))
1778 < TYPE_PRECISION (double_type_node)))
1779 /* Convert `float' to `double'. */
1780 result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
1781 else
1782 /* Convert `short' and `char' to full-size `int'. */
1783 result = tree_cons (NULL_TREE, default_conversion (val), result);
1784
1785 if (typetail)
1786 typetail = TREE_CHAIN (typetail);
1787 }
1788
1789 if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
1790 {
1791 if (name)
1792 error ("too few arguments to function `%s'",
1793 IDENTIFIER_POINTER (name));
1794 else
1795 error ("too few arguments to function");
1796 }
1797
1798 return nreverse (result);
1799}
1800
1801/* This is the entry point used by the parser
1802 for binary operators in the input.
1803 In addition to constructing the expression,
1804 we check for operands that were written with other binary operators
1805 in a way that is likely to confuse the user. */
1806
1807tree
1808parser_build_binary_op (code, arg1, arg2)
1809 enum tree_code code;
1810 tree arg1, arg2;
1811{
1812 tree result = build_binary_op (code, arg1, arg2, 1);
1813
1814 char class;
1815 char class1 = TREE_CODE_CLASS (TREE_CODE (arg1));
1816 char class2 = TREE_CODE_CLASS (TREE_CODE (arg2));
1817 enum tree_code code1 = ERROR_MARK;
1818 enum tree_code code2 = ERROR_MARK;
1819
1820 if (class1 == 'e' || class1 == '1'
1821 || class1 == '2' || class1 == '<')
1822 code1 = C_EXP_ORIGINAL_CODE (arg1);
1823 if (class2 == 'e' || class2 == '1'
1824 || class2 == '2' || class2 == '<')
1825 code2 = C_EXP_ORIGINAL_CODE (arg2);
1826
1827 /* Check for cases such as x+y<<z which users are likely
1828 to misinterpret. If parens are used, C_EXP_ORIGINAL_CODE
1829 is cleared to prevent these warnings. */
1830 if (warn_parentheses)
1831 {
1832 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
1833 {
1834 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1835 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1836 warning ("suggest parentheses around + or - inside shift");
1837 }
1838
1839 if (code == TRUTH_ORIF_EXPR)
1840 {
1841 if (code1 == TRUTH_ANDIF_EXPR
1842 || code2 == TRUTH_ANDIF_EXPR)
1843 warning ("suggest parentheses around && within ||");
1844 }
1845
1846 if (code == BIT_IOR_EXPR)
1847 {
1848 if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
1849 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1850 || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
1851 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1852 warning ("suggest parentheses around arithmetic in operand of |");
1853 /* Check cases like x|y==z */
1854 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1855 warning ("suggest parentheses around comparison in operand of |");
1856 }
1857
1858 if (code == BIT_XOR_EXPR)
1859 {
1860 if (code1 == BIT_AND_EXPR
1861 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1862 || code2 == BIT_AND_EXPR
1863 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1864 warning ("suggest parentheses around arithmetic in operand of ^");
1865 /* Check cases like x^y==z */
1866 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1867 warning ("suggest parentheses around comparison in operand of ^");
1868 }
1869
1870 if (code == BIT_AND_EXPR)
1871 {
1872 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1873 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1874 warning ("suggest parentheses around + or - in operand of &");
1875 /* Check cases like x&y==z */
1876 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1877 warning ("suggest parentheses around comparison in operand of &");
1878 }
1879 }
1880
1881 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */
1882 if (TREE_CODE_CLASS (code) == '<' && extra_warnings
1883 && (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<'))
1884 warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
1885
1886 unsigned_conversion_warning (result, arg1);
1887 unsigned_conversion_warning (result, arg2);
1888 overflow_warning (result);
1889
1890 class = TREE_CODE_CLASS (TREE_CODE (result));
1891
1892 /* Record the code that was specified in the source,
1893 for the sake of warnings about confusing nesting. */
1894 if (class == 'e' || class == '1'
1895 || class == '2' || class == '<')
1896 C_SET_EXP_ORIGINAL_CODE (result, code);
1897 else
1898 {
1899 int flag = TREE_CONSTANT (result);
1900 /* We used to use NOP_EXPR rather than NON_LVALUE_EXPR
1901 so that convert_for_assignment wouldn't strip it.
1902 That way, we got warnings for things like p = (1 - 1).
1903 But it turns out we should not get those warnings. */
1904 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
1905 C_SET_EXP_ORIGINAL_CODE (result, code);
1906 TREE_CONSTANT (result) = flag;
1907 }
1908
1909 return result;
1910}
1911
1912/* Build a binary-operation expression without default conversions.
1913 CODE is the kind of expression to build.
1914 This function differs from `build' in several ways:
1915 the data type of the result is computed and recorded in it,
1916 warnings are generated if arg data types are invalid,
1917 special handling for addition and subtraction of pointers is known,
1918 and some optimization is done (operations on narrow ints
1919 are done in the narrower type when that gives the same result).
1920 Constant folding is also done before the result is returned.
1921
1922 Note that the operands will never have enumeral types, or function
1923 or array types, because either they will have the default conversions
1924 performed or they have both just been converted to some other type in which
1925 the arithmetic is to be done. */
1926
1927tree
1928build_binary_op (code, orig_op0, orig_op1, convert_p)
1929 enum tree_code code;
1930 tree orig_op0, orig_op1;
1931 int convert_p;
1932{
1933 tree type0, type1;
1934 register enum tree_code code0, code1;
1935 tree op0, op1;
1936
1937 /* Expression code to give to the expression when it is built.
1938 Normally this is CODE, which is what the caller asked for,
1939 but in some special cases we change it. */
1940 register enum tree_code resultcode = code;
1941
1942 /* Data type in which the computation is to be performed.
1943 In the simplest cases this is the common type of the arguments. */
1944 register tree result_type = NULL;
1945
1946 /* Nonzero means operands have already been type-converted
1947 in whatever way is necessary.
1948 Zero means they need to be converted to RESULT_TYPE. */
1949 int converted = 0;
1950
1951 /* Nonzero means create the expression with this type, rather than
1952 RESULT_TYPE. */
1953 tree build_type = 0;
1954
1955 /* Nonzero means after finally constructing the expression
1956 convert it to this type. */
1957 tree final_type = 0;
1958
1959 /* Nonzero if this is an operation like MIN or MAX which can
1960 safely be computed in short if both args are promoted shorts.
1961 Also implies COMMON.
1962 -1 indicates a bitwise operation; this makes a difference
1963 in the exact conditions for when it is safe to do the operation
1964 in a narrower mode. */
1965 int shorten = 0;
1966
1967 /* Nonzero if this is a comparison operation;
1968 if both args are promoted shorts, compare the original shorts.
1969 Also implies COMMON. */
1970 int short_compare = 0;
1971
1972 /* Nonzero if this is a right-shift operation, which can be computed on the
1973 original short and then promoted if the operand is a promoted short. */
1974 int short_shift = 0;
1975
1976 /* Nonzero means set RESULT_TYPE to the common type of the args. */
1977 int common = 0;
1978
1979 if (convert_p)
1980 {
1981 op0 = default_conversion (orig_op0);
1982 op1 = default_conversion (orig_op1);
1983 }
1984 else
1985 {
1986 op0 = orig_op0;
1987 op1 = orig_op1;
1988 }
1989
1990 type0 = TREE_TYPE (op0);
1991 type1 = TREE_TYPE (op1);
1992
1993 /* The expression codes of the data types of the arguments tell us
1994 whether the arguments are integers, floating, pointers, etc. */
1995 code0 = TREE_CODE (type0);
1996 code1 = TREE_CODE (type1);
1997
1998 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1999 STRIP_TYPE_NOPS (op0);
2000 STRIP_TYPE_NOPS (op1);
2001
2002 /* If an error was already reported for one of the arguments,
2003 avoid reporting another error. */
2004
2005 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
2006 return error_mark_node;
2007
2008 switch (code)
2009 {
2010 case PLUS_EXPR:
2011 /* Handle the pointer + int case. */
2012 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2013 return pointer_int_sum (PLUS_EXPR, op0, op1);
2014 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
2015 return pointer_int_sum (PLUS_EXPR, op1, op0);
2016 else
2017 common = 1;
2018 break;
2019
2020 case MINUS_EXPR:
2021 /* Subtraction of two similar pointers.
2022 We must subtract them as integers, then divide by object size. */
2023 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
2024 && comp_target_types (type0, type1))
2025 return pointer_diff (op0, op1);
2026 /* Handle pointer minus int. Just like pointer plus int. */
2027 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2028 return pointer_int_sum (MINUS_EXPR, op0, op1);
2029 else
2030 common = 1;
2031 break;
2032
2033 case MULT_EXPR:
2034 common = 1;
2035 break;
2036
2037 case TRUNC_DIV_EXPR:
2038 case CEIL_DIV_EXPR:
2039 case FLOOR_DIV_EXPR:
2040 case ROUND_DIV_EXPR:
2041 case EXACT_DIV_EXPR:
2042 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2043 || code0 == COMPLEX_TYPE)
2044 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2045 || code1 == COMPLEX_TYPE))
2046 {
2047 if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
2048 resultcode = RDIV_EXPR;
2049 else
2050 {
2051 /* Although it would be tempting to shorten always here, that
2052 loses on some targets, since the modulo instruction is
2053 undefined if the quotient can't be represented in the
2054 computation mode. We shorten only if unsigned or if
2055 dividing by something we know != -1. */
2056 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2057 || (TREE_CODE (op1) == INTEGER_CST
2058 && (TREE_INT_CST_LOW (op1) != -1
2059 || TREE_INT_CST_HIGH (op1) != -1)));
2060 }
2061 common = 1;
2062 }
2063 break;
2064
2065 case BIT_AND_EXPR:
2066 case BIT_ANDTC_EXPR:
2067 case BIT_IOR_EXPR:
2068 case BIT_XOR_EXPR:
2069 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2070 shorten = -1;
2071 /* If one operand is a constant, and the other is a short type
2072 that has been converted to an int,
2073 really do the work in the short type and then convert the
2074 result to int. If we are lucky, the constant will be 0 or 1
2075 in the short type, making the entire operation go away. */
2076 if (TREE_CODE (op0) == INTEGER_CST
2077 && TREE_CODE (op1) == NOP_EXPR
2078 && TYPE_PRECISION (type1) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))
2079 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1, 0))))
2080 {
2081 final_type = result_type;
2082 op1 = TREE_OPERAND (op1, 0);
2083 result_type = TREE_TYPE (op1);
2084 }
2085 if (TREE_CODE (op1) == INTEGER_CST
2086 && TREE_CODE (op0) == NOP_EXPR
2087 && TYPE_PRECISION (type0) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))
2088 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2089 {
2090 final_type = result_type;
2091 op0 = TREE_OPERAND (op0, 0);
2092 result_type = TREE_TYPE (op0);
2093 }
2094 break;
2095
2096 case TRUNC_MOD_EXPR:
2097 case FLOOR_MOD_EXPR:
2098 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2099 {
2100 /* Although it would be tempting to shorten always here, that loses
2101 on some targets, since the modulo instruction is undefined if the
2102 quotient can't be represented in the computation mode. We shorten
2103 only if unsigned or if dividing by something we know != -1. */
2104 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2105 || (TREE_CODE (op1) == INTEGER_CST
2106 && (TREE_INT_CST_LOW (op1) != -1
2107 || TREE_INT_CST_HIGH (op1) != -1)));
2108 common = 1;
2109 }
2110 break;
2111
2112 case TRUTH_ANDIF_EXPR:
2113 case TRUTH_ORIF_EXPR:
2114 case TRUTH_AND_EXPR:
2115 case TRUTH_OR_EXPR:
2116 case TRUTH_XOR_EXPR:
2117 if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
2118 || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2119 && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
2120 || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2121 {
2122 /* Result of these operations is always an int,
2123 but that does not mean the operands should be
2124 converted to ints! */
2125 result_type = integer_type_node;
2126 op0 = truthvalue_conversion (op0);
2127 op1 = truthvalue_conversion (op1);
2128 converted = 1;
2129 }
2130 break;
2131
2132 /* Shift operations: result has same type as first operand;
2133 always convert second operand to int.
2134 Also set SHORT_SHIFT if shifting rightward. */
2135
2136 case RSHIFT_EXPR:
2137 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2138 {
2139 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2140 {
2141 if (tree_int_cst_sgn (op1) < 0)
2142 warning ("right shift count is negative");
2143 else
2144 {
2145 if (TREE_INT_CST_LOW (op1) | TREE_INT_CST_HIGH (op1))
2146 short_shift = 1;
2147 if (TREE_INT_CST_HIGH (op1) != 0
2148 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
2149 >= TYPE_PRECISION (type0)))
2150 warning ("right shift count >= width of type");
2151 }
2152 }
2153 /* Use the type of the value to be shifted.
2154 This is what most traditional C compilers do. */
2155 result_type = type0;
2156 /* Unless traditional, convert the shift-count to an integer,
2157 regardless of size of value being shifted. */
2158 if (! flag_traditional)
2159 {
2160 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2161 op1 = convert (integer_type_node, op1);
2162 /* Avoid converting op1 to result_type later. */
2163 converted = 1;
2164 }
2165 }
2166 break;
2167
2168 case LSHIFT_EXPR:
2169 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2170 {
2171 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2172 {
2173 if (tree_int_cst_sgn (op1) < 0)
2174 warning ("left shift count is negative");
2175 else if (TREE_INT_CST_HIGH (op1) != 0
2176 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
2177 >= TYPE_PRECISION (type0)))
2178 warning ("left shift count >= width of type");
2179 }
2180 /* Use the type of the value to be shifted.
2181 This is what most traditional C compilers do. */
2182 result_type = type0;
2183 /* Unless traditional, convert the shift-count to an integer,
2184 regardless of size of value being shifted. */
2185 if (! flag_traditional)
2186 {
2187 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2188 op1 = convert (integer_type_node, op1);
2189 /* Avoid converting op1 to result_type later. */
2190 converted = 1;
2191 }
2192 }
2193 break;
2194
2195 case RROTATE_EXPR:
2196 case LROTATE_EXPR:
2197 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2198 {
2199 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2200 {
2201 if (tree_int_cst_sgn (op1) < 0)
2202 warning ("shift count is negative");
2203 else if (TREE_INT_CST_HIGH (op1) != 0
2204 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
2205 >= TYPE_PRECISION (type0)))
2206 warning ("shift count >= width of type");
2207 }
2208 /* Use the type of the value to be shifted.
2209 This is what most traditional C compilers do. */
2210 result_type = type0;
2211 /* Unless traditional, convert the shift-count to an integer,
2212 regardless of size of value being shifted. */
2213 if (! flag_traditional)
2214 {
2215 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2216 op1 = convert (integer_type_node, op1);
2217 /* Avoid converting op1 to result_type later. */
2218 converted = 1;
2219 }
2220 }
2221 break;
2222
2223 case EQ_EXPR:
2224 case NE_EXPR:
2225 /* Result of comparison is always int,
2226 but don't convert the args to int! */
2227 build_type = integer_type_node;
2228 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2229 || code0 == COMPLEX_TYPE)
2230 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2231 || code1 == COMPLEX_TYPE))
2232 short_compare = 1;
2233 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2234 {
2235 register tree tt0 = TREE_TYPE (type0);
2236 register tree tt1 = TREE_TYPE (type1);
2237 /* Anything compares with void *. void * compares with anything.
2238 Otherwise, the targets must be compatible
2239 and both must be object or both incomplete. */
2240 if (comp_target_types (type0, type1))
2241 result_type = common_type (type0, type1);
2242 else if (TYPE_MAIN_VARIANT (tt0) == void_type_node)
2243 {
2244 /* op0 != orig_op0 detects the case of something
2245 whose value is 0 but which isn't a valid null ptr const. */
2246 if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
2247 && TREE_CODE (tt1) == FUNCTION_TYPE)
2248 pedwarn ("ANSI C forbids comparison of `void *' with function pointer");
2249 }
2250 else if (TYPE_MAIN_VARIANT (tt1) == void_type_node)
2251 {
2252 if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
2253 && TREE_CODE (tt0) == FUNCTION_TYPE)
2254 pedwarn ("ANSI C forbids comparison of `void *' with function pointer");
2255 }
2256 else
2257 pedwarn ("comparison of distinct pointer types lacks a cast");
2258
2259 if (result_type == NULL_TREE)
2260 result_type = ptr_type_node;
2261 }
2262 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2263 && integer_zerop (op1))
2264 result_type = type0;
2265 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2266 && integer_zerop (op0))
2267 result_type = type1;
2268 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2269 {
2270 result_type = type0;
2271 if (! flag_traditional)
2272 pedwarn ("comparison between pointer and integer");
2273 }
2274 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2275 {
2276 result_type = type1;
2277 if (! flag_traditional)
2278 pedwarn ("comparison between pointer and integer");
2279 }
2280 break;
2281
2282 case MAX_EXPR:
2283 case MIN_EXPR:
2284 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2285 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2286 shorten = 1;
2287 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2288 {
2289 if (comp_target_types (type0, type1))
2290 {
2291 result_type = common_type (type0, type1);
2292 if (pedantic
2293 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2294 pedwarn ("ANSI C forbids ordered comparisons of pointers to functions");
2295 }
2296 else
2297 {
2298 result_type = ptr_type_node;
2299 pedwarn ("comparison of distinct pointer types lacks a cast");
2300 }
2301 }
2302 break;
2303
2304 case LE_EXPR:
2305 case GE_EXPR:
2306 case LT_EXPR:
2307 case GT_EXPR:
2308 build_type = integer_type_node;
2309 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2310 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2311 short_compare = 1;
2312 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2313 {
2314 if (comp_target_types (type0, type1))
2315 {
2316 result_type = common_type (type0, type1);
2317 if ((TYPE_SIZE (TREE_TYPE (type0)) != 0)
2318 != (TYPE_SIZE (TREE_TYPE (type1)) != 0))
2319 pedwarn ("comparison of complete and incomplete pointers");
2320 else if (pedantic
2321 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2322 pedwarn ("ANSI C forbids ordered comparisons of pointers to functions");
2323 }
2324 else
2325 {
2326 result_type = ptr_type_node;
2327 pedwarn ("comparison of distinct pointer types lacks a cast");
2328 }
2329 }
2330 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2331 && integer_zerop (op1))
2332 {
2333 result_type = type0;
2334 if (pedantic || extra_warnings)
2335 pedwarn ("ordered comparison of pointer with integer zero");
2336 }
2337 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2338 && integer_zerop (op0))
2339 {
2340 result_type = type1;
2341 if (pedantic)
2342 pedwarn ("ordered comparison of pointer with integer zero");
2343 }
2344 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2345 {
2346 result_type = type0;
2347 if (! flag_traditional)
2348 pedwarn ("comparison between pointer and integer");
2349 }
2350 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2351 {
2352 result_type = type1;
2353 if (! flag_traditional)
2354 pedwarn ("comparison between pointer and integer");
2355 }
2356 break;
2357
2358 default:
2359 break;
2360 }
2361
2362 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2363 &&
2364 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2365 {
2366 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
2367
2368 if (shorten || common || short_compare)
2369 result_type = common_type (type0, type1);
2370
2371 /* For certain operations (which identify themselves by shorten != 0)
2372 if both args were extended from the same smaller type,
2373 do the arithmetic in that type and then extend.
2374
2375 shorten !=0 and !=1 indicates a bitwise operation.
2376 For them, this optimization is safe only if
2377 both args are zero-extended or both are sign-extended.
2378 Otherwise, we might change the result.
2379 Eg, (short)-1 | (unsigned short)-1 is (int)-1
2380 but calculated in (unsigned short) it would be (unsigned short)-1. */
2381
2382 if (shorten && none_complex)
2383 {
2384 int unsigned0, unsigned1;
2385 tree arg0 = get_narrower (op0, &unsigned0);
2386 tree arg1 = get_narrower (op1, &unsigned1);
2387 /* UNS is 1 if the operation to be done is an unsigned one. */
2388 int uns = TREE_UNSIGNED (result_type);
2389 tree type;
2390
2391 final_type = result_type;
2392
2393 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
2394 but it *requires* conversion to FINAL_TYPE. */
2395
2396 if ((TYPE_PRECISION (TREE_TYPE (op0))
2397 == TYPE_PRECISION (TREE_TYPE (arg0)))
2398 && TREE_TYPE (op0) != final_type)
2399 unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
2400 if ((TYPE_PRECISION (TREE_TYPE (op1))
2401 == TYPE_PRECISION (TREE_TYPE (arg1)))
2402 && TREE_TYPE (op1) != final_type)
2403 unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
2404
2405 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
2406
2407 /* For bitwise operations, signedness of nominal type
2408 does not matter. Consider only how operands were extended. */
2409 if (shorten == -1)
2410 uns = unsigned0;
2411
2412 /* Note that in all three cases below we refrain from optimizing
2413 an unsigned operation on sign-extended args.
2414 That would not be valid. */
2415
2416 /* Both args variable: if both extended in same way
2417 from same width, do it in that width.
2418 Do it unsigned if args were zero-extended. */
2419 if ((TYPE_PRECISION (TREE_TYPE (arg0))
2420 < TYPE_PRECISION (result_type))
2421 && (TYPE_PRECISION (TREE_TYPE (arg1))
2422 == TYPE_PRECISION (TREE_TYPE (arg0)))
2423 && unsigned0 == unsigned1
2424 && (unsigned0 || !uns))
2425 result_type
2426 = signed_or_unsigned_type (unsigned0,
2427 common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
2428 else if (TREE_CODE (arg0) == INTEGER_CST
2429 && (unsigned1 || !uns)
2430 && (TYPE_PRECISION (TREE_TYPE (arg1))
2431 < TYPE_PRECISION (result_type))
2432 && (type = signed_or_unsigned_type (unsigned1,
2433 TREE_TYPE (arg1)),
2434 int_fits_type_p (arg0, type)))
2435 result_type = type;
2436 else if (TREE_CODE (arg1) == INTEGER_CST
2437 && (unsigned0 || !uns)
2438 && (TYPE_PRECISION (TREE_TYPE (arg0))
2439 < TYPE_PRECISION (result_type))
2440 && (type = signed_or_unsigned_type (unsigned0,
2441 TREE_TYPE (arg0)),
2442 int_fits_type_p (arg1, type)))
2443 result_type = type;
2444 }
2445
2446 /* Shifts can be shortened if shifting right. */
2447
2448 if (short_shift)
2449 {
2450 int unsigned_arg;
2451 tree arg0 = get_narrower (op0, &unsigned_arg);
2452
2453 final_type = result_type;
2454
2455 if (arg0 == op0 && final_type == TREE_TYPE (op0))
2456 unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
2457
2458 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
2459 /* We can shorten only if the shift count is less than the
2460 number of bits in the smaller type size. */
2461 && TREE_INT_CST_HIGH (op1) == 0
2462 && TYPE_PRECISION (TREE_TYPE (arg0)) > TREE_INT_CST_LOW (op1)
2463 /* If arg is sign-extended and then unsigned-shifted,
2464 we can simulate this with a signed shift in arg's type
2465 only if the extended result is at least twice as wide
2466 as the arg. Otherwise, the shift could use up all the
2467 ones made by sign-extension and bring in zeros.
2468 We can't optimize that case at all, but in most machines
2469 it never happens because available widths are 2**N. */
2470 && (!TREE_UNSIGNED (final_type)
2471 || unsigned_arg
2472 || 2 * TYPE_PRECISION (TREE_TYPE (arg0)) <= TYPE_PRECISION (result_type)))
2473 {
2474 /* Do an unsigned shift if the operand was zero-extended. */
2475 result_type
2476 = signed_or_unsigned_type (unsigned_arg,
2477 TREE_TYPE (arg0));
2478 /* Convert value-to-be-shifted to that type. */
2479 if (TREE_TYPE (op0) != result_type)
2480 op0 = convert (result_type, op0);
2481 converted = 1;
2482 }
2483 }
2484
2485 /* Comparison operations are shortened too but differently.
2486 They identify themselves by setting short_compare = 1. */
2487
2488 if (short_compare)
2489 {
2490 /* Don't write &op0, etc., because that would prevent op0
2491 from being kept in a register.
2492 Instead, make copies of the our local variables and
2493 pass the copies by reference, then copy them back afterward. */
2494 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
2495 enum tree_code xresultcode = resultcode;
2496 tree val
2497 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
2498 if (val != 0)
2499 return val;
2500 op0 = xop0, op1 = xop1;
2501 converted = 1;
2502 resultcode = xresultcode;
2503
2504 if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare != 0)
2505 && skip_evaluation == 0)
2506 {
2507 int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
2508 int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
2509
2510 int unsignedp0, unsignedp1;
2511 tree primop0 = get_narrower (op0, &unsignedp0);
2512 tree primop1 = get_narrower (op1, &unsignedp1);
2513
2514 /* Avoid spurious warnings for comparison with enumerators. */
2515
2516 xop0 = orig_op0;
2517 xop1 = orig_op1;
2518 STRIP_TYPE_NOPS (xop0);
2519 STRIP_TYPE_NOPS (xop1);
2520
2521 /* Give warnings for comparisons between signed and unsigned
2522 quantities that may fail. */
2523 /* Do the checking based on the original operand trees, so that
2524 casts will be considered, but default promotions won't be. */
2525
2526 /* Do not warn if the comparison is being done in a signed type,
2527 since the signed type will only be chosen if it can represent
2528 all the values of the unsigned type. */
2529 if (! TREE_UNSIGNED (result_type))
2530 /* OK */;
2531 /* Do not warn if both operands are unsigned. */
2532 else if (op0_signed == op1_signed)
2533 /* OK */;
2534 /* Do not warn if the signed quantity is an unsuffixed
2535 integer literal (or some static constant expression
2536 involving such literals) and it is non-negative. */
2537 else if ((op0_signed && TREE_CODE (xop0) == INTEGER_CST
2538 && tree_int_cst_sgn (xop0) >= 0)
2539 || (op1_signed && TREE_CODE (xop1) == INTEGER_CST
2540 && tree_int_cst_sgn (xop1) >= 0))
2541 /* OK */;
2542 /* Do not warn if the comparison is an equality operation,
2543 the unsigned quantity is an integral constant and it does
2544 not use the most significant bit of result_type. */
2545 else if ((resultcode == EQ_EXPR || resultcode == NE_EXPR)
2546 && ((op0_signed && TREE_CODE (xop1) == INTEGER_CST
2547 && int_fits_type_p (xop1, signed_type (result_type)))
2548 || (op1_signed && TREE_CODE (xop0) == INTEGER_CST
2549 && int_fits_type_p (xop0, signed_type (result_type)))))
2550 /* OK */;
2551 else
2552 warning ("comparison between signed and unsigned");
2553
2554 /* Warn if two unsigned values are being compared in a size
2555 larger than their original size, and one (and only one) is the
2556 result of a `~' operator. This comparison will always fail.
2557
2558 Also warn if one operand is a constant, and the constant
2559 does not have all bits set that are set in the ~ operand
2560 when it is extended. */
2561
2562 if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
2563 != (TREE_CODE (primop1) == BIT_NOT_EXPR))
2564 {
2565 if (TREE_CODE (primop0) == BIT_NOT_EXPR)
2566 primop0 = get_narrower (TREE_OPERAND (primop0, 0),
2567 &unsignedp0);
2568 else
2569 primop1 = get_narrower (TREE_OPERAND (primop1, 0),
2570 &unsignedp1);
2571
2572 if (TREE_CODE (primop0) == INTEGER_CST
2573 || TREE_CODE (primop1) == INTEGER_CST)
2574 {
2575 tree primop;
2576 long constant, mask;
2577 int unsignedp, bits;
2578
2579 if (TREE_CODE (primop0) == INTEGER_CST)
2580 {
2581 primop = primop1;
2582 unsignedp = unsignedp1;
2583 constant = TREE_INT_CST_LOW (primop0);
2584 }
2585 else
2586 {
2587 primop = primop0;
2588 unsignedp = unsignedp0;
2589 constant = TREE_INT_CST_LOW (primop1);
2590 }
2591
2592 bits = TYPE_PRECISION (TREE_TYPE (primop));
2593 if (bits < TYPE_PRECISION (result_type)
2594 && bits < HOST_BITS_PER_LONG && unsignedp)
2595 {
2596 mask = (~0L) << bits;
2597 if ((mask & constant) != mask)
2598 warning ("comparison of promoted ~unsigned with constant");
2599 }
2600 }
2601 else if (unsignedp0 && unsignedp1
2602 && (TYPE_PRECISION (TREE_TYPE (primop0))
2603 < TYPE_PRECISION (result_type))
2604 && (TYPE_PRECISION (TREE_TYPE (primop1))
2605 < TYPE_PRECISION (result_type)))
2606 warning ("comparison of promoted ~unsigned with unsigned");
2607 }
2608 }
2609 }
2610 }
2611
2612 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
2613 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
2614 Then the expression will be built.
2615 It will be given type FINAL_TYPE if that is nonzero;
2616 otherwise, it will be given type RESULT_TYPE. */
2617
2618 if (!result_type)
2619 {
2620 binary_op_error (code);
2621 return error_mark_node;
2622 }
2623
2624 if (! converted)
2625 {
2626 if (TREE_TYPE (op0) != result_type)
2627 op0 = convert (result_type, op0);
2628 if (TREE_TYPE (op1) != result_type)
2629 op1 = convert (result_type, op1);
2630 }
2631
2632 if (build_type == NULL_TREE)
2633 build_type = result_type;
2634
2635 {
2636 register tree result = build (resultcode, build_type, op0, op1);
2637 register tree folded;
2638
2639 folded = fold (result);
2640 if (folded == result)
2641 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2642 if (final_type != 0)
2643 return convert (final_type, folded);
2644 return folded;
2645 }
2646}
2647
2648/* Return a tree for the sum or difference (RESULTCODE says which)
2649 of pointer PTROP and integer INTOP. */
2650
2651static tree
2652pointer_int_sum (resultcode, ptrop, intop)
2653 enum tree_code resultcode;
2654 register tree ptrop, intop;
2655{
2656 tree size_exp;
2657
2658 register tree result;
2659 register tree folded;
2660
2661 /* The result is a pointer of the same type that is being added. */
2662
2663 register tree result_type = TREE_TYPE (ptrop);
2664
2665 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2666 {
2667 if (pedantic || warn_pointer_arith)
2668 pedwarn ("pointer of type `void *' used in arithmetic");
2669 size_exp = integer_one_node;
2670 }
2671 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2672 {
2673 if (pedantic || warn_pointer_arith)
2674 pedwarn ("pointer to a function used in arithmetic");
2675 size_exp = integer_one_node;
2676 }
2677 else
2678 size_exp = c_size_in_bytes (TREE_TYPE (result_type));
2679
2680 /* If what we are about to multiply by the size of the elements
2681 contains a constant term, apply distributive law
2682 and multiply that constant term separately.
2683 This helps produce common subexpressions. */
2684
2685 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2686 && ! TREE_CONSTANT (intop)
2687 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2688 && TREE_CONSTANT (size_exp)
2689 /* If the constant comes from pointer subtraction,
2690 skip this optimization--it would cause an error. */
2691 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2692 /* If the constant is unsigned, and smaller than the pointer size,
2693 then we must skip this optimization. This is because it could cause
2694 an overflow error if the constant is negative but INTOP is not. */
2695 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2696 || (TYPE_PRECISION (TREE_TYPE (intop))
2697 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2698 {
2699 enum tree_code subcode = resultcode;
2700 tree int_type = TREE_TYPE (intop);
2701 if (TREE_CODE (intop) == MINUS_EXPR)
2702 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2703 /* Convert both subexpression types to the type of intop,
2704 because weird cases involving pointer arithmetic
2705 can result in a sum or difference with different type args. */
2706 ptrop = build_binary_op (subcode, ptrop,
2707 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2708 intop = convert (int_type, TREE_OPERAND (intop, 0));
2709 }
2710
2711 /* Convert the integer argument to a type the same size as sizetype
2712 so the multiply won't overflow spuriously. */
2713
2714 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2715 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2716 intop = convert (type_for_size (TYPE_PRECISION (sizetype),
2717 TREE_UNSIGNED (sizetype)), intop);
2718
2719 /* Replace the integer argument with a suitable product by the object size.
2720 Do this multiplication as signed, then convert to the appropriate
2721 pointer type (actually unsigned integral). */
2722
2723 intop = convert (result_type,
2724 build_binary_op (MULT_EXPR, intop,
2725 convert (TREE_TYPE (intop), size_exp), 1));
2726
2727 /* Create the sum or difference. */
2728
2729 result = build (resultcode, result_type, ptrop, intop);
2730
2731 folded = fold (result);
2732 if (folded == result)
2733 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2734 return folded;
2735}
2736
2737/* Return a tree for the difference of pointers OP0 and OP1.
2738 The resulting tree has type int. */
2739
2740static tree
2741pointer_diff (op0, op1)
2742 register tree op0, op1;
2743{
2744 register tree result, folded;
2745 tree restype = ptrdiff_type_node;
2746
2747 tree target_type = TREE_TYPE (TREE_TYPE (op0));
2748
2749 if (pedantic || warn_pointer_arith)
2750 {
2751 if (TREE_CODE (target_type) == VOID_TYPE)
2752 pedwarn ("pointer of type `void *' used in subtraction");
2753 if (TREE_CODE (target_type) == FUNCTION_TYPE)
2754 pedwarn ("pointer to a function used in subtraction");
2755 }
2756
2757 /* First do the subtraction as integers;
2758 then drop through to build the divide operator.
2759 Do not do default conversions on the minus operator
2760 in case restype is a short type. */
2761
2762 op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2763 convert (restype, op1), 0);
2764 /* This generates an error if op1 is pointer to incomplete type. */
2765 if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1))) == 0)
2766 error ("arithmetic on pointer to an incomplete type");
2767
2768 /* This generates an error if op0 is pointer to incomplete type. */
2769 op1 = c_size_in_bytes (target_type);
2770
2771 /* Divide by the size, in easiest possible way. */
2772
2773 result = build (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
2774
2775 folded = fold (result);
2776 if (folded == result)
2777 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2778 return folded;
2779}
2780
2781/* Construct and perhaps optimize a tree representation
2782 for a unary operation. CODE, a tree_code, specifies the operation
2783 and XARG is the operand. NOCONVERT nonzero suppresses
2784 the default promotions (such as from short to int). */
2785
2786tree
2787build_unary_op (code, xarg, noconvert)
2788 enum tree_code code;
2789 tree xarg;
2790 int noconvert;
2791{
2792 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
2793 register tree arg = xarg;
2794 register tree argtype = 0;
2795 register enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
| 1329{
1330 register tree pointer = default_conversion (ptr);
1331 register tree type = TREE_TYPE (pointer);
1332
1333 if (TREE_CODE (type) == POINTER_TYPE)
1334 {
1335 if (TREE_CODE (pointer) == ADDR_EXPR
1336 && !flag_volatile
1337 && (TREE_TYPE (TREE_OPERAND (pointer, 0))
1338 == TREE_TYPE (type)))
1339 return TREE_OPERAND (pointer, 0);
1340 else
1341 {
1342 tree t = TREE_TYPE (type);
1343 register tree ref = build1 (INDIRECT_REF,
1344 TYPE_MAIN_VARIANT (t), pointer);
1345
1346 if (TYPE_SIZE (t) == 0 && TREE_CODE (t) != ARRAY_TYPE)
1347 {
1348 error ("dereferencing pointer to incomplete type");
1349 return error_mark_node;
1350 }
1351 if (TREE_CODE (t) == VOID_TYPE && skip_evaluation == 0)
1352 warning ("dereferencing `void *' pointer");
1353
1354 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1355 so that we get the proper error message if the result is used
1356 to assign to. Also, &* is supposed to be a no-op.
1357 And ANSI C seems to specify that the type of the result
1358 should be the const type. */
1359 /* A de-reference of a pointer to const is not a const. It is valid
1360 to change it via some other pointer. */
1361 TREE_READONLY (ref) = TYPE_READONLY (t);
1362 TREE_SIDE_EFFECTS (ref)
1363 = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer) || flag_volatile;
1364 TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
1365 return ref;
1366 }
1367 }
1368 else if (TREE_CODE (pointer) != ERROR_MARK)
1369 error ("invalid type argument of `%s'", errorstring);
1370 return error_mark_node;
1371}
1372
1373/* This handles expressions of the form "a[i]", which denotes
1374 an array reference.
1375
1376 This is logically equivalent in C to *(a+i), but we may do it differently.
1377 If A is a variable or a member, we generate a primitive ARRAY_REF.
1378 This avoids forcing the array out of registers, and can work on
1379 arrays that are not lvalues (for example, members of structures returned
1380 by functions). */
1381
1382tree
1383build_array_ref (array, index)
1384 tree array, index;
1385{
1386 if (index == 0)
1387 {
1388 error ("subscript missing in array reference");
1389 return error_mark_node;
1390 }
1391
1392 if (TREE_TYPE (array) == error_mark_node
1393 || TREE_TYPE (index) == error_mark_node)
1394 return error_mark_node;
1395
1396 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
1397 && TREE_CODE (array) != INDIRECT_REF)
1398 {
1399 tree rval, type;
1400
1401 /* Subscripting with type char is likely to lose
1402 on a machine where chars are signed.
1403 So warn on any machine, but optionally.
1404 Don't warn for unsigned char since that type is safe.
1405 Don't warn for signed char because anyone who uses that
1406 must have done so deliberately. */
1407 if (warn_char_subscripts
1408 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1409 warning ("array subscript has type `char'");
1410
1411 /* Apply default promotions *after* noticing character types. */
1412 index = default_conversion (index);
1413
1414 /* Require integer *after* promotion, for sake of enums. */
1415 if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE)
1416 {
1417 error ("array subscript is not an integer");
1418 return error_mark_node;
1419 }
1420
1421 /* An array that is indexed by a non-constant
1422 cannot be stored in a register; we must be able to do
1423 address arithmetic on its address.
1424 Likewise an array of elements of variable size. */
1425 if (TREE_CODE (index) != INTEGER_CST
1426 || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))) != 0
1427 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
1428 {
1429 if (mark_addressable (array) == 0)
1430 return error_mark_node;
1431 }
1432 /* An array that is indexed by a constant value which is not within
1433 the array bounds cannot be stored in a register either; because we
1434 would get a crash in store_bit_field/extract_bit_field when trying
1435 to access a non-existent part of the register. */
1436 if (TREE_CODE (index) == INTEGER_CST
1437 && TYPE_VALUES (TREE_TYPE (array))
1438 && ! int_fits_type_p (index, TYPE_VALUES (TREE_TYPE (array))))
1439 {
1440 if (mark_addressable (array) == 0)
1441 return error_mark_node;
1442 }
1443
1444 if (pedantic && !lvalue_p (array))
1445 {
1446 if (DECL_REGISTER (array))
1447 pedwarn ("ANSI C forbids subscripting `register' array");
1448 else
1449 pedwarn ("ANSI C forbids subscripting non-lvalue array");
1450 }
1451
1452 if (pedantic)
1453 {
1454 tree foo = array;
1455 while (TREE_CODE (foo) == COMPONENT_REF)
1456 foo = TREE_OPERAND (foo, 0);
1457 if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
1458 pedwarn ("ANSI C forbids subscripting non-lvalue array");
1459 }
1460
1461 type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
1462 rval = build (ARRAY_REF, type, array, index);
1463 /* Array ref is const/volatile if the array elements are
1464 or if the array is. */
1465 TREE_READONLY (rval)
1466 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
1467 | TREE_READONLY (array));
1468 TREE_SIDE_EFFECTS (rval)
1469 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1470 | TREE_SIDE_EFFECTS (array));
1471 TREE_THIS_VOLATILE (rval)
1472 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1473 /* This was added by rms on 16 Nov 91.
1474 It fixes vol struct foo *a; a->elts[1]
1475 in an inline function.
1476 Hope it doesn't break something else. */
1477 | TREE_THIS_VOLATILE (array));
1478 return require_complete_type (fold (rval));
1479 }
1480
1481 {
1482 tree ar = default_conversion (array);
1483 tree ind = default_conversion (index);
1484
1485 /* Do the same warning check as above, but only on the part that's
1486 syntactically the index and only if it is also semantically
1487 the index. */
1488 if (warn_char_subscripts
1489 && TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE
1490 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1491 warning ("subscript has type `char'");
1492
1493 /* Put the integer in IND to simplify error checking. */
1494 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
1495 {
1496 tree temp = ar;
1497 ar = ind;
1498 ind = temp;
1499 }
1500
1501 if (ar == error_mark_node)
1502 return ar;
1503
1504 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE
1505 || TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) == FUNCTION_TYPE)
1506 {
1507 error ("subscripted value is neither array nor pointer");
1508 return error_mark_node;
1509 }
1510 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
1511 {
1512 error ("array subscript is not an integer");
1513 return error_mark_node;
1514 }
1515
1516 return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind, 0),
1517 "array indexing");
1518 }
1519}
1520
1521/* Build a function call to function FUNCTION with parameters PARAMS.
1522 PARAMS is a list--a chain of TREE_LIST nodes--in which the
1523 TREE_VALUE of each node is a parameter-expression.
1524 FUNCTION's data type may be a function type or a pointer-to-function. */
1525
1526tree
1527build_function_call (function, params)
1528 tree function, params;
1529{
1530 register tree fntype, fundecl = 0;
1531 register tree coerced_params;
1532 tree name = NULL_TREE, assembler_name = NULL_TREE;
1533
1534 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1535 STRIP_TYPE_NOPS (function);
1536
1537 /* Convert anything with function type to a pointer-to-function. */
1538 if (TREE_CODE (function) == FUNCTION_DECL)
1539 {
1540 name = DECL_NAME (function);
1541 assembler_name = DECL_ASSEMBLER_NAME (function);
1542
1543 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1544 (because calling an inline function does not mean the function
1545 needs to be separately compiled). */
1546 fntype = build_type_variant (TREE_TYPE (function),
1547 TREE_READONLY (function),
1548 TREE_THIS_VOLATILE (function));
1549 fundecl = function;
1550 function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
1551 }
1552 else
1553 function = default_conversion (function);
1554
1555 fntype = TREE_TYPE (function);
1556
1557 if (TREE_CODE (fntype) == ERROR_MARK)
1558 return error_mark_node;
1559
1560 if (!(TREE_CODE (fntype) == POINTER_TYPE
1561 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
1562 {
1563 error ("called object is not a function");
1564 return error_mark_node;
1565 }
1566
1567 /* fntype now gets the type of function pointed to. */
1568 fntype = TREE_TYPE (fntype);
1569
1570 /* Convert the parameters to the types declared in the
1571 function prototype, or apply default promotions. */
1572
1573 coerced_params
1574 = convert_arguments (TYPE_ARG_TYPES (fntype), params, name, fundecl);
1575
1576 /* Check for errors in format strings. */
1577
1578 if (warn_format && (name || assembler_name))
1579 check_function_format (name, assembler_name, coerced_params);
1580
1581 /* Recognize certain built-in functions so we can make tree-codes
1582 other than CALL_EXPR. We do this when it enables fold-const.c
1583 to do something useful. */
1584
1585 if (TREE_CODE (function) == ADDR_EXPR
1586 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
1587 && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
1588 switch (DECL_FUNCTION_CODE (TREE_OPERAND (function, 0)))
1589 {
1590 case BUILT_IN_ABS:
1591 case BUILT_IN_LABS:
1592 case BUILT_IN_FABS:
1593 if (coerced_params == 0)
1594 return integer_zero_node;
1595 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
1596 default:
1597 break;
1598 }
1599
1600 {
1601 register tree result
1602 = build (CALL_EXPR, TREE_TYPE (fntype),
1603 function, coerced_params, NULL_TREE);
1604
1605 TREE_SIDE_EFFECTS (result) = 1;
1606 if (TREE_TYPE (result) == void_type_node)
1607 return result;
1608 return require_complete_type (result);
1609 }
1610}
1611
1612/* Convert the argument expressions in the list VALUES
1613 to the types in the list TYPELIST. The result is a list of converted
1614 argument expressions.
1615
1616 If TYPELIST is exhausted, or when an element has NULL as its type,
1617 perform the default conversions.
1618
1619 PARMLIST is the chain of parm decls for the function being called.
1620 It may be 0, if that info is not available.
1621 It is used only for generating error messages.
1622
1623 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
1624
1625 This is also where warnings about wrong number of args are generated.
1626
1627 Both VALUES and the returned value are chains of TREE_LIST nodes
1628 with the elements of the list in the TREE_VALUE slots of those nodes. */
1629
1630static tree
1631convert_arguments (typelist, values, name, fundecl)
1632 tree typelist, values, name, fundecl;
1633{
1634 register tree typetail, valtail;
1635 register tree result = NULL;
1636 int parmnum;
1637
1638 /* Scan the given expressions and types, producing individual
1639 converted arguments and pushing them on RESULT in reverse order. */
1640
1641 for (valtail = values, typetail = typelist, parmnum = 0;
1642 valtail;
1643 valtail = TREE_CHAIN (valtail), parmnum++)
1644 {
1645 register tree type = typetail ? TREE_VALUE (typetail) : 0;
1646 register tree val = TREE_VALUE (valtail);
1647
1648 if (type == void_type_node)
1649 {
1650 if (name)
1651 error ("too many arguments to function `%s'",
1652 IDENTIFIER_POINTER (name));
1653 else
1654 error ("too many arguments to function");
1655 break;
1656 }
1657
1658 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1659 /* Do not use STRIP_NOPS here! We do not want an enumerator with value 0
1660 to convert automatically to a pointer. */
1661 if (TREE_CODE (val) == NON_LVALUE_EXPR)
1662 val = TREE_OPERAND (val, 0);
1663
1664 if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
1665 || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE)
1666 val = default_conversion (val);
1667
1668 val = require_complete_type (val);
1669
1670 if (type != 0)
1671 {
1672 /* Formal parm type is specified by a function prototype. */
1673 tree parmval;
1674
1675 if (TYPE_SIZE (type) == 0)
1676 {
1677 error ("type of formal parameter %d is incomplete", parmnum + 1);
1678 parmval = val;
1679 }
1680 else
1681 {
1682 /* Optionally warn about conversions that
1683 differ from the default conversions. */
1684 if (warn_conversion)
1685 {
1686 int formal_prec = TYPE_PRECISION (type);
1687
1688 if (INTEGRAL_TYPE_P (type)
1689 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1690 warn_for_assignment ("%s as integer rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1691 else if (TREE_CODE (type) == COMPLEX_TYPE
1692 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1693 warn_for_assignment ("%s as complex rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1694 else if (TREE_CODE (type) == REAL_TYPE
1695 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1696 warn_for_assignment ("%s as floating rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1697 else if (TREE_CODE (type) == REAL_TYPE
1698 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1699 warn_for_assignment ("%s as floating rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1700 /* ??? At some point, messages should be written about
1701 conversions between complex types, but that's too messy
1702 to do now. */
1703 else if (TREE_CODE (type) == REAL_TYPE
1704 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1705 {
1706 /* Warn if any argument is passed as `float',
1707 since without a prototype it would be `double'. */
1708 if (formal_prec == TYPE_PRECISION (float_type_node))
1709 warn_for_assignment ("%s as `float' rather than `double' due to prototype", (char *) 0, name, parmnum + 1);
1710 }
1711 /* Detect integer changing in width or signedness. */
1712 else if (INTEGRAL_TYPE_P (type)
1713 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1714 {
1715 tree would_have_been = default_conversion (val);
1716 tree type1 = TREE_TYPE (would_have_been);
1717
1718 if (TREE_CODE (type) == ENUMERAL_TYPE
1719 && type == TREE_TYPE (val))
1720 /* No warning if function asks for enum
1721 and the actual arg is that enum type. */
1722 ;
1723 else if (formal_prec != TYPE_PRECISION (type1))
1724 warn_for_assignment ("%s with different width due to prototype", (char *) 0, name, parmnum + 1);
1725 else if (TREE_UNSIGNED (type) == TREE_UNSIGNED (type1))
1726 ;
1727 /* Don't complain if the formal parameter type
1728 is an enum, because we can't tell now whether
1729 the value was an enum--even the same enum. */
1730 else if (TREE_CODE (type) == ENUMERAL_TYPE)
1731 ;
1732 else if (TREE_CODE (val) == INTEGER_CST
1733 && int_fits_type_p (val, type))
1734 /* Change in signedness doesn't matter
1735 if a constant value is unaffected. */
1736 ;
1737 /* Likewise for a constant in a NOP_EXPR. */
1738 else if (TREE_CODE (val) == NOP_EXPR
1739 && TREE_CODE (TREE_OPERAND (val, 0)) == INTEGER_CST
1740 && int_fits_type_p (TREE_OPERAND (val, 0), type))
1741 ;
1742#if 0 /* We never get such tree structure here. */
1743 else if (TREE_CODE (TREE_TYPE (val)) == ENUMERAL_TYPE
1744 && int_fits_type_p (TYPE_MIN_VALUE (TREE_TYPE (val)), type)
1745 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (val)), type))
1746 /* Change in signedness doesn't matter
1747 if an enum value is unaffected. */
1748 ;
1749#endif
1750 /* If the value is extended from a narrower
1751 unsigned type, it doesn't matter whether we
1752 pass it as signed or unsigned; the value
1753 certainly is the same either way. */
1754 else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
1755 && TREE_UNSIGNED (TREE_TYPE (val)))
1756 ;
1757 else if (TREE_UNSIGNED (type))
1758 warn_for_assignment ("%s as unsigned due to prototype", (char *) 0, name, parmnum + 1);
1759 else
1760 warn_for_assignment ("%s as signed due to prototype", (char *) 0, name, parmnum + 1);
1761 }
1762 }
1763
1764 parmval = convert_for_assignment (type, val,
1765 (char *) 0, /* arg passing */
1766 fundecl, name, parmnum + 1);
1767
1768#ifdef PROMOTE_PROTOTYPES
1769 if ((TREE_CODE (type) == INTEGER_TYPE
1770 || TREE_CODE (type) == ENUMERAL_TYPE)
1771 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
1772 parmval = default_conversion (parmval);
1773#endif
1774 }
1775 result = tree_cons (NULL_TREE, parmval, result);
1776 }
1777 else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
1778 && (TYPE_PRECISION (TREE_TYPE (val))
1779 < TYPE_PRECISION (double_type_node)))
1780 /* Convert `float' to `double'. */
1781 result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
1782 else
1783 /* Convert `short' and `char' to full-size `int'. */
1784 result = tree_cons (NULL_TREE, default_conversion (val), result);
1785
1786 if (typetail)
1787 typetail = TREE_CHAIN (typetail);
1788 }
1789
1790 if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
1791 {
1792 if (name)
1793 error ("too few arguments to function `%s'",
1794 IDENTIFIER_POINTER (name));
1795 else
1796 error ("too few arguments to function");
1797 }
1798
1799 return nreverse (result);
1800}
1801
1802/* This is the entry point used by the parser
1803 for binary operators in the input.
1804 In addition to constructing the expression,
1805 we check for operands that were written with other binary operators
1806 in a way that is likely to confuse the user. */
1807
1808tree
1809parser_build_binary_op (code, arg1, arg2)
1810 enum tree_code code;
1811 tree arg1, arg2;
1812{
1813 tree result = build_binary_op (code, arg1, arg2, 1);
1814
1815 char class;
1816 char class1 = TREE_CODE_CLASS (TREE_CODE (arg1));
1817 char class2 = TREE_CODE_CLASS (TREE_CODE (arg2));
1818 enum tree_code code1 = ERROR_MARK;
1819 enum tree_code code2 = ERROR_MARK;
1820
1821 if (class1 == 'e' || class1 == '1'
1822 || class1 == '2' || class1 == '<')
1823 code1 = C_EXP_ORIGINAL_CODE (arg1);
1824 if (class2 == 'e' || class2 == '1'
1825 || class2 == '2' || class2 == '<')
1826 code2 = C_EXP_ORIGINAL_CODE (arg2);
1827
1828 /* Check for cases such as x+y<<z which users are likely
1829 to misinterpret. If parens are used, C_EXP_ORIGINAL_CODE
1830 is cleared to prevent these warnings. */
1831 if (warn_parentheses)
1832 {
1833 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
1834 {
1835 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1836 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1837 warning ("suggest parentheses around + or - inside shift");
1838 }
1839
1840 if (code == TRUTH_ORIF_EXPR)
1841 {
1842 if (code1 == TRUTH_ANDIF_EXPR
1843 || code2 == TRUTH_ANDIF_EXPR)
1844 warning ("suggest parentheses around && within ||");
1845 }
1846
1847 if (code == BIT_IOR_EXPR)
1848 {
1849 if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
1850 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1851 || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
1852 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1853 warning ("suggest parentheses around arithmetic in operand of |");
1854 /* Check cases like x|y==z */
1855 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1856 warning ("suggest parentheses around comparison in operand of |");
1857 }
1858
1859 if (code == BIT_XOR_EXPR)
1860 {
1861 if (code1 == BIT_AND_EXPR
1862 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
1863 || code2 == BIT_AND_EXPR
1864 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1865 warning ("suggest parentheses around arithmetic in operand of ^");
1866 /* Check cases like x^y==z */
1867 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1868 warning ("suggest parentheses around comparison in operand of ^");
1869 }
1870
1871 if (code == BIT_AND_EXPR)
1872 {
1873 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1874 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1875 warning ("suggest parentheses around + or - in operand of &");
1876 /* Check cases like x&y==z */
1877 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
1878 warning ("suggest parentheses around comparison in operand of &");
1879 }
1880 }
1881
1882 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */
1883 if (TREE_CODE_CLASS (code) == '<' && extra_warnings
1884 && (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<'))
1885 warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
1886
1887 unsigned_conversion_warning (result, arg1);
1888 unsigned_conversion_warning (result, arg2);
1889 overflow_warning (result);
1890
1891 class = TREE_CODE_CLASS (TREE_CODE (result));
1892
1893 /* Record the code that was specified in the source,
1894 for the sake of warnings about confusing nesting. */
1895 if (class == 'e' || class == '1'
1896 || class == '2' || class == '<')
1897 C_SET_EXP_ORIGINAL_CODE (result, code);
1898 else
1899 {
1900 int flag = TREE_CONSTANT (result);
1901 /* We used to use NOP_EXPR rather than NON_LVALUE_EXPR
1902 so that convert_for_assignment wouldn't strip it.
1903 That way, we got warnings for things like p = (1 - 1).
1904 But it turns out we should not get those warnings. */
1905 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
1906 C_SET_EXP_ORIGINAL_CODE (result, code);
1907 TREE_CONSTANT (result) = flag;
1908 }
1909
1910 return result;
1911}
1912
1913/* Build a binary-operation expression without default conversions.
1914 CODE is the kind of expression to build.
1915 This function differs from `build' in several ways:
1916 the data type of the result is computed and recorded in it,
1917 warnings are generated if arg data types are invalid,
1918 special handling for addition and subtraction of pointers is known,
1919 and some optimization is done (operations on narrow ints
1920 are done in the narrower type when that gives the same result).
1921 Constant folding is also done before the result is returned.
1922
1923 Note that the operands will never have enumeral types, or function
1924 or array types, because either they will have the default conversions
1925 performed or they have both just been converted to some other type in which
1926 the arithmetic is to be done. */
1927
1928tree
1929build_binary_op (code, orig_op0, orig_op1, convert_p)
1930 enum tree_code code;
1931 tree orig_op0, orig_op1;
1932 int convert_p;
1933{
1934 tree type0, type1;
1935 register enum tree_code code0, code1;
1936 tree op0, op1;
1937
1938 /* Expression code to give to the expression when it is built.
1939 Normally this is CODE, which is what the caller asked for,
1940 but in some special cases we change it. */
1941 register enum tree_code resultcode = code;
1942
1943 /* Data type in which the computation is to be performed.
1944 In the simplest cases this is the common type of the arguments. */
1945 register tree result_type = NULL;
1946
1947 /* Nonzero means operands have already been type-converted
1948 in whatever way is necessary.
1949 Zero means they need to be converted to RESULT_TYPE. */
1950 int converted = 0;
1951
1952 /* Nonzero means create the expression with this type, rather than
1953 RESULT_TYPE. */
1954 tree build_type = 0;
1955
1956 /* Nonzero means after finally constructing the expression
1957 convert it to this type. */
1958 tree final_type = 0;
1959
1960 /* Nonzero if this is an operation like MIN or MAX which can
1961 safely be computed in short if both args are promoted shorts.
1962 Also implies COMMON.
1963 -1 indicates a bitwise operation; this makes a difference
1964 in the exact conditions for when it is safe to do the operation
1965 in a narrower mode. */
1966 int shorten = 0;
1967
1968 /* Nonzero if this is a comparison operation;
1969 if both args are promoted shorts, compare the original shorts.
1970 Also implies COMMON. */
1971 int short_compare = 0;
1972
1973 /* Nonzero if this is a right-shift operation, which can be computed on the
1974 original short and then promoted if the operand is a promoted short. */
1975 int short_shift = 0;
1976
1977 /* Nonzero means set RESULT_TYPE to the common type of the args. */
1978 int common = 0;
1979
1980 if (convert_p)
1981 {
1982 op0 = default_conversion (orig_op0);
1983 op1 = default_conversion (orig_op1);
1984 }
1985 else
1986 {
1987 op0 = orig_op0;
1988 op1 = orig_op1;
1989 }
1990
1991 type0 = TREE_TYPE (op0);
1992 type1 = TREE_TYPE (op1);
1993
1994 /* The expression codes of the data types of the arguments tell us
1995 whether the arguments are integers, floating, pointers, etc. */
1996 code0 = TREE_CODE (type0);
1997 code1 = TREE_CODE (type1);
1998
1999 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
2000 STRIP_TYPE_NOPS (op0);
2001 STRIP_TYPE_NOPS (op1);
2002
2003 /* If an error was already reported for one of the arguments,
2004 avoid reporting another error. */
2005
2006 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
2007 return error_mark_node;
2008
2009 switch (code)
2010 {
2011 case PLUS_EXPR:
2012 /* Handle the pointer + int case. */
2013 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2014 return pointer_int_sum (PLUS_EXPR, op0, op1);
2015 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
2016 return pointer_int_sum (PLUS_EXPR, op1, op0);
2017 else
2018 common = 1;
2019 break;
2020
2021 case MINUS_EXPR:
2022 /* Subtraction of two similar pointers.
2023 We must subtract them as integers, then divide by object size. */
2024 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
2025 && comp_target_types (type0, type1))
2026 return pointer_diff (op0, op1);
2027 /* Handle pointer minus int. Just like pointer plus int. */
2028 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2029 return pointer_int_sum (MINUS_EXPR, op0, op1);
2030 else
2031 common = 1;
2032 break;
2033
2034 case MULT_EXPR:
2035 common = 1;
2036 break;
2037
2038 case TRUNC_DIV_EXPR:
2039 case CEIL_DIV_EXPR:
2040 case FLOOR_DIV_EXPR:
2041 case ROUND_DIV_EXPR:
2042 case EXACT_DIV_EXPR:
2043 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2044 || code0 == COMPLEX_TYPE)
2045 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2046 || code1 == COMPLEX_TYPE))
2047 {
2048 if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
2049 resultcode = RDIV_EXPR;
2050 else
2051 {
2052 /* Although it would be tempting to shorten always here, that
2053 loses on some targets, since the modulo instruction is
2054 undefined if the quotient can't be represented in the
2055 computation mode. We shorten only if unsigned or if
2056 dividing by something we know != -1. */
2057 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2058 || (TREE_CODE (op1) == INTEGER_CST
2059 && (TREE_INT_CST_LOW (op1) != -1
2060 || TREE_INT_CST_HIGH (op1) != -1)));
2061 }
2062 common = 1;
2063 }
2064 break;
2065
2066 case BIT_AND_EXPR:
2067 case BIT_ANDTC_EXPR:
2068 case BIT_IOR_EXPR:
2069 case BIT_XOR_EXPR:
2070 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2071 shorten = -1;
2072 /* If one operand is a constant, and the other is a short type
2073 that has been converted to an int,
2074 really do the work in the short type and then convert the
2075 result to int. If we are lucky, the constant will be 0 or 1
2076 in the short type, making the entire operation go away. */
2077 if (TREE_CODE (op0) == INTEGER_CST
2078 && TREE_CODE (op1) == NOP_EXPR
2079 && TYPE_PRECISION (type1) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))
2080 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1, 0))))
2081 {
2082 final_type = result_type;
2083 op1 = TREE_OPERAND (op1, 0);
2084 result_type = TREE_TYPE (op1);
2085 }
2086 if (TREE_CODE (op1) == INTEGER_CST
2087 && TREE_CODE (op0) == NOP_EXPR
2088 && TYPE_PRECISION (type0) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))
2089 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
2090 {
2091 final_type = result_type;
2092 op0 = TREE_OPERAND (op0, 0);
2093 result_type = TREE_TYPE (op0);
2094 }
2095 break;
2096
2097 case TRUNC_MOD_EXPR:
2098 case FLOOR_MOD_EXPR:
2099 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2100 {
2101 /* Although it would be tempting to shorten always here, that loses
2102 on some targets, since the modulo instruction is undefined if the
2103 quotient can't be represented in the computation mode. We shorten
2104 only if unsigned or if dividing by something we know != -1. */
2105 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
2106 || (TREE_CODE (op1) == INTEGER_CST
2107 && (TREE_INT_CST_LOW (op1) != -1
2108 || TREE_INT_CST_HIGH (op1) != -1)));
2109 common = 1;
2110 }
2111 break;
2112
2113 case TRUTH_ANDIF_EXPR:
2114 case TRUTH_ORIF_EXPR:
2115 case TRUTH_AND_EXPR:
2116 case TRUTH_OR_EXPR:
2117 case TRUTH_XOR_EXPR:
2118 if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
2119 || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2120 && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
2121 || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2122 {
2123 /* Result of these operations is always an int,
2124 but that does not mean the operands should be
2125 converted to ints! */
2126 result_type = integer_type_node;
2127 op0 = truthvalue_conversion (op0);
2128 op1 = truthvalue_conversion (op1);
2129 converted = 1;
2130 }
2131 break;
2132
2133 /* Shift operations: result has same type as first operand;
2134 always convert second operand to int.
2135 Also set SHORT_SHIFT if shifting rightward. */
2136
2137 case RSHIFT_EXPR:
2138 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2139 {
2140 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2141 {
2142 if (tree_int_cst_sgn (op1) < 0)
2143 warning ("right shift count is negative");
2144 else
2145 {
2146 if (TREE_INT_CST_LOW (op1) | TREE_INT_CST_HIGH (op1))
2147 short_shift = 1;
2148 if (TREE_INT_CST_HIGH (op1) != 0
2149 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
2150 >= TYPE_PRECISION (type0)))
2151 warning ("right shift count >= width of type");
2152 }
2153 }
2154 /* Use the type of the value to be shifted.
2155 This is what most traditional C compilers do. */
2156 result_type = type0;
2157 /* Unless traditional, convert the shift-count to an integer,
2158 regardless of size of value being shifted. */
2159 if (! flag_traditional)
2160 {
2161 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2162 op1 = convert (integer_type_node, op1);
2163 /* Avoid converting op1 to result_type later. */
2164 converted = 1;
2165 }
2166 }
2167 break;
2168
2169 case LSHIFT_EXPR:
2170 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2171 {
2172 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2173 {
2174 if (tree_int_cst_sgn (op1) < 0)
2175 warning ("left shift count is negative");
2176 else if (TREE_INT_CST_HIGH (op1) != 0
2177 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
2178 >= TYPE_PRECISION (type0)))
2179 warning ("left shift count >= width of type");
2180 }
2181 /* Use the type of the value to be shifted.
2182 This is what most traditional C compilers do. */
2183 result_type = type0;
2184 /* Unless traditional, convert the shift-count to an integer,
2185 regardless of size of value being shifted. */
2186 if (! flag_traditional)
2187 {
2188 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2189 op1 = convert (integer_type_node, op1);
2190 /* Avoid converting op1 to result_type later. */
2191 converted = 1;
2192 }
2193 }
2194 break;
2195
2196 case RROTATE_EXPR:
2197 case LROTATE_EXPR:
2198 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
2199 {
2200 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
2201 {
2202 if (tree_int_cst_sgn (op1) < 0)
2203 warning ("shift count is negative");
2204 else if (TREE_INT_CST_HIGH (op1) != 0
2205 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
2206 >= TYPE_PRECISION (type0)))
2207 warning ("shift count >= width of type");
2208 }
2209 /* Use the type of the value to be shifted.
2210 This is what most traditional C compilers do. */
2211 result_type = type0;
2212 /* Unless traditional, convert the shift-count to an integer,
2213 regardless of size of value being shifted. */
2214 if (! flag_traditional)
2215 {
2216 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
2217 op1 = convert (integer_type_node, op1);
2218 /* Avoid converting op1 to result_type later. */
2219 converted = 1;
2220 }
2221 }
2222 break;
2223
2224 case EQ_EXPR:
2225 case NE_EXPR:
2226 /* Result of comparison is always int,
2227 but don't convert the args to int! */
2228 build_type = integer_type_node;
2229 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
2230 || code0 == COMPLEX_TYPE)
2231 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
2232 || code1 == COMPLEX_TYPE))
2233 short_compare = 1;
2234 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2235 {
2236 register tree tt0 = TREE_TYPE (type0);
2237 register tree tt1 = TREE_TYPE (type1);
2238 /* Anything compares with void *. void * compares with anything.
2239 Otherwise, the targets must be compatible
2240 and both must be object or both incomplete. */
2241 if (comp_target_types (type0, type1))
2242 result_type = common_type (type0, type1);
2243 else if (TYPE_MAIN_VARIANT (tt0) == void_type_node)
2244 {
2245 /* op0 != orig_op0 detects the case of something
2246 whose value is 0 but which isn't a valid null ptr const. */
2247 if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
2248 && TREE_CODE (tt1) == FUNCTION_TYPE)
2249 pedwarn ("ANSI C forbids comparison of `void *' with function pointer");
2250 }
2251 else if (TYPE_MAIN_VARIANT (tt1) == void_type_node)
2252 {
2253 if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
2254 && TREE_CODE (tt0) == FUNCTION_TYPE)
2255 pedwarn ("ANSI C forbids comparison of `void *' with function pointer");
2256 }
2257 else
2258 pedwarn ("comparison of distinct pointer types lacks a cast");
2259
2260 if (result_type == NULL_TREE)
2261 result_type = ptr_type_node;
2262 }
2263 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2264 && integer_zerop (op1))
2265 result_type = type0;
2266 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2267 && integer_zerop (op0))
2268 result_type = type1;
2269 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2270 {
2271 result_type = type0;
2272 if (! flag_traditional)
2273 pedwarn ("comparison between pointer and integer");
2274 }
2275 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2276 {
2277 result_type = type1;
2278 if (! flag_traditional)
2279 pedwarn ("comparison between pointer and integer");
2280 }
2281 break;
2282
2283 case MAX_EXPR:
2284 case MIN_EXPR:
2285 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2286 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2287 shorten = 1;
2288 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2289 {
2290 if (comp_target_types (type0, type1))
2291 {
2292 result_type = common_type (type0, type1);
2293 if (pedantic
2294 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2295 pedwarn ("ANSI C forbids ordered comparisons of pointers to functions");
2296 }
2297 else
2298 {
2299 result_type = ptr_type_node;
2300 pedwarn ("comparison of distinct pointer types lacks a cast");
2301 }
2302 }
2303 break;
2304
2305 case LE_EXPR:
2306 case GE_EXPR:
2307 case LT_EXPR:
2308 case GT_EXPR:
2309 build_type = integer_type_node;
2310 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
2311 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
2312 short_compare = 1;
2313 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
2314 {
2315 if (comp_target_types (type0, type1))
2316 {
2317 result_type = common_type (type0, type1);
2318 if ((TYPE_SIZE (TREE_TYPE (type0)) != 0)
2319 != (TYPE_SIZE (TREE_TYPE (type1)) != 0))
2320 pedwarn ("comparison of complete and incomplete pointers");
2321 else if (pedantic
2322 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
2323 pedwarn ("ANSI C forbids ordered comparisons of pointers to functions");
2324 }
2325 else
2326 {
2327 result_type = ptr_type_node;
2328 pedwarn ("comparison of distinct pointer types lacks a cast");
2329 }
2330 }
2331 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
2332 && integer_zerop (op1))
2333 {
2334 result_type = type0;
2335 if (pedantic || extra_warnings)
2336 pedwarn ("ordered comparison of pointer with integer zero");
2337 }
2338 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
2339 && integer_zerop (op0))
2340 {
2341 result_type = type1;
2342 if (pedantic)
2343 pedwarn ("ordered comparison of pointer with integer zero");
2344 }
2345 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
2346 {
2347 result_type = type0;
2348 if (! flag_traditional)
2349 pedwarn ("comparison between pointer and integer");
2350 }
2351 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
2352 {
2353 result_type = type1;
2354 if (! flag_traditional)
2355 pedwarn ("comparison between pointer and integer");
2356 }
2357 break;
2358
2359 default:
2360 break;
2361 }
2362
2363 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
2364 &&
2365 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
2366 {
2367 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
2368
2369 if (shorten || common || short_compare)
2370 result_type = common_type (type0, type1);
2371
2372 /* For certain operations (which identify themselves by shorten != 0)
2373 if both args were extended from the same smaller type,
2374 do the arithmetic in that type and then extend.
2375
2376 shorten !=0 and !=1 indicates a bitwise operation.
2377 For them, this optimization is safe only if
2378 both args are zero-extended or both are sign-extended.
2379 Otherwise, we might change the result.
2380 Eg, (short)-1 | (unsigned short)-1 is (int)-1
2381 but calculated in (unsigned short) it would be (unsigned short)-1. */
2382
2383 if (shorten && none_complex)
2384 {
2385 int unsigned0, unsigned1;
2386 tree arg0 = get_narrower (op0, &unsigned0);
2387 tree arg1 = get_narrower (op1, &unsigned1);
2388 /* UNS is 1 if the operation to be done is an unsigned one. */
2389 int uns = TREE_UNSIGNED (result_type);
2390 tree type;
2391
2392 final_type = result_type;
2393
2394 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
2395 but it *requires* conversion to FINAL_TYPE. */
2396
2397 if ((TYPE_PRECISION (TREE_TYPE (op0))
2398 == TYPE_PRECISION (TREE_TYPE (arg0)))
2399 && TREE_TYPE (op0) != final_type)
2400 unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
2401 if ((TYPE_PRECISION (TREE_TYPE (op1))
2402 == TYPE_PRECISION (TREE_TYPE (arg1)))
2403 && TREE_TYPE (op1) != final_type)
2404 unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
2405
2406 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
2407
2408 /* For bitwise operations, signedness of nominal type
2409 does not matter. Consider only how operands were extended. */
2410 if (shorten == -1)
2411 uns = unsigned0;
2412
2413 /* Note that in all three cases below we refrain from optimizing
2414 an unsigned operation on sign-extended args.
2415 That would not be valid. */
2416
2417 /* Both args variable: if both extended in same way
2418 from same width, do it in that width.
2419 Do it unsigned if args were zero-extended. */
2420 if ((TYPE_PRECISION (TREE_TYPE (arg0))
2421 < TYPE_PRECISION (result_type))
2422 && (TYPE_PRECISION (TREE_TYPE (arg1))
2423 == TYPE_PRECISION (TREE_TYPE (arg0)))
2424 && unsigned0 == unsigned1
2425 && (unsigned0 || !uns))
2426 result_type
2427 = signed_or_unsigned_type (unsigned0,
2428 common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
2429 else if (TREE_CODE (arg0) == INTEGER_CST
2430 && (unsigned1 || !uns)
2431 && (TYPE_PRECISION (TREE_TYPE (arg1))
2432 < TYPE_PRECISION (result_type))
2433 && (type = signed_or_unsigned_type (unsigned1,
2434 TREE_TYPE (arg1)),
2435 int_fits_type_p (arg0, type)))
2436 result_type = type;
2437 else if (TREE_CODE (arg1) == INTEGER_CST
2438 && (unsigned0 || !uns)
2439 && (TYPE_PRECISION (TREE_TYPE (arg0))
2440 < TYPE_PRECISION (result_type))
2441 && (type = signed_or_unsigned_type (unsigned0,
2442 TREE_TYPE (arg0)),
2443 int_fits_type_p (arg1, type)))
2444 result_type = type;
2445 }
2446
2447 /* Shifts can be shortened if shifting right. */
2448
2449 if (short_shift)
2450 {
2451 int unsigned_arg;
2452 tree arg0 = get_narrower (op0, &unsigned_arg);
2453
2454 final_type = result_type;
2455
2456 if (arg0 == op0 && final_type == TREE_TYPE (op0))
2457 unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
2458
2459 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
2460 /* We can shorten only if the shift count is less than the
2461 number of bits in the smaller type size. */
2462 && TREE_INT_CST_HIGH (op1) == 0
2463 && TYPE_PRECISION (TREE_TYPE (arg0)) > TREE_INT_CST_LOW (op1)
2464 /* If arg is sign-extended and then unsigned-shifted,
2465 we can simulate this with a signed shift in arg's type
2466 only if the extended result is at least twice as wide
2467 as the arg. Otherwise, the shift could use up all the
2468 ones made by sign-extension and bring in zeros.
2469 We can't optimize that case at all, but in most machines
2470 it never happens because available widths are 2**N. */
2471 && (!TREE_UNSIGNED (final_type)
2472 || unsigned_arg
2473 || 2 * TYPE_PRECISION (TREE_TYPE (arg0)) <= TYPE_PRECISION (result_type)))
2474 {
2475 /* Do an unsigned shift if the operand was zero-extended. */
2476 result_type
2477 = signed_or_unsigned_type (unsigned_arg,
2478 TREE_TYPE (arg0));
2479 /* Convert value-to-be-shifted to that type. */
2480 if (TREE_TYPE (op0) != result_type)
2481 op0 = convert (result_type, op0);
2482 converted = 1;
2483 }
2484 }
2485
2486 /* Comparison operations are shortened too but differently.
2487 They identify themselves by setting short_compare = 1. */
2488
2489 if (short_compare)
2490 {
2491 /* Don't write &op0, etc., because that would prevent op0
2492 from being kept in a register.
2493 Instead, make copies of the our local variables and
2494 pass the copies by reference, then copy them back afterward. */
2495 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
2496 enum tree_code xresultcode = resultcode;
2497 tree val
2498 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
2499 if (val != 0)
2500 return val;
2501 op0 = xop0, op1 = xop1;
2502 converted = 1;
2503 resultcode = xresultcode;
2504
2505 if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare != 0)
2506 && skip_evaluation == 0)
2507 {
2508 int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
2509 int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
2510
2511 int unsignedp0, unsignedp1;
2512 tree primop0 = get_narrower (op0, &unsignedp0);
2513 tree primop1 = get_narrower (op1, &unsignedp1);
2514
2515 /* Avoid spurious warnings for comparison with enumerators. */
2516
2517 xop0 = orig_op0;
2518 xop1 = orig_op1;
2519 STRIP_TYPE_NOPS (xop0);
2520 STRIP_TYPE_NOPS (xop1);
2521
2522 /* Give warnings for comparisons between signed and unsigned
2523 quantities that may fail. */
2524 /* Do the checking based on the original operand trees, so that
2525 casts will be considered, but default promotions won't be. */
2526
2527 /* Do not warn if the comparison is being done in a signed type,
2528 since the signed type will only be chosen if it can represent
2529 all the values of the unsigned type. */
2530 if (! TREE_UNSIGNED (result_type))
2531 /* OK */;
2532 /* Do not warn if both operands are unsigned. */
2533 else if (op0_signed == op1_signed)
2534 /* OK */;
2535 /* Do not warn if the signed quantity is an unsuffixed
2536 integer literal (or some static constant expression
2537 involving such literals) and it is non-negative. */
2538 else if ((op0_signed && TREE_CODE (xop0) == INTEGER_CST
2539 && tree_int_cst_sgn (xop0) >= 0)
2540 || (op1_signed && TREE_CODE (xop1) == INTEGER_CST
2541 && tree_int_cst_sgn (xop1) >= 0))
2542 /* OK */;
2543 /* Do not warn if the comparison is an equality operation,
2544 the unsigned quantity is an integral constant and it does
2545 not use the most significant bit of result_type. */
2546 else if ((resultcode == EQ_EXPR || resultcode == NE_EXPR)
2547 && ((op0_signed && TREE_CODE (xop1) == INTEGER_CST
2548 && int_fits_type_p (xop1, signed_type (result_type)))
2549 || (op1_signed && TREE_CODE (xop0) == INTEGER_CST
2550 && int_fits_type_p (xop0, signed_type (result_type)))))
2551 /* OK */;
2552 else
2553 warning ("comparison between signed and unsigned");
2554
2555 /* Warn if two unsigned values are being compared in a size
2556 larger than their original size, and one (and only one) is the
2557 result of a `~' operator. This comparison will always fail.
2558
2559 Also warn if one operand is a constant, and the constant
2560 does not have all bits set that are set in the ~ operand
2561 when it is extended. */
2562
2563 if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
2564 != (TREE_CODE (primop1) == BIT_NOT_EXPR))
2565 {
2566 if (TREE_CODE (primop0) == BIT_NOT_EXPR)
2567 primop0 = get_narrower (TREE_OPERAND (primop0, 0),
2568 &unsignedp0);
2569 else
2570 primop1 = get_narrower (TREE_OPERAND (primop1, 0),
2571 &unsignedp1);
2572
2573 if (TREE_CODE (primop0) == INTEGER_CST
2574 || TREE_CODE (primop1) == INTEGER_CST)
2575 {
2576 tree primop;
2577 long constant, mask;
2578 int unsignedp, bits;
2579
2580 if (TREE_CODE (primop0) == INTEGER_CST)
2581 {
2582 primop = primop1;
2583 unsignedp = unsignedp1;
2584 constant = TREE_INT_CST_LOW (primop0);
2585 }
2586 else
2587 {
2588 primop = primop0;
2589 unsignedp = unsignedp0;
2590 constant = TREE_INT_CST_LOW (primop1);
2591 }
2592
2593 bits = TYPE_PRECISION (TREE_TYPE (primop));
2594 if (bits < TYPE_PRECISION (result_type)
2595 && bits < HOST_BITS_PER_LONG && unsignedp)
2596 {
2597 mask = (~0L) << bits;
2598 if ((mask & constant) != mask)
2599 warning ("comparison of promoted ~unsigned with constant");
2600 }
2601 }
2602 else if (unsignedp0 && unsignedp1
2603 && (TYPE_PRECISION (TREE_TYPE (primop0))
2604 < TYPE_PRECISION (result_type))
2605 && (TYPE_PRECISION (TREE_TYPE (primop1))
2606 < TYPE_PRECISION (result_type)))
2607 warning ("comparison of promoted ~unsigned with unsigned");
2608 }
2609 }
2610 }
2611 }
2612
2613 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
2614 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
2615 Then the expression will be built.
2616 It will be given type FINAL_TYPE if that is nonzero;
2617 otherwise, it will be given type RESULT_TYPE. */
2618
2619 if (!result_type)
2620 {
2621 binary_op_error (code);
2622 return error_mark_node;
2623 }
2624
2625 if (! converted)
2626 {
2627 if (TREE_TYPE (op0) != result_type)
2628 op0 = convert (result_type, op0);
2629 if (TREE_TYPE (op1) != result_type)
2630 op1 = convert (result_type, op1);
2631 }
2632
2633 if (build_type == NULL_TREE)
2634 build_type = result_type;
2635
2636 {
2637 register tree result = build (resultcode, build_type, op0, op1);
2638 register tree folded;
2639
2640 folded = fold (result);
2641 if (folded == result)
2642 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2643 if (final_type != 0)
2644 return convert (final_type, folded);
2645 return folded;
2646 }
2647}
2648
2649/* Return a tree for the sum or difference (RESULTCODE says which)
2650 of pointer PTROP and integer INTOP. */
2651
2652static tree
2653pointer_int_sum (resultcode, ptrop, intop)
2654 enum tree_code resultcode;
2655 register tree ptrop, intop;
2656{
2657 tree size_exp;
2658
2659 register tree result;
2660 register tree folded;
2661
2662 /* The result is a pointer of the same type that is being added. */
2663
2664 register tree result_type = TREE_TYPE (ptrop);
2665
2666 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2667 {
2668 if (pedantic || warn_pointer_arith)
2669 pedwarn ("pointer of type `void *' used in arithmetic");
2670 size_exp = integer_one_node;
2671 }
2672 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2673 {
2674 if (pedantic || warn_pointer_arith)
2675 pedwarn ("pointer to a function used in arithmetic");
2676 size_exp = integer_one_node;
2677 }
2678 else
2679 size_exp = c_size_in_bytes (TREE_TYPE (result_type));
2680
2681 /* If what we are about to multiply by the size of the elements
2682 contains a constant term, apply distributive law
2683 and multiply that constant term separately.
2684 This helps produce common subexpressions. */
2685
2686 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2687 && ! TREE_CONSTANT (intop)
2688 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2689 && TREE_CONSTANT (size_exp)
2690 /* If the constant comes from pointer subtraction,
2691 skip this optimization--it would cause an error. */
2692 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2693 /* If the constant is unsigned, and smaller than the pointer size,
2694 then we must skip this optimization. This is because it could cause
2695 an overflow error if the constant is negative but INTOP is not. */
2696 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2697 || (TYPE_PRECISION (TREE_TYPE (intop))
2698 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2699 {
2700 enum tree_code subcode = resultcode;
2701 tree int_type = TREE_TYPE (intop);
2702 if (TREE_CODE (intop) == MINUS_EXPR)
2703 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2704 /* Convert both subexpression types to the type of intop,
2705 because weird cases involving pointer arithmetic
2706 can result in a sum or difference with different type args. */
2707 ptrop = build_binary_op (subcode, ptrop,
2708 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2709 intop = convert (int_type, TREE_OPERAND (intop, 0));
2710 }
2711
2712 /* Convert the integer argument to a type the same size as sizetype
2713 so the multiply won't overflow spuriously. */
2714
2715 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2716 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2717 intop = convert (type_for_size (TYPE_PRECISION (sizetype),
2718 TREE_UNSIGNED (sizetype)), intop);
2719
2720 /* Replace the integer argument with a suitable product by the object size.
2721 Do this multiplication as signed, then convert to the appropriate
2722 pointer type (actually unsigned integral). */
2723
2724 intop = convert (result_type,
2725 build_binary_op (MULT_EXPR, intop,
2726 convert (TREE_TYPE (intop), size_exp), 1));
2727
2728 /* Create the sum or difference. */
2729
2730 result = build (resultcode, result_type, ptrop, intop);
2731
2732 folded = fold (result);
2733 if (folded == result)
2734 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2735 return folded;
2736}
2737
2738/* Return a tree for the difference of pointers OP0 and OP1.
2739 The resulting tree has type int. */
2740
2741static tree
2742pointer_diff (op0, op1)
2743 register tree op0, op1;
2744{
2745 register tree result, folded;
2746 tree restype = ptrdiff_type_node;
2747
2748 tree target_type = TREE_TYPE (TREE_TYPE (op0));
2749
2750 if (pedantic || warn_pointer_arith)
2751 {
2752 if (TREE_CODE (target_type) == VOID_TYPE)
2753 pedwarn ("pointer of type `void *' used in subtraction");
2754 if (TREE_CODE (target_type) == FUNCTION_TYPE)
2755 pedwarn ("pointer to a function used in subtraction");
2756 }
2757
2758 /* First do the subtraction as integers;
2759 then drop through to build the divide operator.
2760 Do not do default conversions on the minus operator
2761 in case restype is a short type. */
2762
2763 op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2764 convert (restype, op1), 0);
2765 /* This generates an error if op1 is pointer to incomplete type. */
2766 if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1))) == 0)
2767 error ("arithmetic on pointer to an incomplete type");
2768
2769 /* This generates an error if op0 is pointer to incomplete type. */
2770 op1 = c_size_in_bytes (target_type);
2771
2772 /* Divide by the size, in easiest possible way. */
2773
2774 result = build (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
2775
2776 folded = fold (result);
2777 if (folded == result)
2778 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2779 return folded;
2780}
2781
2782/* Construct and perhaps optimize a tree representation
2783 for a unary operation. CODE, a tree_code, specifies the operation
2784 and XARG is the operand. NOCONVERT nonzero suppresses
2785 the default promotions (such as from short to int). */
2786
2787tree
2788build_unary_op (code, xarg, noconvert)
2789 enum tree_code code;
2790 tree xarg;
2791 int noconvert;
2792{
2793 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
2794 register tree arg = xarg;
2795 register tree argtype = 0;
2796 register enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
|
2796 char *errstring = NULL;
| |
2797 tree val;
2798
2799 if (typecode == ERROR_MARK)
2800 return error_mark_node;
2801 if (typecode == ENUMERAL_TYPE)
2802 typecode = INTEGER_TYPE;
2803
2804 switch (code)
2805 {
2806 case CONVERT_EXPR:
2807 /* This is used for unary plus, because a CONVERT_EXPR
2808 is enough to prevent anybody from looking inside for
2809 associativity, but won't generate any code. */
2810 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2811 || typecode == COMPLEX_TYPE))
| 2797 tree val;
2798
2799 if (typecode == ERROR_MARK)
2800 return error_mark_node;
2801 if (typecode == ENUMERAL_TYPE)
2802 typecode = INTEGER_TYPE;
2803
2804 switch (code)
2805 {
2806 case CONVERT_EXPR:
2807 /* This is used for unary plus, because a CONVERT_EXPR
2808 is enough to prevent anybody from looking inside for
2809 associativity, but won't generate any code. */
2810 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2811 || typecode == COMPLEX_TYPE))
|
2812 errstring = "wrong type argument to unary plus";
| 2812 {
2813 error ("wrong type argument to unary plus");
2814 return error_mark_node;
2815 }
|
2813 else if (!noconvert)
2814 arg = default_conversion (arg);
2815 break;
2816
2817 case NEGATE_EXPR:
2818 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2819 || typecode == COMPLEX_TYPE))
| 2816 else if (!noconvert)
2817 arg = default_conversion (arg);
2818 break;
2819
2820 case NEGATE_EXPR:
2821 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2822 || typecode == COMPLEX_TYPE))
|
2820 errstring = "wrong type argument to unary minus";
| 2823 {
2824 error ("wrong type argument to unary minus");
2825 return error_mark_node;
2826 }
|
2821 else if (!noconvert)
2822 arg = default_conversion (arg);
2823 break;
2824
2825 case BIT_NOT_EXPR:
2826 if (typecode == COMPLEX_TYPE)
2827 {
2828 code = CONJ_EXPR;
2829 if (!noconvert)
2830 arg = default_conversion (arg);
2831 }
2832 else if (typecode != INTEGER_TYPE)
| 2827 else if (!noconvert)
2828 arg = default_conversion (arg);
2829 break;
2830
2831 case BIT_NOT_EXPR:
2832 if (typecode == COMPLEX_TYPE)
2833 {
2834 code = CONJ_EXPR;
2835 if (!noconvert)
2836 arg = default_conversion (arg);
2837 }
2838 else if (typecode != INTEGER_TYPE)
|
2833 errstring = "wrong type argument to bit-complement";
| 2839 {
2840 error ("wrong type argument to bit-complement");
2841 return error_mark_node;
2842 }
|
2834 else if (!noconvert)
2835 arg = default_conversion (arg);
2836 break;
2837
2838 case ABS_EXPR:
2839 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2840 || typecode == COMPLEX_TYPE))
| 2843 else if (!noconvert)
2844 arg = default_conversion (arg);
2845 break;
2846
2847 case ABS_EXPR:
2848 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2849 || typecode == COMPLEX_TYPE))
|
2841 errstring = "wrong type argument to abs";
| 2850 {
2851 error ("wrong type argument to abs");
2852 return error_mark_node;
2853 }
|
2842 else if (!noconvert)
2843 arg = default_conversion (arg);
2844 break;
2845
2846 case CONJ_EXPR:
2847 /* Conjugating a real value is a no-op, but allow it anyway. */
2848 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2849 || typecode == COMPLEX_TYPE))
| 2854 else if (!noconvert)
2855 arg = default_conversion (arg);
2856 break;
2857
2858 case CONJ_EXPR:
2859 /* Conjugating a real value is a no-op, but allow it anyway. */
2860 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2861 || typecode == COMPLEX_TYPE))
|
2850 errstring = "wrong type argument to conjugation";
| 2862 {
2863 error ("wrong type argument to conjugation");
2864 return error_mark_node;
2865 }
|
2851 else if (!noconvert)
2852 arg = default_conversion (arg);
2853 break;
2854
2855 case TRUTH_NOT_EXPR:
2856 if (typecode != INTEGER_TYPE
2857 && typecode != REAL_TYPE && typecode != POINTER_TYPE
2858 && typecode != COMPLEX_TYPE
2859 /* These will convert to a pointer. */
2860 && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2861 {
| 2866 else if (!noconvert)
2867 arg = default_conversion (arg);
2868 break;
2869
2870 case TRUTH_NOT_EXPR:
2871 if (typecode != INTEGER_TYPE
2872 && typecode != REAL_TYPE && typecode != POINTER_TYPE
2873 && typecode != COMPLEX_TYPE
2874 /* These will convert to a pointer. */
2875 && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2876 {
|
2862 errstring = "wrong type argument to unary exclamation mark";
2863 break;
| 2877 error ("wrong type argument to unary exclamation mark");
2878 return error_mark_node;
|
2864 }
2865 arg = truthvalue_conversion (arg);
2866 return invert_truthvalue (arg);
2867
2868 case NOP_EXPR:
2869 break;
2870
2871 case REALPART_EXPR:
2872 if (TREE_CODE (arg) == COMPLEX_CST)
2873 return TREE_REALPART (arg);
2874 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2875 return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2876 else
2877 return arg;
2878
2879 case IMAGPART_EXPR:
2880 if (TREE_CODE (arg) == COMPLEX_CST)
2881 return TREE_IMAGPART (arg);
2882 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2883 return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2884 else
2885 return convert (TREE_TYPE (arg), integer_zero_node);
2886
2887 case PREINCREMENT_EXPR:
2888 case POSTINCREMENT_EXPR:
2889 case PREDECREMENT_EXPR:
2890 case POSTDECREMENT_EXPR:
2891 /* Handle complex lvalues (when permitted)
2892 by reduction to simpler cases. */
2893
2894 val = unary_complex_lvalue (code, arg);
2895 if (val != 0)
2896 return val;
2897
2898 /* Increment or decrement the real part of the value,
2899 and don't change the imaginary part. */
2900 if (typecode == COMPLEX_TYPE)
2901 {
2902 tree real, imag;
2903
2904 arg = stabilize_reference (arg);
2905 real = build_unary_op (REALPART_EXPR, arg, 1);
2906 imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2907 return build (COMPLEX_EXPR, TREE_TYPE (arg),
2908 build_unary_op (code, real, 1), imag);
2909 }
2910
2911 /* Report invalid types. */
2912
2913 if (typecode != POINTER_TYPE
2914 && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2915 {
| 2879 }
2880 arg = truthvalue_conversion (arg);
2881 return invert_truthvalue (arg);
2882
2883 case NOP_EXPR:
2884 break;
2885
2886 case REALPART_EXPR:
2887 if (TREE_CODE (arg) == COMPLEX_CST)
2888 return TREE_REALPART (arg);
2889 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2890 return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2891 else
2892 return arg;
2893
2894 case IMAGPART_EXPR:
2895 if (TREE_CODE (arg) == COMPLEX_CST)
2896 return TREE_IMAGPART (arg);
2897 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2898 return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2899 else
2900 return convert (TREE_TYPE (arg), integer_zero_node);
2901
2902 case PREINCREMENT_EXPR:
2903 case POSTINCREMENT_EXPR:
2904 case PREDECREMENT_EXPR:
2905 case POSTDECREMENT_EXPR:
2906 /* Handle complex lvalues (when permitted)
2907 by reduction to simpler cases. */
2908
2909 val = unary_complex_lvalue (code, arg);
2910 if (val != 0)
2911 return val;
2912
2913 /* Increment or decrement the real part of the value,
2914 and don't change the imaginary part. */
2915 if (typecode == COMPLEX_TYPE)
2916 {
2917 tree real, imag;
2918
2919 arg = stabilize_reference (arg);
2920 real = build_unary_op (REALPART_EXPR, arg, 1);
2921 imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2922 return build (COMPLEX_EXPR, TREE_TYPE (arg),
2923 build_unary_op (code, real, 1), imag);
2924 }
2925
2926 /* Report invalid types. */
2927
2928 if (typecode != POINTER_TYPE
2929 && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2930 {
|
2916 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2917 errstring ="wrong type argument to increment";
2918 else
2919 errstring ="wrong type argument to decrement";
2920 break;
| 2931 error (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2932 ? "wrong type argument to increment"
2933 : "wrong type argument to decrement");
2934 return error_mark_node;
|
2921 }
2922
2923 {
2924 register tree inc;
2925 tree result_type = TREE_TYPE (arg);
2926
2927 arg = get_unwidened (arg, 0);
2928 argtype = TREE_TYPE (arg);
2929
2930 /* Compute the increment. */
2931
2932 if (typecode == POINTER_TYPE)
2933 {
2934 /* If pointer target is an undefined struct,
2935 we just cannot know how to do the arithmetic. */
2936 if (TYPE_SIZE (TREE_TYPE (result_type)) == 0)
| 2935 }
2936
2937 {
2938 register tree inc;
2939 tree result_type = TREE_TYPE (arg);
2940
2941 arg = get_unwidened (arg, 0);
2942 argtype = TREE_TYPE (arg);
2943
2944 /* Compute the increment. */
2945
2946 if (typecode == POINTER_TYPE)
2947 {
2948 /* If pointer target is an undefined struct,
2949 we just cannot know how to do the arithmetic. */
2950 if (TYPE_SIZE (TREE_TYPE (result_type)) == 0)
|
2937 error ("%s of pointer to unknown structure",
2938 ((code == PREINCREMENT_EXPR
2939 || code == POSTINCREMENT_EXPR)
2940 ? "increment" : "decrement"));
| 2951 error (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2952 ? "increment of pointer to unknown structure"
2953 : "decrement of pointer to unknown structure");
|
2941 else if ((pedantic || warn_pointer_arith)
2942 && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2943 || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
| 2954 else if ((pedantic || warn_pointer_arith)
2955 && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2956 || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
|
2944 pedwarn ("wrong type argument to %s",
2945 ((code == PREINCREMENT_EXPR
2946 || code == POSTINCREMENT_EXPR)
2947 ? "increment" : "decrement"));
| 2957 pedwarn (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
2958 ? "wrong type argument to increment"
2959 : "wrong type argument to decrement");
|
2948 inc = c_size_in_bytes (TREE_TYPE (result_type));
2949 }
2950 else
2951 inc = integer_one_node;
2952
2953 inc = convert (argtype, inc);
2954
2955 /* Handle incrementing a cast-expression. */
2956
2957 while (1)
2958 switch (TREE_CODE (arg))
2959 {
2960 case NOP_EXPR:
2961 case CONVERT_EXPR:
2962 case FLOAT_EXPR:
2963 case FIX_TRUNC_EXPR:
2964 case FIX_FLOOR_EXPR:
2965 case FIX_ROUND_EXPR:
2966 case FIX_CEIL_EXPR:
2967 pedantic_lvalue_warning (CONVERT_EXPR);
2968 /* If the real type has the same machine representation
2969 as the type it is cast to, we can make better output
2970 by adding directly to the inside of the cast. */
2971 if ((TREE_CODE (TREE_TYPE (arg))
2972 == TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))))
2973 && (TYPE_MODE (TREE_TYPE (arg))
2974 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg, 0)))))
2975 arg = TREE_OPERAND (arg, 0);
2976 else
2977 {
2978 tree incremented, modify, value;
2979 arg = stabilize_reference (arg);
2980 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
2981 value = arg;
2982 else
2983 value = save_expr (arg);
2984 incremented = build (((code == PREINCREMENT_EXPR
2985 || code == POSTINCREMENT_EXPR)
2986 ? PLUS_EXPR : MINUS_EXPR),
2987 argtype, value, inc);
2988 TREE_SIDE_EFFECTS (incremented) = 1;
2989 modify = build_modify_expr (arg, NOP_EXPR, incremented);
2990 value = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
2991 TREE_USED (value) = 1;
2992 return value;
2993 }
2994 break;
2995
2996 default:
2997 goto give_up;
2998 }
2999 give_up:
3000
3001 /* Complain about anything else that is not a true lvalue. */
3002 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
3003 || code == POSTINCREMENT_EXPR)
| 2960 inc = c_size_in_bytes (TREE_TYPE (result_type));
2961 }
2962 else
2963 inc = integer_one_node;
2964
2965 inc = convert (argtype, inc);
2966
2967 /* Handle incrementing a cast-expression. */
2968
2969 while (1)
2970 switch (TREE_CODE (arg))
2971 {
2972 case NOP_EXPR:
2973 case CONVERT_EXPR:
2974 case FLOAT_EXPR:
2975 case FIX_TRUNC_EXPR:
2976 case FIX_FLOOR_EXPR:
2977 case FIX_ROUND_EXPR:
2978 case FIX_CEIL_EXPR:
2979 pedantic_lvalue_warning (CONVERT_EXPR);
2980 /* If the real type has the same machine representation
2981 as the type it is cast to, we can make better output
2982 by adding directly to the inside of the cast. */
2983 if ((TREE_CODE (TREE_TYPE (arg))
2984 == TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))))
2985 && (TYPE_MODE (TREE_TYPE (arg))
2986 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg, 0)))))
2987 arg = TREE_OPERAND (arg, 0);
2988 else
2989 {
2990 tree incremented, modify, value;
2991 arg = stabilize_reference (arg);
2992 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
2993 value = arg;
2994 else
2995 value = save_expr (arg);
2996 incremented = build (((code == PREINCREMENT_EXPR
2997 || code == POSTINCREMENT_EXPR)
2998 ? PLUS_EXPR : MINUS_EXPR),
2999 argtype, value, inc);
3000 TREE_SIDE_EFFECTS (incremented) = 1;
3001 modify = build_modify_expr (arg, NOP_EXPR, incremented);
3002 value = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
3003 TREE_USED (value) = 1;
3004 return value;
3005 }
3006 break;
3007
3008 default:
3009 goto give_up;
3010 }
3011 give_up:
3012
3013 /* Complain about anything else that is not a true lvalue. */
3014 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
3015 || code == POSTINCREMENT_EXPR)
|
3004 ? "increment" : "decrement")))
| 3016 ? "invalid lvalue in increment"
3017 : "invalid lvalue in decrement")))
|
3005 return error_mark_node;
3006
3007 /* Report a read-only lvalue. */
3008 if (TREE_READONLY (arg))
3009 readonly_warning (arg,
3010 ((code == PREINCREMENT_EXPR
3011 || code == POSTINCREMENT_EXPR)
3012 ? "increment" : "decrement"));
3013
3014 val = build (code, TREE_TYPE (arg), arg, inc);
3015 TREE_SIDE_EFFECTS (val) = 1;
3016 val = convert (result_type, val);
3017 if (TREE_CODE (val) != code)
3018 TREE_NO_UNUSED_WARNING (val) = 1;
3019 return val;
3020 }
3021
3022 case ADDR_EXPR:
3023 /* Note that this operation never does default_conversion
3024 regardless of NOCONVERT. */
3025
3026 /* Let &* cancel out to simplify resulting code. */
3027 if (TREE_CODE (arg) == INDIRECT_REF)
3028 {
3029 /* Don't let this be an lvalue. */
3030 if (lvalue_p (TREE_OPERAND (arg, 0)))
3031 return non_lvalue (TREE_OPERAND (arg, 0));
3032 return TREE_OPERAND (arg, 0);
3033 }
3034
3035 /* For &x[y], return x+y */
3036 if (TREE_CODE (arg) == ARRAY_REF)
3037 {
3038 if (mark_addressable (TREE_OPERAND (arg, 0)) == 0)
3039 return error_mark_node;
3040 return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
3041 TREE_OPERAND (arg, 1), 1);
3042 }
3043
3044 /* Handle complex lvalues (when permitted)
3045 by reduction to simpler cases. */
3046 val = unary_complex_lvalue (code, arg);
3047 if (val != 0)
3048 return val;
3049
3050#if 0 /* Turned off because inconsistent;
3051 float f; *&(int)f = 3.4 stores in int format
3052 whereas (int)f = 3.4 stores in float format. */
3053 /* Address of a cast is just a cast of the address
3054 of the operand of the cast. */
3055 switch (TREE_CODE (arg))
3056 {
3057 case NOP_EXPR:
3058 case CONVERT_EXPR:
3059 case FLOAT_EXPR:
3060 case FIX_TRUNC_EXPR:
3061 case FIX_FLOOR_EXPR:
3062 case FIX_ROUND_EXPR:
3063 case FIX_CEIL_EXPR:
3064 if (pedantic)
3065 pedwarn ("ANSI C forbids the address of a cast expression");
3066 return convert (build_pointer_type (TREE_TYPE (arg)),
3067 build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0),
3068 0));
3069 }
3070#endif
3071
3072 /* Allow the address of a constructor if all the elements
3073 are constant. */
3074 if (TREE_CODE (arg) == CONSTRUCTOR && TREE_CONSTANT (arg))
3075 ;
3076 /* Anything not already handled and not a true memory reference
3077 is an error. */
| 3018 return error_mark_node;
3019
3020 /* Report a read-only lvalue. */
3021 if (TREE_READONLY (arg))
3022 readonly_warning (arg,
3023 ((code == PREINCREMENT_EXPR
3024 || code == POSTINCREMENT_EXPR)
3025 ? "increment" : "decrement"));
3026
3027 val = build (code, TREE_TYPE (arg), arg, inc);
3028 TREE_SIDE_EFFECTS (val) = 1;
3029 val = convert (result_type, val);
3030 if (TREE_CODE (val) != code)
3031 TREE_NO_UNUSED_WARNING (val) = 1;
3032 return val;
3033 }
3034
3035 case ADDR_EXPR:
3036 /* Note that this operation never does default_conversion
3037 regardless of NOCONVERT. */
3038
3039 /* Let &* cancel out to simplify resulting code. */
3040 if (TREE_CODE (arg) == INDIRECT_REF)
3041 {
3042 /* Don't let this be an lvalue. */
3043 if (lvalue_p (TREE_OPERAND (arg, 0)))
3044 return non_lvalue (TREE_OPERAND (arg, 0));
3045 return TREE_OPERAND (arg, 0);
3046 }
3047
3048 /* For &x[y], return x+y */
3049 if (TREE_CODE (arg) == ARRAY_REF)
3050 {
3051 if (mark_addressable (TREE_OPERAND (arg, 0)) == 0)
3052 return error_mark_node;
3053 return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
3054 TREE_OPERAND (arg, 1), 1);
3055 }
3056
3057 /* Handle complex lvalues (when permitted)
3058 by reduction to simpler cases. */
3059 val = unary_complex_lvalue (code, arg);
3060 if (val != 0)
3061 return val;
3062
3063#if 0 /* Turned off because inconsistent;
3064 float f; *&(int)f = 3.4 stores in int format
3065 whereas (int)f = 3.4 stores in float format. */
3066 /* Address of a cast is just a cast of the address
3067 of the operand of the cast. */
3068 switch (TREE_CODE (arg))
3069 {
3070 case NOP_EXPR:
3071 case CONVERT_EXPR:
3072 case FLOAT_EXPR:
3073 case FIX_TRUNC_EXPR:
3074 case FIX_FLOOR_EXPR:
3075 case FIX_ROUND_EXPR:
3076 case FIX_CEIL_EXPR:
3077 if (pedantic)
3078 pedwarn ("ANSI C forbids the address of a cast expression");
3079 return convert (build_pointer_type (TREE_TYPE (arg)),
3080 build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0),
3081 0));
3082 }
3083#endif
3084
3085 /* Allow the address of a constructor if all the elements
3086 are constant. */
3087 if (TREE_CODE (arg) == CONSTRUCTOR && TREE_CONSTANT (arg))
3088 ;
3089 /* Anything not already handled and not a true memory reference
3090 is an error. */
|
3078 else if (typecode != FUNCTION_TYPE && !lvalue_or_else (arg, "unary `&'"))
| 3091 else if (typecode != FUNCTION_TYPE
3092 && !lvalue_or_else (arg, "invalid lvalue in unary `&'"))
|
3079 return error_mark_node;
3080
3081 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
3082 argtype = TREE_TYPE (arg);
| 3093 return error_mark_node;
3094
3095 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
3096 argtype = TREE_TYPE (arg);
|
3083 /* If the lvalue is const or volatile,
3084 merge that into the type that the address will point to. */
| 3097 /* If the lvalue is const or volatile, merge that into the type
3098 to which the address will point. Note that you can't get a
3099 restricted pointer by taking the address of something, so we
3100 only have to deal with `const' and `volatile' here. */
|
3085 if (TREE_CODE_CLASS (TREE_CODE (arg)) == 'd'
3086 || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
3087 {
3088 if (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))
3089 argtype = c_build_type_variant (argtype,
3090 TREE_READONLY (arg),
3091 TREE_THIS_VOLATILE (arg));
3092 }
3093
3094 argtype = build_pointer_type (argtype);
3095
3096 if (mark_addressable (arg) == 0)
3097 return error_mark_node;
3098
3099 {
3100 tree addr;
3101
3102 if (TREE_CODE (arg) == COMPONENT_REF)
3103 {
3104 tree field = TREE_OPERAND (arg, 1);
3105
3106 addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
3107
3108 if (DECL_C_BIT_FIELD (field))
3109 {
3110 error ("attempt to take address of bit-field structure member `%s'",
3111 IDENTIFIER_POINTER (DECL_NAME (field)));
3112 return error_mark_node;
3113 }
3114
3115 addr = convert (argtype, addr);
3116
3117 if (! integer_zerop (DECL_FIELD_BITPOS (field)))
3118 {
3119 tree offset
3120 = size_binop (EASY_DIV_EXPR, DECL_FIELD_BITPOS (field),
3121 size_int (BITS_PER_UNIT));
3122 int flag = TREE_CONSTANT (addr);
3123 addr = fold (build (PLUS_EXPR, argtype,
3124 addr, convert (argtype, offset)));
3125 TREE_CONSTANT (addr) = flag;
3126 }
3127 }
3128 else
3129 addr = build1 (code, argtype, arg);
3130
3131 /* Address of a static or external variable or
3132 file-scope function counts as a constant. */
3133 if (staticp (arg)
3134 && ! (TREE_CODE (arg) == FUNCTION_DECL
3135 && DECL_CONTEXT (arg) != 0))
3136 TREE_CONSTANT (addr) = 1;
3137 return addr;
3138 }
3139
3140 default:
3141 break;
3142 }
3143
| 3101 if (TREE_CODE_CLASS (TREE_CODE (arg)) == 'd'
3102 || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
3103 {
3104 if (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))
3105 argtype = c_build_type_variant (argtype,
3106 TREE_READONLY (arg),
3107 TREE_THIS_VOLATILE (arg));
3108 }
3109
3110 argtype = build_pointer_type (argtype);
3111
3112 if (mark_addressable (arg) == 0)
3113 return error_mark_node;
3114
3115 {
3116 tree addr;
3117
3118 if (TREE_CODE (arg) == COMPONENT_REF)
3119 {
3120 tree field = TREE_OPERAND (arg, 1);
3121
3122 addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
3123
3124 if (DECL_C_BIT_FIELD (field))
3125 {
3126 error ("attempt to take address of bit-field structure member `%s'",
3127 IDENTIFIER_POINTER (DECL_NAME (field)));
3128 return error_mark_node;
3129 }
3130
3131 addr = convert (argtype, addr);
3132
3133 if (! integer_zerop (DECL_FIELD_BITPOS (field)))
3134 {
3135 tree offset
3136 = size_binop (EASY_DIV_EXPR, DECL_FIELD_BITPOS (field),
3137 size_int (BITS_PER_UNIT));
3138 int flag = TREE_CONSTANT (addr);
3139 addr = fold (build (PLUS_EXPR, argtype,
3140 addr, convert (argtype, offset)));
3141 TREE_CONSTANT (addr) = flag;
3142 }
3143 }
3144 else
3145 addr = build1 (code, argtype, arg);
3146
3147 /* Address of a static or external variable or
3148 file-scope function counts as a constant. */
3149 if (staticp (arg)
3150 && ! (TREE_CODE (arg) == FUNCTION_DECL
3151 && DECL_CONTEXT (arg) != 0))
3152 TREE_CONSTANT (addr) = 1;
3153 return addr;
3154 }
3155
3156 default:
3157 break;
3158 }
3159
|
3144 if (!errstring)
3145 {
3146 if (argtype == 0)
3147 argtype = TREE_TYPE (arg);
3148 return fold (build1 (code, argtype, arg));
3149 }
3150
3151 error (errstring);
3152 return error_mark_node;
| 3160 if (argtype == 0)
3161 argtype = TREE_TYPE (arg);
3162 return fold (build1 (code, argtype, arg));
|
3153}
3154
3155#if 0
3156/* If CONVERSIONS is a conversion expression or a nested sequence of such,
3157 convert ARG with the same conversions in the same order
3158 and return the result. */
3159
3160static tree
3161convert_sequence (conversions, arg)
3162 tree conversions;
3163 tree arg;
3164{
3165 switch (TREE_CODE (conversions))
3166 {
3167 case NOP_EXPR:
3168 case CONVERT_EXPR:
3169 case FLOAT_EXPR:
3170 case FIX_TRUNC_EXPR:
3171 case FIX_FLOOR_EXPR:
3172 case FIX_ROUND_EXPR:
3173 case FIX_CEIL_EXPR:
3174 return convert (TREE_TYPE (conversions),
3175 convert_sequence (TREE_OPERAND (conversions, 0),
3176 arg));
3177
3178 default:
3179 return arg;
3180 }
3181}
3182#endif /* 0 */
3183
3184/* Return nonzero if REF is an lvalue valid for this language.
3185 Lvalues can be assigned, unless their type has TYPE_READONLY.
3186 Lvalues can have their address taken, unless they have DECL_REGISTER. */
3187
3188int
3189lvalue_p (ref)
3190 tree ref;
3191{
3192 register enum tree_code code = TREE_CODE (ref);
3193
3194 switch (code)
3195 {
3196 case REALPART_EXPR:
3197 case IMAGPART_EXPR:
3198 case COMPONENT_REF:
3199 return lvalue_p (TREE_OPERAND (ref, 0));
3200
3201 case STRING_CST:
3202 return 1;
3203
3204 case INDIRECT_REF:
3205 case ARRAY_REF:
3206 case VAR_DECL:
3207 case PARM_DECL:
3208 case RESULT_DECL:
3209 case ERROR_MARK:
3210 return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
3211 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
3212
3213 case BIND_EXPR:
3214 case RTL_EXPR:
3215 return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
3216
3217 default:
3218 return 0;
3219 }
3220}
3221
3222/* Return nonzero if REF is an lvalue valid for this language;
3223 otherwise, print an error message and return zero. */
3224
3225int
| 3163}
3164
3165#if 0
3166/* If CONVERSIONS is a conversion expression or a nested sequence of such,
3167 convert ARG with the same conversions in the same order
3168 and return the result. */
3169
3170static tree
3171convert_sequence (conversions, arg)
3172 tree conversions;
3173 tree arg;
3174{
3175 switch (TREE_CODE (conversions))
3176 {
3177 case NOP_EXPR:
3178 case CONVERT_EXPR:
3179 case FLOAT_EXPR:
3180 case FIX_TRUNC_EXPR:
3181 case FIX_FLOOR_EXPR:
3182 case FIX_ROUND_EXPR:
3183 case FIX_CEIL_EXPR:
3184 return convert (TREE_TYPE (conversions),
3185 convert_sequence (TREE_OPERAND (conversions, 0),
3186 arg));
3187
3188 default:
3189 return arg;
3190 }
3191}
3192#endif /* 0 */
3193
3194/* Return nonzero if REF is an lvalue valid for this language.
3195 Lvalues can be assigned, unless their type has TYPE_READONLY.
3196 Lvalues can have their address taken, unless they have DECL_REGISTER. */
3197
3198int
3199lvalue_p (ref)
3200 tree ref;
3201{
3202 register enum tree_code code = TREE_CODE (ref);
3203
3204 switch (code)
3205 {
3206 case REALPART_EXPR:
3207 case IMAGPART_EXPR:
3208 case COMPONENT_REF:
3209 return lvalue_p (TREE_OPERAND (ref, 0));
3210
3211 case STRING_CST:
3212 return 1;
3213
3214 case INDIRECT_REF:
3215 case ARRAY_REF:
3216 case VAR_DECL:
3217 case PARM_DECL:
3218 case RESULT_DECL:
3219 case ERROR_MARK:
3220 return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
3221 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
3222
3223 case BIND_EXPR:
3224 case RTL_EXPR:
3225 return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
3226
3227 default:
3228 return 0;
3229 }
3230}
3231
3232/* Return nonzero if REF is an lvalue valid for this language;
3233 otherwise, print an error message and return zero. */
3234
3235int
|
3226lvalue_or_else (ref, string)
| 3236lvalue_or_else (ref, msgid)
|
3227 tree ref;
| 3237 tree ref;
|
3228 char *string;
| 3238 const char *msgid;
|
3229{
3230 int win = lvalue_p (ref);
3231 if (! win)
| 3239{
3240 int win = lvalue_p (ref);
3241 if (! win)
|
3232 error ("invalid lvalue in %s", string);
| 3242 error (msgid);
|
3233 return win;
3234}
3235
3236/* Apply unary lvalue-demanding operator CODE to the expression ARG
3237 for certain kinds of expressions which are not really lvalues
3238 but which we can accept as lvalues.
3239
3240 If ARG is not a kind of expression we can handle, return zero. */
3241
3242static tree
3243unary_complex_lvalue (code, arg)
3244 enum tree_code code;
3245 tree arg;
3246{
3247 /* Handle (a, b) used as an "lvalue". */
3248 if (TREE_CODE (arg) == COMPOUND_EXPR)
3249 {
3250 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
3251
3252 /* If this returns a function type, it isn't really being used as
3253 an lvalue, so don't issue a warning about it. */
3254 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
3255 pedantic_lvalue_warning (COMPOUND_EXPR);
3256
3257 return build (COMPOUND_EXPR, TREE_TYPE (real_result),
3258 TREE_OPERAND (arg, 0), real_result);
3259 }
3260
3261 /* Handle (a ? b : c) used as an "lvalue". */
3262 if (TREE_CODE (arg) == COND_EXPR)
3263 {
3264 pedantic_lvalue_warning (COND_EXPR);
3265 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
3266 pedantic_lvalue_warning (COMPOUND_EXPR);
3267
3268 return (build_conditional_expr
3269 (TREE_OPERAND (arg, 0),
3270 build_unary_op (code, TREE_OPERAND (arg, 1), 0),
3271 build_unary_op (code, TREE_OPERAND (arg, 2), 0)));
3272 }
3273
3274 return 0;
3275}
3276
3277/* If pedantic, warn about improper lvalue. CODE is either COND_EXPR
3278 COMPOUND_EXPR, or CONVERT_EXPR (for casts). */
3279
3280static void
3281pedantic_lvalue_warning (code)
3282 enum tree_code code;
3283{
3284 if (pedantic)
| 3243 return win;
3244}
3245
3246/* Apply unary lvalue-demanding operator CODE to the expression ARG
3247 for certain kinds of expressions which are not really lvalues
3248 but which we can accept as lvalues.
3249
3250 If ARG is not a kind of expression we can handle, return zero. */
3251
3252static tree
3253unary_complex_lvalue (code, arg)
3254 enum tree_code code;
3255 tree arg;
3256{
3257 /* Handle (a, b) used as an "lvalue". */
3258 if (TREE_CODE (arg) == COMPOUND_EXPR)
3259 {
3260 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
3261
3262 /* If this returns a function type, it isn't really being used as
3263 an lvalue, so don't issue a warning about it. */
3264 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
3265 pedantic_lvalue_warning (COMPOUND_EXPR);
3266
3267 return build (COMPOUND_EXPR, TREE_TYPE (real_result),
3268 TREE_OPERAND (arg, 0), real_result);
3269 }
3270
3271 /* Handle (a ? b : c) used as an "lvalue". */
3272 if (TREE_CODE (arg) == COND_EXPR)
3273 {
3274 pedantic_lvalue_warning (COND_EXPR);
3275 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
3276 pedantic_lvalue_warning (COMPOUND_EXPR);
3277
3278 return (build_conditional_expr
3279 (TREE_OPERAND (arg, 0),
3280 build_unary_op (code, TREE_OPERAND (arg, 1), 0),
3281 build_unary_op (code, TREE_OPERAND (arg, 2), 0)));
3282 }
3283
3284 return 0;
3285}
3286
3287/* If pedantic, warn about improper lvalue. CODE is either COND_EXPR
3288 COMPOUND_EXPR, or CONVERT_EXPR (for casts). */
3289
3290static void
3291pedantic_lvalue_warning (code)
3292 enum tree_code code;
3293{
3294 if (pedantic)
|
3285 pedwarn ("ANSI C forbids use of %s expressions as lvalues",
3286 code == COND_EXPR ? "conditional"
3287 : code == COMPOUND_EXPR ? "compound" : "cast");
| 3295 pedwarn (code == COND_EXPR
3296 ? "ANSI C forbids use of conditional expressions as lvalues"
3297 : code == COMPOUND_EXPR
3298 ? "ANSI C forbids use of compound expressions as lvalues"
3299 : "ANSI C forbids use of cast expressions as lvalues");
|
3288}
3289
3290/* Warn about storing in something that is `const'. */
3291
3292void
| 3300}
3301
3302/* Warn about storing in something that is `const'. */
3303
3304void
|
3293readonly_warning (arg, string)
| 3305readonly_warning (arg, msgid)
|
3294 tree arg;
| 3306 tree arg;
|
3295 char *string;
| 3307 const char *msgid;
|
3296{
| 3308{
|
3297 char buf[80];
3298 strcpy (buf, string);
3299
| |
3300 /* Forbid assignments to iterators. */
3301 if (TREE_CODE (arg) == VAR_DECL && ITERATOR_P (arg))
| 3309 /* Forbid assignments to iterators. */
3310 if (TREE_CODE (arg) == VAR_DECL && ITERATOR_P (arg))
|
3302 {
3303 strcat (buf, " of iterator `%s'");
3304 pedwarn (buf, IDENTIFIER_POINTER (DECL_NAME (arg)));
3305 }
| 3311 pedwarn ("%s of iterator `%s'", _(msgid),
3312 IDENTIFIER_POINTER (DECL_NAME (arg)));
|
3306
3307 if (TREE_CODE (arg) == COMPONENT_REF)
3308 {
3309 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
| 3313
3314 if (TREE_CODE (arg) == COMPONENT_REF)
3315 {
3316 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
|
3310 readonly_warning (TREE_OPERAND (arg, 0), string);
| 3317 readonly_warning (TREE_OPERAND (arg, 0), msgid);
|
3311 else
| 3318 else
|
3312 {
3313 strcat (buf, " of read-only member `%s'");
3314 pedwarn (buf, IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
3315 }
| 3319 pedwarn ("%s of read-only member `%s'", _(msgid),
3320 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
|
3316 }
3317 else if (TREE_CODE (arg) == VAR_DECL)
| 3321 }
3322 else if (TREE_CODE (arg) == VAR_DECL)
|
3318 {
3319 strcat (buf, " of read-only variable `%s'");
3320 pedwarn (buf, IDENTIFIER_POINTER (DECL_NAME (arg)));
3321 }
| 3323 pedwarn ("%s of read-only variable `%s'", _(msgid),
3324 IDENTIFIER_POINTER (DECL_NAME (arg)));
|
3322 else
| 3325 else
|
3323 {
3324 pedwarn ("%s of read-only location", buf);
3325 }
| 3326 pedwarn ("%s of read-only location", _(msgid));
|
3326}
3327
3328/* Mark EXP saying that we need to be able to take the
3329 address of it; it should not be allocated in a register.
3330 Value is 1 if successful. */
3331
3332int
3333mark_addressable (exp)
3334 tree exp;
3335{
3336 register tree x = exp;
3337 while (1)
3338 switch (TREE_CODE (x))
3339 {
3340 case COMPONENT_REF:
3341 if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
3342 {
3343 error ("cannot take address of bitfield `%s'",
3344 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
3345 return 0;
3346 }
3347
3348 /* ... fall through ... */
3349
3350 case ADDR_EXPR:
3351 case ARRAY_REF:
3352 case REALPART_EXPR:
3353 case IMAGPART_EXPR:
3354 x = TREE_OPERAND (x, 0);
3355 break;
3356
3357 case CONSTRUCTOR:
3358 TREE_ADDRESSABLE (x) = 1;
3359 return 1;
3360
3361 case VAR_DECL:
3362 case CONST_DECL:
3363 case PARM_DECL:
3364 case RESULT_DECL:
3365 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
3366 && DECL_NONLOCAL (x))
3367 {
3368 if (TREE_PUBLIC (x))
3369 {
3370 error ("global register variable `%s' used in nested function",
3371 IDENTIFIER_POINTER (DECL_NAME (x)));
3372 return 0;
3373 }
3374 pedwarn ("register variable `%s' used in nested function",
3375 IDENTIFIER_POINTER (DECL_NAME (x)));
3376 }
3377 else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
3378 {
3379 if (TREE_PUBLIC (x))
3380 {
3381 error ("address of global register variable `%s' requested",
3382 IDENTIFIER_POINTER (DECL_NAME (x)));
3383 return 0;
3384 }
3385
3386 /* If we are making this addressable due to its having
3387 volatile components, give a different error message. Also
3388 handle the case of an unnamed parameter by not trying
3389 to give the name. */
3390
3391 else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x)))
3392 {
3393 error ("cannot put object with volatile field into register");
3394 return 0;
3395 }
3396
3397 pedwarn ("address of register variable `%s' requested",
3398 IDENTIFIER_POINTER (DECL_NAME (x)));
3399 }
3400 put_var_into_stack (x);
3401
3402 /* drops in */
3403 case FUNCTION_DECL:
3404 TREE_ADDRESSABLE (x) = 1;
3405#if 0 /* poplevel deals with this now. */
3406 if (DECL_CONTEXT (x) == 0)
3407 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
3408#endif
3409
3410 default:
3411 return 1;
3412 }
3413}
3414
3415/* Build and return a conditional expression IFEXP ? OP1 : OP2. */
3416
3417tree
3418build_conditional_expr (ifexp, op1, op2)
3419 tree ifexp, op1, op2;
3420{
3421 register tree type1;
3422 register tree type2;
3423 register enum tree_code code1;
3424 register enum tree_code code2;
3425 register tree result_type = NULL;
3426 tree orig_op1 = op1, orig_op2 = op2;
3427
3428 ifexp = truthvalue_conversion (default_conversion (ifexp));
3429
3430#if 0 /* Produces wrong result if within sizeof. */
3431 /* Don't promote the operands separately if they promote
3432 the same way. Return the unpromoted type and let the combined
3433 value get promoted if necessary. */
3434
3435 if (TREE_TYPE (op1) == TREE_TYPE (op2)
3436 && TREE_CODE (TREE_TYPE (op1)) != ARRAY_TYPE
3437 && TREE_CODE (TREE_TYPE (op1)) != ENUMERAL_TYPE
3438 && TREE_CODE (TREE_TYPE (op1)) != FUNCTION_TYPE)
3439 {
3440 if (TREE_CODE (ifexp) == INTEGER_CST)
3441 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3442
3443 return fold (build (COND_EXPR, TREE_TYPE (op1), ifexp, op1, op2));
3444 }
3445#endif
3446
3447 /* Promote both alternatives. */
3448
3449 if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
3450 op1 = default_conversion (op1);
3451 if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
3452 op2 = default_conversion (op2);
3453
3454 if (TREE_CODE (ifexp) == ERROR_MARK
3455 || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
3456 || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
3457 return error_mark_node;
3458
3459 type1 = TREE_TYPE (op1);
3460 code1 = TREE_CODE (type1);
3461 type2 = TREE_TYPE (op2);
3462 code2 = TREE_CODE (type2);
3463
3464 /* Quickly detect the usual case where op1 and op2 have the same type
3465 after promotion. */
3466 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
3467 {
3468 if (type1 == type2)
3469 result_type = type1;
3470 else
3471 result_type = TYPE_MAIN_VARIANT (type1);
3472 }
3473 else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE)
3474 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE))
3475 {
3476 result_type = common_type (type1, type2);
3477 }
3478 else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
3479 {
3480 if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
3481 pedwarn ("ANSI C forbids conditional expr with only one void side");
3482 result_type = void_type_node;
3483 }
3484 else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
3485 {
3486 if (comp_target_types (type1, type2))
3487 result_type = common_type (type1, type2);
3488 else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
3489 && TREE_CODE (orig_op1) != NOP_EXPR)
3490 result_type = qualify_type (type2, type1);
3491 else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
3492 && TREE_CODE (orig_op2) != NOP_EXPR)
3493 result_type = qualify_type (type1, type2);
3494 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type1)) == void_type_node)
3495 {
3496 if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
3497 pedwarn ("ANSI C forbids conditional expr between `void *' and function pointer");
3498 result_type = qualify_type (type1, type2);
3499 }
3500 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type2)) == void_type_node)
3501 {
3502 if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
3503 pedwarn ("ANSI C forbids conditional expr between `void *' and function pointer");
3504 result_type = qualify_type (type2, type1);
3505 }
3506 else
3507 {
3508 pedwarn ("pointer type mismatch in conditional expression");
3509 result_type = build_pointer_type (void_type_node);
3510 }
3511 }
3512 else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
3513 {
3514 if (! integer_zerop (op2))
3515 pedwarn ("pointer/integer type mismatch in conditional expression");
3516 else
3517 {
3518 op2 = null_pointer_node;
3519#if 0 /* The spec seems to say this is permitted. */
3520 if (pedantic && TREE_CODE (type1) == FUNCTION_TYPE)
3521 pedwarn ("ANSI C forbids conditional expr between 0 and function pointer");
3522#endif
3523 }
3524 result_type = type1;
3525 }
3526 else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
3527 {
3528 if (!integer_zerop (op1))
3529 pedwarn ("pointer/integer type mismatch in conditional expression");
3530 else
3531 {
3532 op1 = null_pointer_node;
3533#if 0 /* The spec seems to say this is permitted. */
3534 if (pedantic && TREE_CODE (type2) == FUNCTION_TYPE)
3535 pedwarn ("ANSI C forbids conditional expr between 0 and function pointer");
3536#endif
3537 }
3538 result_type = type2;
3539 }
3540
3541 if (!result_type)
3542 {
3543 if (flag_cond_mismatch)
3544 result_type = void_type_node;
3545 else
3546 {
3547 error ("type mismatch in conditional expression");
3548 return error_mark_node;
3549 }
3550 }
3551
3552 /* Merge const and volatile flags of the incoming types. */
3553 result_type
3554 = build_type_variant (result_type,
3555 TREE_READONLY (op1) || TREE_READONLY (op2),
3556 TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3557
3558 if (result_type != TREE_TYPE (op1))
3559 op1 = convert_and_check (result_type, op1);
3560 if (result_type != TREE_TYPE (op2))
3561 op2 = convert_and_check (result_type, op2);
3562
3563#if 0
3564 if (code1 == RECORD_TYPE || code1 == UNION_TYPE)
3565 {
3566 result_type = TREE_TYPE (op1);
3567 if (TREE_CONSTANT (ifexp))
3568 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3569
3570 if (TYPE_MODE (result_type) == BLKmode)
3571 {
3572 register tree tempvar
3573 = build_decl (VAR_DECL, NULL_TREE, result_type);
3574 register tree xop1 = build_modify_expr (tempvar, op1);
3575 register tree xop2 = build_modify_expr (tempvar, op2);
3576 register tree result = fold (build (COND_EXPR, result_type,
3577 ifexp, xop1, xop2));
3578
3579 layout_decl (tempvar, TYPE_ALIGN (result_type));
3580 /* No way to handle variable-sized objects here.
3581 I fear that the entire handling of BLKmode conditional exprs
3582 needs to be redone. */
3583 if (TREE_CODE (DECL_SIZE (tempvar)) != INTEGER_CST)
3584 abort ();
3585 DECL_RTL (tempvar)
3586 = assign_stack_local (DECL_MODE (tempvar),
3587 (TREE_INT_CST_LOW (DECL_SIZE (tempvar))
3588 + BITS_PER_UNIT - 1)
3589 / BITS_PER_UNIT,
3590 0);
3591
3592 TREE_SIDE_EFFECTS (result)
3593 = TREE_SIDE_EFFECTS (ifexp) | TREE_SIDE_EFFECTS (op1)
3594 | TREE_SIDE_EFFECTS (op2);
3595 return build (COMPOUND_EXPR, result_type, result, tempvar);
3596 }
3597 }
3598#endif /* 0 */
3599
3600 if (TREE_CODE (ifexp) == INTEGER_CST)
3601 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3602
3603 return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
3604}
3605
3606/* Given a list of expressions, return a compound expression
3607 that performs them all and returns the value of the last of them. */
3608
3609tree
3610build_compound_expr (list)
3611 tree list;
3612{
3613 return internal_build_compound_expr (list, TRUE);
3614}
3615
3616static tree
3617internal_build_compound_expr (list, first_p)
3618 tree list;
3619 int first_p;
3620{
3621 register tree rest;
3622
3623 if (TREE_CHAIN (list) == 0)
3624 {
3625#if 0 /* If something inside inhibited lvalueness, we should not override. */
3626 /* Consider (x, y+0), which is not an lvalue since y+0 is not. */
3627
3628 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3629 if (TREE_CODE (list) == NON_LVALUE_EXPR)
3630 list = TREE_OPERAND (list, 0);
3631#endif
3632
3633 /* Don't let (0, 0) be null pointer constant. */
3634 if (!first_p && integer_zerop (TREE_VALUE (list)))
3635 return non_lvalue (TREE_VALUE (list));
3636 return TREE_VALUE (list);
3637 }
3638
3639 if (TREE_CHAIN (list) != 0 && TREE_CHAIN (TREE_CHAIN (list)) == 0)
3640 {
3641 /* Convert arrays to pointers when there really is a comma operator. */
3642 if (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (list)))) == ARRAY_TYPE)
3643 TREE_VALUE (TREE_CHAIN (list))
3644 = default_conversion (TREE_VALUE (TREE_CHAIN (list)));
3645 }
3646
3647 rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE);
3648
3649 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
3650 {
3651 /* The left-hand operand of a comma expression is like an expression
3652 statement: with -W or -Wunused, we should warn if it doesn't have
3653 any side-effects, unless it was explicitly cast to (void). */
3654 if ((extra_warnings || warn_unused)
3655 && ! (TREE_CODE (TREE_VALUE (list)) == CONVERT_EXPR
3656 && TREE_TYPE (TREE_VALUE (list)) == void_type_node))
3657 warning ("left-hand operand of comma expression has no effect");
3658
3659 /* When pedantic, a compound expression can be neither an lvalue
3660 nor an integer constant expression. */
3661 if (! pedantic)
3662 return rest;
3663 }
3664
3665 /* With -Wunused, we should also warn if the left-hand operand does have
3666 side-effects, but computes a value which is not used. For example, in
3667 `foo() + bar(), baz()' the result of the `+' operator is not used,
3668 so we should issue a warning. */
3669 else if (warn_unused)
3670 warn_if_unused_value (TREE_VALUE (list));
3671
3672 return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest);
3673}
3674
3675/* Build an expression representing a cast to type TYPE of expression EXPR. */
3676
3677tree
3678build_c_cast (type, expr)
3679 register tree type;
3680 tree expr;
3681{
3682 register tree value = expr;
3683
3684 if (type == error_mark_node || expr == error_mark_node)
3685 return error_mark_node;
3686 type = TYPE_MAIN_VARIANT (type);
3687
3688#if 0
3689 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3690 if (TREE_CODE (value) == NON_LVALUE_EXPR)
3691 value = TREE_OPERAND (value, 0);
3692#endif
3693
3694 if (TREE_CODE (type) == ARRAY_TYPE)
3695 {
3696 error ("cast specifies array type");
3697 return error_mark_node;
3698 }
3699
3700 if (TREE_CODE (type) == FUNCTION_TYPE)
3701 {
3702 error ("cast specifies function type");
3703 return error_mark_node;
3704 }
3705
3706 if (type == TREE_TYPE (value))
3707 {
3708 if (pedantic)
3709 {
3710 if (TREE_CODE (type) == RECORD_TYPE
3711 || TREE_CODE (type) == UNION_TYPE)
3712 pedwarn ("ANSI C forbids casting nonscalar to the same type");
3713 }
3714 }
3715 else if (TREE_CODE (type) == UNION_TYPE)
3716 {
3717 tree field;
3718 if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
3719 || TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE)
3720 value = default_conversion (value);
3721
3722 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3723 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3724 TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3725 break;
3726
3727 if (field)
3728 {
| 3327}
3328
3329/* Mark EXP saying that we need to be able to take the
3330 address of it; it should not be allocated in a register.
3331 Value is 1 if successful. */
3332
3333int
3334mark_addressable (exp)
3335 tree exp;
3336{
3337 register tree x = exp;
3338 while (1)
3339 switch (TREE_CODE (x))
3340 {
3341 case COMPONENT_REF:
3342 if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
3343 {
3344 error ("cannot take address of bitfield `%s'",
3345 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
3346 return 0;
3347 }
3348
3349 /* ... fall through ... */
3350
3351 case ADDR_EXPR:
3352 case ARRAY_REF:
3353 case REALPART_EXPR:
3354 case IMAGPART_EXPR:
3355 x = TREE_OPERAND (x, 0);
3356 break;
3357
3358 case CONSTRUCTOR:
3359 TREE_ADDRESSABLE (x) = 1;
3360 return 1;
3361
3362 case VAR_DECL:
3363 case CONST_DECL:
3364 case PARM_DECL:
3365 case RESULT_DECL:
3366 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
3367 && DECL_NONLOCAL (x))
3368 {
3369 if (TREE_PUBLIC (x))
3370 {
3371 error ("global register variable `%s' used in nested function",
3372 IDENTIFIER_POINTER (DECL_NAME (x)));
3373 return 0;
3374 }
3375 pedwarn ("register variable `%s' used in nested function",
3376 IDENTIFIER_POINTER (DECL_NAME (x)));
3377 }
3378 else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
3379 {
3380 if (TREE_PUBLIC (x))
3381 {
3382 error ("address of global register variable `%s' requested",
3383 IDENTIFIER_POINTER (DECL_NAME (x)));
3384 return 0;
3385 }
3386
3387 /* If we are making this addressable due to its having
3388 volatile components, give a different error message. Also
3389 handle the case of an unnamed parameter by not trying
3390 to give the name. */
3391
3392 else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x)))
3393 {
3394 error ("cannot put object with volatile field into register");
3395 return 0;
3396 }
3397
3398 pedwarn ("address of register variable `%s' requested",
3399 IDENTIFIER_POINTER (DECL_NAME (x)));
3400 }
3401 put_var_into_stack (x);
3402
3403 /* drops in */
3404 case FUNCTION_DECL:
3405 TREE_ADDRESSABLE (x) = 1;
3406#if 0 /* poplevel deals with this now. */
3407 if (DECL_CONTEXT (x) == 0)
3408 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
3409#endif
3410
3411 default:
3412 return 1;
3413 }
3414}
3415
3416/* Build and return a conditional expression IFEXP ? OP1 : OP2. */
3417
3418tree
3419build_conditional_expr (ifexp, op1, op2)
3420 tree ifexp, op1, op2;
3421{
3422 register tree type1;
3423 register tree type2;
3424 register enum tree_code code1;
3425 register enum tree_code code2;
3426 register tree result_type = NULL;
3427 tree orig_op1 = op1, orig_op2 = op2;
3428
3429 ifexp = truthvalue_conversion (default_conversion (ifexp));
3430
3431#if 0 /* Produces wrong result if within sizeof. */
3432 /* Don't promote the operands separately if they promote
3433 the same way. Return the unpromoted type and let the combined
3434 value get promoted if necessary. */
3435
3436 if (TREE_TYPE (op1) == TREE_TYPE (op2)
3437 && TREE_CODE (TREE_TYPE (op1)) != ARRAY_TYPE
3438 && TREE_CODE (TREE_TYPE (op1)) != ENUMERAL_TYPE
3439 && TREE_CODE (TREE_TYPE (op1)) != FUNCTION_TYPE)
3440 {
3441 if (TREE_CODE (ifexp) == INTEGER_CST)
3442 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3443
3444 return fold (build (COND_EXPR, TREE_TYPE (op1), ifexp, op1, op2));
3445 }
3446#endif
3447
3448 /* Promote both alternatives. */
3449
3450 if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
3451 op1 = default_conversion (op1);
3452 if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
3453 op2 = default_conversion (op2);
3454
3455 if (TREE_CODE (ifexp) == ERROR_MARK
3456 || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
3457 || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
3458 return error_mark_node;
3459
3460 type1 = TREE_TYPE (op1);
3461 code1 = TREE_CODE (type1);
3462 type2 = TREE_TYPE (op2);
3463 code2 = TREE_CODE (type2);
3464
3465 /* Quickly detect the usual case where op1 and op2 have the same type
3466 after promotion. */
3467 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
3468 {
3469 if (type1 == type2)
3470 result_type = type1;
3471 else
3472 result_type = TYPE_MAIN_VARIANT (type1);
3473 }
3474 else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE)
3475 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE))
3476 {
3477 result_type = common_type (type1, type2);
3478 }
3479 else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
3480 {
3481 if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
3482 pedwarn ("ANSI C forbids conditional expr with only one void side");
3483 result_type = void_type_node;
3484 }
3485 else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
3486 {
3487 if (comp_target_types (type1, type2))
3488 result_type = common_type (type1, type2);
3489 else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
3490 && TREE_CODE (orig_op1) != NOP_EXPR)
3491 result_type = qualify_type (type2, type1);
3492 else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
3493 && TREE_CODE (orig_op2) != NOP_EXPR)
3494 result_type = qualify_type (type1, type2);
3495 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type1)) == void_type_node)
3496 {
3497 if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
3498 pedwarn ("ANSI C forbids conditional expr between `void *' and function pointer");
3499 result_type = qualify_type (type1, type2);
3500 }
3501 else if (TYPE_MAIN_VARIANT (TREE_TYPE (type2)) == void_type_node)
3502 {
3503 if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
3504 pedwarn ("ANSI C forbids conditional expr between `void *' and function pointer");
3505 result_type = qualify_type (type2, type1);
3506 }
3507 else
3508 {
3509 pedwarn ("pointer type mismatch in conditional expression");
3510 result_type = build_pointer_type (void_type_node);
3511 }
3512 }
3513 else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
3514 {
3515 if (! integer_zerop (op2))
3516 pedwarn ("pointer/integer type mismatch in conditional expression");
3517 else
3518 {
3519 op2 = null_pointer_node;
3520#if 0 /* The spec seems to say this is permitted. */
3521 if (pedantic && TREE_CODE (type1) == FUNCTION_TYPE)
3522 pedwarn ("ANSI C forbids conditional expr between 0 and function pointer");
3523#endif
3524 }
3525 result_type = type1;
3526 }
3527 else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
3528 {
3529 if (!integer_zerop (op1))
3530 pedwarn ("pointer/integer type mismatch in conditional expression");
3531 else
3532 {
3533 op1 = null_pointer_node;
3534#if 0 /* The spec seems to say this is permitted. */
3535 if (pedantic && TREE_CODE (type2) == FUNCTION_TYPE)
3536 pedwarn ("ANSI C forbids conditional expr between 0 and function pointer");
3537#endif
3538 }
3539 result_type = type2;
3540 }
3541
3542 if (!result_type)
3543 {
3544 if (flag_cond_mismatch)
3545 result_type = void_type_node;
3546 else
3547 {
3548 error ("type mismatch in conditional expression");
3549 return error_mark_node;
3550 }
3551 }
3552
3553 /* Merge const and volatile flags of the incoming types. */
3554 result_type
3555 = build_type_variant (result_type,
3556 TREE_READONLY (op1) || TREE_READONLY (op2),
3557 TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3558
3559 if (result_type != TREE_TYPE (op1))
3560 op1 = convert_and_check (result_type, op1);
3561 if (result_type != TREE_TYPE (op2))
3562 op2 = convert_and_check (result_type, op2);
3563
3564#if 0
3565 if (code1 == RECORD_TYPE || code1 == UNION_TYPE)
3566 {
3567 result_type = TREE_TYPE (op1);
3568 if (TREE_CONSTANT (ifexp))
3569 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3570
3571 if (TYPE_MODE (result_type) == BLKmode)
3572 {
3573 register tree tempvar
3574 = build_decl (VAR_DECL, NULL_TREE, result_type);
3575 register tree xop1 = build_modify_expr (tempvar, op1);
3576 register tree xop2 = build_modify_expr (tempvar, op2);
3577 register tree result = fold (build (COND_EXPR, result_type,
3578 ifexp, xop1, xop2));
3579
3580 layout_decl (tempvar, TYPE_ALIGN (result_type));
3581 /* No way to handle variable-sized objects here.
3582 I fear that the entire handling of BLKmode conditional exprs
3583 needs to be redone. */
3584 if (TREE_CODE (DECL_SIZE (tempvar)) != INTEGER_CST)
3585 abort ();
3586 DECL_RTL (tempvar)
3587 = assign_stack_local (DECL_MODE (tempvar),
3588 (TREE_INT_CST_LOW (DECL_SIZE (tempvar))
3589 + BITS_PER_UNIT - 1)
3590 / BITS_PER_UNIT,
3591 0);
3592
3593 TREE_SIDE_EFFECTS (result)
3594 = TREE_SIDE_EFFECTS (ifexp) | TREE_SIDE_EFFECTS (op1)
3595 | TREE_SIDE_EFFECTS (op2);
3596 return build (COMPOUND_EXPR, result_type, result, tempvar);
3597 }
3598 }
3599#endif /* 0 */
3600
3601 if (TREE_CODE (ifexp) == INTEGER_CST)
3602 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3603
3604 return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
3605}
3606
3607/* Given a list of expressions, return a compound expression
3608 that performs them all and returns the value of the last of them. */
3609
3610tree
3611build_compound_expr (list)
3612 tree list;
3613{
3614 return internal_build_compound_expr (list, TRUE);
3615}
3616
3617static tree
3618internal_build_compound_expr (list, first_p)
3619 tree list;
3620 int first_p;
3621{
3622 register tree rest;
3623
3624 if (TREE_CHAIN (list) == 0)
3625 {
3626#if 0 /* If something inside inhibited lvalueness, we should not override. */
3627 /* Consider (x, y+0), which is not an lvalue since y+0 is not. */
3628
3629 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3630 if (TREE_CODE (list) == NON_LVALUE_EXPR)
3631 list = TREE_OPERAND (list, 0);
3632#endif
3633
3634 /* Don't let (0, 0) be null pointer constant. */
3635 if (!first_p && integer_zerop (TREE_VALUE (list)))
3636 return non_lvalue (TREE_VALUE (list));
3637 return TREE_VALUE (list);
3638 }
3639
3640 if (TREE_CHAIN (list) != 0 && TREE_CHAIN (TREE_CHAIN (list)) == 0)
3641 {
3642 /* Convert arrays to pointers when there really is a comma operator. */
3643 if (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (list)))) == ARRAY_TYPE)
3644 TREE_VALUE (TREE_CHAIN (list))
3645 = default_conversion (TREE_VALUE (TREE_CHAIN (list)));
3646 }
3647
3648 rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE);
3649
3650 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
3651 {
3652 /* The left-hand operand of a comma expression is like an expression
3653 statement: with -W or -Wunused, we should warn if it doesn't have
3654 any side-effects, unless it was explicitly cast to (void). */
3655 if ((extra_warnings || warn_unused)
3656 && ! (TREE_CODE (TREE_VALUE (list)) == CONVERT_EXPR
3657 && TREE_TYPE (TREE_VALUE (list)) == void_type_node))
3658 warning ("left-hand operand of comma expression has no effect");
3659
3660 /* When pedantic, a compound expression can be neither an lvalue
3661 nor an integer constant expression. */
3662 if (! pedantic)
3663 return rest;
3664 }
3665
3666 /* With -Wunused, we should also warn if the left-hand operand does have
3667 side-effects, but computes a value which is not used. For example, in
3668 `foo() + bar(), baz()' the result of the `+' operator is not used,
3669 so we should issue a warning. */
3670 else if (warn_unused)
3671 warn_if_unused_value (TREE_VALUE (list));
3672
3673 return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest);
3674}
3675
3676/* Build an expression representing a cast to type TYPE of expression EXPR. */
3677
3678tree
3679build_c_cast (type, expr)
3680 register tree type;
3681 tree expr;
3682{
3683 register tree value = expr;
3684
3685 if (type == error_mark_node || expr == error_mark_node)
3686 return error_mark_node;
3687 type = TYPE_MAIN_VARIANT (type);
3688
3689#if 0
3690 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3691 if (TREE_CODE (value) == NON_LVALUE_EXPR)
3692 value = TREE_OPERAND (value, 0);
3693#endif
3694
3695 if (TREE_CODE (type) == ARRAY_TYPE)
3696 {
3697 error ("cast specifies array type");
3698 return error_mark_node;
3699 }
3700
3701 if (TREE_CODE (type) == FUNCTION_TYPE)
3702 {
3703 error ("cast specifies function type");
3704 return error_mark_node;
3705 }
3706
3707 if (type == TREE_TYPE (value))
3708 {
3709 if (pedantic)
3710 {
3711 if (TREE_CODE (type) == RECORD_TYPE
3712 || TREE_CODE (type) == UNION_TYPE)
3713 pedwarn ("ANSI C forbids casting nonscalar to the same type");
3714 }
3715 }
3716 else if (TREE_CODE (type) == UNION_TYPE)
3717 {
3718 tree field;
3719 if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
3720 || TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE)
3721 value = default_conversion (value);
3722
3723 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3724 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3725 TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3726 break;
3727
3728 if (field)
3729 {
|
3729 char *name;
| 3730 const char *name;
|
3730 tree t;
3731
3732 if (pedantic)
3733 pedwarn ("ANSI C forbids casts to union type");
3734 if (TYPE_NAME (type) != 0)
3735 {
3736 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
3737 name = IDENTIFIER_POINTER (TYPE_NAME (type));
3738 else
3739 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
3740 }
3741 else
3742 name = "";
3743 t = digest_init (type, build (CONSTRUCTOR, type, NULL_TREE,
3744 build_tree_list (field, value)),
3745 0, 0);
3746 TREE_CONSTANT (t) = TREE_CONSTANT (value);
3747 return t;
3748 }
3749 error ("cast to union type from type not present in union");
3750 return error_mark_node;
3751 }
3752 else
3753 {
3754 tree otype, ovalue;
3755
3756 /* If casting to void, avoid the error that would come
3757 from default_conversion in the case of a non-lvalue array. */
3758 if (type == void_type_node)
3759 return build1 (CONVERT_EXPR, type, value);
3760
3761 /* Convert functions and arrays to pointers,
3762 but don't convert any other types. */
3763 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
3764 || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE)
3765 value = default_conversion (value);
3766 otype = TREE_TYPE (value);
3767
3768 /* Optionally warn about potentially worrisome casts. */
3769
3770 if (warn_cast_qual
3771 && TREE_CODE (type) == POINTER_TYPE
3772 && TREE_CODE (otype) == POINTER_TYPE)
3773 {
3774 /* Go to the innermost object being pointed to. */
3775 tree in_type = type;
3776 tree in_otype = otype;
3777
3778 while (TREE_CODE (in_type) == POINTER_TYPE)
3779 in_type = TREE_TYPE (in_type);
3780 while (TREE_CODE (in_otype) == POINTER_TYPE)
3781 in_otype = TREE_TYPE (in_otype);
| 3731 tree t;
3732
3733 if (pedantic)
3734 pedwarn ("ANSI C forbids casts to union type");
3735 if (TYPE_NAME (type) != 0)
3736 {
3737 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
3738 name = IDENTIFIER_POINTER (TYPE_NAME (type));
3739 else
3740 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
3741 }
3742 else
3743 name = "";
3744 t = digest_init (type, build (CONSTRUCTOR, type, NULL_TREE,
3745 build_tree_list (field, value)),
3746 0, 0);
3747 TREE_CONSTANT (t) = TREE_CONSTANT (value);
3748 return t;
3749 }
3750 error ("cast to union type from type not present in union");
3751 return error_mark_node;
3752 }
3753 else
3754 {
3755 tree otype, ovalue;
3756
3757 /* If casting to void, avoid the error that would come
3758 from default_conversion in the case of a non-lvalue array. */
3759 if (type == void_type_node)
3760 return build1 (CONVERT_EXPR, type, value);
3761
3762 /* Convert functions and arrays to pointers,
3763 but don't convert any other types. */
3764 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
3765 || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE)
3766 value = default_conversion (value);
3767 otype = TREE_TYPE (value);
3768
3769 /* Optionally warn about potentially worrisome casts. */
3770
3771 if (warn_cast_qual
3772 && TREE_CODE (type) == POINTER_TYPE
3773 && TREE_CODE (otype) == POINTER_TYPE)
3774 {
3775 /* Go to the innermost object being pointed to. */
3776 tree in_type = type;
3777 tree in_otype = otype;
3778
3779 while (TREE_CODE (in_type) == POINTER_TYPE)
3780 in_type = TREE_TYPE (in_type);
3781 while (TREE_CODE (in_otype) == POINTER_TYPE)
3782 in_otype = TREE_TYPE (in_otype);
|
3782
3783 if (TYPE_VOLATILE (in_otype) && ! TYPE_VOLATILE (in_type))
3784 pedwarn ("cast discards `volatile' from pointer target type");
3785 if (TYPE_READONLY (in_otype) && ! TYPE_READONLY (in_type))
3786 pedwarn ("cast discards `const' from pointer target type");
| 3783
3784 if (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type))
3785 /* There are qualifiers present in IN_OTYPE that are not
3786 present in IN_TYPE. */
3787 pedwarn ("cast discards qualifiers from pointer target type");
|
3787 }
3788
3789 /* Warn about possible alignment problems. */
3790 if (STRICT_ALIGNMENT && warn_cast_align
3791 && TREE_CODE (type) == POINTER_TYPE
3792 && TREE_CODE (otype) == POINTER_TYPE
3793 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3794 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3795 /* Don't warn about opaque types, where the actual alignment
3796 restriction is unknown. */
3797 && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3798 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3799 && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3800 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3801 warning ("cast increases required alignment of target type");
3802
3803 if (TREE_CODE (type) == INTEGER_TYPE
3804 && TREE_CODE (otype) == POINTER_TYPE
3805 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3806 && !TREE_CONSTANT (value))
3807 warning ("cast from pointer to integer of different size");
3808
3809 if (warn_bad_function_cast
3810 && TREE_CODE (value) == CALL_EXPR
3811 && TREE_CODE (type) != TREE_CODE (otype))
3812 warning ("cast does not match function type");
3813
3814 if (TREE_CODE (type) == POINTER_TYPE
3815 && TREE_CODE (otype) == INTEGER_TYPE
3816 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3817#if 0
3818 /* Don't warn about converting 0 to pointer,
3819 provided the 0 was explicit--not cast or made by folding. */
3820 && !(TREE_CODE (value) == INTEGER_CST && integer_zerop (value))
3821#endif
3822 /* Don't warn about converting any constant. */
3823 && !TREE_CONSTANT (value))
3824 warning ("cast to pointer from integer of different size");
3825
3826 ovalue = value;
3827 value = convert (type, value);
3828
3829 /* Ignore any integer overflow caused by the cast. */
3830 if (TREE_CODE (value) == INTEGER_CST)
3831 {
3832 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3833 TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3834 }
3835 }
3836
3837 /* Pedantically, don't ley (void *) (FOO *) 0 be a null pointer constant. */
3838 if (pedantic && TREE_CODE (value) == INTEGER_CST
3839 && TREE_CODE (expr) == INTEGER_CST
3840 && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3841 value = non_lvalue (value);
3842
3843 /* If pedantic, don't let a cast be an lvalue. */
3844 if (value == expr && pedantic)
3845 value = non_lvalue (value);
3846
3847 return value;
3848}
3849
3850/* Build an assignment expression of lvalue LHS from value RHS.
3851 MODIFYCODE is the code for a binary operator that we use
3852 to combine the old value of LHS with RHS to get the new value.
3853 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */
3854
3855tree
3856build_modify_expr (lhs, modifycode, rhs)
3857 tree lhs, rhs;
3858 enum tree_code modifycode;
3859{
3860 register tree result;
3861 tree newrhs;
3862 tree lhstype = TREE_TYPE (lhs);
3863 tree olhstype = lhstype;
3864
3865 /* Types that aren't fully specified cannot be used in assignments. */
3866 lhs = require_complete_type (lhs);
3867
3868 /* Avoid duplicate error messages from operands that had errors. */
3869 if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3870 return error_mark_node;
3871
3872 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3873 /* Do not use STRIP_NOPS here. We do not want an enumerator
3874 whose value is 0 to count as a null pointer constant. */
3875 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3876 rhs = TREE_OPERAND (rhs, 0);
3877
3878 newrhs = rhs;
3879
3880 /* Handle control structure constructs used as "lvalues". */
3881
3882 switch (TREE_CODE (lhs))
3883 {
3884 /* Handle (a, b) used as an "lvalue". */
3885 case COMPOUND_EXPR:
3886 pedantic_lvalue_warning (COMPOUND_EXPR);
3887 newrhs = build_modify_expr (TREE_OPERAND (lhs, 1),
3888 modifycode, rhs);
3889 if (TREE_CODE (newrhs) == ERROR_MARK)
3890 return error_mark_node;
3891 return build (COMPOUND_EXPR, lhstype,
3892 TREE_OPERAND (lhs, 0), newrhs);
3893
3894 /* Handle (a ? b : c) used as an "lvalue". */
3895 case COND_EXPR:
3896 pedantic_lvalue_warning (COND_EXPR);
3897 rhs = save_expr (rhs);
3898 {
3899 /* Produce (a ? (b = rhs) : (c = rhs))
3900 except that the RHS goes through a save-expr
3901 so the code to compute it is only emitted once. */
3902 tree cond
3903 = build_conditional_expr (TREE_OPERAND (lhs, 0),
3904 build_modify_expr (TREE_OPERAND (lhs, 1),
3905 modifycode, rhs),
3906 build_modify_expr (TREE_OPERAND (lhs, 2),
3907 modifycode, rhs));
3908 if (TREE_CODE (cond) == ERROR_MARK)
3909 return cond;
3910 /* Make sure the code to compute the rhs comes out
3911 before the split. */
3912 return build (COMPOUND_EXPR, TREE_TYPE (lhs),
3913 /* But cast it to void to avoid an "unused" error. */
3914 convert (void_type_node, rhs), cond);
3915 }
3916 default:
3917 break;
3918 }
3919
3920 /* If a binary op has been requested, combine the old LHS value with the RHS
3921 producing the value we should actually store into the LHS. */
3922
3923 if (modifycode != NOP_EXPR)
3924 {
3925 lhs = stabilize_reference (lhs);
3926 newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3927 }
3928
3929 /* Handle a cast used as an "lvalue".
3930 We have already performed any binary operator using the value as cast.
3931 Now convert the result to the cast type of the lhs,
3932 and then true type of the lhs and store it there;
3933 then convert result back to the cast type to be the value
3934 of the assignment. */
3935
3936 switch (TREE_CODE (lhs))
3937 {
3938 case NOP_EXPR:
3939 case CONVERT_EXPR:
3940 case FLOAT_EXPR:
3941 case FIX_TRUNC_EXPR:
3942 case FIX_FLOOR_EXPR:
3943 case FIX_ROUND_EXPR:
3944 case FIX_CEIL_EXPR:
3945 if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
3946 || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE)
3947 newrhs = default_conversion (newrhs);
3948 {
3949 tree inner_lhs = TREE_OPERAND (lhs, 0);
3950 tree result;
3951 result = build_modify_expr (inner_lhs, NOP_EXPR,
3952 convert (TREE_TYPE (inner_lhs),
3953 convert (lhstype, newrhs)));
3954 if (TREE_CODE (result) == ERROR_MARK)
3955 return result;
3956 pedantic_lvalue_warning (CONVERT_EXPR);
3957 return convert (TREE_TYPE (lhs), result);
3958 }
3959
3960 default:
3961 break;
3962 }
3963
3964 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
3965 Reject anything strange now. */
3966
| 3788 }
3789
3790 /* Warn about possible alignment problems. */
3791 if (STRICT_ALIGNMENT && warn_cast_align
3792 && TREE_CODE (type) == POINTER_TYPE
3793 && TREE_CODE (otype) == POINTER_TYPE
3794 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3795 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3796 /* Don't warn about opaque types, where the actual alignment
3797 restriction is unknown. */
3798 && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3799 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3800 && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3801 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3802 warning ("cast increases required alignment of target type");
3803
3804 if (TREE_CODE (type) == INTEGER_TYPE
3805 && TREE_CODE (otype) == POINTER_TYPE
3806 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3807 && !TREE_CONSTANT (value))
3808 warning ("cast from pointer to integer of different size");
3809
3810 if (warn_bad_function_cast
3811 && TREE_CODE (value) == CALL_EXPR
3812 && TREE_CODE (type) != TREE_CODE (otype))
3813 warning ("cast does not match function type");
3814
3815 if (TREE_CODE (type) == POINTER_TYPE
3816 && TREE_CODE (otype) == INTEGER_TYPE
3817 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3818#if 0
3819 /* Don't warn about converting 0 to pointer,
3820 provided the 0 was explicit--not cast or made by folding. */
3821 && !(TREE_CODE (value) == INTEGER_CST && integer_zerop (value))
3822#endif
3823 /* Don't warn about converting any constant. */
3824 && !TREE_CONSTANT (value))
3825 warning ("cast to pointer from integer of different size");
3826
3827 ovalue = value;
3828 value = convert (type, value);
3829
3830 /* Ignore any integer overflow caused by the cast. */
3831 if (TREE_CODE (value) == INTEGER_CST)
3832 {
3833 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3834 TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3835 }
3836 }
3837
3838 /* Pedantically, don't ley (void *) (FOO *) 0 be a null pointer constant. */
3839 if (pedantic && TREE_CODE (value) == INTEGER_CST
3840 && TREE_CODE (expr) == INTEGER_CST
3841 && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3842 value = non_lvalue (value);
3843
3844 /* If pedantic, don't let a cast be an lvalue. */
3845 if (value == expr && pedantic)
3846 value = non_lvalue (value);
3847
3848 return value;
3849}
3850
3851/* Build an assignment expression of lvalue LHS from value RHS.
3852 MODIFYCODE is the code for a binary operator that we use
3853 to combine the old value of LHS with RHS to get the new value.
3854 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */
3855
3856tree
3857build_modify_expr (lhs, modifycode, rhs)
3858 tree lhs, rhs;
3859 enum tree_code modifycode;
3860{
3861 register tree result;
3862 tree newrhs;
3863 tree lhstype = TREE_TYPE (lhs);
3864 tree olhstype = lhstype;
3865
3866 /* Types that aren't fully specified cannot be used in assignments. */
3867 lhs = require_complete_type (lhs);
3868
3869 /* Avoid duplicate error messages from operands that had errors. */
3870 if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3871 return error_mark_node;
3872
3873 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3874 /* Do not use STRIP_NOPS here. We do not want an enumerator
3875 whose value is 0 to count as a null pointer constant. */
3876 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3877 rhs = TREE_OPERAND (rhs, 0);
3878
3879 newrhs = rhs;
3880
3881 /* Handle control structure constructs used as "lvalues". */
3882
3883 switch (TREE_CODE (lhs))
3884 {
3885 /* Handle (a, b) used as an "lvalue". */
3886 case COMPOUND_EXPR:
3887 pedantic_lvalue_warning (COMPOUND_EXPR);
3888 newrhs = build_modify_expr (TREE_OPERAND (lhs, 1),
3889 modifycode, rhs);
3890 if (TREE_CODE (newrhs) == ERROR_MARK)
3891 return error_mark_node;
3892 return build (COMPOUND_EXPR, lhstype,
3893 TREE_OPERAND (lhs, 0), newrhs);
3894
3895 /* Handle (a ? b : c) used as an "lvalue". */
3896 case COND_EXPR:
3897 pedantic_lvalue_warning (COND_EXPR);
3898 rhs = save_expr (rhs);
3899 {
3900 /* Produce (a ? (b = rhs) : (c = rhs))
3901 except that the RHS goes through a save-expr
3902 so the code to compute it is only emitted once. */
3903 tree cond
3904 = build_conditional_expr (TREE_OPERAND (lhs, 0),
3905 build_modify_expr (TREE_OPERAND (lhs, 1),
3906 modifycode, rhs),
3907 build_modify_expr (TREE_OPERAND (lhs, 2),
3908 modifycode, rhs));
3909 if (TREE_CODE (cond) == ERROR_MARK)
3910 return cond;
3911 /* Make sure the code to compute the rhs comes out
3912 before the split. */
3913 return build (COMPOUND_EXPR, TREE_TYPE (lhs),
3914 /* But cast it to void to avoid an "unused" error. */
3915 convert (void_type_node, rhs), cond);
3916 }
3917 default:
3918 break;
3919 }
3920
3921 /* If a binary op has been requested, combine the old LHS value with the RHS
3922 producing the value we should actually store into the LHS. */
3923
3924 if (modifycode != NOP_EXPR)
3925 {
3926 lhs = stabilize_reference (lhs);
3927 newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3928 }
3929
3930 /* Handle a cast used as an "lvalue".
3931 We have already performed any binary operator using the value as cast.
3932 Now convert the result to the cast type of the lhs,
3933 and then true type of the lhs and store it there;
3934 then convert result back to the cast type to be the value
3935 of the assignment. */
3936
3937 switch (TREE_CODE (lhs))
3938 {
3939 case NOP_EXPR:
3940 case CONVERT_EXPR:
3941 case FLOAT_EXPR:
3942 case FIX_TRUNC_EXPR:
3943 case FIX_FLOOR_EXPR:
3944 case FIX_ROUND_EXPR:
3945 case FIX_CEIL_EXPR:
3946 if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
3947 || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE)
3948 newrhs = default_conversion (newrhs);
3949 {
3950 tree inner_lhs = TREE_OPERAND (lhs, 0);
3951 tree result;
3952 result = build_modify_expr (inner_lhs, NOP_EXPR,
3953 convert (TREE_TYPE (inner_lhs),
3954 convert (lhstype, newrhs)));
3955 if (TREE_CODE (result) == ERROR_MARK)
3956 return result;
3957 pedantic_lvalue_warning (CONVERT_EXPR);
3958 return convert (TREE_TYPE (lhs), result);
3959 }
3960
3961 default:
3962 break;
3963 }
3964
3965 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
3966 Reject anything strange now. */
3967
|
3967 if (!lvalue_or_else (lhs, "assignment"))
| 3968 if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
|
3968 return error_mark_node;
3969
3970 /* Warn about storing in something that is `const'. */
3971
3972 if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3973 || ((TREE_CODE (lhstype) == RECORD_TYPE
3974 || TREE_CODE (lhstype) == UNION_TYPE)
3975 && C_TYPE_FIELDS_READONLY (lhstype)))
3976 readonly_warning (lhs, "assignment");
3977
3978 /* If storing into a structure or union member,
3979 it has probably been given type `int'.
3980 Compute the type that would go with
3981 the actual amount of storage the member occupies. */
3982
3983 if (TREE_CODE (lhs) == COMPONENT_REF
3984 && (TREE_CODE (lhstype) == INTEGER_TYPE
3985 || TREE_CODE (lhstype) == REAL_TYPE
3986 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3987 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3988
3989 /* If storing in a field that is in actuality a short or narrower than one,
3990 we must store in the field in its actual type. */
3991
3992 if (lhstype != TREE_TYPE (lhs))
3993 {
3994 lhs = copy_node (lhs);
3995 TREE_TYPE (lhs) = lhstype;
3996 }
3997
3998 /* Convert new value to destination type. */
3999
| 3969 return error_mark_node;
3970
3971 /* Warn about storing in something that is `const'. */
3972
3973 if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3974 || ((TREE_CODE (lhstype) == RECORD_TYPE
3975 || TREE_CODE (lhstype) == UNION_TYPE)
3976 && C_TYPE_FIELDS_READONLY (lhstype)))
3977 readonly_warning (lhs, "assignment");
3978
3979 /* If storing into a structure or union member,
3980 it has probably been given type `int'.
3981 Compute the type that would go with
3982 the actual amount of storage the member occupies. */
3983
3984 if (TREE_CODE (lhs) == COMPONENT_REF
3985 && (TREE_CODE (lhstype) == INTEGER_TYPE
3986 || TREE_CODE (lhstype) == REAL_TYPE
3987 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3988 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3989
3990 /* If storing in a field that is in actuality a short or narrower than one,
3991 we must store in the field in its actual type. */
3992
3993 if (lhstype != TREE_TYPE (lhs))
3994 {
3995 lhs = copy_node (lhs);
3996 TREE_TYPE (lhs) = lhstype;
3997 }
3998
3999 /* Convert new value to destination type. */
4000
|
4000 newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
| 4001 newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
|
4001 NULL_TREE, NULL_TREE, 0);
4002 if (TREE_CODE (newrhs) == ERROR_MARK)
4003 return error_mark_node;
4004
4005 result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
4006 TREE_SIDE_EFFECTS (result) = 1;
4007
4008 /* If we got the LHS in a different type for storing in,
4009 convert the result back to the nominal type of LHS
4010 so that the value we return always has the same type
4011 as the LHS argument. */
4012
4013 if (olhstype == TREE_TYPE (result))
4014 return result;
| 4002 NULL_TREE, NULL_TREE, 0);
4003 if (TREE_CODE (newrhs) == ERROR_MARK)
4004 return error_mark_node;
4005
4006 result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
4007 TREE_SIDE_EFFECTS (result) = 1;
4008
4009 /* If we got the LHS in a different type for storing in,
4010 convert the result back to the nominal type of LHS
4011 so that the value we return always has the same type
4012 as the LHS argument. */
4013
4014 if (olhstype == TREE_TYPE (result))
4015 return result;
|
4015 return convert_for_assignment (olhstype, result, "assignment",
| 4016 return convert_for_assignment (olhstype, result, _("assignment"),
|
4016 NULL_TREE, NULL_TREE, 0);
4017}
4018
4019/* Convert value RHS to type TYPE as preparation for an assignment
4020 to an lvalue of type TYPE.
4021 The real work of conversion is done by `convert'.
4022 The purpose of this function is to generate error messages
4023 for assignments that are not allowed in C.
4024 ERRTYPE is a string to use in error messages:
4025 "assignment", "return", etc. If it is null, this is parameter passing
| 4017 NULL_TREE, NULL_TREE, 0);
4018}
4019
4020/* Convert value RHS to type TYPE as preparation for an assignment
4021 to an lvalue of type TYPE.
4022 The real work of conversion is done by `convert'.
4023 The purpose of this function is to generate error messages
4024 for assignments that are not allowed in C.
4025 ERRTYPE is a string to use in error messages:
4026 "assignment", "return", etc. If it is null, this is parameter passing
|
4026 for a function call (and different error messages are output). Otherwise,
4027 it may be a name stored in the spelling stack and interpreted by
4028 get_spelling.
| 4027 for a function call (and different error messages are output).
|
4029
4030 FUNNAME is the name of the function being called,
4031 as an IDENTIFIER_NODE, or null.
4032 PARMNUM is the number of the argument, for printing in error messages. */
4033
4034static tree
4035convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
4036 tree type, rhs;
| 4028
4029 FUNNAME is the name of the function being called,
4030 as an IDENTIFIER_NODE, or null.
4031 PARMNUM is the number of the argument, for printing in error messages. */
4032
4033static tree
4034convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
4035 tree type, rhs;
|
4037 char *errtype;
| 4036 const char *errtype;
|
4038 tree fundecl, funname;
4039 int parmnum;
4040{
4041 register enum tree_code codel = TREE_CODE (type);
4042 register tree rhstype;
4043 register enum tree_code coder;
4044
4045 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4046 /* Do not use STRIP_NOPS here. We do not want an enumerator
4047 whose value is 0 to count as a null pointer constant. */
4048 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
4049 rhs = TREE_OPERAND (rhs, 0);
4050
4051 if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
4052 || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
4053 rhs = default_conversion (rhs);
4054 else if (optimize && TREE_CODE (rhs) == VAR_DECL)
4055 rhs = decl_constant_value (rhs);
4056
4057 rhstype = TREE_TYPE (rhs);
4058 coder = TREE_CODE (rhstype);
4059
4060 if (coder == ERROR_MARK)
4061 return error_mark_node;
4062
4063 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
4064 {
4065 overflow_warning (rhs);
4066 /* Check for Objective-C protocols. This will issue a warning if
4067 there are protocol violations. No need to use the return value. */
4068 maybe_objc_comptypes (type, rhstype, 0);
4069 return rhs;
4070 }
4071
4072 if (coder == VOID_TYPE)
4073 {
4074 error ("void value not ignored as it ought to be");
4075 return error_mark_node;
4076 }
4077 /* Arithmetic types all interconvert, and enum is treated like int. */
4078 if ((codel == INTEGER_TYPE || codel == REAL_TYPE || codel == ENUMERAL_TYPE
4079 || codel == COMPLEX_TYPE)
4080 && (coder == INTEGER_TYPE || coder == REAL_TYPE || coder == ENUMERAL_TYPE
4081 || coder == COMPLEX_TYPE))
4082 return convert_and_check (type, rhs);
4083
4084 /* Conversion to a transparent union from its member types.
4085 This applies only to function arguments. */
4086 else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
4087 {
4088 tree memb_types;
4089 tree marginal_memb_type = 0;
4090
4091 for (memb_types = TYPE_FIELDS (type); memb_types;
4092 memb_types = TREE_CHAIN (memb_types))
4093 {
4094 tree memb_type = TREE_TYPE (memb_types);
4095
4096 if (comptypes (TYPE_MAIN_VARIANT (memb_type),
4097 TYPE_MAIN_VARIANT (rhstype)))
4098 break;
4099
4100 if (TREE_CODE (memb_type) != POINTER_TYPE)
4101 continue;
4102
4103 if (coder == POINTER_TYPE)
4104 {
4105 register tree ttl = TREE_TYPE (memb_type);
4106 register tree ttr = TREE_TYPE (rhstype);
4107
4108 /* Any non-function converts to a [const][volatile] void *
4109 and vice versa; otherwise, targets must be the same.
4110 Meanwhile, the lhs target must have all the qualifiers of
4111 the rhs. */
4112 if (TYPE_MAIN_VARIANT (ttl) == void_type_node
4113 || TYPE_MAIN_VARIANT (ttr) == void_type_node
4114 || comp_target_types (memb_type, rhstype))
4115 {
4116 /* If this type won't generate any warnings, use it. */
| 4037 tree fundecl, funname;
4038 int parmnum;
4039{
4040 register enum tree_code codel = TREE_CODE (type);
4041 register tree rhstype;
4042 register enum tree_code coder;
4043
4044 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4045 /* Do not use STRIP_NOPS here. We do not want an enumerator
4046 whose value is 0 to count as a null pointer constant. */
4047 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
4048 rhs = TREE_OPERAND (rhs, 0);
4049
4050 if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
4051 || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
4052 rhs = default_conversion (rhs);
4053 else if (optimize && TREE_CODE (rhs) == VAR_DECL)
4054 rhs = decl_constant_value (rhs);
4055
4056 rhstype = TREE_TYPE (rhs);
4057 coder = TREE_CODE (rhstype);
4058
4059 if (coder == ERROR_MARK)
4060 return error_mark_node;
4061
4062 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
4063 {
4064 overflow_warning (rhs);
4065 /* Check for Objective-C protocols. This will issue a warning if
4066 there are protocol violations. No need to use the return value. */
4067 maybe_objc_comptypes (type, rhstype, 0);
4068 return rhs;
4069 }
4070
4071 if (coder == VOID_TYPE)
4072 {
4073 error ("void value not ignored as it ought to be");
4074 return error_mark_node;
4075 }
4076 /* Arithmetic types all interconvert, and enum is treated like int. */
4077 if ((codel == INTEGER_TYPE || codel == REAL_TYPE || codel == ENUMERAL_TYPE
4078 || codel == COMPLEX_TYPE)
4079 && (coder == INTEGER_TYPE || coder == REAL_TYPE || coder == ENUMERAL_TYPE
4080 || coder == COMPLEX_TYPE))
4081 return convert_and_check (type, rhs);
4082
4083 /* Conversion to a transparent union from its member types.
4084 This applies only to function arguments. */
4085 else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
4086 {
4087 tree memb_types;
4088 tree marginal_memb_type = 0;
4089
4090 for (memb_types = TYPE_FIELDS (type); memb_types;
4091 memb_types = TREE_CHAIN (memb_types))
4092 {
4093 tree memb_type = TREE_TYPE (memb_types);
4094
4095 if (comptypes (TYPE_MAIN_VARIANT (memb_type),
4096 TYPE_MAIN_VARIANT (rhstype)))
4097 break;
4098
4099 if (TREE_CODE (memb_type) != POINTER_TYPE)
4100 continue;
4101
4102 if (coder == POINTER_TYPE)
4103 {
4104 register tree ttl = TREE_TYPE (memb_type);
4105 register tree ttr = TREE_TYPE (rhstype);
4106
4107 /* Any non-function converts to a [const][volatile] void *
4108 and vice versa; otherwise, targets must be the same.
4109 Meanwhile, the lhs target must have all the qualifiers of
4110 the rhs. */
4111 if (TYPE_MAIN_VARIANT (ttl) == void_type_node
4112 || TYPE_MAIN_VARIANT (ttr) == void_type_node
4113 || comp_target_types (memb_type, rhstype))
4114 {
4115 /* If this type won't generate any warnings, use it. */
|
4117 if ((TREE_CODE (ttr) == FUNCTION_TYPE
4118 && TREE_CODE (ttl) == FUNCTION_TYPE)
4119 ? ((! TYPE_READONLY (ttl) | TYPE_READONLY (ttr))
4120 & (! TYPE_VOLATILE (ttl) | TYPE_VOLATILE (ttr)))
4121 : ((TYPE_READONLY (ttl) | ! TYPE_READONLY (ttr))
4122 & (TYPE_VOLATILE (ttl) | ! TYPE_VOLATILE (ttr))))
| 4116 if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
4117 || ((TREE_CODE (ttr) == FUNCTION_TYPE
4118 && TREE_CODE (ttl) == FUNCTION_TYPE)
4119 ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4120 == TYPE_QUALS (ttr))
4121 : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4122 == TYPE_QUALS (ttl))))
|
4123 break;
4124
4125 /* Keep looking for a better type, but remember this one. */
4126 if (! marginal_memb_type)
4127 marginal_memb_type = memb_type;
4128 }
4129 }
4130
4131 /* Can convert integer zero to any pointer type. */
4132 if (integer_zerop (rhs)
4133 || (TREE_CODE (rhs) == NOP_EXPR
4134 && integer_zerop (TREE_OPERAND (rhs, 0))))
4135 {
4136 rhs = null_pointer_node;
4137 break;
4138 }
4139 }
4140
4141 if (memb_types || marginal_memb_type)
4142 {
4143 if (! memb_types)
4144 {
4145 /* We have only a marginally acceptable member type;
4146 it needs a warning. */
4147 register tree ttl = TREE_TYPE (marginal_memb_type);
4148 register tree ttr = TREE_TYPE (rhstype);
4149
4150 /* Const and volatile mean something different for function
4151 types, so the usual warnings are not appropriate. */
4152 if (TREE_CODE (ttr) == FUNCTION_TYPE
4153 && TREE_CODE (ttl) == FUNCTION_TYPE)
4154 {
4155 /* Because const and volatile on functions are
4156 restrictions that say the function will not do
4157 certain things, it is okay to use a const or volatile
4158 function where an ordinary one is wanted, but not
4159 vice-versa. */
| 4123 break;
4124
4125 /* Keep looking for a better type, but remember this one. */
4126 if (! marginal_memb_type)
4127 marginal_memb_type = memb_type;
4128 }
4129 }
4130
4131 /* Can convert integer zero to any pointer type. */
4132 if (integer_zerop (rhs)
4133 || (TREE_CODE (rhs) == NOP_EXPR
4134 && integer_zerop (TREE_OPERAND (rhs, 0))))
4135 {
4136 rhs = null_pointer_node;
4137 break;
4138 }
4139 }
4140
4141 if (memb_types || marginal_memb_type)
4142 {
4143 if (! memb_types)
4144 {
4145 /* We have only a marginally acceptable member type;
4146 it needs a warning. */
4147 register tree ttl = TREE_TYPE (marginal_memb_type);
4148 register tree ttr = TREE_TYPE (rhstype);
4149
4150 /* Const and volatile mean something different for function
4151 types, so the usual warnings are not appropriate. */
4152 if (TREE_CODE (ttr) == FUNCTION_TYPE
4153 && TREE_CODE (ttl) == FUNCTION_TYPE)
4154 {
4155 /* Because const and volatile on functions are
4156 restrictions that say the function will not do
4157 certain things, it is okay to use a const or volatile
4158 function where an ordinary one is wanted, but not
4159 vice-versa. */
|
4160 if (TYPE_READONLY (ttl) && ! TYPE_READONLY (ttr))
4161 warn_for_assignment ("%s makes `const *' function pointer from non-const",
4162 get_spelling (errtype), funname,
4163 parmnum);
4164 if (TYPE_VOLATILE (ttl) && ! TYPE_VOLATILE (ttr))
4165 warn_for_assignment ("%s makes `volatile *' function pointer from non-volatile",
4166 get_spelling (errtype), funname,
4167 parmnum);
| 4160 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4161 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4162 errtype, funname, parmnum);
|
4168 }
| 4163 }
|
4169 else
4170 {
4171 if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
4172 warn_for_assignment ("%s discards `const' from pointer target type",
4173 get_spelling (errtype), funname,
4174 parmnum);
4175 if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
4176 warn_for_assignment ("%s discards `volatile' from pointer target type",
4177 get_spelling (errtype), funname,
4178 parmnum);
4179 }
| 4164 else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4165 warn_for_assignment ("%s discards qualifiers from pointer target type",
4166 errtype, funname,
4167 parmnum);
|
4180 }
4181
4182 if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
4183 pedwarn ("ANSI C prohibits argument conversion to union type");
4184
4185 return build1 (NOP_EXPR, type, rhs);
4186 }
4187 }
4188
4189 /* Conversions among pointers */
4190 else if (codel == POINTER_TYPE && coder == POINTER_TYPE)
4191 {
4192 register tree ttl = TREE_TYPE (type);
4193 register tree ttr = TREE_TYPE (rhstype);
4194
4195 /* Any non-function converts to a [const][volatile] void *
4196 and vice versa; otherwise, targets must be the same.
4197 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
4198 if (TYPE_MAIN_VARIANT (ttl) == void_type_node
4199 || TYPE_MAIN_VARIANT (ttr) == void_type_node
4200 || comp_target_types (type, rhstype)
4201 || (unsigned_type (TYPE_MAIN_VARIANT (ttl))
4202 == unsigned_type (TYPE_MAIN_VARIANT (ttr))))
4203 {
4204 if (pedantic
4205 && ((TYPE_MAIN_VARIANT (ttl) == void_type_node
4206 && TREE_CODE (ttr) == FUNCTION_TYPE)
4207 ||
4208 (TYPE_MAIN_VARIANT (ttr) == void_type_node
4209 /* Check TREE_CODE to catch cases like (void *) (char *) 0
4210 which are not ANSI null ptr constants. */
4211 && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
4212 && TREE_CODE (ttl) == FUNCTION_TYPE)))
4213 warn_for_assignment ("ANSI forbids %s between function pointer and `void *'",
| 4168 }
4169
4170 if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
4171 pedwarn ("ANSI C prohibits argument conversion to union type");
4172
4173 return build1 (NOP_EXPR, type, rhs);
4174 }
4175 }
4176
4177 /* Conversions among pointers */
4178 else if (codel == POINTER_TYPE && coder == POINTER_TYPE)
4179 {
4180 register tree ttl = TREE_TYPE (type);
4181 register tree ttr = TREE_TYPE (rhstype);
4182
4183 /* Any non-function converts to a [const][volatile] void *
4184 and vice versa; otherwise, targets must be the same.
4185 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
4186 if (TYPE_MAIN_VARIANT (ttl) == void_type_node
4187 || TYPE_MAIN_VARIANT (ttr) == void_type_node
4188 || comp_target_types (type, rhstype)
4189 || (unsigned_type (TYPE_MAIN_VARIANT (ttl))
4190 == unsigned_type (TYPE_MAIN_VARIANT (ttr))))
4191 {
4192 if (pedantic
4193 && ((TYPE_MAIN_VARIANT (ttl) == void_type_node
4194 && TREE_CODE (ttr) == FUNCTION_TYPE)
4195 ||
4196 (TYPE_MAIN_VARIANT (ttr) == void_type_node
4197 /* Check TREE_CODE to catch cases like (void *) (char *) 0
4198 which are not ANSI null ptr constants. */
4199 && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
4200 && TREE_CODE (ttl) == FUNCTION_TYPE)))
4201 warn_for_assignment ("ANSI forbids %s between function pointer and `void *'",
|
4214 get_spelling (errtype), funname, parmnum);
| 4202 errtype, funname, parmnum);
|
4215 /* Const and volatile mean something different for function types,
4216 so the usual warnings are not appropriate. */
4217 else if (TREE_CODE (ttr) != FUNCTION_TYPE
4218 && TREE_CODE (ttl) != FUNCTION_TYPE)
4219 {
| 4203 /* Const and volatile mean something different for function types,
4204 so the usual warnings are not appropriate. */
4205 else if (TREE_CODE (ttr) != FUNCTION_TYPE
4206 && TREE_CODE (ttl) != FUNCTION_TYPE)
4207 {
|
4220 if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
4221 warn_for_assignment ("%s discards `const' from pointer target type",
4222 get_spelling (errtype), funname, parmnum);
4223 else if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
4224 warn_for_assignment ("%s discards `volatile' from pointer target type",
4225 get_spelling (errtype), funname, parmnum);
| 4208 if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4209 warn_for_assignment ("%s discards qualifiers from pointer target type",
4210 errtype, funname, parmnum);
|
4226 /* If this is not a case of ignoring a mismatch in signedness,
4227 no warning. */
4228 else if (TYPE_MAIN_VARIANT (ttl) == void_type_node
4229 || TYPE_MAIN_VARIANT (ttr) == void_type_node
4230 || comp_target_types (type, rhstype))
4231 ;
4232 /* If there is a mismatch, do warn. */
4233 else if (pedantic)
4234 warn_for_assignment ("pointer targets in %s differ in signedness",
| 4211 /* If this is not a case of ignoring a mismatch in signedness,
4212 no warning. */
4213 else if (TYPE_MAIN_VARIANT (ttl) == void_type_node
4214 || TYPE_MAIN_VARIANT (ttr) == void_type_node
4215 || comp_target_types (type, rhstype))
4216 ;
4217 /* If there is a mismatch, do warn. */
4218 else if (pedantic)
4219 warn_for_assignment ("pointer targets in %s differ in signedness",
|
4235 get_spelling (errtype), funname, parmnum);
| 4220 errtype, funname, parmnum);
|
4236 }
4237 else if (TREE_CODE (ttl) == FUNCTION_TYPE
4238 && TREE_CODE (ttr) == FUNCTION_TYPE)
4239 {
4240 /* Because const and volatile on functions are restrictions
4241 that say the function will not do certain things,
4242 it is okay to use a const or volatile function
4243 where an ordinary one is wanted, but not vice-versa. */
| 4221 }
4222 else if (TREE_CODE (ttl) == FUNCTION_TYPE
4223 && TREE_CODE (ttr) == FUNCTION_TYPE)
4224 {
4225 /* Because const and volatile on functions are restrictions
4226 that say the function will not do certain things,
4227 it is okay to use a const or volatile function
4228 where an ordinary one is wanted, but not vice-versa. */
|
4244 if (TYPE_READONLY (ttl) && ! TYPE_READONLY (ttr))
4245 warn_for_assignment ("%s makes `const *' function pointer from non-const",
4246 get_spelling (errtype), funname, parmnum);
4247 if (TYPE_VOLATILE (ttl) && ! TYPE_VOLATILE (ttr))
4248 warn_for_assignment ("%s makes `volatile *' function pointer from non-volatile",
4249 get_spelling (errtype), funname, parmnum);
| 4229 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4230 warn_for_assignment ("%s makes qualified function pointer from unqualified",
4231 errtype, funname, parmnum);
|
4250 }
4251 }
4252 else
4253 warn_for_assignment ("%s from incompatible pointer type",
| 4232 }
4233 }
4234 else
4235 warn_for_assignment ("%s from incompatible pointer type",
|
4254 get_spelling (errtype), funname, parmnum);
| 4236 errtype, funname, parmnum);
|
4255 return convert (type, rhs);
4256 }
4257 else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
4258 {
4259 /* An explicit constant 0 can convert to a pointer,
4260 or one that results from arithmetic, even including
4261 a cast to integer type. */
4262 if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
4263 &&
4264 ! (TREE_CODE (rhs) == NOP_EXPR
4265 && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
4266 && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
4267 && integer_zerop (TREE_OPERAND (rhs, 0))))
4268 {
4269 warn_for_assignment ("%s makes pointer from integer without a cast",
| 4237 return convert (type, rhs);
4238 }
4239 else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
4240 {
4241 /* An explicit constant 0 can convert to a pointer,
4242 or one that results from arithmetic, even including
4243 a cast to integer type. */
4244 if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
4245 &&
4246 ! (TREE_CODE (rhs) == NOP_EXPR
4247 && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
4248 && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
4249 && integer_zerop (TREE_OPERAND (rhs, 0))))
4250 {
4251 warn_for_assignment ("%s makes pointer from integer without a cast",
|
4270 get_spelling (errtype), funname, parmnum);
| 4252 errtype, funname, parmnum);
|
4271 return convert (type, rhs);
4272 }
4273 return null_pointer_node;
4274 }
4275 else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
4276 {
4277 warn_for_assignment ("%s makes integer from pointer without a cast",
| 4253 return convert (type, rhs);
4254 }
4255 return null_pointer_node;
4256 }
4257 else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
4258 {
4259 warn_for_assignment ("%s makes integer from pointer without a cast",
|
4278 get_spelling (errtype), funname, parmnum);
| 4260 errtype, funname, parmnum);
|
4279 return convert (type, rhs);
4280 }
4281
4282 if (!errtype)
4283 {
4284 if (funname)
4285 {
4286 tree selector = maybe_building_objc_message_expr ();
4287
4288 if (selector && parmnum > 2)
4289 error ("incompatible type for argument %d of `%s'",
4290 parmnum - 2, IDENTIFIER_POINTER (selector));
4291 else
4292 error ("incompatible type for argument %d of `%s'",
4293 parmnum, IDENTIFIER_POINTER (funname));
4294 }
4295 else
4296 error ("incompatible type for argument %d of indirect function call",
4297 parmnum);
4298 }
4299 else
| 4261 return convert (type, rhs);
4262 }
4263
4264 if (!errtype)
4265 {
4266 if (funname)
4267 {
4268 tree selector = maybe_building_objc_message_expr ();
4269
4270 if (selector && parmnum > 2)
4271 error ("incompatible type for argument %d of `%s'",
4272 parmnum - 2, IDENTIFIER_POINTER (selector));
4273 else
4274 error ("incompatible type for argument %d of `%s'",
4275 parmnum, IDENTIFIER_POINTER (funname));
4276 }
4277 else
4278 error ("incompatible type for argument %d of indirect function call",
4279 parmnum);
4280 }
4281 else
|
4300 error ("incompatible types in %s", get_spelling (errtype));
| 4282 error ("incompatible types in %s", errtype);
|
4301
4302 return error_mark_node;
4303}
4304
| 4283
4284 return error_mark_node;
4285}
4286
|
4305/* Print a warning using MSG.
| 4287/* Print a warning using MSGID.
|
4306 It gets OPNAME as its one parameter.
4307 If OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
4308 FUNCTION and ARGNUM are handled specially if we are building an
4309 Objective-C selector. */
4310
4311static void
| 4288 It gets OPNAME as its one parameter.
4289 If OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
4290 FUNCTION and ARGNUM are handled specially if we are building an
4291 Objective-C selector. */
4292
4293static void
|
4312warn_for_assignment (msg, opname, function, argnum)
4313 char *msg;
4314 char *opname;
| 4294warn_for_assignment (msgid, opname, function, argnum)
4295 const char *msgid;
4296 const char *opname;
|
4315 tree function;
4316 int argnum;
4317{
| 4297 tree function;
4298 int argnum;
4299{
|
4318 static char argstring[] = "passing arg %d of `%s'";
4319 static char argnofun[] = "passing arg %d";
4320
| |
4321 if (opname == 0)
4322 {
4323 tree selector = maybe_building_objc_message_expr ();
| 4300 if (opname == 0)
4301 {
4302 tree selector = maybe_building_objc_message_expr ();
|
| 4303 char * new_opname;
|
4324
4325 if (selector && argnum > 2)
4326 {
4327 function = selector;
4328 argnum -= 2;
4329 }
4330 if (function)
4331 {
4332 /* Function name is known; supply it. */
| 4304
4305 if (selector && argnum > 2)
4306 {
4307 function = selector;
4308 argnum -= 2;
4309 }
4310 if (function)
4311 {
4312 /* Function name is known; supply it. */
|
4333 opname = (char *) alloca (IDENTIFIER_LENGTH (function)
4334 + sizeof (argstring) + 25 /*%d*/ + 1);
4335 sprintf (opname, argstring, argnum, IDENTIFIER_POINTER (function));
| 4313 const char *argstring = _("passing arg %d of `%s'");
4314 new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
4315 + strlen (argstring) + 1 + 25
4316 /*%d*/ + 1);
4317 sprintf (new_opname, argstring, argnum,
4318 IDENTIFIER_POINTER (function));
|
4336 }
4337 else
4338 {
| 4319 }
4320 else
4321 {
|
4339 /* Function name unknown (call through ptr); just give arg number. */
4340 opname = (char *) alloca (sizeof (argnofun) + 25 /*%d*/ + 1);
4341 sprintf (opname, argnofun, argnum);
| 4322 /* Function name unknown (call through ptr); just give arg number.*/
4323 const char *argnofun = _("passing arg %d of pointer to function");
4324 new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
4325 sprintf (new_opname, argnofun, argnum);
|
4342 }
| 4326 }
|
| 4327 opname = new_opname;
|
4343 }
| 4328 }
|
4344 pedwarn (msg, opname);
| 4329 pedwarn (msgid, opname);
|
4345}
4346
4347/* Return nonzero if VALUE is a valid constant-valued expression
4348 for use in initializing a static variable; one that can be an
4349 element of a "constant" initializer.
4350
4351 Return null_pointer_node if the value is absolute;
4352 if it is relocatable, return the variable that determines the relocation.
4353 We assume that VALUE has been folded as much as possible;
4354 therefore, we do not need to check for such things as
4355 arithmetic-combinations of integers. */
4356
4357tree
4358initializer_constant_valid_p (value, endtype)
4359 tree value;
4360 tree endtype;
4361{
4362 switch (TREE_CODE (value))
4363 {
4364 case CONSTRUCTOR:
4365 if ((TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
4366 || TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE)
4367 && TREE_CONSTANT (value)
4368 && CONSTRUCTOR_ELTS (value))
4369 return
4370 initializer_constant_valid_p (TREE_VALUE (CONSTRUCTOR_ELTS (value)),
4371 endtype);
4372
4373 return TREE_STATIC (value) ? null_pointer_node : 0;
4374
4375 case INTEGER_CST:
4376 case REAL_CST:
4377 case STRING_CST:
4378 case COMPLEX_CST:
4379 return null_pointer_node;
4380
4381 case ADDR_EXPR:
4382 return TREE_OPERAND (value, 0);
4383
4384 case NON_LVALUE_EXPR:
4385 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4386
4387 case CONVERT_EXPR:
4388 case NOP_EXPR:
4389 /* Allow conversions between pointer types. */
4390 if (TREE_CODE (TREE_TYPE (value)) == POINTER_TYPE
4391 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == POINTER_TYPE)
4392 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4393
4394 /* Allow conversions between real types. */
4395 if (TREE_CODE (TREE_TYPE (value)) == REAL_TYPE
4396 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == REAL_TYPE)
4397 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4398
4399 /* Allow length-preserving conversions between integer types. */
4400 if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
4401 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE
4402 && (TYPE_PRECISION (TREE_TYPE (value))
4403 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4404 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4405
4406 /* Allow conversions between other integer types only if
4407 explicit value. */
4408 if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
4409 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE)
4410 {
4411 tree inner = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4412 endtype);
4413 if (inner == null_pointer_node)
4414 return null_pointer_node;
4415 return 0;
4416 }
4417
4418 /* Allow (int) &foo provided int is as wide as a pointer. */
4419 if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
4420 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == POINTER_TYPE
4421 && (TYPE_PRECISION (TREE_TYPE (value))
4422 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4423 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4424 endtype);
4425
| 4330}
4331
4332/* Return nonzero if VALUE is a valid constant-valued expression
4333 for use in initializing a static variable; one that can be an
4334 element of a "constant" initializer.
4335
4336 Return null_pointer_node if the value is absolute;
4337 if it is relocatable, return the variable that determines the relocation.
4338 We assume that VALUE has been folded as much as possible;
4339 therefore, we do not need to check for such things as
4340 arithmetic-combinations of integers. */
4341
4342tree
4343initializer_constant_valid_p (value, endtype)
4344 tree value;
4345 tree endtype;
4346{
4347 switch (TREE_CODE (value))
4348 {
4349 case CONSTRUCTOR:
4350 if ((TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
4351 || TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE)
4352 && TREE_CONSTANT (value)
4353 && CONSTRUCTOR_ELTS (value))
4354 return
4355 initializer_constant_valid_p (TREE_VALUE (CONSTRUCTOR_ELTS (value)),
4356 endtype);
4357
4358 return TREE_STATIC (value) ? null_pointer_node : 0;
4359
4360 case INTEGER_CST:
4361 case REAL_CST:
4362 case STRING_CST:
4363 case COMPLEX_CST:
4364 return null_pointer_node;
4365
4366 case ADDR_EXPR:
4367 return TREE_OPERAND (value, 0);
4368
4369 case NON_LVALUE_EXPR:
4370 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4371
4372 case CONVERT_EXPR:
4373 case NOP_EXPR:
4374 /* Allow conversions between pointer types. */
4375 if (TREE_CODE (TREE_TYPE (value)) == POINTER_TYPE
4376 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == POINTER_TYPE)
4377 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4378
4379 /* Allow conversions between real types. */
4380 if (TREE_CODE (TREE_TYPE (value)) == REAL_TYPE
4381 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == REAL_TYPE)
4382 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4383
4384 /* Allow length-preserving conversions between integer types. */
4385 if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
4386 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE
4387 && (TYPE_PRECISION (TREE_TYPE (value))
4388 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4389 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4390
4391 /* Allow conversions between other integer types only if
4392 explicit value. */
4393 if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
4394 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE)
4395 {
4396 tree inner = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4397 endtype);
4398 if (inner == null_pointer_node)
4399 return null_pointer_node;
4400 return 0;
4401 }
4402
4403 /* Allow (int) &foo provided int is as wide as a pointer. */
4404 if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
4405 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == POINTER_TYPE
4406 && (TYPE_PRECISION (TREE_TYPE (value))
4407 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4408 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4409 endtype);
4410
|
4426 /* Likewise conversions from int to pointers. */
| 4411 /* Likewise conversions from int to pointers, but also allow
4412 conversions from 0. */
|
4427 if (TREE_CODE (TREE_TYPE (value)) == POINTER_TYPE
| 4413 if (TREE_CODE (TREE_TYPE (value)) == POINTER_TYPE
|
4428 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE
4429 && (TYPE_PRECISION (TREE_TYPE (value))
4430 <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4431 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4432 endtype);
| 4414 && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE)
4415 {
4416 if (integer_zerop (TREE_OPERAND (value, 0)))
4417 return null_pointer_node;
4418 else if (TYPE_PRECISION (TREE_TYPE (value))
4419 <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0))))
4420 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4421 endtype);
4422 }
|
4433
4434 /* Allow conversions to union types if the value inside is okay. */
4435 if (TREE_CODE (TREE_TYPE (value)) == UNION_TYPE)
4436 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4437 endtype);
4438 return 0;
4439
4440 case PLUS_EXPR:
4441 if (TREE_CODE (endtype) == INTEGER_TYPE
4442 && TYPE_PRECISION (endtype) < POINTER_SIZE)
4443 return 0;
4444 {
4445 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4446 endtype);
4447 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4448 endtype);
4449 /* If either term is absolute, use the other terms relocation. */
4450 if (valid0 == null_pointer_node)
4451 return valid1;
4452 if (valid1 == null_pointer_node)
4453 return valid0;
4454 return 0;
4455 }
4456
4457 case MINUS_EXPR:
4458 if (TREE_CODE (endtype) == INTEGER_TYPE
4459 && TYPE_PRECISION (endtype) < POINTER_SIZE)
4460 return 0;
4461 {
4462 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4463 endtype);
4464 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4465 endtype);
4466 /* Win if second argument is absolute. */
4467 if (valid1 == null_pointer_node)
4468 return valid0;
4469 /* Win if both arguments have the same relocation.
4470 Then the value is absolute. */
4471 if (valid0 == valid1)
4472 return null_pointer_node;
4473 return 0;
4474 }
4475
4476 default:
4477 return 0;
4478 }
4479}
4480
4481/* If VALUE is a compound expr all of whose expressions are constant, then
4482 return its value. Otherwise, return error_mark_node.
4483
4484 This is for handling COMPOUND_EXPRs as initializer elements
4485 which is allowed with a warning when -pedantic is specified. */
4486
4487static tree
4488valid_compound_expr_initializer (value, endtype)
4489 tree value;
4490 tree endtype;
4491{
4492 if (TREE_CODE (value) == COMPOUND_EXPR)
4493 {
4494 if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
4495 == error_mark_node)
4496 return error_mark_node;
4497 return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
4498 endtype);
4499 }
4500 else if (! TREE_CONSTANT (value)
4501 && ! initializer_constant_valid_p (value, endtype))
4502 return error_mark_node;
4503 else
4504 return value;
4505}
4506
4507/* Perform appropriate conversions on the initial value of a variable,
4508 store it in the declaration DECL,
4509 and print any error messages that are appropriate.
4510 If the init is invalid, store an ERROR_MARK. */
4511
4512void
4513store_init_value (decl, init)
4514 tree decl, init;
4515{
4516 register tree value, type;
4517
4518 /* If variable's type was invalidly declared, just ignore it. */
4519
4520 type = TREE_TYPE (decl);
4521 if (TREE_CODE (type) == ERROR_MARK)
4522 return;
4523
4524 /* Digest the specified initializer into an expression. */
4525
4526 value = digest_init (type, init, TREE_STATIC (decl),
4527 TREE_STATIC (decl) || pedantic);
4528
4529 /* Store the expression if valid; else report error. */
4530
4531#if 0
4532 /* Note that this is the only place we can detect the error
4533 in a case such as struct foo bar = (struct foo) { x, y };
4534 where there is one initial value which is a constructor expression. */
4535 if (value == error_mark_node)
4536 ;
4537 else if (TREE_STATIC (decl) && ! TREE_CONSTANT (value))
4538 {
4539 error ("initializer for static variable is not constant");
4540 value = error_mark_node;
4541 }
4542 else if (TREE_STATIC (decl)
4543 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
4544 {
4545 error ("initializer for static variable uses complicated arithmetic");
4546 value = error_mark_node;
4547 }
4548 else
4549 {
4550 if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
4551 {
4552 if (! TREE_CONSTANT (value))
4553 pedwarn ("aggregate initializer is not constant");
4554 else if (! TREE_STATIC (value))
4555 pedwarn ("aggregate initializer uses complicated arithmetic");
4556 }
4557 }
4558#endif
4559
4560 DECL_INITIAL (decl) = value;
4561
4562 /* ANSI wants warnings about out-of-range constant initializers. */
4563 STRIP_TYPE_NOPS (value);
4564 constant_expression_warning (value);
4565}
4566
4567/* Methods for storing and printing names for error messages. */
4568
4569/* Implement a spelling stack that allows components of a name to be pushed
4570 and popped. Each element on the stack is this structure. */
4571
4572struct spelling
4573{
4574 int kind;
4575 union
4576 {
4577 int i;
| 4423
4424 /* Allow conversions to union types if the value inside is okay. */
4425 if (TREE_CODE (TREE_TYPE (value)) == UNION_TYPE)
4426 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4427 endtype);
4428 return 0;
4429
4430 case PLUS_EXPR:
4431 if (TREE_CODE (endtype) == INTEGER_TYPE
4432 && TYPE_PRECISION (endtype) < POINTER_SIZE)
4433 return 0;
4434 {
4435 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4436 endtype);
4437 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4438 endtype);
4439 /* If either term is absolute, use the other terms relocation. */
4440 if (valid0 == null_pointer_node)
4441 return valid1;
4442 if (valid1 == null_pointer_node)
4443 return valid0;
4444 return 0;
4445 }
4446
4447 case MINUS_EXPR:
4448 if (TREE_CODE (endtype) == INTEGER_TYPE
4449 && TYPE_PRECISION (endtype) < POINTER_SIZE)
4450 return 0;
4451 {
4452 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4453 endtype);
4454 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4455 endtype);
4456 /* Win if second argument is absolute. */
4457 if (valid1 == null_pointer_node)
4458 return valid0;
4459 /* Win if both arguments have the same relocation.
4460 Then the value is absolute. */
4461 if (valid0 == valid1)
4462 return null_pointer_node;
4463 return 0;
4464 }
4465
4466 default:
4467 return 0;
4468 }
4469}
4470
4471/* If VALUE is a compound expr all of whose expressions are constant, then
4472 return its value. Otherwise, return error_mark_node.
4473
4474 This is for handling COMPOUND_EXPRs as initializer elements
4475 which is allowed with a warning when -pedantic is specified. */
4476
4477static tree
4478valid_compound_expr_initializer (value, endtype)
4479 tree value;
4480 tree endtype;
4481{
4482 if (TREE_CODE (value) == COMPOUND_EXPR)
4483 {
4484 if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
4485 == error_mark_node)
4486 return error_mark_node;
4487 return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
4488 endtype);
4489 }
4490 else if (! TREE_CONSTANT (value)
4491 && ! initializer_constant_valid_p (value, endtype))
4492 return error_mark_node;
4493 else
4494 return value;
4495}
4496
4497/* Perform appropriate conversions on the initial value of a variable,
4498 store it in the declaration DECL,
4499 and print any error messages that are appropriate.
4500 If the init is invalid, store an ERROR_MARK. */
4501
4502void
4503store_init_value (decl, init)
4504 tree decl, init;
4505{
4506 register tree value, type;
4507
4508 /* If variable's type was invalidly declared, just ignore it. */
4509
4510 type = TREE_TYPE (decl);
4511 if (TREE_CODE (type) == ERROR_MARK)
4512 return;
4513
4514 /* Digest the specified initializer into an expression. */
4515
4516 value = digest_init (type, init, TREE_STATIC (decl),
4517 TREE_STATIC (decl) || pedantic);
4518
4519 /* Store the expression if valid; else report error. */
4520
4521#if 0
4522 /* Note that this is the only place we can detect the error
4523 in a case such as struct foo bar = (struct foo) { x, y };
4524 where there is one initial value which is a constructor expression. */
4525 if (value == error_mark_node)
4526 ;
4527 else if (TREE_STATIC (decl) && ! TREE_CONSTANT (value))
4528 {
4529 error ("initializer for static variable is not constant");
4530 value = error_mark_node;
4531 }
4532 else if (TREE_STATIC (decl)
4533 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
4534 {
4535 error ("initializer for static variable uses complicated arithmetic");
4536 value = error_mark_node;
4537 }
4538 else
4539 {
4540 if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
4541 {
4542 if (! TREE_CONSTANT (value))
4543 pedwarn ("aggregate initializer is not constant");
4544 else if (! TREE_STATIC (value))
4545 pedwarn ("aggregate initializer uses complicated arithmetic");
4546 }
4547 }
4548#endif
4549
4550 DECL_INITIAL (decl) = value;
4551
4552 /* ANSI wants warnings about out-of-range constant initializers. */
4553 STRIP_TYPE_NOPS (value);
4554 constant_expression_warning (value);
4555}
4556
4557/* Methods for storing and printing names for error messages. */
4558
4559/* Implement a spelling stack that allows components of a name to be pushed
4560 and popped. Each element on the stack is this structure. */
4561
4562struct spelling
4563{
4564 int kind;
4565 union
4566 {
4567 int i;
|
4578 char *s;
| 4568 const char *s;
|
4579 } u;
4580};
4581
4582#define SPELLING_STRING 1
4583#define SPELLING_MEMBER 2
4584#define SPELLING_BOUNDS 3
4585
4586static struct spelling *spelling; /* Next stack element (unused). */
4587static struct spelling *spelling_base; /* Spelling stack base. */
4588static int spelling_size; /* Size of the spelling stack. */
4589
4590/* Macros to save and restore the spelling stack around push_... functions.
4591 Alternative to SAVE_SPELLING_STACK. */
4592
4593#define SPELLING_DEPTH() (spelling - spelling_base)
4594#define RESTORE_SPELLING_DEPTH(depth) (spelling = spelling_base + depth)
4595
4596/* Save and restore the spelling stack around arbitrary C code. */
4597
4598#define SAVE_SPELLING_DEPTH(code) \
4599{ \
4600 int __depth = SPELLING_DEPTH (); \
4601 code; \
4602 RESTORE_SPELLING_DEPTH (__depth); \
4603}
4604
4605/* Push an element on the spelling stack with type KIND and assign VALUE
4606 to MEMBER. */
4607
4608#define PUSH_SPELLING(KIND, VALUE, MEMBER) \
4609{ \
4610 int depth = SPELLING_DEPTH (); \
4611 \
4612 if (depth >= spelling_size) \
4613 { \
4614 spelling_size += 10; \
4615 if (spelling_base == 0) \
4616 spelling_base \
4617 = (struct spelling *) xmalloc (spelling_size * sizeof (struct spelling)); \
4618 else \
4619 spelling_base \
4620 = (struct spelling *) xrealloc (spelling_base, \
4621 spelling_size * sizeof (struct spelling)); \
4622 RESTORE_SPELLING_DEPTH (depth); \
4623 } \
4624 \
4625 spelling->kind = (KIND); \
4626 spelling->MEMBER = (VALUE); \
4627 spelling++; \
4628}
4629
4630/* Push STRING on the stack. Printed literally. */
4631
4632static void
4633push_string (string)
| 4569 } u;
4570};
4571
4572#define SPELLING_STRING 1
4573#define SPELLING_MEMBER 2
4574#define SPELLING_BOUNDS 3
4575
4576static struct spelling *spelling; /* Next stack element (unused). */
4577static struct spelling *spelling_base; /* Spelling stack base. */
4578static int spelling_size; /* Size of the spelling stack. */
4579
4580/* Macros to save and restore the spelling stack around push_... functions.
4581 Alternative to SAVE_SPELLING_STACK. */
4582
4583#define SPELLING_DEPTH() (spelling - spelling_base)
4584#define RESTORE_SPELLING_DEPTH(depth) (spelling = spelling_base + depth)
4585
4586/* Save and restore the spelling stack around arbitrary C code. */
4587
4588#define SAVE_SPELLING_DEPTH(code) \
4589{ \
4590 int __depth = SPELLING_DEPTH (); \
4591 code; \
4592 RESTORE_SPELLING_DEPTH (__depth); \
4593}
4594
4595/* Push an element on the spelling stack with type KIND and assign VALUE
4596 to MEMBER. */
4597
4598#define PUSH_SPELLING(KIND, VALUE, MEMBER) \
4599{ \
4600 int depth = SPELLING_DEPTH (); \
4601 \
4602 if (depth >= spelling_size) \
4603 { \
4604 spelling_size += 10; \
4605 if (spelling_base == 0) \
4606 spelling_base \
4607 = (struct spelling *) xmalloc (spelling_size * sizeof (struct spelling)); \
4608 else \
4609 spelling_base \
4610 = (struct spelling *) xrealloc (spelling_base, \
4611 spelling_size * sizeof (struct spelling)); \
4612 RESTORE_SPELLING_DEPTH (depth); \
4613 } \
4614 \
4615 spelling->kind = (KIND); \
4616 spelling->MEMBER = (VALUE); \
4617 spelling++; \
4618}
4619
4620/* Push STRING on the stack. Printed literally. */
4621
4622static void
4623push_string (string)
|
4634 char *string;
| 4624 const char *string;
|
4635{
4636 PUSH_SPELLING (SPELLING_STRING, string, u.s);
4637}
4638
4639/* Push a member name on the stack. Printed as '.' STRING. */
4640
4641static void
4642push_member_name (decl)
4643 tree decl;
4644
4645{
| 4625{
4626 PUSH_SPELLING (SPELLING_STRING, string, u.s);
4627}
4628
4629/* Push a member name on the stack. Printed as '.' STRING. */
4630
4631static void
4632push_member_name (decl)
4633 tree decl;
4634
4635{
|
4646 char *string
| 4636 const char *string
|
4647 = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
4648 PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
4649}
4650
4651/* Push an array bounds on the stack. Printed as [BOUNDS]. */
4652
4653static void
4654push_array_bounds (bounds)
4655 int bounds;
4656{
4657 PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
4658}
4659
4660/* Compute the maximum size in bytes of the printed spelling. */
4661
4662static int
4663spelling_length ()
4664{
4665 register int size = 0;
4666 register struct spelling *p;
4667
4668 for (p = spelling_base; p < spelling; p++)
4669 {
4670 if (p->kind == SPELLING_BOUNDS)
4671 size += 25;
4672 else
4673 size += strlen (p->u.s) + 1;
4674 }
4675
4676 return size;
4677}
4678
4679/* Print the spelling to BUFFER and return it. */
4680
4681static char *
4682print_spelling (buffer)
4683 register char *buffer;
4684{
4685 register char *d = buffer;
| 4637 = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
4638 PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
4639}
4640
4641/* Push an array bounds on the stack. Printed as [BOUNDS]. */
4642
4643static void
4644push_array_bounds (bounds)
4645 int bounds;
4646{
4647 PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
4648}
4649
4650/* Compute the maximum size in bytes of the printed spelling. */
4651
4652static int
4653spelling_length ()
4654{
4655 register int size = 0;
4656 register struct spelling *p;
4657
4658 for (p = spelling_base; p < spelling; p++)
4659 {
4660 if (p->kind == SPELLING_BOUNDS)
4661 size += 25;
4662 else
4663 size += strlen (p->u.s) + 1;
4664 }
4665
4666 return size;
4667}
4668
4669/* Print the spelling to BUFFER and return it. */
4670
4671static char *
4672print_spelling (buffer)
4673 register char *buffer;
4674{
4675 register char *d = buffer;
|
4686 register char *s;
| |
4687 register struct spelling *p;
4688
4689 for (p = spelling_base; p < spelling; p++)
4690 if (p->kind == SPELLING_BOUNDS)
4691 {
4692 sprintf (d, "[%d]", p->u.i);
4693 d += strlen (d);
4694 }
4695 else
4696 {
| 4676 register struct spelling *p;
4677
4678 for (p = spelling_base; p < spelling; p++)
4679 if (p->kind == SPELLING_BOUNDS)
4680 {
4681 sprintf (d, "[%d]", p->u.i);
4682 d += strlen (d);
4683 }
4684 else
4685 {
|
| 4686 register const char *s;
|
4697 if (p->kind == SPELLING_MEMBER)
4698 *d++ = '.';
4699 for (s = p->u.s; (*d = *s++); d++)
4700 ;
4701 }
4702 *d++ = '\0';
4703 return buffer;
4704}
4705
| 4687 if (p->kind == SPELLING_MEMBER)
4688 *d++ = '.';
4689 for (s = p->u.s; (*d = *s++); d++)
4690 ;
4691 }
4692 *d++ = '\0';
4693 return buffer;
4694}
4695
|
4706/* Provide a means to pass component names derived from the spelling stack. */
4707
4708char initialization_message;
4709
4710/* Interpret the spelling of the given ERRTYPE message. */
4711
4712static char *
4713get_spelling (errtype)
4714 char *errtype;
4715{
4716 static char *buffer;
4717 static int size = -1;
4718
4719 if (errtype == &initialization_message)
4720 {
4721 /* Avoid counting chars */
4722 static char message[] = "initialization of `%s'";
4723 register int needed = sizeof (message) + spelling_length () + 1;
4724 char *temp;
4725
4726 if (size < 0)
4727 buffer = (char *) xmalloc (size = needed);
4728 if (needed > size)
4729 buffer = (char *) xrealloc (buffer, size = needed);
4730
4731 temp = (char *) alloca (needed);
4732 sprintf (buffer, message, print_spelling (temp));
4733 return buffer;
4734 }
4735
4736 return errtype;
4737}
4738
| |
4739/* Issue an error message for a bad initializer component.
| 4696/* Issue an error message for a bad initializer component.
|
4740 FORMAT describes the message. OFWHAT is the name for the component.
4741 LOCAL is a format string for formatting the insertion of the name
4742 into the message.
| 4697 MSGID identifies the message.
4698 The component name is taken from the spelling stack. */
|
4743
| 4699
|
4744 If OFWHAT is null, the component name is stored on the spelling stack.
4745 If the component name is a null string, then LOCAL is omitted entirely. */
4746
| |
4747void
| 4700void
|
4748error_init (format, local, ofwhat)
4749 char *format, *local, *ofwhat;
| 4701error_init (msgid)
4702 const char *msgid;
|
4750{
| 4703{
|
4751 char *buffer;
| 4704 char *ofwhat;
|
4752
| 4705
|
4753 if (ofwhat == 0)
4754 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4755 buffer = (char *) alloca (strlen (local) + strlen (ofwhat) + 2);
4756
| 4706 error (msgid);
4707 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
|
4757 if (*ofwhat)
| 4708 if (*ofwhat)
|
4758 sprintf (buffer, local, ofwhat);
4759 else
4760 buffer[0] = 0;
4761
4762 error (format, buffer);
| 4709 error ("(near initialization for `%s')", ofwhat);
|
4763}
4764
4765/* Issue a pedantic warning for a bad initializer component.
| 4710}
4711
4712/* Issue a pedantic warning for a bad initializer component.
|
4766 FORMAT describes the message. OFWHAT is the name for the component.
4767 LOCAL is a format string for formatting the insertion of the name
4768 into the message.
| 4713 MSGID identifies the message.
4714 The component name is taken from the spelling stack. */
|
4769
| 4715
|
4770 If OFWHAT is null, the component name is stored on the spelling stack.
4771 If the component name is a null string, then LOCAL is omitted entirely. */
4772
| |
4773void
| 4716void
|
4774pedwarn_init (format, local, ofwhat)
4775 char *format, *local, *ofwhat;
| 4717pedwarn_init (msgid)
4718 const char *msgid;
|
4776{
| 4719{
|
4777 char *buffer;
| 4720 char *ofwhat;
|
4778
| 4721
|
4779 if (ofwhat == 0)
4780 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4781 buffer = (char *) alloca (strlen (local) + strlen (ofwhat) + 2);
4782
| 4722 pedwarn (msgid);
4723 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
|
4783 if (*ofwhat)
| 4724 if (*ofwhat)
|
4784 sprintf (buffer, local, ofwhat);
4785 else
4786 buffer[0] = 0;
4787
4788 pedwarn (format, buffer);
| 4725 pedwarn ("(near initialization for `%s')", ofwhat);
|
4789}
4790
4791/* Issue a warning for a bad initializer component.
| 4726}
4727
4728/* Issue a warning for a bad initializer component.
|
4792 FORMAT describes the message. OFWHAT is the name for the component.
4793 LOCAL is a format string for formatting the insertion of the name
4794 into the message.
| 4729 MSGID identifies the message.
4730 The component name is taken from the spelling stack. */
|
4795
| 4731
|
4796 If OFWHAT is null, the component name is stored on the spelling stack.
4797 If the component name is a null string, then LOCAL is omitted entirely. */
4798
| |
4799static void
| 4732static void
|
4800warning_init (format, local, ofwhat)
4801 char *format, *local, *ofwhat;
| 4733warning_init (msgid)
4734 const char *msgid;
|
4802{
| 4735{
|
4803 char *buffer;
| 4736 char *ofwhat;
|
4804
| 4737
|
4805 if (ofwhat == 0)
4806 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4807 buffer = (char *) alloca (strlen (local) + strlen (ofwhat) + 2);
4808
| 4738 warning (msgid);
4739 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
|
4809 if (*ofwhat)
| 4740 if (*ofwhat)
|
4810 sprintf (buffer, local, ofwhat);
4811 else
4812 buffer[0] = 0;
4813
4814 warning (format, buffer);
| 4741 warning ("(near initialization for `%s')", ofwhat);
|
4815}
4816
4817/* Digest the parser output INIT as an initializer for type TYPE.
4818 Return a C expression of type TYPE to represent the initial value.
4819
4820 The arguments REQUIRE_CONSTANT and CONSTRUCTOR_CONSTANT request errors
4821 if non-constant initializers or elements are seen. CONSTRUCTOR_CONSTANT
4822 applies only to elements of constructors. */
4823
4824static tree
4825digest_init (type, init, require_constant, constructor_constant)
4826 tree type, init;
4827 int require_constant, constructor_constant;
4828{
4829 enum tree_code code = TREE_CODE (type);
4830 tree inside_init = init;
4831
4832 if (init == error_mark_node)
4833 return init;
4834
4835 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4836 /* Do not use STRIP_NOPS here. We do not want an enumerator
4837 whose value is 0 to count as a null pointer constant. */
4838 if (TREE_CODE (init) == NON_LVALUE_EXPR)
4839 inside_init = TREE_OPERAND (init, 0);
4840
4841 /* Initialization of an array of chars from a string constant
4842 optionally enclosed in braces. */
4843
4844 if (code == ARRAY_TYPE)
4845 {
4846 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4847 if ((typ1 == char_type_node
4848 || typ1 == signed_char_type_node
4849 || typ1 == unsigned_char_type_node
4850 || typ1 == unsigned_wchar_type_node
4851 || typ1 == signed_wchar_type_node)
4852 && ((inside_init && TREE_CODE (inside_init) == STRING_CST)))
4853 {
4854 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4855 TYPE_MAIN_VARIANT (type)))
4856 return inside_init;
4857
4858 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4859 != char_type_node)
4860 && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node))
4861 {
| 4742}
4743
4744/* Digest the parser output INIT as an initializer for type TYPE.
4745 Return a C expression of type TYPE to represent the initial value.
4746
4747 The arguments REQUIRE_CONSTANT and CONSTRUCTOR_CONSTANT request errors
4748 if non-constant initializers or elements are seen. CONSTRUCTOR_CONSTANT
4749 applies only to elements of constructors. */
4750
4751static tree
4752digest_init (type, init, require_constant, constructor_constant)
4753 tree type, init;
4754 int require_constant, constructor_constant;
4755{
4756 enum tree_code code = TREE_CODE (type);
4757 tree inside_init = init;
4758
4759 if (init == error_mark_node)
4760 return init;
4761
4762 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4763 /* Do not use STRIP_NOPS here. We do not want an enumerator
4764 whose value is 0 to count as a null pointer constant. */
4765 if (TREE_CODE (init) == NON_LVALUE_EXPR)
4766 inside_init = TREE_OPERAND (init, 0);
4767
4768 /* Initialization of an array of chars from a string constant
4769 optionally enclosed in braces. */
4770
4771 if (code == ARRAY_TYPE)
4772 {
4773 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4774 if ((typ1 == char_type_node
4775 || typ1 == signed_char_type_node
4776 || typ1 == unsigned_char_type_node
4777 || typ1 == unsigned_wchar_type_node
4778 || typ1 == signed_wchar_type_node)
4779 && ((inside_init && TREE_CODE (inside_init) == STRING_CST)))
4780 {
4781 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4782 TYPE_MAIN_VARIANT (type)))
4783 return inside_init;
4784
4785 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4786 != char_type_node)
4787 && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node))
4788 {
|
4862 error_init ("char-array%s initialized from wide string",
4863 " `%s'", NULL);
| 4789 error_init ("char-array initialized from wide string");
|
4864 return error_mark_node;
4865 }
4866 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4867 == char_type_node)
4868 && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node))
4869 {
| 4790 return error_mark_node;
4791 }
4792 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4793 == char_type_node)
4794 && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node))
4795 {
|
4870 error_init ("int-array%s initialized from non-wide string",
4871 " `%s'", NULL);
| 4796 error_init ("int-array initialized from non-wide string");
|
4872 return error_mark_node;
4873 }
4874
4875 TREE_TYPE (inside_init) = type;
4876 if (TYPE_DOMAIN (type) != 0
4877 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
4878 {
4879 register int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
4880 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
4881 /* Subtract 1 (or sizeof (wchar_t))
4882 because it's ok to ignore the terminating null char
4883 that is counted in the length of the constant. */
4884 if (size < TREE_STRING_LENGTH (inside_init)
4885 - (TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node)
4886 ? TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT
4887 : 1))
| 4797 return error_mark_node;
4798 }
4799
4800 TREE_TYPE (inside_init) = type;
4801 if (TYPE_DOMAIN (type) != 0
4802 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
4803 {
4804 register int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
4805 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
4806 /* Subtract 1 (or sizeof (wchar_t))
4807 because it's ok to ignore the terminating null char
4808 that is counted in the length of the constant. */
4809 if (size < TREE_STRING_LENGTH (inside_init)
4810 - (TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node)
4811 ? TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT
4812 : 1))
|
4888 pedwarn_init (
4889 "initializer-string for array of chars%s is too long",
4890 " `%s'", NULL);
| 4813 pedwarn_init ("initializer-string for array of chars is too long");
|
4891 }
4892 return inside_init;
4893 }
4894 }
4895
4896 /* Any type can be initialized
4897 from an expression of the same type, optionally with braces. */
4898
4899 if (inside_init && TREE_TYPE (inside_init) != 0
4900 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4901 TYPE_MAIN_VARIANT (type))
4902 || (code == ARRAY_TYPE
4903 && comptypes (TREE_TYPE (inside_init), type))
4904 || (code == POINTER_TYPE
4905 && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4906 || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE)
4907 && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4908 TREE_TYPE (type)))))
4909 {
4910 if (code == POINTER_TYPE
4911 && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4912 || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE))
4913 inside_init = default_conversion (inside_init);
4914 else if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4915 && TREE_CODE (inside_init) != CONSTRUCTOR)
4916 {
| 4814 }
4815 return inside_init;
4816 }
4817 }
4818
4819 /* Any type can be initialized
4820 from an expression of the same type, optionally with braces. */
4821
4822 if (inside_init && TREE_TYPE (inside_init) != 0
4823 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4824 TYPE_MAIN_VARIANT (type))
4825 || (code == ARRAY_TYPE
4826 && comptypes (TREE_TYPE (inside_init), type))
4827 || (code == POINTER_TYPE
4828 && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4829 || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE)
4830 && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4831 TREE_TYPE (type)))))
4832 {
4833 if (code == POINTER_TYPE
4834 && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4835 || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE))
4836 inside_init = default_conversion (inside_init);
4837 else if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4838 && TREE_CODE (inside_init) != CONSTRUCTOR)
4839 {
|
4917 error_init ("array%s initialized from non-constant array expression",
4918 " `%s'", NULL);
| 4840 error_init ("array initialized from non-constant array expression");
|
4919 return error_mark_node;
4920 }
4921
4922 if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4923 inside_init = decl_constant_value (inside_init);
4924
4925 /* Compound expressions can only occur here if -pedantic or
4926 -pedantic-errors is specified. In the later case, we always want
4927 an error. In the former case, we simply want a warning. */
4928 if (require_constant && pedantic
4929 && TREE_CODE (inside_init) == COMPOUND_EXPR)
4930 {
4931 inside_init
4932 = valid_compound_expr_initializer (inside_init,
4933 TREE_TYPE (inside_init));
4934 if (inside_init == error_mark_node)
| 4841 return error_mark_node;
4842 }
4843
4844 if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4845 inside_init = decl_constant_value (inside_init);
4846
4847 /* Compound expressions can only occur here if -pedantic or
4848 -pedantic-errors is specified. In the later case, we always want
4849 an error. In the former case, we simply want a warning. */
4850 if (require_constant && pedantic
4851 && TREE_CODE (inside_init) == COMPOUND_EXPR)
4852 {
4853 inside_init
4854 = valid_compound_expr_initializer (inside_init,
4855 TREE_TYPE (inside_init));
4856 if (inside_init == error_mark_node)
|
4935 error_init ("initializer element%s is not constant",
4936 " for `%s'", NULL);
| 4857 error_init ("initializer element is not constant");
|
4937 else
| 4858 else
|
4938 pedwarn_init ("initializer element%s is not constant",
4939 " for `%s'", NULL);
| 4859 pedwarn_init ("initializer element is not constant");
|
4940 if (flag_pedantic_errors)
4941 inside_init = error_mark_node;
4942 }
4943 else if (require_constant && ! TREE_CONSTANT (inside_init))
4944 {
| 4860 if (flag_pedantic_errors)
4861 inside_init = error_mark_node;
4862 }
4863 else if (require_constant && ! TREE_CONSTANT (inside_init))
4864 {
|
4945 error_init ("initializer element%s is not constant",
4946 " for `%s'", NULL);
| 4865 error_init ("initializer element is not constant");
|
4947 inside_init = error_mark_node;
4948 }
4949 else if (require_constant
4950 && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4951 {
| 4866 inside_init = error_mark_node;
4867 }
4868 else if (require_constant
4869 && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4870 {
|
4952 error_init ("initializer element%s is not computable at load time",
4953 " for `%s'", NULL);
| 4871 error_init ("initializer element is not computable at load time");
|
4954 inside_init = error_mark_node;
4955 }
4956
4957 return inside_init;
4958 }
4959
4960 /* Handle scalar types, including conversions. */
4961
4962 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4963 || code == ENUMERAL_TYPE || code == COMPLEX_TYPE)
4964 {
4965 /* Note that convert_for_assignment calls default_conversion
4966 for arrays and functions. We must not call it in the
4967 case where inside_init is a null pointer constant. */
4968 inside_init
| 4872 inside_init = error_mark_node;
4873 }
4874
4875 return inside_init;
4876 }
4877
4878 /* Handle scalar types, including conversions. */
4879
4880 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4881 || code == ENUMERAL_TYPE || code == COMPLEX_TYPE)
4882 {
4883 /* Note that convert_for_assignment calls default_conversion
4884 for arrays and functions. We must not call it in the
4885 case where inside_init is a null pointer constant. */
4886 inside_init
|
4969 = convert_for_assignment (type, init, "initialization",
| 4887 = convert_for_assignment (type, init, _("initialization"),
|
4970 NULL_TREE, NULL_TREE, 0);
4971
4972 if (require_constant && ! TREE_CONSTANT (inside_init))
4973 {
| 4888 NULL_TREE, NULL_TREE, 0);
4889
4890 if (require_constant && ! TREE_CONSTANT (inside_init))
4891 {
|
4974 error_init ("initializer element%s is not constant",
4975 " for `%s'", NULL);
| 4892 error_init ("initializer element is not constant");
|
4976 inside_init = error_mark_node;
4977 }
4978 else if (require_constant
4979 && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4980 {
| 4893 inside_init = error_mark_node;
4894 }
4895 else if (require_constant
4896 && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4897 {
|
4981 error_init ("initializer element%s is not computable at load time",
4982 " for `%s'", NULL);
| 4898 error_init ("initializer element is not computable at load time");
|
4983 inside_init = error_mark_node;
4984 }
4985
4986 return inside_init;
4987 }
4988
4989 /* Come here only for records and arrays. */
4990
4991 if (TYPE_SIZE (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4992 {
| 4899 inside_init = error_mark_node;
4900 }
4901
4902 return inside_init;
4903 }
4904
4905 /* Come here only for records and arrays. */
4906
4907 if (TYPE_SIZE (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4908 {
|
4993 error_init ("variable-sized object%s may not be initialized",
4994 " `%s'", NULL);
| 4909 error_init ("variable-sized object may not be initialized");
|
4995 return error_mark_node;
4996 }
4997
4998 /* Traditionally, you can write struct foo x = 0;
4999 and it initializes the first element of x to 0. */
5000 if (flag_traditional)
5001 {
5002 tree top = 0, prev = 0, otype = type;
5003 while (TREE_CODE (type) == RECORD_TYPE
5004 || TREE_CODE (type) == ARRAY_TYPE
5005 || TREE_CODE (type) == QUAL_UNION_TYPE
5006 || TREE_CODE (type) == UNION_TYPE)
5007 {
5008 tree temp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
5009 if (prev == 0)
5010 top = temp;
5011 else
5012 TREE_OPERAND (prev, 1) = build_tree_list (NULL_TREE, temp);
5013 prev = temp;
5014 if (TREE_CODE (type) == ARRAY_TYPE)
5015 type = TREE_TYPE (type);
5016 else if (TYPE_FIELDS (type))
5017 type = TREE_TYPE (TYPE_FIELDS (type));
5018 else
5019 {
| 4910 return error_mark_node;
4911 }
4912
4913 /* Traditionally, you can write struct foo x = 0;
4914 and it initializes the first element of x to 0. */
4915 if (flag_traditional)
4916 {
4917 tree top = 0, prev = 0, otype = type;
4918 while (TREE_CODE (type) == RECORD_TYPE
4919 || TREE_CODE (type) == ARRAY_TYPE
4920 || TREE_CODE (type) == QUAL_UNION_TYPE
4921 || TREE_CODE (type) == UNION_TYPE)
4922 {
4923 tree temp = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
4924 if (prev == 0)
4925 top = temp;
4926 else
4927 TREE_OPERAND (prev, 1) = build_tree_list (NULL_TREE, temp);
4928 prev = temp;
4929 if (TREE_CODE (type) == ARRAY_TYPE)
4930 type = TREE_TYPE (type);
4931 else if (TYPE_FIELDS (type))
4932 type = TREE_TYPE (TYPE_FIELDS (type));
4933 else
4934 {
|
5020 error_init ("invalid initializer%s", " for `%s'", NULL);
| 4935 error_init ("invalid initializer");
|
5021 return error_mark_node;
5022 }
5023 }
5024
5025 if (otype != type)
5026 {
5027 TREE_OPERAND (prev, 1)
5028 = build_tree_list (NULL_TREE,
5029 digest_init (type, init, require_constant,
5030 constructor_constant));
5031 return top;
5032 }
5033 else
5034 return error_mark_node;
5035 }
| 4936 return error_mark_node;
4937 }
4938 }
4939
4940 if (otype != type)
4941 {
4942 TREE_OPERAND (prev, 1)
4943 = build_tree_list (NULL_TREE,
4944 digest_init (type, init, require_constant,
4945 constructor_constant));
4946 return top;
4947 }
4948 else
4949 return error_mark_node;
4950 }
|
5036 error_init ("invalid initializer%s", " for `%s'", NULL);
| 4951 error_init ("invalid initializer");
|
5037 return error_mark_node;
5038}
5039
5040/* Handle initializers that use braces. */
5041
5042/* Type of object we are accumulating a constructor for.
5043 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
5044static tree constructor_type;
5045
5046/* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
5047 left to fill. */
5048static tree constructor_fields;
5049
5050/* For an ARRAY_TYPE, this is the specified index
5051 at which to store the next element we get.
5052 This is a special INTEGER_CST node that we modify in place. */
5053static tree constructor_index;
5054
5055/* For an ARRAY_TYPE, this is the end index of the range
5056 to initialize with the next element, or NULL in the ordinary case
5057 where the element is used just once. */
5058static tree constructor_range_end;
5059
5060/* For an ARRAY_TYPE, this is the maximum index. */
5061static tree constructor_max_index;
5062
5063/* For a RECORD_TYPE, this is the first field not yet written out. */
5064static tree constructor_unfilled_fields;
5065
5066/* For an ARRAY_TYPE, this is the index of the first element
5067 not yet written out.
5068 This is a special INTEGER_CST node that we modify in place. */
5069static tree constructor_unfilled_index;
5070
5071/* In a RECORD_TYPE, the byte index of the next consecutive field.
5072 This is so we can generate gaps between fields, when appropriate.
5073 This is a special INTEGER_CST node that we modify in place. */
5074static tree constructor_bit_index;
5075
5076/* If we are saving up the elements rather than allocating them,
5077 this is the list of elements so far (in reverse order,
5078 most recent first). */
5079static tree constructor_elements;
5080
5081/* 1 if so far this constructor's elements are all compile-time constants. */
5082static int constructor_constant;
5083
5084/* 1 if so far this constructor's elements are all valid address constants. */
5085static int constructor_simple;
5086
5087/* 1 if this constructor is erroneous so far. */
5088static int constructor_erroneous;
5089
5090/* 1 if have called defer_addressed_constants. */
5091static int constructor_subconstants_deferred;
5092
5093/* Structure for managing pending initializer elements, organized as an
5094 AVL tree. */
5095
5096struct init_node
5097{
5098 struct init_node *left, *right;
5099 struct init_node *parent;
5100 int balance;
5101 tree purpose;
5102 tree value;
5103};
5104
5105/* Tree of pending elements at this constructor level.
5106 These are elements encountered out of order
5107 which belong at places we haven't reached yet in actually
5108 writing the output. */
5109static struct init_node *constructor_pending_elts;
5110
5111/* The SPELLING_DEPTH of this constructor. */
5112static int constructor_depth;
5113
5114/* 0 if implicitly pushing constructor levels is allowed. */
5115int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages. */
5116
5117static int require_constant_value;
5118static int require_constant_elements;
5119
5120/* 1 if it is ok to output this constructor as we read it.
5121 0 means must accumulate a CONSTRUCTOR expression. */
5122static int constructor_incremental;
5123
5124/* DECL node for which an initializer is being read.
5125 0 means we are reading a constructor expression
5126 such as (struct foo) {...}. */
5127static tree constructor_decl;
5128
5129/* start_init saves the ASMSPEC arg here for really_start_incremental_init. */
5130static char *constructor_asmspec;
5131
5132/* Nonzero if this is an initializer for a top-level decl. */
5133static int constructor_top_level;
5134
5135
5136/* This stack has a level for each implicit or explicit level of
5137 structuring in the initializer, including the outermost one. It
5138 saves the values of most of the variables above. */
5139
5140struct constructor_stack
5141{
5142 struct constructor_stack *next;
5143 tree type;
5144 tree fields;
5145 tree index;
5146 tree range_end;
5147 tree max_index;
5148 tree unfilled_index;
5149 tree unfilled_fields;
5150 tree bit_index;
5151 tree elements;
5152 int offset;
5153 struct init_node *pending_elts;
5154 int depth;
5155 /* If nonzero, this value should replace the entire
5156 constructor at this level. */
5157 tree replacement_value;
5158 char constant;
5159 char simple;
5160 char implicit;
5161 char incremental;
5162 char erroneous;
5163 char outer;
5164};
5165
5166struct constructor_stack *constructor_stack;
5167
5168/* This stack records separate initializers that are nested.
5169 Nested initializers can't happen in ANSI C, but GNU C allows them
5170 in cases like { ... (struct foo) { ... } ... }. */
5171
5172struct initializer_stack
5173{
5174 struct initializer_stack *next;
5175 tree decl;
5176 char *asmspec;
5177 struct constructor_stack *constructor_stack;
5178 tree elements;
5179 struct spelling *spelling;
5180 struct spelling *spelling_base;
5181 int spelling_size;
5182 char top_level;
5183 char incremental;
5184 char require_constant_value;
5185 char require_constant_elements;
5186 char deferred;
5187};
5188
5189struct initializer_stack *initializer_stack;
5190
5191/* Prepare to parse and output the initializer for variable DECL. */
5192
5193void
5194start_init (decl, asmspec_tree, top_level)
5195 tree decl;
5196 tree asmspec_tree;
5197 int top_level;
5198{
| 4952 return error_mark_node;
4953}
4954
4955/* Handle initializers that use braces. */
4956
4957/* Type of object we are accumulating a constructor for.
4958 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
4959static tree constructor_type;
4960
4961/* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4962 left to fill. */
4963static tree constructor_fields;
4964
4965/* For an ARRAY_TYPE, this is the specified index
4966 at which to store the next element we get.
4967 This is a special INTEGER_CST node that we modify in place. */
4968static tree constructor_index;
4969
4970/* For an ARRAY_TYPE, this is the end index of the range
4971 to initialize with the next element, or NULL in the ordinary case
4972 where the element is used just once. */
4973static tree constructor_range_end;
4974
4975/* For an ARRAY_TYPE, this is the maximum index. */
4976static tree constructor_max_index;
4977
4978/* For a RECORD_TYPE, this is the first field not yet written out. */
4979static tree constructor_unfilled_fields;
4980
4981/* For an ARRAY_TYPE, this is the index of the first element
4982 not yet written out.
4983 This is a special INTEGER_CST node that we modify in place. */
4984static tree constructor_unfilled_index;
4985
4986/* In a RECORD_TYPE, the byte index of the next consecutive field.
4987 This is so we can generate gaps between fields, when appropriate.
4988 This is a special INTEGER_CST node that we modify in place. */
4989static tree constructor_bit_index;
4990
4991/* If we are saving up the elements rather than allocating them,
4992 this is the list of elements so far (in reverse order,
4993 most recent first). */
4994static tree constructor_elements;
4995
4996/* 1 if so far this constructor's elements are all compile-time constants. */
4997static int constructor_constant;
4998
4999/* 1 if so far this constructor's elements are all valid address constants. */
5000static int constructor_simple;
5001
5002/* 1 if this constructor is erroneous so far. */
5003static int constructor_erroneous;
5004
5005/* 1 if have called defer_addressed_constants. */
5006static int constructor_subconstants_deferred;
5007
5008/* Structure for managing pending initializer elements, organized as an
5009 AVL tree. */
5010
5011struct init_node
5012{
5013 struct init_node *left, *right;
5014 struct init_node *parent;
5015 int balance;
5016 tree purpose;
5017 tree value;
5018};
5019
5020/* Tree of pending elements at this constructor level.
5021 These are elements encountered out of order
5022 which belong at places we haven't reached yet in actually
5023 writing the output. */
5024static struct init_node *constructor_pending_elts;
5025
5026/* The SPELLING_DEPTH of this constructor. */
5027static int constructor_depth;
5028
5029/* 0 if implicitly pushing constructor levels is allowed. */
5030int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages. */
5031
5032static int require_constant_value;
5033static int require_constant_elements;
5034
5035/* 1 if it is ok to output this constructor as we read it.
5036 0 means must accumulate a CONSTRUCTOR expression. */
5037static int constructor_incremental;
5038
5039/* DECL node for which an initializer is being read.
5040 0 means we are reading a constructor expression
5041 such as (struct foo) {...}. */
5042static tree constructor_decl;
5043
5044/* start_init saves the ASMSPEC arg here for really_start_incremental_init. */
5045static char *constructor_asmspec;
5046
5047/* Nonzero if this is an initializer for a top-level decl. */
5048static int constructor_top_level;
5049
5050
5051/* This stack has a level for each implicit or explicit level of
5052 structuring in the initializer, including the outermost one. It
5053 saves the values of most of the variables above. */
5054
5055struct constructor_stack
5056{
5057 struct constructor_stack *next;
5058 tree type;
5059 tree fields;
5060 tree index;
5061 tree range_end;
5062 tree max_index;
5063 tree unfilled_index;
5064 tree unfilled_fields;
5065 tree bit_index;
5066 tree elements;
5067 int offset;
5068 struct init_node *pending_elts;
5069 int depth;
5070 /* If nonzero, this value should replace the entire
5071 constructor at this level. */
5072 tree replacement_value;
5073 char constant;
5074 char simple;
5075 char implicit;
5076 char incremental;
5077 char erroneous;
5078 char outer;
5079};
5080
5081struct constructor_stack *constructor_stack;
5082
5083/* This stack records separate initializers that are nested.
5084 Nested initializers can't happen in ANSI C, but GNU C allows them
5085 in cases like { ... (struct foo) { ... } ... }. */
5086
5087struct initializer_stack
5088{
5089 struct initializer_stack *next;
5090 tree decl;
5091 char *asmspec;
5092 struct constructor_stack *constructor_stack;
5093 tree elements;
5094 struct spelling *spelling;
5095 struct spelling *spelling_base;
5096 int spelling_size;
5097 char top_level;
5098 char incremental;
5099 char require_constant_value;
5100 char require_constant_elements;
5101 char deferred;
5102};
5103
5104struct initializer_stack *initializer_stack;
5105
5106/* Prepare to parse and output the initializer for variable DECL. */
5107
5108void
5109start_init (decl, asmspec_tree, top_level)
5110 tree decl;
5111 tree asmspec_tree;
5112 int top_level;
5113{
|
5199 char *locus;
| 5114 const char *locus;
|
5200 struct initializer_stack *p
5201 = (struct initializer_stack *) xmalloc (sizeof (struct initializer_stack));
5202 char *asmspec = 0;
5203
5204 if (asmspec_tree)
5205 asmspec = TREE_STRING_POINTER (asmspec_tree);
5206
5207 p->decl = constructor_decl;
5208 p->asmspec = constructor_asmspec;
5209 p->incremental = constructor_incremental;
5210 p->require_constant_value = require_constant_value;
5211 p->require_constant_elements = require_constant_elements;
5212 p->constructor_stack = constructor_stack;
5213 p->elements = constructor_elements;
5214 p->spelling = spelling;
5215 p->spelling_base = spelling_base;
5216 p->spelling_size = spelling_size;
5217 p->deferred = constructor_subconstants_deferred;
5218 p->top_level = constructor_top_level;
5219 p->next = initializer_stack;
5220 initializer_stack = p;
5221
5222 constructor_decl = decl;
5223 constructor_incremental = top_level;
5224 constructor_asmspec = asmspec;
5225 constructor_subconstants_deferred = 0;
5226 constructor_top_level = top_level;
5227
5228 if (decl != 0)
5229 {
5230 require_constant_value = TREE_STATIC (decl);
5231 require_constant_elements
5232 = ((TREE_STATIC (decl) || pedantic)
5233 /* For a scalar, you can always use any value to initialize,
5234 even within braces. */
5235 && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
5236 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
5237 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
5238 || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
5239 locus = IDENTIFIER_POINTER (DECL_NAME (decl));
5240 constructor_incremental |= TREE_STATIC (decl);
5241 }
5242 else
5243 {
5244 require_constant_value = 0;
5245 require_constant_elements = 0;
5246 locus = "(anonymous)";
5247 }
5248
5249 constructor_stack = 0;
5250
5251 missing_braces_mentioned = 0;
5252
5253 spelling_base = 0;
5254 spelling_size = 0;
5255 RESTORE_SPELLING_DEPTH (0);
5256
5257 if (locus)
5258 push_string (locus);
5259}
5260
5261void
5262finish_init ()
5263{
5264 struct initializer_stack *p = initializer_stack;
5265
5266 /* Output subconstants (string constants, usually)
5267 that were referenced within this initializer and saved up.
5268 Must do this if and only if we called defer_addressed_constants. */
5269 if (constructor_subconstants_deferred)
5270 output_deferred_addressed_constants ();
5271
5272 /* Free the whole constructor stack of this initializer. */
5273 while (constructor_stack)
5274 {
5275 struct constructor_stack *q = constructor_stack;
5276 constructor_stack = q->next;
5277 free (q);
5278 }
5279
5280 /* Pop back to the data of the outer initializer (if any). */
5281 constructor_decl = p->decl;
5282 constructor_asmspec = p->asmspec;
5283 constructor_incremental = p->incremental;
5284 require_constant_value = p->require_constant_value;
5285 require_constant_elements = p->require_constant_elements;
5286 constructor_stack = p->constructor_stack;
5287 constructor_elements = p->elements;
5288 spelling = p->spelling;
5289 spelling_base = p->spelling_base;
5290 spelling_size = p->spelling_size;
5291 constructor_subconstants_deferred = p->deferred;
5292 constructor_top_level = p->top_level;
5293 initializer_stack = p->next;
5294 free (p);
5295}
5296
5297/* Call here when we see the initializer is surrounded by braces.
5298 This is instead of a call to push_init_level;
5299 it is matched by a call to pop_init_level.
5300
5301 TYPE is the type to initialize, for a constructor expression.
5302 For an initializer for a decl, TYPE is zero. */
5303
5304void
5305really_start_incremental_init (type)
5306 tree type;
5307{
5308 struct constructor_stack *p
5309 = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5310
5311 if (type == 0)
5312 type = TREE_TYPE (constructor_decl);
5313
5314 /* Turn off constructor_incremental if type is a struct with bitfields.
5315 Do this before the first push, so that the corrected value
5316 is available in finish_init. */
5317 check_init_type_bitfields (type);
5318
5319 p->type = constructor_type;
5320 p->fields = constructor_fields;
5321 p->index = constructor_index;
5322 p->range_end = constructor_range_end;
5323 p->max_index = constructor_max_index;
5324 p->unfilled_index = constructor_unfilled_index;
5325 p->unfilled_fields = constructor_unfilled_fields;
5326 p->bit_index = constructor_bit_index;
5327 p->elements = constructor_elements;
5328 p->constant = constructor_constant;
5329 p->simple = constructor_simple;
5330 p->erroneous = constructor_erroneous;
5331 p->pending_elts = constructor_pending_elts;
5332 p->depth = constructor_depth;
5333 p->replacement_value = 0;
5334 p->implicit = 0;
5335 p->incremental = constructor_incremental;
5336 p->outer = 0;
5337 p->next = 0;
5338 constructor_stack = p;
5339
5340 constructor_constant = 1;
5341 constructor_simple = 1;
5342 constructor_depth = SPELLING_DEPTH ();
5343 constructor_elements = 0;
5344 constructor_pending_elts = 0;
5345 constructor_type = type;
5346
5347 if (TREE_CODE (constructor_type) == RECORD_TYPE
5348 || TREE_CODE (constructor_type) == UNION_TYPE)
5349 {
5350 constructor_fields = TYPE_FIELDS (constructor_type);
5351 /* Skip any nameless bit fields at the beginning. */
5352 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5353 && DECL_NAME (constructor_fields) == 0)
5354 constructor_fields = TREE_CHAIN (constructor_fields);
5355 constructor_unfilled_fields = constructor_fields;
5356 constructor_bit_index = copy_node (integer_zero_node);
5357 TREE_TYPE (constructor_bit_index) = sbitsizetype;
5358 }
5359 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5360 {
5361 constructor_range_end = 0;
5362 if (TYPE_DOMAIN (constructor_type))
5363 {
5364 constructor_max_index
5365 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5366 constructor_index
5367 = copy_node (TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5368 }
5369 else
5370 constructor_index = copy_node (integer_zero_node);
5371 constructor_unfilled_index = copy_node (constructor_index);
5372 }
5373 else
5374 {
5375 /* Handle the case of int x = {5}; */
5376 constructor_fields = constructor_type;
5377 constructor_unfilled_fields = constructor_type;
5378 }
5379
5380 if (constructor_incremental)
5381 {
5382 int momentary = suspend_momentary ();
5383 push_obstacks_nochange ();
5384 if (TREE_PERMANENT (constructor_decl))
5385 end_temporary_allocation ();
5386 make_decl_rtl (constructor_decl, constructor_asmspec,
5387 constructor_top_level);
5388 assemble_variable (constructor_decl, constructor_top_level, 0, 1);
5389 pop_obstacks ();
5390 resume_momentary (momentary);
5391 }
5392
5393 if (constructor_incremental)
5394 {
5395 defer_addressed_constants ();
5396 constructor_subconstants_deferred = 1;
5397 }
5398}
5399
5400/* Push down into a subobject, for initialization.
5401 If this is for an explicit set of braces, IMPLICIT is 0.
5402 If it is because the next element belongs at a lower level,
5403 IMPLICIT is 1. */
5404
5405void
5406push_init_level (implicit)
5407 int implicit;
5408{
5409 struct constructor_stack *p;
5410
5411 /* If we've exhausted any levels that didn't have braces,
5412 pop them now. */
5413 while (constructor_stack->implicit)
5414 {
5415 if ((TREE_CODE (constructor_type) == RECORD_TYPE
5416 || TREE_CODE (constructor_type) == UNION_TYPE)
5417 && constructor_fields == 0)
5418 process_init_element (pop_init_level (1));
5419 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5420 && tree_int_cst_lt (constructor_max_index, constructor_index))
5421 process_init_element (pop_init_level (1));
5422 else
5423 break;
5424 }
5425
5426 /* Structure elements may require alignment. Do this now if necessary
5427 for the subaggregate, and if it comes next in sequence. Don't do
5428 this for subaggregates that will go on the pending list. */
5429 if (constructor_incremental && constructor_type != 0
5430 && TREE_CODE (constructor_type) == RECORD_TYPE && constructor_fields
5431 && constructor_fields == constructor_unfilled_fields)
5432 {
5433 /* Advance to offset of this element. */
5434 if (! tree_int_cst_equal (constructor_bit_index,
5435 DECL_FIELD_BITPOS (constructor_fields)))
5436 {
5437 /* By using unsigned arithmetic, the result will be correct even
5438 in case of overflows, if BITS_PER_UNIT is a power of two. */
5439 unsigned next = (TREE_INT_CST_LOW
5440 (DECL_FIELD_BITPOS (constructor_fields))
5441 / (unsigned)BITS_PER_UNIT);
5442 unsigned here = (TREE_INT_CST_LOW (constructor_bit_index)
5443 / (unsigned)BITS_PER_UNIT);
5444
5445 assemble_zeros ((next - here)
5446 * (unsigned)BITS_PER_UNIT
5447 / (unsigned)BITS_PER_UNIT);
5448 }
5449 /* Indicate that we have now filled the structure up to the current
5450 field. */
5451 constructor_unfilled_fields = constructor_fields;
5452 }
5453
5454 p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5455 p->type = constructor_type;
5456 p->fields = constructor_fields;
5457 p->index = constructor_index;
5458 p->range_end = constructor_range_end;
5459 p->max_index = constructor_max_index;
5460 p->unfilled_index = constructor_unfilled_index;
5461 p->unfilled_fields = constructor_unfilled_fields;
5462 p->bit_index = constructor_bit_index;
5463 p->elements = constructor_elements;
5464 p->constant = constructor_constant;
5465 p->simple = constructor_simple;
5466 p->erroneous = constructor_erroneous;
5467 p->pending_elts = constructor_pending_elts;
5468 p->depth = constructor_depth;
5469 p->replacement_value = 0;
5470 p->implicit = implicit;
5471 p->incremental = constructor_incremental;
5472 p->outer = 0;
5473 p->next = constructor_stack;
5474 constructor_stack = p;
5475
5476 constructor_constant = 1;
5477 constructor_simple = 1;
5478 constructor_depth = SPELLING_DEPTH ();
5479 constructor_elements = 0;
5480 constructor_pending_elts = 0;
5481
5482 /* Don't die if an entire brace-pair level is superfluous
5483 in the containing level. */
5484 if (constructor_type == 0)
5485 ;
5486 else if (TREE_CODE (constructor_type) == RECORD_TYPE
5487 || TREE_CODE (constructor_type) == UNION_TYPE)
5488 {
5489 /* Don't die if there are extra init elts at the end. */
5490 if (constructor_fields == 0)
5491 constructor_type = 0;
5492 else
5493 {
5494 constructor_type = TREE_TYPE (constructor_fields);
5495 push_member_name (constructor_fields);
5496 constructor_depth++;
5497 if (constructor_fields != constructor_unfilled_fields)
5498 constructor_incremental = 0;
5499 }
5500 }
5501 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5502 {
5503 constructor_type = TREE_TYPE (constructor_type);
5504 push_array_bounds (TREE_INT_CST_LOW (constructor_index));
5505 constructor_depth++;
5506 if (! tree_int_cst_equal (constructor_index, constructor_unfilled_index)
5507 || constructor_range_end != 0)
5508 constructor_incremental = 0;
5509 }
5510
5511 if (constructor_type == 0)
5512 {
| 5115 struct initializer_stack *p
5116 = (struct initializer_stack *) xmalloc (sizeof (struct initializer_stack));
5117 char *asmspec = 0;
5118
5119 if (asmspec_tree)
5120 asmspec = TREE_STRING_POINTER (asmspec_tree);
5121
5122 p->decl = constructor_decl;
5123 p->asmspec = constructor_asmspec;
5124 p->incremental = constructor_incremental;
5125 p->require_constant_value = require_constant_value;
5126 p->require_constant_elements = require_constant_elements;
5127 p->constructor_stack = constructor_stack;
5128 p->elements = constructor_elements;
5129 p->spelling = spelling;
5130 p->spelling_base = spelling_base;
5131 p->spelling_size = spelling_size;
5132 p->deferred = constructor_subconstants_deferred;
5133 p->top_level = constructor_top_level;
5134 p->next = initializer_stack;
5135 initializer_stack = p;
5136
5137 constructor_decl = decl;
5138 constructor_incremental = top_level;
5139 constructor_asmspec = asmspec;
5140 constructor_subconstants_deferred = 0;
5141 constructor_top_level = top_level;
5142
5143 if (decl != 0)
5144 {
5145 require_constant_value = TREE_STATIC (decl);
5146 require_constant_elements
5147 = ((TREE_STATIC (decl) || pedantic)
5148 /* For a scalar, you can always use any value to initialize,
5149 even within braces. */
5150 && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
5151 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
5152 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
5153 || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
5154 locus = IDENTIFIER_POINTER (DECL_NAME (decl));
5155 constructor_incremental |= TREE_STATIC (decl);
5156 }
5157 else
5158 {
5159 require_constant_value = 0;
5160 require_constant_elements = 0;
5161 locus = "(anonymous)";
5162 }
5163
5164 constructor_stack = 0;
5165
5166 missing_braces_mentioned = 0;
5167
5168 spelling_base = 0;
5169 spelling_size = 0;
5170 RESTORE_SPELLING_DEPTH (0);
5171
5172 if (locus)
5173 push_string (locus);
5174}
5175
5176void
5177finish_init ()
5178{
5179 struct initializer_stack *p = initializer_stack;
5180
5181 /* Output subconstants (string constants, usually)
5182 that were referenced within this initializer and saved up.
5183 Must do this if and only if we called defer_addressed_constants. */
5184 if (constructor_subconstants_deferred)
5185 output_deferred_addressed_constants ();
5186
5187 /* Free the whole constructor stack of this initializer. */
5188 while (constructor_stack)
5189 {
5190 struct constructor_stack *q = constructor_stack;
5191 constructor_stack = q->next;
5192 free (q);
5193 }
5194
5195 /* Pop back to the data of the outer initializer (if any). */
5196 constructor_decl = p->decl;
5197 constructor_asmspec = p->asmspec;
5198 constructor_incremental = p->incremental;
5199 require_constant_value = p->require_constant_value;
5200 require_constant_elements = p->require_constant_elements;
5201 constructor_stack = p->constructor_stack;
5202 constructor_elements = p->elements;
5203 spelling = p->spelling;
5204 spelling_base = p->spelling_base;
5205 spelling_size = p->spelling_size;
5206 constructor_subconstants_deferred = p->deferred;
5207 constructor_top_level = p->top_level;
5208 initializer_stack = p->next;
5209 free (p);
5210}
5211
5212/* Call here when we see the initializer is surrounded by braces.
5213 This is instead of a call to push_init_level;
5214 it is matched by a call to pop_init_level.
5215
5216 TYPE is the type to initialize, for a constructor expression.
5217 For an initializer for a decl, TYPE is zero. */
5218
5219void
5220really_start_incremental_init (type)
5221 tree type;
5222{
5223 struct constructor_stack *p
5224 = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5225
5226 if (type == 0)
5227 type = TREE_TYPE (constructor_decl);
5228
5229 /* Turn off constructor_incremental if type is a struct with bitfields.
5230 Do this before the first push, so that the corrected value
5231 is available in finish_init. */
5232 check_init_type_bitfields (type);
5233
5234 p->type = constructor_type;
5235 p->fields = constructor_fields;
5236 p->index = constructor_index;
5237 p->range_end = constructor_range_end;
5238 p->max_index = constructor_max_index;
5239 p->unfilled_index = constructor_unfilled_index;
5240 p->unfilled_fields = constructor_unfilled_fields;
5241 p->bit_index = constructor_bit_index;
5242 p->elements = constructor_elements;
5243 p->constant = constructor_constant;
5244 p->simple = constructor_simple;
5245 p->erroneous = constructor_erroneous;
5246 p->pending_elts = constructor_pending_elts;
5247 p->depth = constructor_depth;
5248 p->replacement_value = 0;
5249 p->implicit = 0;
5250 p->incremental = constructor_incremental;
5251 p->outer = 0;
5252 p->next = 0;
5253 constructor_stack = p;
5254
5255 constructor_constant = 1;
5256 constructor_simple = 1;
5257 constructor_depth = SPELLING_DEPTH ();
5258 constructor_elements = 0;
5259 constructor_pending_elts = 0;
5260 constructor_type = type;
5261
5262 if (TREE_CODE (constructor_type) == RECORD_TYPE
5263 || TREE_CODE (constructor_type) == UNION_TYPE)
5264 {
5265 constructor_fields = TYPE_FIELDS (constructor_type);
5266 /* Skip any nameless bit fields at the beginning. */
5267 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5268 && DECL_NAME (constructor_fields) == 0)
5269 constructor_fields = TREE_CHAIN (constructor_fields);
5270 constructor_unfilled_fields = constructor_fields;
5271 constructor_bit_index = copy_node (integer_zero_node);
5272 TREE_TYPE (constructor_bit_index) = sbitsizetype;
5273 }
5274 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5275 {
5276 constructor_range_end = 0;
5277 if (TYPE_DOMAIN (constructor_type))
5278 {
5279 constructor_max_index
5280 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5281 constructor_index
5282 = copy_node (TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5283 }
5284 else
5285 constructor_index = copy_node (integer_zero_node);
5286 constructor_unfilled_index = copy_node (constructor_index);
5287 }
5288 else
5289 {
5290 /* Handle the case of int x = {5}; */
5291 constructor_fields = constructor_type;
5292 constructor_unfilled_fields = constructor_type;
5293 }
5294
5295 if (constructor_incremental)
5296 {
5297 int momentary = suspend_momentary ();
5298 push_obstacks_nochange ();
5299 if (TREE_PERMANENT (constructor_decl))
5300 end_temporary_allocation ();
5301 make_decl_rtl (constructor_decl, constructor_asmspec,
5302 constructor_top_level);
5303 assemble_variable (constructor_decl, constructor_top_level, 0, 1);
5304 pop_obstacks ();
5305 resume_momentary (momentary);
5306 }
5307
5308 if (constructor_incremental)
5309 {
5310 defer_addressed_constants ();
5311 constructor_subconstants_deferred = 1;
5312 }
5313}
5314
5315/* Push down into a subobject, for initialization.
5316 If this is for an explicit set of braces, IMPLICIT is 0.
5317 If it is because the next element belongs at a lower level,
5318 IMPLICIT is 1. */
5319
5320void
5321push_init_level (implicit)
5322 int implicit;
5323{
5324 struct constructor_stack *p;
5325
5326 /* If we've exhausted any levels that didn't have braces,
5327 pop them now. */
5328 while (constructor_stack->implicit)
5329 {
5330 if ((TREE_CODE (constructor_type) == RECORD_TYPE
5331 || TREE_CODE (constructor_type) == UNION_TYPE)
5332 && constructor_fields == 0)
5333 process_init_element (pop_init_level (1));
5334 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5335 && tree_int_cst_lt (constructor_max_index, constructor_index))
5336 process_init_element (pop_init_level (1));
5337 else
5338 break;
5339 }
5340
5341 /* Structure elements may require alignment. Do this now if necessary
5342 for the subaggregate, and if it comes next in sequence. Don't do
5343 this for subaggregates that will go on the pending list. */
5344 if (constructor_incremental && constructor_type != 0
5345 && TREE_CODE (constructor_type) == RECORD_TYPE && constructor_fields
5346 && constructor_fields == constructor_unfilled_fields)
5347 {
5348 /* Advance to offset of this element. */
5349 if (! tree_int_cst_equal (constructor_bit_index,
5350 DECL_FIELD_BITPOS (constructor_fields)))
5351 {
5352 /* By using unsigned arithmetic, the result will be correct even
5353 in case of overflows, if BITS_PER_UNIT is a power of two. */
5354 unsigned next = (TREE_INT_CST_LOW
5355 (DECL_FIELD_BITPOS (constructor_fields))
5356 / (unsigned)BITS_PER_UNIT);
5357 unsigned here = (TREE_INT_CST_LOW (constructor_bit_index)
5358 / (unsigned)BITS_PER_UNIT);
5359
5360 assemble_zeros ((next - here)
5361 * (unsigned)BITS_PER_UNIT
5362 / (unsigned)BITS_PER_UNIT);
5363 }
5364 /* Indicate that we have now filled the structure up to the current
5365 field. */
5366 constructor_unfilled_fields = constructor_fields;
5367 }
5368
5369 p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
5370 p->type = constructor_type;
5371 p->fields = constructor_fields;
5372 p->index = constructor_index;
5373 p->range_end = constructor_range_end;
5374 p->max_index = constructor_max_index;
5375 p->unfilled_index = constructor_unfilled_index;
5376 p->unfilled_fields = constructor_unfilled_fields;
5377 p->bit_index = constructor_bit_index;
5378 p->elements = constructor_elements;
5379 p->constant = constructor_constant;
5380 p->simple = constructor_simple;
5381 p->erroneous = constructor_erroneous;
5382 p->pending_elts = constructor_pending_elts;
5383 p->depth = constructor_depth;
5384 p->replacement_value = 0;
5385 p->implicit = implicit;
5386 p->incremental = constructor_incremental;
5387 p->outer = 0;
5388 p->next = constructor_stack;
5389 constructor_stack = p;
5390
5391 constructor_constant = 1;
5392 constructor_simple = 1;
5393 constructor_depth = SPELLING_DEPTH ();
5394 constructor_elements = 0;
5395 constructor_pending_elts = 0;
5396
5397 /* Don't die if an entire brace-pair level is superfluous
5398 in the containing level. */
5399 if (constructor_type == 0)
5400 ;
5401 else if (TREE_CODE (constructor_type) == RECORD_TYPE
5402 || TREE_CODE (constructor_type) == UNION_TYPE)
5403 {
5404 /* Don't die if there are extra init elts at the end. */
5405 if (constructor_fields == 0)
5406 constructor_type = 0;
5407 else
5408 {
5409 constructor_type = TREE_TYPE (constructor_fields);
5410 push_member_name (constructor_fields);
5411 constructor_depth++;
5412 if (constructor_fields != constructor_unfilled_fields)
5413 constructor_incremental = 0;
5414 }
5415 }
5416 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5417 {
5418 constructor_type = TREE_TYPE (constructor_type);
5419 push_array_bounds (TREE_INT_CST_LOW (constructor_index));
5420 constructor_depth++;
5421 if (! tree_int_cst_equal (constructor_index, constructor_unfilled_index)
5422 || constructor_range_end != 0)
5423 constructor_incremental = 0;
5424 }
5425
5426 if (constructor_type == 0)
5427 {
|
5513 error_init ("extra brace group at end of initializer%s",
5514 " for `%s'", NULL);
| 5428 error_init ("extra brace group at end of initializer");
|
5515 constructor_fields = 0;
5516 constructor_unfilled_fields = 0;
5517 return;
5518 }
5519
5520 /* Turn off constructor_incremental if type is a struct with bitfields. */
5521 check_init_type_bitfields (constructor_type);
5522
5523 if (implicit && warn_missing_braces && !missing_braces_mentioned)
5524 {
5525 missing_braces_mentioned = 1;
| 5429 constructor_fields = 0;
5430 constructor_unfilled_fields = 0;
5431 return;
5432 }
5433
5434 /* Turn off constructor_incremental if type is a struct with bitfields. */
5435 check_init_type_bitfields (constructor_type);
5436
5437 if (implicit && warn_missing_braces && !missing_braces_mentioned)
5438 {
5439 missing_braces_mentioned = 1;
|
5526 warning_init ("missing braces around initializer%s", " for `%s'", NULL);
| 5440 warning_init ("missing braces around initializer");
|
5527 }
5528
5529 if (TREE_CODE (constructor_type) == RECORD_TYPE
5530 || TREE_CODE (constructor_type) == UNION_TYPE)
5531 {
5532 constructor_fields = TYPE_FIELDS (constructor_type);
5533 /* Skip any nameless bit fields at the beginning. */
5534 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5535 && DECL_NAME (constructor_fields) == 0)
5536 constructor_fields = TREE_CHAIN (constructor_fields);
5537 constructor_unfilled_fields = constructor_fields;
5538 constructor_bit_index = copy_node (integer_zero_node);
5539 TREE_TYPE (constructor_bit_index) = sbitsizetype;
5540 }
5541 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5542 {
5543 constructor_range_end = 0;
5544 if (TYPE_DOMAIN (constructor_type))
5545 {
5546 constructor_max_index
5547 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5548 constructor_index
5549 = copy_node (TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5550 }
5551 else
5552 constructor_index = copy_node (integer_zero_node);
5553 constructor_unfilled_index = copy_node (constructor_index);
5554 }
5555 else
5556 {
| 5441 }
5442
5443 if (TREE_CODE (constructor_type) == RECORD_TYPE
5444 || TREE_CODE (constructor_type) == UNION_TYPE)
5445 {
5446 constructor_fields = TYPE_FIELDS (constructor_type);
5447 /* Skip any nameless bit fields at the beginning. */
5448 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5449 && DECL_NAME (constructor_fields) == 0)
5450 constructor_fields = TREE_CHAIN (constructor_fields);
5451 constructor_unfilled_fields = constructor_fields;
5452 constructor_bit_index = copy_node (integer_zero_node);
5453 TREE_TYPE (constructor_bit_index) = sbitsizetype;
5454 }
5455 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5456 {
5457 constructor_range_end = 0;
5458 if (TYPE_DOMAIN (constructor_type))
5459 {
5460 constructor_max_index
5461 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5462 constructor_index
5463 = copy_node (TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5464 }
5465 else
5466 constructor_index = copy_node (integer_zero_node);
5467 constructor_unfilled_index = copy_node (constructor_index);
5468 }
5469 else
5470 {
|
5557 warning_init ("braces around scalar initializer%s", " for `%s'", NULL);
| 5471 warning_init ("braces around scalar initializer");
|
5558 constructor_fields = constructor_type;
5559 constructor_unfilled_fields = constructor_type;
5560 }
5561}
5562
5563/* Don't read a struct incrementally if it has any bitfields,
5564 because the incremental reading code doesn't know how to
5565 handle bitfields yet. */
5566
5567static void
5568check_init_type_bitfields (type)
5569 tree type;
5570{
5571 if (TREE_CODE (type) == RECORD_TYPE)
5572 {
5573 tree tail;
5574 for (tail = TYPE_FIELDS (type); tail;
5575 tail = TREE_CHAIN (tail))
5576 {
| 5472 constructor_fields = constructor_type;
5473 constructor_unfilled_fields = constructor_type;
5474 }
5475}
5476
5477/* Don't read a struct incrementally if it has any bitfields,
5478 because the incremental reading code doesn't know how to
5479 handle bitfields yet. */
5480
5481static void
5482check_init_type_bitfields (type)
5483 tree type;
5484{
5485 if (TREE_CODE (type) == RECORD_TYPE)
5486 {
5487 tree tail;
5488 for (tail = TYPE_FIELDS (type); tail;
5489 tail = TREE_CHAIN (tail))
5490 {
|
5577 if (DECL_C_BIT_FIELD (tail)
5578 /* This catches cases like `int foo : 8;'. */
5579 || DECL_MODE (tail) != TYPE_MODE (TREE_TYPE (tail)))
| 5491 if (DECL_C_BIT_FIELD (tail))
|
5580 {
5581 constructor_incremental = 0;
5582 break;
5583 }
5584
5585 check_init_type_bitfields (TREE_TYPE (tail));
5586 }
5587 }
5588
| 5492 {
5493 constructor_incremental = 0;
5494 break;
5495 }
5496
5497 check_init_type_bitfields (TREE_TYPE (tail));
5498 }
5499 }
5500
|
| 5501 else if (TREE_CODE (type) == UNION_TYPE)
5502 {
5503 tree tail = TYPE_FIELDS (type);
5504 if (tail && DECL_C_BIT_FIELD (tail))
5505 /* We also use the nonincremental algorithm for initiliazation
5506 of unions whose first member is a bitfield, becuase the
5507 incremental algorithm has no code for dealing with
5508 bitfields. */
5509 constructor_incremental = 0;
5510 }
5511
|
5589 else if (TREE_CODE (type) == ARRAY_TYPE)
5590 check_init_type_bitfields (TREE_TYPE (type));
5591}
5592
5593/* At the end of an implicit or explicit brace level,
5594 finish up that level of constructor.
5595 If we were outputting the elements as they are read, return 0
5596 from inner levels (process_init_element ignores that),
5597 but return error_mark_node from the outermost level
5598 (that's what we want to put in DECL_INITIAL).
5599 Otherwise, return a CONSTRUCTOR expression. */
5600
5601tree
5602pop_init_level (implicit)
5603 int implicit;
5604{
5605 struct constructor_stack *p;
5606 int size = 0;
5607 tree constructor = 0;
5608
5609 if (implicit == 0)
5610 {
5611 /* When we come to an explicit close brace,
5612 pop any inner levels that didn't have explicit braces. */
5613 while (constructor_stack->implicit)
5614 process_init_element (pop_init_level (1));
5615 }
5616
5617 p = constructor_stack;
5618
5619 if (constructor_type != 0)
5620 size = int_size_in_bytes (constructor_type);
5621
5622 /* Warn when some struct elements are implicitly initialized to zero. */
5623 if (extra_warnings
5624 && constructor_type
5625 && TREE_CODE (constructor_type) == RECORD_TYPE
5626 && constructor_unfilled_fields)
5627 {
5628 push_member_name (constructor_unfilled_fields);
| 5512 else if (TREE_CODE (type) == ARRAY_TYPE)
5513 check_init_type_bitfields (TREE_TYPE (type));
5514}
5515
5516/* At the end of an implicit or explicit brace level,
5517 finish up that level of constructor.
5518 If we were outputting the elements as they are read, return 0
5519 from inner levels (process_init_element ignores that),
5520 but return error_mark_node from the outermost level
5521 (that's what we want to put in DECL_INITIAL).
5522 Otherwise, return a CONSTRUCTOR expression. */
5523
5524tree
5525pop_init_level (implicit)
5526 int implicit;
5527{
5528 struct constructor_stack *p;
5529 int size = 0;
5530 tree constructor = 0;
5531
5532 if (implicit == 0)
5533 {
5534 /* When we come to an explicit close brace,
5535 pop any inner levels that didn't have explicit braces. */
5536 while (constructor_stack->implicit)
5537 process_init_element (pop_init_level (1));
5538 }
5539
5540 p = constructor_stack;
5541
5542 if (constructor_type != 0)
5543 size = int_size_in_bytes (constructor_type);
5544
5545 /* Warn when some struct elements are implicitly initialized to zero. */
5546 if (extra_warnings
5547 && constructor_type
5548 && TREE_CODE (constructor_type) == RECORD_TYPE
5549 && constructor_unfilled_fields)
5550 {
5551 push_member_name (constructor_unfilled_fields);
|
5629 warning_init ("missing initializer%s", " for `%s'", NULL);
| 5552 warning_init ("missing initializer");
|
5630 RESTORE_SPELLING_DEPTH (constructor_depth);
5631 }
5632
5633 /* Now output all pending elements. */
5634 output_pending_init_elements (1);
5635
5636#if 0 /* c-parse.in warns about {}. */
5637 /* In ANSI, each brace level must have at least one element. */
5638 if (! implicit && pedantic
5639 && (TREE_CODE (constructor_type) == ARRAY_TYPE
5640 ? integer_zerop (constructor_unfilled_index)
5641 : constructor_unfilled_fields == TYPE_FIELDS (constructor_type)))
| 5553 RESTORE_SPELLING_DEPTH (constructor_depth);
5554 }
5555
5556 /* Now output all pending elements. */
5557 output_pending_init_elements (1);
5558
5559#if 0 /* c-parse.in warns about {}. */
5560 /* In ANSI, each brace level must have at least one element. */
5561 if (! implicit && pedantic
5562 && (TREE_CODE (constructor_type) == ARRAY_TYPE
5563 ? integer_zerop (constructor_unfilled_index)
5564 : constructor_unfilled_fields == TYPE_FIELDS (constructor_type)))
|
5642 pedwarn_init ("empty braces in initializer%s", " for `%s'", NULL);
| 5565 pedwarn_init ("empty braces in initializer");
|
5643#endif
5644
5645 /* Pad out the end of the structure. */
5646
5647 if (p->replacement_value)
5648 {
5649 /* If this closes a superfluous brace pair,
5650 just pass out the element between them. */
5651 constructor = p->replacement_value;
5652 /* If this is the top level thing within the initializer,
5653 and it's for a variable, then since we already called
5654 assemble_variable, we must output the value now. */
5655 if (p->next == 0 && constructor_decl != 0
5656 && constructor_incremental)
5657 {
5658 constructor = digest_init (constructor_type, constructor,
5659 require_constant_value,
5660 require_constant_elements);
5661
5662 /* If initializing an array of unknown size,
5663 determine the size now. */
5664 if (TREE_CODE (constructor_type) == ARRAY_TYPE
5665 && TYPE_DOMAIN (constructor_type) == 0)
5666 {
5667 int failure;
5668 int momentary_p;
5669
5670 push_obstacks_nochange ();
5671 if (TREE_PERMANENT (constructor_type))
5672 end_temporary_allocation ();
5673
5674 momentary_p = suspend_momentary ();
5675
5676 /* We shouldn't have an incomplete array type within
5677 some other type. */
5678 if (constructor_stack->next)
5679 abort ();
5680
5681 failure
5682 = complete_array_type (constructor_type,
5683 constructor, 0);
5684 if (failure)
5685 abort ();
5686
5687 size = int_size_in_bytes (constructor_type);
5688 resume_momentary (momentary_p);
5689 pop_obstacks ();
5690 }
5691
5692 output_constant (constructor, size);
5693 }
5694 }
5695 else if (constructor_type == 0)
5696 ;
5697 else if (TREE_CODE (constructor_type) != RECORD_TYPE
5698 && TREE_CODE (constructor_type) != UNION_TYPE
5699 && TREE_CODE (constructor_type) != ARRAY_TYPE
5700 && ! constructor_incremental)
5701 {
5702 /* A nonincremental scalar initializer--just return
5703 the element, after verifying there is just one. */
5704 if (constructor_elements == 0)
5705 {
| 5566#endif
5567
5568 /* Pad out the end of the structure. */
5569
5570 if (p->replacement_value)
5571 {
5572 /* If this closes a superfluous brace pair,
5573 just pass out the element between them. */
5574 constructor = p->replacement_value;
5575 /* If this is the top level thing within the initializer,
5576 and it's for a variable, then since we already called
5577 assemble_variable, we must output the value now. */
5578 if (p->next == 0 && constructor_decl != 0
5579 && constructor_incremental)
5580 {
5581 constructor = digest_init (constructor_type, constructor,
5582 require_constant_value,
5583 require_constant_elements);
5584
5585 /* If initializing an array of unknown size,
5586 determine the size now. */
5587 if (TREE_CODE (constructor_type) == ARRAY_TYPE
5588 && TYPE_DOMAIN (constructor_type) == 0)
5589 {
5590 int failure;
5591 int momentary_p;
5592
5593 push_obstacks_nochange ();
5594 if (TREE_PERMANENT (constructor_type))
5595 end_temporary_allocation ();
5596
5597 momentary_p = suspend_momentary ();
5598
5599 /* We shouldn't have an incomplete array type within
5600 some other type. */
5601 if (constructor_stack->next)
5602 abort ();
5603
5604 failure
5605 = complete_array_type (constructor_type,
5606 constructor, 0);
5607 if (failure)
5608 abort ();
5609
5610 size = int_size_in_bytes (constructor_type);
5611 resume_momentary (momentary_p);
5612 pop_obstacks ();
5613 }
5614
5615 output_constant (constructor, size);
5616 }
5617 }
5618 else if (constructor_type == 0)
5619 ;
5620 else if (TREE_CODE (constructor_type) != RECORD_TYPE
5621 && TREE_CODE (constructor_type) != UNION_TYPE
5622 && TREE_CODE (constructor_type) != ARRAY_TYPE
5623 && ! constructor_incremental)
5624 {
5625 /* A nonincremental scalar initializer--just return
5626 the element, after verifying there is just one. */
5627 if (constructor_elements == 0)
5628 {
|
5706 error_init ("empty scalar initializer%s",
5707 " for `%s'", NULL);
| 5629 error_init ("empty scalar initializer");
|
5708 constructor = error_mark_node;
5709 }
5710 else if (TREE_CHAIN (constructor_elements) != 0)
5711 {
| 5630 constructor = error_mark_node;
5631 }
5632 else if (TREE_CHAIN (constructor_elements) != 0)
5633 {
|
5712 error_init ("extra elements in scalar initializer%s",
5713 " for `%s'", NULL);
| 5634 error_init ("extra elements in scalar initializer");
|
5714 constructor = TREE_VALUE (constructor_elements);
5715 }
5716 else
5717 constructor = TREE_VALUE (constructor_elements);
5718 }
5719 else if (! constructor_incremental)
5720 {
5721 if (constructor_erroneous)
5722 constructor = error_mark_node;
5723 else
5724 {
5725 int momentary = suspend_momentary ();
5726
5727 constructor = build (CONSTRUCTOR, constructor_type, NULL_TREE,
5728 nreverse (constructor_elements));
5729 if (constructor_constant)
5730 TREE_CONSTANT (constructor) = 1;
5731 if (constructor_constant && constructor_simple)
5732 TREE_STATIC (constructor) = 1;
5733
5734 resume_momentary (momentary);
5735 }
5736 }
5737 else
5738 {
5739 tree filled;
5740 int momentary = suspend_momentary ();
5741
5742 if (TREE_CODE (constructor_type) == RECORD_TYPE
5743 || TREE_CODE (constructor_type) == UNION_TYPE)
5744 {
5745 /* Find the offset of the end of that field. */
5746 filled = size_binop (CEIL_DIV_EXPR,
5747 constructor_bit_index,
5748 size_int (BITS_PER_UNIT));
5749 }
5750 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5751 {
5752 /* If initializing an array of unknown size,
5753 determine the size now. */
5754 if (TREE_CODE (constructor_type) == ARRAY_TYPE
5755 && TYPE_DOMAIN (constructor_type) == 0)
5756 {
5757 tree maxindex
5758 = size_binop (MINUS_EXPR,
5759 constructor_unfilled_index,
5760 integer_one_node);
5761
5762 push_obstacks_nochange ();
5763 if (TREE_PERMANENT (constructor_type))
5764 end_temporary_allocation ();
5765 maxindex = copy_node (maxindex);
5766 TYPE_DOMAIN (constructor_type) = build_index_type (maxindex);
5767 TREE_TYPE (maxindex) = TYPE_DOMAIN (constructor_type);
5768
5769 /* TYPE_MAX_VALUE is always one less than the number of elements
5770 in the array, because we start counting at zero. Therefore,
5771 warn only if the value is less than zero. */
5772 if (pedantic
5773 && (tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
5774 < 0))
5775 error_with_decl (constructor_decl,
5776 "zero or negative array size `%s'");
5777 layout_type (constructor_type);
5778 size = int_size_in_bytes (constructor_type);
5779 pop_obstacks ();
5780 }
5781
5782 filled = size_binop (MULT_EXPR, constructor_unfilled_index,
5783 size_in_bytes (TREE_TYPE (constructor_type)));
5784 }
5785 else
5786 filled = 0;
5787
5788 if (filled != 0)
5789 assemble_zeros (size - TREE_INT_CST_LOW (filled));
5790
5791 resume_momentary (momentary);
5792 }
5793
5794
5795 constructor_type = p->type;
5796 constructor_fields = p->fields;
5797 constructor_index = p->index;
5798 constructor_range_end = p->range_end;
5799 constructor_max_index = p->max_index;
5800 constructor_unfilled_index = p->unfilled_index;
5801 constructor_unfilled_fields = p->unfilled_fields;
5802 constructor_bit_index = p->bit_index;
5803 constructor_elements = p->elements;
5804 constructor_constant = p->constant;
5805 constructor_simple = p->simple;
5806 constructor_erroneous = p->erroneous;
5807 constructor_pending_elts = p->pending_elts;
5808 constructor_depth = p->depth;
5809 constructor_incremental = p->incremental;
5810 RESTORE_SPELLING_DEPTH (constructor_depth);
5811
5812 constructor_stack = p->next;
5813 free (p);
5814
5815 if (constructor == 0)
5816 {
5817 if (constructor_stack == 0)
5818 return error_mark_node;
5819 return NULL_TREE;
5820 }
5821 return constructor;
5822}
5823
5824/* Within an array initializer, specify the next index to be initialized.
5825 FIRST is that index. If LAST is nonzero, then initialize a range
5826 of indices, running from FIRST through LAST. */
5827
5828void
5829set_init_index (first, last)
5830 tree first, last;
5831{
5832 while ((TREE_CODE (first) == NOP_EXPR
5833 || TREE_CODE (first) == CONVERT_EXPR
5834 || TREE_CODE (first) == NON_LVALUE_EXPR)
5835 && (TYPE_MODE (TREE_TYPE (first))
5836 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5837 (first) = TREE_OPERAND (first, 0);
5838 if (last)
5839 while ((TREE_CODE (last) == NOP_EXPR
5840 || TREE_CODE (last) == CONVERT_EXPR
5841 || TREE_CODE (last) == NON_LVALUE_EXPR)
5842 && (TYPE_MODE (TREE_TYPE (last))
5843 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5844 (last) = TREE_OPERAND (last, 0);
5845
5846 if (TREE_CODE (first) != INTEGER_CST)
| 5635 constructor = TREE_VALUE (constructor_elements);
5636 }
5637 else
5638 constructor = TREE_VALUE (constructor_elements);
5639 }
5640 else if (! constructor_incremental)
5641 {
5642 if (constructor_erroneous)
5643 constructor = error_mark_node;
5644 else
5645 {
5646 int momentary = suspend_momentary ();
5647
5648 constructor = build (CONSTRUCTOR, constructor_type, NULL_TREE,
5649 nreverse (constructor_elements));
5650 if (constructor_constant)
5651 TREE_CONSTANT (constructor) = 1;
5652 if (constructor_constant && constructor_simple)
5653 TREE_STATIC (constructor) = 1;
5654
5655 resume_momentary (momentary);
5656 }
5657 }
5658 else
5659 {
5660 tree filled;
5661 int momentary = suspend_momentary ();
5662
5663 if (TREE_CODE (constructor_type) == RECORD_TYPE
5664 || TREE_CODE (constructor_type) == UNION_TYPE)
5665 {
5666 /* Find the offset of the end of that field. */
5667 filled = size_binop (CEIL_DIV_EXPR,
5668 constructor_bit_index,
5669 size_int (BITS_PER_UNIT));
5670 }
5671 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5672 {
5673 /* If initializing an array of unknown size,
5674 determine the size now. */
5675 if (TREE_CODE (constructor_type) == ARRAY_TYPE
5676 && TYPE_DOMAIN (constructor_type) == 0)
5677 {
5678 tree maxindex
5679 = size_binop (MINUS_EXPR,
5680 constructor_unfilled_index,
5681 integer_one_node);
5682
5683 push_obstacks_nochange ();
5684 if (TREE_PERMANENT (constructor_type))
5685 end_temporary_allocation ();
5686 maxindex = copy_node (maxindex);
5687 TYPE_DOMAIN (constructor_type) = build_index_type (maxindex);
5688 TREE_TYPE (maxindex) = TYPE_DOMAIN (constructor_type);
5689
5690 /* TYPE_MAX_VALUE is always one less than the number of elements
5691 in the array, because we start counting at zero. Therefore,
5692 warn only if the value is less than zero. */
5693 if (pedantic
5694 && (tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
5695 < 0))
5696 error_with_decl (constructor_decl,
5697 "zero or negative array size `%s'");
5698 layout_type (constructor_type);
5699 size = int_size_in_bytes (constructor_type);
5700 pop_obstacks ();
5701 }
5702
5703 filled = size_binop (MULT_EXPR, constructor_unfilled_index,
5704 size_in_bytes (TREE_TYPE (constructor_type)));
5705 }
5706 else
5707 filled = 0;
5708
5709 if (filled != 0)
5710 assemble_zeros (size - TREE_INT_CST_LOW (filled));
5711
5712 resume_momentary (momentary);
5713 }
5714
5715
5716 constructor_type = p->type;
5717 constructor_fields = p->fields;
5718 constructor_index = p->index;
5719 constructor_range_end = p->range_end;
5720 constructor_max_index = p->max_index;
5721 constructor_unfilled_index = p->unfilled_index;
5722 constructor_unfilled_fields = p->unfilled_fields;
5723 constructor_bit_index = p->bit_index;
5724 constructor_elements = p->elements;
5725 constructor_constant = p->constant;
5726 constructor_simple = p->simple;
5727 constructor_erroneous = p->erroneous;
5728 constructor_pending_elts = p->pending_elts;
5729 constructor_depth = p->depth;
5730 constructor_incremental = p->incremental;
5731 RESTORE_SPELLING_DEPTH (constructor_depth);
5732
5733 constructor_stack = p->next;
5734 free (p);
5735
5736 if (constructor == 0)
5737 {
5738 if (constructor_stack == 0)
5739 return error_mark_node;
5740 return NULL_TREE;
5741 }
5742 return constructor;
5743}
5744
5745/* Within an array initializer, specify the next index to be initialized.
5746 FIRST is that index. If LAST is nonzero, then initialize a range
5747 of indices, running from FIRST through LAST. */
5748
5749void
5750set_init_index (first, last)
5751 tree first, last;
5752{
5753 while ((TREE_CODE (first) == NOP_EXPR
5754 || TREE_CODE (first) == CONVERT_EXPR
5755 || TREE_CODE (first) == NON_LVALUE_EXPR)
5756 && (TYPE_MODE (TREE_TYPE (first))
5757 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5758 (first) = TREE_OPERAND (first, 0);
5759 if (last)
5760 while ((TREE_CODE (last) == NOP_EXPR
5761 || TREE_CODE (last) == CONVERT_EXPR
5762 || TREE_CODE (last) == NON_LVALUE_EXPR)
5763 && (TYPE_MODE (TREE_TYPE (last))
5764 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5765 (last) = TREE_OPERAND (last, 0);
5766
5767 if (TREE_CODE (first) != INTEGER_CST)
|
5847 error_init ("nonconstant array index in initializer%s", " for `%s'", NULL);
| 5768 error_init ("nonconstant array index in initializer");
|
5848 else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
| 5769 else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
|
5849 error_init ("nonconstant array index in initializer%s", " for `%s'", NULL);
| 5770 error_init ("nonconstant array index in initializer");
|
5850 else if (! constructor_unfilled_index)
| 5771 else if (! constructor_unfilled_index)
|
5851 error_init ("array index in non-array initializer%s", " for `%s'", NULL);
| 5772 error_init ("array index in non-array initializer");
|
5852 else if (tree_int_cst_lt (first, constructor_unfilled_index))
| 5773 else if (tree_int_cst_lt (first, constructor_unfilled_index))
|
5853 error_init ("duplicate array index in initializer%s", " for `%s'", NULL);
| 5774 error_init ("duplicate array index in initializer");
|
5854 else
5855 {
5856 TREE_INT_CST_LOW (constructor_index) = TREE_INT_CST_LOW (first);
5857 TREE_INT_CST_HIGH (constructor_index) = TREE_INT_CST_HIGH (first);
5858
5859 if (last != 0 && tree_int_cst_lt (last, first))
| 5775 else
5776 {
5777 TREE_INT_CST_LOW (constructor_index) = TREE_INT_CST_LOW (first);
5778 TREE_INT_CST_HIGH (constructor_index) = TREE_INT_CST_HIGH (first);
5779
5780 if (last != 0 && tree_int_cst_lt (last, first))
|
5860 error_init ("empty index range in initializer%s", " for `%s'", NULL);
| 5781 error_init ("empty index range in initializer");
|
5861 else
5862 {
5863 if (pedantic)
5864 pedwarn ("ANSI C forbids specifying element to initialize");
5865 constructor_range_end = last;
5866 }
5867 }
5868}
5869
5870/* Within a struct initializer, specify the next field to be initialized. */
5871
5872void
5873set_init_label (fieldname)
5874 tree fieldname;
5875{
5876 tree tail;
5877 int passed = 0;
5878
5879 /* Don't die if an entire brace-pair level is superfluous
5880 in the containing level. */
5881 if (constructor_type == 0)
5882 return;
5883
5884 for (tail = TYPE_FIELDS (constructor_type); tail;
5885 tail = TREE_CHAIN (tail))
5886 {
5887 if (tail == constructor_unfilled_fields)
5888 passed = 1;
5889 if (DECL_NAME (tail) == fieldname)
5890 break;
5891 }
5892
5893 if (tail == 0)
5894 error ("unknown field `%s' specified in initializer",
5895 IDENTIFIER_POINTER (fieldname));
5896 else if (!passed)
5897 error ("field `%s' already initialized",
5898 IDENTIFIER_POINTER (fieldname));
5899 else
5900 {
5901 constructor_fields = tail;
5902 if (pedantic)
5903 pedwarn ("ANSI C forbids specifying structure member to initialize");
5904 }
5905}
5906
5907/* Add a new initializer to the tree of pending initializers. PURPOSE
5908 indentifies the initializer, either array index or field in a structure.
5909 VALUE is the value of that index or field. */
5910
5911static void
5912add_pending_init (purpose, value)
5913 tree purpose, value;
5914{
5915 struct init_node *p, **q, *r;
5916
5917 q = &constructor_pending_elts;
5918 p = 0;
5919
5920 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5921 {
5922 while (*q != 0)
5923 {
5924 p = *q;
5925 if (tree_int_cst_lt (purpose, p->purpose))
5926 q = &p->left;
5927 else if (tree_int_cst_lt (p->purpose, purpose))
5928 q = &p->right;
5929 else
5930 abort ();
5931 }
5932 }
5933 else
5934 {
5935 while (*q != NULL)
5936 {
5937 p = *q;
5938 if (tree_int_cst_lt (DECL_FIELD_BITPOS (purpose),
5939 DECL_FIELD_BITPOS (p->purpose)))
5940 q = &p->left;
5941 else if (tree_int_cst_lt (DECL_FIELD_BITPOS (p->purpose),
5942 DECL_FIELD_BITPOS (purpose)))
5943 q = &p->right;
5944 else
5945 abort ();
5946 }
5947 }
5948
5949 r = (struct init_node *) oballoc (sizeof (struct init_node));
5950 r->purpose = purpose;
5951 r->value = value;
5952
5953 *q = r;
5954 r->parent = p;
5955 r->left = 0;
5956 r->right = 0;
5957 r->balance = 0;
5958
5959 while (p)
5960 {
5961 struct init_node *s;
5962
5963 if (r == p->left)
5964 {
5965 if (p->balance == 0)
5966 p->balance = -1;
5967 else if (p->balance < 0)
5968 {
5969 if (r->balance < 0)
5970 {
5971 /* L rotation. */
5972 p->left = r->right;
5973 if (p->left)
5974 p->left->parent = p;
5975 r->right = p;
5976
5977 p->balance = 0;
5978 r->balance = 0;
5979
5980 s = p->parent;
5981 p->parent = r;
5982 r->parent = s;
5983 if (s)
5984 {
5985 if (s->left == p)
5986 s->left = r;
5987 else
5988 s->right = r;
5989 }
5990 else
5991 constructor_pending_elts = r;
5992 }
5993 else
5994 {
5995 /* LR rotation. */
5996 struct init_node *t = r->right;
5997
5998 r->right = t->left;
5999 if (r->right)
6000 r->right->parent = r;
6001 t->left = r;
6002
6003 p->left = t->right;
6004 if (p->left)
6005 p->left->parent = p;
6006 t->right = p;
6007
6008 p->balance = t->balance < 0;
6009 r->balance = -(t->balance > 0);
6010 t->balance = 0;
6011
6012 s = p->parent;
6013 p->parent = t;
6014 r->parent = t;
6015 t->parent = s;
6016 if (s)
6017 {
6018 if (s->left == p)
6019 s->left = t;
6020 else
6021 s->right = t;
6022 }
6023 else
6024 constructor_pending_elts = t;
6025 }
6026 break;
6027 }
6028 else
6029 {
6030 /* p->balance == +1; growth of left side balances the node. */
6031 p->balance = 0;
6032 break;
6033 }
6034 }
6035 else /* r == p->right */
6036 {
6037 if (p->balance == 0)
6038 /* Growth propagation from right side. */
6039 p->balance++;
6040 else if (p->balance > 0)
6041 {
6042 if (r->balance > 0)
6043 {
6044 /* R rotation. */
6045 p->right = r->left;
6046 if (p->right)
6047 p->right->parent = p;
6048 r->left = p;
6049
6050 p->balance = 0;
6051 r->balance = 0;
6052
6053 s = p->parent;
6054 p->parent = r;
6055 r->parent = s;
6056 if (s)
6057 {
6058 if (s->left == p)
6059 s->left = r;
6060 else
6061 s->right = r;
6062 }
6063 else
6064 constructor_pending_elts = r;
6065 }
6066 else /* r->balance == -1 */
6067 {
6068 /* RL rotation */
6069 struct init_node *t = r->left;
6070
6071 r->left = t->right;
6072 if (r->left)
6073 r->left->parent = r;
6074 t->right = r;
6075
6076 p->right = t->left;
6077 if (p->right)
6078 p->right->parent = p;
6079 t->left = p;
6080
6081 r->balance = (t->balance < 0);
6082 p->balance = -(t->balance > 0);
6083 t->balance = 0;
6084
6085 s = p->parent;
6086 p->parent = t;
6087 r->parent = t;
6088 t->parent = s;
6089 if (s)
6090 {
6091 if (s->left == p)
6092 s->left = t;
6093 else
6094 s->right = t;
6095 }
6096 else
6097 constructor_pending_elts = t;
6098 }
6099 break;
6100 }
6101 else
6102 {
6103 /* p->balance == -1; growth of right side balances the node. */
6104 p->balance = 0;
6105 break;
6106 }
6107 }
6108
6109 r = p;
6110 p = p->parent;
6111 }
6112}
6113
6114/* Return nonzero if FIELD is equal to the index of a pending initializer. */
6115
6116static int
6117pending_init_member (field)
6118 tree field;
6119{
6120 struct init_node *p;
6121
6122 p = constructor_pending_elts;
6123 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6124 {
6125 while (p)
6126 {
6127 if (tree_int_cst_equal (field, p->purpose))
6128 return 1;
6129 else if (tree_int_cst_lt (field, p->purpose))
6130 p = p->left;
6131 else
6132 p = p->right;
6133 }
6134 }
6135 else
6136 {
6137 while (p)
6138 {
6139 if (field == p->purpose)
6140 return 1;
6141 else if (tree_int_cst_lt (DECL_FIELD_BITPOS (field),
6142 DECL_FIELD_BITPOS (p->purpose)))
6143 p = p->left;
6144 else
6145 p = p->right;
6146 }
6147 }
6148
6149 return 0;
6150}
6151
6152/* "Output" the next constructor element.
6153 At top level, really output it to assembler code now.
6154 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
6155 TYPE is the data type that the containing data type wants here.
6156 FIELD is the field (a FIELD_DECL) or the index that this element fills.
6157
6158 PENDING if non-nil means output pending elements that belong
6159 right after this element. (PENDING is normally 1;
6160 it is 0 while outputting pending elements, to avoid recursion.) */
6161
6162static void
6163output_init_element (value, type, field, pending)
6164 tree value, type, field;
6165 int pending;
6166{
6167 int duplicate = 0;
6168
6169 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
6170 || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
6171 && !(TREE_CODE (value) == STRING_CST
6172 && TREE_CODE (type) == ARRAY_TYPE
6173 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
6174 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
6175 TYPE_MAIN_VARIANT (type))))
6176 value = default_conversion (value);
6177
6178 if (value == error_mark_node)
6179 constructor_erroneous = 1;
6180 else if (!TREE_CONSTANT (value))
6181 constructor_constant = 0;
6182 else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
6183 || ((TREE_CODE (constructor_type) == RECORD_TYPE
6184 || TREE_CODE (constructor_type) == UNION_TYPE)
6185 && DECL_C_BIT_FIELD (field)
6186 && TREE_CODE (value) != INTEGER_CST))
6187 constructor_simple = 0;
6188
6189 if (require_constant_value && ! TREE_CONSTANT (value))
6190 {
| 5782 else
5783 {
5784 if (pedantic)
5785 pedwarn ("ANSI C forbids specifying element to initialize");
5786 constructor_range_end = last;
5787 }
5788 }
5789}
5790
5791/* Within a struct initializer, specify the next field to be initialized. */
5792
5793void
5794set_init_label (fieldname)
5795 tree fieldname;
5796{
5797 tree tail;
5798 int passed = 0;
5799
5800 /* Don't die if an entire brace-pair level is superfluous
5801 in the containing level. */
5802 if (constructor_type == 0)
5803 return;
5804
5805 for (tail = TYPE_FIELDS (constructor_type); tail;
5806 tail = TREE_CHAIN (tail))
5807 {
5808 if (tail == constructor_unfilled_fields)
5809 passed = 1;
5810 if (DECL_NAME (tail) == fieldname)
5811 break;
5812 }
5813
5814 if (tail == 0)
5815 error ("unknown field `%s' specified in initializer",
5816 IDENTIFIER_POINTER (fieldname));
5817 else if (!passed)
5818 error ("field `%s' already initialized",
5819 IDENTIFIER_POINTER (fieldname));
5820 else
5821 {
5822 constructor_fields = tail;
5823 if (pedantic)
5824 pedwarn ("ANSI C forbids specifying structure member to initialize");
5825 }
5826}
5827
5828/* Add a new initializer to the tree of pending initializers. PURPOSE
5829 indentifies the initializer, either array index or field in a structure.
5830 VALUE is the value of that index or field. */
5831
5832static void
5833add_pending_init (purpose, value)
5834 tree purpose, value;
5835{
5836 struct init_node *p, **q, *r;
5837
5838 q = &constructor_pending_elts;
5839 p = 0;
5840
5841 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5842 {
5843 while (*q != 0)
5844 {
5845 p = *q;
5846 if (tree_int_cst_lt (purpose, p->purpose))
5847 q = &p->left;
5848 else if (tree_int_cst_lt (p->purpose, purpose))
5849 q = &p->right;
5850 else
5851 abort ();
5852 }
5853 }
5854 else
5855 {
5856 while (*q != NULL)
5857 {
5858 p = *q;
5859 if (tree_int_cst_lt (DECL_FIELD_BITPOS (purpose),
5860 DECL_FIELD_BITPOS (p->purpose)))
5861 q = &p->left;
5862 else if (tree_int_cst_lt (DECL_FIELD_BITPOS (p->purpose),
5863 DECL_FIELD_BITPOS (purpose)))
5864 q = &p->right;
5865 else
5866 abort ();
5867 }
5868 }
5869
5870 r = (struct init_node *) oballoc (sizeof (struct init_node));
5871 r->purpose = purpose;
5872 r->value = value;
5873
5874 *q = r;
5875 r->parent = p;
5876 r->left = 0;
5877 r->right = 0;
5878 r->balance = 0;
5879
5880 while (p)
5881 {
5882 struct init_node *s;
5883
5884 if (r == p->left)
5885 {
5886 if (p->balance == 0)
5887 p->balance = -1;
5888 else if (p->balance < 0)
5889 {
5890 if (r->balance < 0)
5891 {
5892 /* L rotation. */
5893 p->left = r->right;
5894 if (p->left)
5895 p->left->parent = p;
5896 r->right = p;
5897
5898 p->balance = 0;
5899 r->balance = 0;
5900
5901 s = p->parent;
5902 p->parent = r;
5903 r->parent = s;
5904 if (s)
5905 {
5906 if (s->left == p)
5907 s->left = r;
5908 else
5909 s->right = r;
5910 }
5911 else
5912 constructor_pending_elts = r;
5913 }
5914 else
5915 {
5916 /* LR rotation. */
5917 struct init_node *t = r->right;
5918
5919 r->right = t->left;
5920 if (r->right)
5921 r->right->parent = r;
5922 t->left = r;
5923
5924 p->left = t->right;
5925 if (p->left)
5926 p->left->parent = p;
5927 t->right = p;
5928
5929 p->balance = t->balance < 0;
5930 r->balance = -(t->balance > 0);
5931 t->balance = 0;
5932
5933 s = p->parent;
5934 p->parent = t;
5935 r->parent = t;
5936 t->parent = s;
5937 if (s)
5938 {
5939 if (s->left == p)
5940 s->left = t;
5941 else
5942 s->right = t;
5943 }
5944 else
5945 constructor_pending_elts = t;
5946 }
5947 break;
5948 }
5949 else
5950 {
5951 /* p->balance == +1; growth of left side balances the node. */
5952 p->balance = 0;
5953 break;
5954 }
5955 }
5956 else /* r == p->right */
5957 {
5958 if (p->balance == 0)
5959 /* Growth propagation from right side. */
5960 p->balance++;
5961 else if (p->balance > 0)
5962 {
5963 if (r->balance > 0)
5964 {
5965 /* R rotation. */
5966 p->right = r->left;
5967 if (p->right)
5968 p->right->parent = p;
5969 r->left = p;
5970
5971 p->balance = 0;
5972 r->balance = 0;
5973
5974 s = p->parent;
5975 p->parent = r;
5976 r->parent = s;
5977 if (s)
5978 {
5979 if (s->left == p)
5980 s->left = r;
5981 else
5982 s->right = r;
5983 }
5984 else
5985 constructor_pending_elts = r;
5986 }
5987 else /* r->balance == -1 */
5988 {
5989 /* RL rotation */
5990 struct init_node *t = r->left;
5991
5992 r->left = t->right;
5993 if (r->left)
5994 r->left->parent = r;
5995 t->right = r;
5996
5997 p->right = t->left;
5998 if (p->right)
5999 p->right->parent = p;
6000 t->left = p;
6001
6002 r->balance = (t->balance < 0);
6003 p->balance = -(t->balance > 0);
6004 t->balance = 0;
6005
6006 s = p->parent;
6007 p->parent = t;
6008 r->parent = t;
6009 t->parent = s;
6010 if (s)
6011 {
6012 if (s->left == p)
6013 s->left = t;
6014 else
6015 s->right = t;
6016 }
6017 else
6018 constructor_pending_elts = t;
6019 }
6020 break;
6021 }
6022 else
6023 {
6024 /* p->balance == -1; growth of right side balances the node. */
6025 p->balance = 0;
6026 break;
6027 }
6028 }
6029
6030 r = p;
6031 p = p->parent;
6032 }
6033}
6034
6035/* Return nonzero if FIELD is equal to the index of a pending initializer. */
6036
6037static int
6038pending_init_member (field)
6039 tree field;
6040{
6041 struct init_node *p;
6042
6043 p = constructor_pending_elts;
6044 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6045 {
6046 while (p)
6047 {
6048 if (tree_int_cst_equal (field, p->purpose))
6049 return 1;
6050 else if (tree_int_cst_lt (field, p->purpose))
6051 p = p->left;
6052 else
6053 p = p->right;
6054 }
6055 }
6056 else
6057 {
6058 while (p)
6059 {
6060 if (field == p->purpose)
6061 return 1;
6062 else if (tree_int_cst_lt (DECL_FIELD_BITPOS (field),
6063 DECL_FIELD_BITPOS (p->purpose)))
6064 p = p->left;
6065 else
6066 p = p->right;
6067 }
6068 }
6069
6070 return 0;
6071}
6072
6073/* "Output" the next constructor element.
6074 At top level, really output it to assembler code now.
6075 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
6076 TYPE is the data type that the containing data type wants here.
6077 FIELD is the field (a FIELD_DECL) or the index that this element fills.
6078
6079 PENDING if non-nil means output pending elements that belong
6080 right after this element. (PENDING is normally 1;
6081 it is 0 while outputting pending elements, to avoid recursion.) */
6082
6083static void
6084output_init_element (value, type, field, pending)
6085 tree value, type, field;
6086 int pending;
6087{
6088 int duplicate = 0;
6089
6090 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
6091 || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
6092 && !(TREE_CODE (value) == STRING_CST
6093 && TREE_CODE (type) == ARRAY_TYPE
6094 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
6095 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
6096 TYPE_MAIN_VARIANT (type))))
6097 value = default_conversion (value);
6098
6099 if (value == error_mark_node)
6100 constructor_erroneous = 1;
6101 else if (!TREE_CONSTANT (value))
6102 constructor_constant = 0;
6103 else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
6104 || ((TREE_CODE (constructor_type) == RECORD_TYPE
6105 || TREE_CODE (constructor_type) == UNION_TYPE)
6106 && DECL_C_BIT_FIELD (field)
6107 && TREE_CODE (value) != INTEGER_CST))
6108 constructor_simple = 0;
6109
6110 if (require_constant_value && ! TREE_CONSTANT (value))
6111 {
|
6191 error_init ("initializer element%s is not constant",
6192 " for `%s'", NULL);
| 6112 error_init ("initializer element is not constant");
|
6193 value = error_mark_node;
6194 }
6195 else if (require_constant_elements
6196 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
6197 {
| 6113 value = error_mark_node;
6114 }
6115 else if (require_constant_elements
6116 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
6117 {
|
6198 error_init ("initializer element%s is not computable at load time",
6199 " for `%s'", NULL);
| 6118 error_init ("initializer element is not computable at load time");
|
6200 value = error_mark_node;
6201 }
6202
6203 /* If this element duplicates one on constructor_pending_elts,
6204 print a message and ignore it. Don't do this when we're
6205 processing elements taken off constructor_pending_elts,
6206 because we'd always get spurious errors. */
6207 if (pending)
6208 {
6209 if (TREE_CODE (constructor_type) == RECORD_TYPE
6210 || TREE_CODE (constructor_type) == UNION_TYPE
6211 || TREE_CODE (constructor_type) == ARRAY_TYPE)
6212 {
6213 if (pending_init_member (field))
6214 {
| 6119 value = error_mark_node;
6120 }
6121
6122 /* If this element duplicates one on constructor_pending_elts,
6123 print a message and ignore it. Don't do this when we're
6124 processing elements taken off constructor_pending_elts,
6125 because we'd always get spurious errors. */
6126 if (pending)
6127 {
6128 if (TREE_CODE (constructor_type) == RECORD_TYPE
6129 || TREE_CODE (constructor_type) == UNION_TYPE
6130 || TREE_CODE (constructor_type) == ARRAY_TYPE)
6131 {
6132 if (pending_init_member (field))
6133 {
|
6215 error_init ("duplicate initializer%s", " for `%s'", NULL);
| 6134 error_init ("duplicate initializer");
|
6216 duplicate = 1;
6217 }
6218 }
6219 }
6220
6221 /* If this element doesn't come next in sequence,
6222 put it on constructor_pending_elts. */
6223 if (TREE_CODE (constructor_type) == ARRAY_TYPE
6224 && !tree_int_cst_equal (field, constructor_unfilled_index))
6225 {
6226 if (! duplicate)
6227 /* The copy_node is needed in case field is actually
6228 constructor_index, which is modified in place. */
6229 add_pending_init (copy_node (field),
6230 digest_init (type, value, require_constant_value,
6231 require_constant_elements));
6232 }
6233 else if (TREE_CODE (constructor_type) == RECORD_TYPE
6234 && field != constructor_unfilled_fields)
6235 {
6236 /* We do this for records but not for unions. In a union,
6237 no matter which field is specified, it can be initialized
6238 right away since it starts at the beginning of the union. */
6239 if (!duplicate)
6240 add_pending_init (field,
6241 digest_init (type, value, require_constant_value,
6242 require_constant_elements));
6243 }
6244 else
6245 {
6246 /* Otherwise, output this element either to
6247 constructor_elements or to the assembler file. */
6248
6249 if (!duplicate)
6250 {
6251 if (! constructor_incremental)
6252 {
6253 if (field && TREE_CODE (field) == INTEGER_CST)
6254 field = copy_node (field);
6255 constructor_elements
6256 = tree_cons (field, digest_init (type, value,
6257 require_constant_value,
6258 require_constant_elements),
6259 constructor_elements);
6260 }
6261 else
6262 {
6263 /* Structure elements may require alignment.
6264 Do this, if necessary. */
6265 if (TREE_CODE (constructor_type) == RECORD_TYPE)
6266 {
6267 /* Advance to offset of this element. */
6268 if (! tree_int_cst_equal (constructor_bit_index,
6269 DECL_FIELD_BITPOS (field)))
6270 {
6271 /* By using unsigned arithmetic, the result will be
6272 correct even in case of overflows, if BITS_PER_UNIT
6273 is a power of two. */
6274 unsigned next = (TREE_INT_CST_LOW
6275 (DECL_FIELD_BITPOS (field))
6276 / (unsigned)BITS_PER_UNIT);
6277 unsigned here = (TREE_INT_CST_LOW
6278 (constructor_bit_index)
6279 / (unsigned)BITS_PER_UNIT);
6280
6281 assemble_zeros ((next - here)
6282 * (unsigned)BITS_PER_UNIT
6283 / (unsigned)BITS_PER_UNIT);
6284 }
6285 }
6286 output_constant (digest_init (type, value,
6287 require_constant_value,
6288 require_constant_elements),
6289 int_size_in_bytes (type));
6290
6291 /* For a record or union,
6292 keep track of end position of last field. */
6293 if (TREE_CODE (constructor_type) == RECORD_TYPE
6294 || TREE_CODE (constructor_type) == UNION_TYPE)
6295 {
6296 tree temp = size_binop (PLUS_EXPR, DECL_FIELD_BITPOS (field),
6297 DECL_SIZE (field));
6298 TREE_INT_CST_LOW (constructor_bit_index)
6299 = TREE_INT_CST_LOW (temp);
6300 TREE_INT_CST_HIGH (constructor_bit_index)
6301 = TREE_INT_CST_HIGH (temp);
6302 }
6303 }
6304 }
6305
6306 /* Advance the variable that indicates sequential elements output. */
6307 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6308 {
6309 tree tem = size_binop (PLUS_EXPR, constructor_unfilled_index,
6310 integer_one_node);
6311 TREE_INT_CST_LOW (constructor_unfilled_index)
6312 = TREE_INT_CST_LOW (tem);
6313 TREE_INT_CST_HIGH (constructor_unfilled_index)
6314 = TREE_INT_CST_HIGH (tem);
6315 }
6316 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6317 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
6318 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6319 constructor_unfilled_fields = 0;
6320
6321 /* Now output any pending elements which have become next. */
6322 if (pending)
6323 output_pending_init_elements (0);
6324 }
6325}
6326
6327/* Output any pending elements which have become next.
6328 As we output elements, constructor_unfilled_{fields,index}
6329 advances, which may cause other elements to become next;
6330 if so, they too are output.
6331
6332 If ALL is 0, we return when there are
6333 no more pending elements to output now.
6334
6335 If ALL is 1, we output space as necessary so that
6336 we can output all the pending elements. */
6337
6338static void
6339output_pending_init_elements (all)
6340 int all;
6341{
6342 struct init_node *elt = constructor_pending_elts;
6343 tree next;
6344
6345 retry:
6346
6347 /* Look thru the whole pending tree.
6348 If we find an element that should be output now,
6349 output it. Otherwise, set NEXT to the element
6350 that comes first among those still pending. */
6351
6352 next = 0;
6353 while (elt)
6354 {
6355 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6356 {
6357 if (tree_int_cst_equal (elt->purpose,
6358 constructor_unfilled_index))
6359 output_init_element (elt->value,
6360 TREE_TYPE (constructor_type),
6361 constructor_unfilled_index, 0);
6362 else if (tree_int_cst_lt (constructor_unfilled_index,
6363 elt->purpose))
6364 {
6365 /* Advance to the next smaller node. */
6366 if (elt->left)
6367 elt = elt->left;
6368 else
6369 {
6370 /* We have reached the smallest node bigger than the
6371 current unfilled index. Fill the space first. */
6372 next = elt->purpose;
6373 break;
6374 }
6375 }
6376 else
6377 {
6378 /* Advance to the next bigger node. */
6379 if (elt->right)
6380 elt = elt->right;
6381 else
6382 {
6383 /* We have reached the biggest node in a subtree. Find
6384 the parent of it, which is the next bigger node. */
6385 while (elt->parent && elt->parent->right == elt)
6386 elt = elt->parent;
6387 elt = elt->parent;
6388 if (elt && tree_int_cst_lt (constructor_unfilled_index,
6389 elt->purpose))
6390 {
6391 next = elt->purpose;
6392 break;
6393 }
6394 }
6395 }
6396 }
6397 else if (TREE_CODE (constructor_type) == RECORD_TYPE
6398 || TREE_CODE (constructor_type) == UNION_TYPE)
6399 {
6400 /* If the current record is complete we are done. */
6401 if (constructor_unfilled_fields == 0)
6402 break;
6403 if (elt->purpose == constructor_unfilled_fields)
6404 {
6405 output_init_element (elt->value,
6406 TREE_TYPE (constructor_unfilled_fields),
6407 constructor_unfilled_fields,
6408 0);
6409 }
6410 else if (tree_int_cst_lt (DECL_FIELD_BITPOS (constructor_unfilled_fields),
6411 DECL_FIELD_BITPOS (elt->purpose)))
6412 {
6413 /* Advance to the next smaller node. */
6414 if (elt->left)
6415 elt = elt->left;
6416 else
6417 {
6418 /* We have reached the smallest node bigger than the
6419 current unfilled field. Fill the space first. */
6420 next = elt->purpose;
6421 break;
6422 }
6423 }
6424 else
6425 {
6426 /* Advance to the next bigger node. */
6427 if (elt->right)
6428 elt = elt->right;
6429 else
6430 {
6431 /* We have reached the biggest node in a subtree. Find
6432 the parent of it, which is the next bigger node. */
6433 while (elt->parent && elt->parent->right == elt)
6434 elt = elt->parent;
6435 elt = elt->parent;
6436 if (elt
6437 && tree_int_cst_lt (DECL_FIELD_BITPOS (constructor_unfilled_fields),
6438 DECL_FIELD_BITPOS (elt->purpose)))
6439 {
6440 next = elt->purpose;
6441 break;
6442 }
6443 }
6444 }
6445 }
6446 }
6447
6448 /* Ordinarily return, but not if we want to output all
6449 and there are elements left. */
6450 if (! (all && next != 0))
6451 return;
6452
6453 /* Generate space up to the position of NEXT. */
6454 if (constructor_incremental)
6455 {
6456 tree filled;
6457 tree nextpos_tree = size_int (0);
6458
6459 if (TREE_CODE (constructor_type) == RECORD_TYPE
6460 || TREE_CODE (constructor_type) == UNION_TYPE)
6461 {
6462 tree tail;
6463 /* Find the last field written out, if any. */
6464 for (tail = TYPE_FIELDS (constructor_type); tail;
6465 tail = TREE_CHAIN (tail))
6466 if (TREE_CHAIN (tail) == constructor_unfilled_fields)
6467 break;
6468
6469 if (tail)
6470 /* Find the offset of the end of that field. */
6471 filled = size_binop (CEIL_DIV_EXPR,
6472 size_binop (PLUS_EXPR,
6473 DECL_FIELD_BITPOS (tail),
6474 DECL_SIZE (tail)),
6475 size_int (BITS_PER_UNIT));
6476 else
6477 filled = size_int (0);
6478
6479 nextpos_tree = size_binop (CEIL_DIV_EXPR,
6480 DECL_FIELD_BITPOS (next),
6481 size_int (BITS_PER_UNIT));
6482
6483 TREE_INT_CST_HIGH (constructor_bit_index)
6484 = TREE_INT_CST_HIGH (DECL_FIELD_BITPOS (next));
6485 TREE_INT_CST_LOW (constructor_bit_index)
6486 = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (next));
6487 constructor_unfilled_fields = next;
6488 }
6489 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6490 {
6491 filled = size_binop (MULT_EXPR, constructor_unfilled_index,
6492 size_in_bytes (TREE_TYPE (constructor_type)));
6493 nextpos_tree
6494 = size_binop (MULT_EXPR, next,
6495 size_in_bytes (TREE_TYPE (constructor_type)));
6496 TREE_INT_CST_LOW (constructor_unfilled_index)
6497 = TREE_INT_CST_LOW (next);
6498 TREE_INT_CST_HIGH (constructor_unfilled_index)
6499 = TREE_INT_CST_HIGH (next);
6500 }
6501 else
6502 filled = 0;
6503
6504 if (filled)
6505 {
6506 int nextpos = TREE_INT_CST_LOW (nextpos_tree);
6507
6508 assemble_zeros (nextpos - TREE_INT_CST_LOW (filled));
6509 }
6510 }
6511 else
6512 {
6513 /* If it's not incremental, just skip over the gap,
6514 so that after jumping to retry we will output the next
6515 successive element. */
6516 if (TREE_CODE (constructor_type) == RECORD_TYPE
6517 || TREE_CODE (constructor_type) == UNION_TYPE)
6518 constructor_unfilled_fields = next;
6519 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6520 {
6521 TREE_INT_CST_LOW (constructor_unfilled_index)
6522 = TREE_INT_CST_LOW (next);
6523 TREE_INT_CST_HIGH (constructor_unfilled_index)
6524 = TREE_INT_CST_HIGH (next);
6525 }
6526 }
6527
6528 /* ELT now points to the node in the pending tree with the next
6529 initializer to output. */
6530 goto retry;
6531}
6532
6533/* Add one non-braced element to the current constructor level.
6534 This adjusts the current position within the constructor's type.
6535 This may also start or terminate implicit levels
6536 to handle a partly-braced initializer.
6537
6538 Once this has found the correct level for the new element,
6539 it calls output_init_element.
6540
6541 Note: if we are incrementally outputting this constructor,
6542 this function may be called with a null argument
6543 representing a sub-constructor that was already incrementally output.
6544 When that happens, we output nothing, but we do the bookkeeping
6545 to skip past that element of the current constructor. */
6546
6547void
6548process_init_element (value)
6549 tree value;
6550{
6551 tree orig_value = value;
6552 int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
6553
6554 /* Handle superfluous braces around string cst as in
6555 char x[] = {"foo"}; */
6556 if (string_flag
6557 && constructor_type
6558 && TREE_CODE (constructor_type) == ARRAY_TYPE
6559 && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
6560 && integer_zerop (constructor_unfilled_index))
6561 {
6562 constructor_stack->replacement_value = value;
6563 return;
6564 }
6565
6566 if (constructor_stack->replacement_value != 0)
6567 {
| 6135 duplicate = 1;
6136 }
6137 }
6138 }
6139
6140 /* If this element doesn't come next in sequence,
6141 put it on constructor_pending_elts. */
6142 if (TREE_CODE (constructor_type) == ARRAY_TYPE
6143 && !tree_int_cst_equal (field, constructor_unfilled_index))
6144 {
6145 if (! duplicate)
6146 /* The copy_node is needed in case field is actually
6147 constructor_index, which is modified in place. */
6148 add_pending_init (copy_node (field),
6149 digest_init (type, value, require_constant_value,
6150 require_constant_elements));
6151 }
6152 else if (TREE_CODE (constructor_type) == RECORD_TYPE
6153 && field != constructor_unfilled_fields)
6154 {
6155 /* We do this for records but not for unions. In a union,
6156 no matter which field is specified, it can be initialized
6157 right away since it starts at the beginning of the union. */
6158 if (!duplicate)
6159 add_pending_init (field,
6160 digest_init (type, value, require_constant_value,
6161 require_constant_elements));
6162 }
6163 else
6164 {
6165 /* Otherwise, output this element either to
6166 constructor_elements or to the assembler file. */
6167
6168 if (!duplicate)
6169 {
6170 if (! constructor_incremental)
6171 {
6172 if (field && TREE_CODE (field) == INTEGER_CST)
6173 field = copy_node (field);
6174 constructor_elements
6175 = tree_cons (field, digest_init (type, value,
6176 require_constant_value,
6177 require_constant_elements),
6178 constructor_elements);
6179 }
6180 else
6181 {
6182 /* Structure elements may require alignment.
6183 Do this, if necessary. */
6184 if (TREE_CODE (constructor_type) == RECORD_TYPE)
6185 {
6186 /* Advance to offset of this element. */
6187 if (! tree_int_cst_equal (constructor_bit_index,
6188 DECL_FIELD_BITPOS (field)))
6189 {
6190 /* By using unsigned arithmetic, the result will be
6191 correct even in case of overflows, if BITS_PER_UNIT
6192 is a power of two. */
6193 unsigned next = (TREE_INT_CST_LOW
6194 (DECL_FIELD_BITPOS (field))
6195 / (unsigned)BITS_PER_UNIT);
6196 unsigned here = (TREE_INT_CST_LOW
6197 (constructor_bit_index)
6198 / (unsigned)BITS_PER_UNIT);
6199
6200 assemble_zeros ((next - here)
6201 * (unsigned)BITS_PER_UNIT
6202 / (unsigned)BITS_PER_UNIT);
6203 }
6204 }
6205 output_constant (digest_init (type, value,
6206 require_constant_value,
6207 require_constant_elements),
6208 int_size_in_bytes (type));
6209
6210 /* For a record or union,
6211 keep track of end position of last field. */
6212 if (TREE_CODE (constructor_type) == RECORD_TYPE
6213 || TREE_CODE (constructor_type) == UNION_TYPE)
6214 {
6215 tree temp = size_binop (PLUS_EXPR, DECL_FIELD_BITPOS (field),
6216 DECL_SIZE (field));
6217 TREE_INT_CST_LOW (constructor_bit_index)
6218 = TREE_INT_CST_LOW (temp);
6219 TREE_INT_CST_HIGH (constructor_bit_index)
6220 = TREE_INT_CST_HIGH (temp);
6221 }
6222 }
6223 }
6224
6225 /* Advance the variable that indicates sequential elements output. */
6226 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6227 {
6228 tree tem = size_binop (PLUS_EXPR, constructor_unfilled_index,
6229 integer_one_node);
6230 TREE_INT_CST_LOW (constructor_unfilled_index)
6231 = TREE_INT_CST_LOW (tem);
6232 TREE_INT_CST_HIGH (constructor_unfilled_index)
6233 = TREE_INT_CST_HIGH (tem);
6234 }
6235 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6236 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
6237 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6238 constructor_unfilled_fields = 0;
6239
6240 /* Now output any pending elements which have become next. */
6241 if (pending)
6242 output_pending_init_elements (0);
6243 }
6244}
6245
6246/* Output any pending elements which have become next.
6247 As we output elements, constructor_unfilled_{fields,index}
6248 advances, which may cause other elements to become next;
6249 if so, they too are output.
6250
6251 If ALL is 0, we return when there are
6252 no more pending elements to output now.
6253
6254 If ALL is 1, we output space as necessary so that
6255 we can output all the pending elements. */
6256
6257static void
6258output_pending_init_elements (all)
6259 int all;
6260{
6261 struct init_node *elt = constructor_pending_elts;
6262 tree next;
6263
6264 retry:
6265
6266 /* Look thru the whole pending tree.
6267 If we find an element that should be output now,
6268 output it. Otherwise, set NEXT to the element
6269 that comes first among those still pending. */
6270
6271 next = 0;
6272 while (elt)
6273 {
6274 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6275 {
6276 if (tree_int_cst_equal (elt->purpose,
6277 constructor_unfilled_index))
6278 output_init_element (elt->value,
6279 TREE_TYPE (constructor_type),
6280 constructor_unfilled_index, 0);
6281 else if (tree_int_cst_lt (constructor_unfilled_index,
6282 elt->purpose))
6283 {
6284 /* Advance to the next smaller node. */
6285 if (elt->left)
6286 elt = elt->left;
6287 else
6288 {
6289 /* We have reached the smallest node bigger than the
6290 current unfilled index. Fill the space first. */
6291 next = elt->purpose;
6292 break;
6293 }
6294 }
6295 else
6296 {
6297 /* Advance to the next bigger node. */
6298 if (elt->right)
6299 elt = elt->right;
6300 else
6301 {
6302 /* We have reached the biggest node in a subtree. Find
6303 the parent of it, which is the next bigger node. */
6304 while (elt->parent && elt->parent->right == elt)
6305 elt = elt->parent;
6306 elt = elt->parent;
6307 if (elt && tree_int_cst_lt (constructor_unfilled_index,
6308 elt->purpose))
6309 {
6310 next = elt->purpose;
6311 break;
6312 }
6313 }
6314 }
6315 }
6316 else if (TREE_CODE (constructor_type) == RECORD_TYPE
6317 || TREE_CODE (constructor_type) == UNION_TYPE)
6318 {
6319 /* If the current record is complete we are done. */
6320 if (constructor_unfilled_fields == 0)
6321 break;
6322 if (elt->purpose == constructor_unfilled_fields)
6323 {
6324 output_init_element (elt->value,
6325 TREE_TYPE (constructor_unfilled_fields),
6326 constructor_unfilled_fields,
6327 0);
6328 }
6329 else if (tree_int_cst_lt (DECL_FIELD_BITPOS (constructor_unfilled_fields),
6330 DECL_FIELD_BITPOS (elt->purpose)))
6331 {
6332 /* Advance to the next smaller node. */
6333 if (elt->left)
6334 elt = elt->left;
6335 else
6336 {
6337 /* We have reached the smallest node bigger than the
6338 current unfilled field. Fill the space first. */
6339 next = elt->purpose;
6340 break;
6341 }
6342 }
6343 else
6344 {
6345 /* Advance to the next bigger node. */
6346 if (elt->right)
6347 elt = elt->right;
6348 else
6349 {
6350 /* We have reached the biggest node in a subtree. Find
6351 the parent of it, which is the next bigger node. */
6352 while (elt->parent && elt->parent->right == elt)
6353 elt = elt->parent;
6354 elt = elt->parent;
6355 if (elt
6356 && tree_int_cst_lt (DECL_FIELD_BITPOS (constructor_unfilled_fields),
6357 DECL_FIELD_BITPOS (elt->purpose)))
6358 {
6359 next = elt->purpose;
6360 break;
6361 }
6362 }
6363 }
6364 }
6365 }
6366
6367 /* Ordinarily return, but not if we want to output all
6368 and there are elements left. */
6369 if (! (all && next != 0))
6370 return;
6371
6372 /* Generate space up to the position of NEXT. */
6373 if (constructor_incremental)
6374 {
6375 tree filled;
6376 tree nextpos_tree = size_int (0);
6377
6378 if (TREE_CODE (constructor_type) == RECORD_TYPE
6379 || TREE_CODE (constructor_type) == UNION_TYPE)
6380 {
6381 tree tail;
6382 /* Find the last field written out, if any. */
6383 for (tail = TYPE_FIELDS (constructor_type); tail;
6384 tail = TREE_CHAIN (tail))
6385 if (TREE_CHAIN (tail) == constructor_unfilled_fields)
6386 break;
6387
6388 if (tail)
6389 /* Find the offset of the end of that field. */
6390 filled = size_binop (CEIL_DIV_EXPR,
6391 size_binop (PLUS_EXPR,
6392 DECL_FIELD_BITPOS (tail),
6393 DECL_SIZE (tail)),
6394 size_int (BITS_PER_UNIT));
6395 else
6396 filled = size_int (0);
6397
6398 nextpos_tree = size_binop (CEIL_DIV_EXPR,
6399 DECL_FIELD_BITPOS (next),
6400 size_int (BITS_PER_UNIT));
6401
6402 TREE_INT_CST_HIGH (constructor_bit_index)
6403 = TREE_INT_CST_HIGH (DECL_FIELD_BITPOS (next));
6404 TREE_INT_CST_LOW (constructor_bit_index)
6405 = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (next));
6406 constructor_unfilled_fields = next;
6407 }
6408 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6409 {
6410 filled = size_binop (MULT_EXPR, constructor_unfilled_index,
6411 size_in_bytes (TREE_TYPE (constructor_type)));
6412 nextpos_tree
6413 = size_binop (MULT_EXPR, next,
6414 size_in_bytes (TREE_TYPE (constructor_type)));
6415 TREE_INT_CST_LOW (constructor_unfilled_index)
6416 = TREE_INT_CST_LOW (next);
6417 TREE_INT_CST_HIGH (constructor_unfilled_index)
6418 = TREE_INT_CST_HIGH (next);
6419 }
6420 else
6421 filled = 0;
6422
6423 if (filled)
6424 {
6425 int nextpos = TREE_INT_CST_LOW (nextpos_tree);
6426
6427 assemble_zeros (nextpos - TREE_INT_CST_LOW (filled));
6428 }
6429 }
6430 else
6431 {
6432 /* If it's not incremental, just skip over the gap,
6433 so that after jumping to retry we will output the next
6434 successive element. */
6435 if (TREE_CODE (constructor_type) == RECORD_TYPE
6436 || TREE_CODE (constructor_type) == UNION_TYPE)
6437 constructor_unfilled_fields = next;
6438 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6439 {
6440 TREE_INT_CST_LOW (constructor_unfilled_index)
6441 = TREE_INT_CST_LOW (next);
6442 TREE_INT_CST_HIGH (constructor_unfilled_index)
6443 = TREE_INT_CST_HIGH (next);
6444 }
6445 }
6446
6447 /* ELT now points to the node in the pending tree with the next
6448 initializer to output. */
6449 goto retry;
6450}
6451
6452/* Add one non-braced element to the current constructor level.
6453 This adjusts the current position within the constructor's type.
6454 This may also start or terminate implicit levels
6455 to handle a partly-braced initializer.
6456
6457 Once this has found the correct level for the new element,
6458 it calls output_init_element.
6459
6460 Note: if we are incrementally outputting this constructor,
6461 this function may be called with a null argument
6462 representing a sub-constructor that was already incrementally output.
6463 When that happens, we output nothing, but we do the bookkeeping
6464 to skip past that element of the current constructor. */
6465
6466void
6467process_init_element (value)
6468 tree value;
6469{
6470 tree orig_value = value;
6471 int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
6472
6473 /* Handle superfluous braces around string cst as in
6474 char x[] = {"foo"}; */
6475 if (string_flag
6476 && constructor_type
6477 && TREE_CODE (constructor_type) == ARRAY_TYPE
6478 && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
6479 && integer_zerop (constructor_unfilled_index))
6480 {
6481 constructor_stack->replacement_value = value;
6482 return;
6483 }
6484
6485 if (constructor_stack->replacement_value != 0)
6486 {
|
6568 error_init ("excess elements in struct initializer%s",
6569 " after `%s'", NULL_PTR);
| 6487 error_init ("excess elements in struct initializer");
|
6570 return;
6571 }
6572
6573 /* Ignore elements of a brace group if it is entirely superfluous
6574 and has already been diagnosed. */
6575 if (constructor_type == 0)
6576 return;
6577
6578 /* If we've exhausted any levels that didn't have braces,
6579 pop them now. */
6580 while (constructor_stack->implicit)
6581 {
6582 if ((TREE_CODE (constructor_type) == RECORD_TYPE
6583 || TREE_CODE (constructor_type) == UNION_TYPE)
6584 && constructor_fields == 0)
6585 process_init_element (pop_init_level (1));
6586 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6587 && (constructor_max_index == 0
6588 || tree_int_cst_lt (constructor_max_index,
6589 constructor_index)))
6590 process_init_element (pop_init_level (1));
6591 else
6592 break;
6593 }
6594
6595 while (1)
6596 {
6597 if (TREE_CODE (constructor_type) == RECORD_TYPE)
6598 {
6599 tree fieldtype;
6600 enum tree_code fieldcode;
6601
6602 if (constructor_fields == 0)
6603 {
| 6488 return;
6489 }
6490
6491 /* Ignore elements of a brace group if it is entirely superfluous
6492 and has already been diagnosed. */
6493 if (constructor_type == 0)
6494 return;
6495
6496 /* If we've exhausted any levels that didn't have braces,
6497 pop them now. */
6498 while (constructor_stack->implicit)
6499 {
6500 if ((TREE_CODE (constructor_type) == RECORD_TYPE
6501 || TREE_CODE (constructor_type) == UNION_TYPE)
6502 && constructor_fields == 0)
6503 process_init_element (pop_init_level (1));
6504 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6505 && (constructor_max_index == 0
6506 || tree_int_cst_lt (constructor_max_index,
6507 constructor_index)))
6508 process_init_element (pop_init_level (1));
6509 else
6510 break;
6511 }
6512
6513 while (1)
6514 {
6515 if (TREE_CODE (constructor_type) == RECORD_TYPE)
6516 {
6517 tree fieldtype;
6518 enum tree_code fieldcode;
6519
6520 if (constructor_fields == 0)
6521 {
|
6604 pedwarn_init ("excess elements in struct initializer%s",
6605 " after `%s'", NULL_PTR);
| 6522 pedwarn_init ("excess elements in struct initializer");
|
6606 break;
6607 }
6608
6609 fieldtype = TREE_TYPE (constructor_fields);
6610 if (fieldtype != error_mark_node)
6611 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6612 fieldcode = TREE_CODE (fieldtype);
6613
6614 /* Accept a string constant to initialize a subarray. */
6615 if (value != 0
6616 && fieldcode == ARRAY_TYPE
6617 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6618 && string_flag)
6619 value = orig_value;
6620 /* Otherwise, if we have come to a subaggregate,
6621 and we don't have an element of its type, push into it. */
6622 else if (value != 0 && !constructor_no_implicit
6623 && value != error_mark_node
6624 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6625 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6626 || fieldcode == UNION_TYPE))
6627 {
6628 push_init_level (1);
6629 continue;
6630 }
6631
6632 if (value)
6633 {
6634 push_member_name (constructor_fields);
6635 output_init_element (value, fieldtype, constructor_fields, 1);
6636 RESTORE_SPELLING_DEPTH (constructor_depth);
6637 }
6638 else
6639 /* Do the bookkeeping for an element that was
6640 directly output as a constructor. */
6641 {
6642 /* For a record, keep track of end position of last field. */
6643 tree temp = size_binop (PLUS_EXPR,
6644 DECL_FIELD_BITPOS (constructor_fields),
6645 DECL_SIZE (constructor_fields));
6646 TREE_INT_CST_LOW (constructor_bit_index)
6647 = TREE_INT_CST_LOW (temp);
6648 TREE_INT_CST_HIGH (constructor_bit_index)
6649 = TREE_INT_CST_HIGH (temp);
6650
6651 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6652 }
6653
6654 constructor_fields = TREE_CHAIN (constructor_fields);
6655 /* Skip any nameless bit fields at the beginning. */
6656 while (constructor_fields != 0
6657 && DECL_C_BIT_FIELD (constructor_fields)
6658 && DECL_NAME (constructor_fields) == 0)
6659 constructor_fields = TREE_CHAIN (constructor_fields);
6660 break;
6661 }
6662 if (TREE_CODE (constructor_type) == UNION_TYPE)
6663 {
6664 tree fieldtype;
6665 enum tree_code fieldcode;
6666
6667 if (constructor_fields == 0)
6668 {
| 6523 break;
6524 }
6525
6526 fieldtype = TREE_TYPE (constructor_fields);
6527 if (fieldtype != error_mark_node)
6528 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6529 fieldcode = TREE_CODE (fieldtype);
6530
6531 /* Accept a string constant to initialize a subarray. */
6532 if (value != 0
6533 && fieldcode == ARRAY_TYPE
6534 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6535 && string_flag)
6536 value = orig_value;
6537 /* Otherwise, if we have come to a subaggregate,
6538 and we don't have an element of its type, push into it. */
6539 else if (value != 0 && !constructor_no_implicit
6540 && value != error_mark_node
6541 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6542 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6543 || fieldcode == UNION_TYPE))
6544 {
6545 push_init_level (1);
6546 continue;
6547 }
6548
6549 if (value)
6550 {
6551 push_member_name (constructor_fields);
6552 output_init_element (value, fieldtype, constructor_fields, 1);
6553 RESTORE_SPELLING_DEPTH (constructor_depth);
6554 }
6555 else
6556 /* Do the bookkeeping for an element that was
6557 directly output as a constructor. */
6558 {
6559 /* For a record, keep track of end position of last field. */
6560 tree temp = size_binop (PLUS_EXPR,
6561 DECL_FIELD_BITPOS (constructor_fields),
6562 DECL_SIZE (constructor_fields));
6563 TREE_INT_CST_LOW (constructor_bit_index)
6564 = TREE_INT_CST_LOW (temp);
6565 TREE_INT_CST_HIGH (constructor_bit_index)
6566 = TREE_INT_CST_HIGH (temp);
6567
6568 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6569 }
6570
6571 constructor_fields = TREE_CHAIN (constructor_fields);
6572 /* Skip any nameless bit fields at the beginning. */
6573 while (constructor_fields != 0
6574 && DECL_C_BIT_FIELD (constructor_fields)
6575 && DECL_NAME (constructor_fields) == 0)
6576 constructor_fields = TREE_CHAIN (constructor_fields);
6577 break;
6578 }
6579 if (TREE_CODE (constructor_type) == UNION_TYPE)
6580 {
6581 tree fieldtype;
6582 enum tree_code fieldcode;
6583
6584 if (constructor_fields == 0)
6585 {
|
6669 pedwarn_init ("excess elements in union initializer%s",
6670 " after `%s'", NULL_PTR);
| 6586 pedwarn_init ("excess elements in union initializer");
|
6671 break;
6672 }
6673
6674 fieldtype = TREE_TYPE (constructor_fields);
6675 if (fieldtype != error_mark_node)
6676 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6677 fieldcode = TREE_CODE (fieldtype);
6678
6679 /* Accept a string constant to initialize a subarray. */
6680 if (value != 0
6681 && fieldcode == ARRAY_TYPE
6682 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6683 && string_flag)
6684 value = orig_value;
6685 /* Otherwise, if we have come to a subaggregate,
6686 and we don't have an element of its type, push into it. */
6687 else if (value != 0 && !constructor_no_implicit
6688 && value != error_mark_node
6689 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6690 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6691 || fieldcode == UNION_TYPE))
6692 {
6693 push_init_level (1);
6694 continue;
6695 }
6696
6697 if (value)
6698 {
6699 push_member_name (constructor_fields);
6700 output_init_element (value, fieldtype, constructor_fields, 1);
6701 RESTORE_SPELLING_DEPTH (constructor_depth);
6702 }
6703 else
6704 /* Do the bookkeeping for an element that was
6705 directly output as a constructor. */
6706 {
6707 TREE_INT_CST_LOW (constructor_bit_index)
6708 = TREE_INT_CST_LOW (DECL_SIZE (constructor_fields));
6709 TREE_INT_CST_HIGH (constructor_bit_index)
6710 = TREE_INT_CST_HIGH (DECL_SIZE (constructor_fields));
6711
6712 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6713 }
6714
6715 constructor_fields = 0;
6716 break;
6717 }
6718 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6719 {
6720 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6721 enum tree_code eltcode = TREE_CODE (elttype);
6722
6723 /* Accept a string constant to initialize a subarray. */
6724 if (value != 0
6725 && eltcode == ARRAY_TYPE
6726 && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
6727 && string_flag)
6728 value = orig_value;
6729 /* Otherwise, if we have come to a subaggregate,
6730 and we don't have an element of its type, push into it. */
6731 else if (value != 0 && !constructor_no_implicit
6732 && value != error_mark_node
6733 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
6734 && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6735 || eltcode == UNION_TYPE))
6736 {
6737 push_init_level (1);
6738 continue;
6739 }
6740
6741 if (constructor_max_index != 0
6742 && tree_int_cst_lt (constructor_max_index, constructor_index))
6743 {
| 6587 break;
6588 }
6589
6590 fieldtype = TREE_TYPE (constructor_fields);
6591 if (fieldtype != error_mark_node)
6592 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6593 fieldcode = TREE_CODE (fieldtype);
6594
6595 /* Accept a string constant to initialize a subarray. */
6596 if (value != 0
6597 && fieldcode == ARRAY_TYPE
6598 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6599 && string_flag)
6600 value = orig_value;
6601 /* Otherwise, if we have come to a subaggregate,
6602 and we don't have an element of its type, push into it. */
6603 else if (value != 0 && !constructor_no_implicit
6604 && value != error_mark_node
6605 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6606 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6607 || fieldcode == UNION_TYPE))
6608 {
6609 push_init_level (1);
6610 continue;
6611 }
6612
6613 if (value)
6614 {
6615 push_member_name (constructor_fields);
6616 output_init_element (value, fieldtype, constructor_fields, 1);
6617 RESTORE_SPELLING_DEPTH (constructor_depth);
6618 }
6619 else
6620 /* Do the bookkeeping for an element that was
6621 directly output as a constructor. */
6622 {
6623 TREE_INT_CST_LOW (constructor_bit_index)
6624 = TREE_INT_CST_LOW (DECL_SIZE (constructor_fields));
6625 TREE_INT_CST_HIGH (constructor_bit_index)
6626 = TREE_INT_CST_HIGH (DECL_SIZE (constructor_fields));
6627
6628 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6629 }
6630
6631 constructor_fields = 0;
6632 break;
6633 }
6634 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6635 {
6636 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6637 enum tree_code eltcode = TREE_CODE (elttype);
6638
6639 /* Accept a string constant to initialize a subarray. */
6640 if (value != 0
6641 && eltcode == ARRAY_TYPE
6642 && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
6643 && string_flag)
6644 value = orig_value;
6645 /* Otherwise, if we have come to a subaggregate,
6646 and we don't have an element of its type, push into it. */
6647 else if (value != 0 && !constructor_no_implicit
6648 && value != error_mark_node
6649 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
6650 && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6651 || eltcode == UNION_TYPE))
6652 {
6653 push_init_level (1);
6654 continue;
6655 }
6656
6657 if (constructor_max_index != 0
6658 && tree_int_cst_lt (constructor_max_index, constructor_index))
6659 {
|
6744 pedwarn_init ("excess elements in array initializer%s",
6745 " after `%s'", NULL_PTR);
| 6660 pedwarn_init ("excess elements in array initializer");
|
6746 break;
6747 }
6748
6749 /* In the case of [LO .. HI] = VALUE, only evaluate VALUE once. */
6750 if (constructor_range_end)
6751 {
6752 if (constructor_max_index != 0
6753 && tree_int_cst_lt (constructor_max_index,
6754 constructor_range_end))
6755 {
| 6661 break;
6662 }
6663
6664 /* In the case of [LO .. HI] = VALUE, only evaluate VALUE once. */
6665 if (constructor_range_end)
6666 {
6667 if (constructor_max_index != 0
6668 && tree_int_cst_lt (constructor_max_index,
6669 constructor_range_end))
6670 {
|
6756 pedwarn_init ("excess elements in array initializer%s",
6757 " after `%s'", NULL_PTR);
| 6671 pedwarn_init ("excess elements in array initializer");
|
6758 TREE_INT_CST_HIGH (constructor_range_end)
6759 = TREE_INT_CST_HIGH (constructor_max_index);
6760 TREE_INT_CST_LOW (constructor_range_end)
6761 = TREE_INT_CST_LOW (constructor_max_index);
6762 }
6763
6764 value = save_expr (value);
6765 }
6766
6767 /* Now output the actual element.
6768 Ordinarily, output once.
6769 If there is a range, repeat it till we advance past the range. */
6770 do
6771 {
6772 tree tem;
6773
6774 if (value)
6775 {
6776 push_array_bounds (TREE_INT_CST_LOW (constructor_index));
6777 output_init_element (value, elttype, constructor_index, 1);
6778 RESTORE_SPELLING_DEPTH (constructor_depth);
6779 }
6780
6781 tem = size_binop (PLUS_EXPR, constructor_index,
6782 integer_one_node);
6783 TREE_INT_CST_LOW (constructor_index) = TREE_INT_CST_LOW (tem);
6784 TREE_INT_CST_HIGH (constructor_index) = TREE_INT_CST_HIGH (tem);
6785
6786 if (!value)
6787 /* If we are doing the bookkeeping for an element that was
6788 directly output as a constructor,
6789 we must update constructor_unfilled_index. */
6790 {
6791 TREE_INT_CST_LOW (constructor_unfilled_index)
6792 = TREE_INT_CST_LOW (constructor_index);
6793 TREE_INT_CST_HIGH (constructor_unfilled_index)
6794 = TREE_INT_CST_HIGH (constructor_index);
6795 }
6796 }
6797 while (! (constructor_range_end == 0
6798 || tree_int_cst_lt (constructor_range_end,
6799 constructor_index)));
6800
6801 break;
6802 }
6803
6804 /* Handle the sole element allowed in a braced initializer
6805 for a scalar variable. */
6806 if (constructor_fields == 0)
6807 {
| 6672 TREE_INT_CST_HIGH (constructor_range_end)
6673 = TREE_INT_CST_HIGH (constructor_max_index);
6674 TREE_INT_CST_LOW (constructor_range_end)
6675 = TREE_INT_CST_LOW (constructor_max_index);
6676 }
6677
6678 value = save_expr (value);
6679 }
6680
6681 /* Now output the actual element.
6682 Ordinarily, output once.
6683 If there is a range, repeat it till we advance past the range. */
6684 do
6685 {
6686 tree tem;
6687
6688 if (value)
6689 {
6690 push_array_bounds (TREE_INT_CST_LOW (constructor_index));
6691 output_init_element (value, elttype, constructor_index, 1);
6692 RESTORE_SPELLING_DEPTH (constructor_depth);
6693 }
6694
6695 tem = size_binop (PLUS_EXPR, constructor_index,
6696 integer_one_node);
6697 TREE_INT_CST_LOW (constructor_index) = TREE_INT_CST_LOW (tem);
6698 TREE_INT_CST_HIGH (constructor_index) = TREE_INT_CST_HIGH (tem);
6699
6700 if (!value)
6701 /* If we are doing the bookkeeping for an element that was
6702 directly output as a constructor,
6703 we must update constructor_unfilled_index. */
6704 {
6705 TREE_INT_CST_LOW (constructor_unfilled_index)
6706 = TREE_INT_CST_LOW (constructor_index);
6707 TREE_INT_CST_HIGH (constructor_unfilled_index)
6708 = TREE_INT_CST_HIGH (constructor_index);
6709 }
6710 }
6711 while (! (constructor_range_end == 0
6712 || tree_int_cst_lt (constructor_range_end,
6713 constructor_index)));
6714
6715 break;
6716 }
6717
6718 /* Handle the sole element allowed in a braced initializer
6719 for a scalar variable. */
6720 if (constructor_fields == 0)
6721 {
|
6808 pedwarn_init ("excess elements in scalar initializer%s",
6809 " after `%s'", NULL_PTR);
| 6722 pedwarn_init ("excess elements in scalar initializer");
|
6810 break;
6811 }
6812
6813 if (value)
6814 output_init_element (value, constructor_type, NULL_TREE, 1);
6815 constructor_fields = 0;
6816 break;
6817 }
6818
6819 /* If the (lexically) previous elments are not now saved,
6820 we can discard the storage for them. */
6821 if (constructor_incremental && constructor_pending_elts == 0 && value != 0
6822 && constructor_stack == 0)
6823 clear_momentary ();
6824}
6825
6826/* Expand an ASM statement with operands, handling output operands
6827 that are not variables or INDIRECT_REFS by transforming such
6828 cases into cases that expand_asm_operands can handle.
6829
6830 Arguments are same as for expand_asm_operands. */
6831
6832void
6833c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6834 tree string, outputs, inputs, clobbers;
6835 int vol;
6836 char *filename;
6837 int line;
6838{
6839 int noutputs = list_length (outputs);
6840 register int i;
6841 /* o[I] is the place that output number I should be written. */
6842 register tree *o = (tree *) alloca (noutputs * sizeof (tree));
6843 register tree tail;
6844
6845 if (TREE_CODE (string) == ADDR_EXPR)
6846 string = TREE_OPERAND (string, 0);
6847 if (TREE_CODE (string) != STRING_CST)
6848 {
6849 error ("asm template is not a string constant");
6850 return;
6851 }
6852
6853 /* Record the contents of OUTPUTS before it is modified. */
6854 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6855 o[i] = TREE_VALUE (tail);
6856
6857 /* Perform default conversions on array and function inputs. */
6858 /* Don't do this for other types--
6859 it would screw up operands expected to be in memory. */
6860 for (i = 0, tail = inputs; tail; tail = TREE_CHAIN (tail), i++)
6861 if (TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == ARRAY_TYPE
6862 || TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == FUNCTION_TYPE)
6863 TREE_VALUE (tail) = default_conversion (TREE_VALUE (tail));
6864
6865 /* Generate the ASM_OPERANDS insn;
6866 store into the TREE_VALUEs of OUTPUTS some trees for
6867 where the values were actually stored. */
6868 expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
6869
6870 /* Copy all the intermediate outputs into the specified outputs. */
6871 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6872 {
6873 if (o[i] != TREE_VALUE (tail))
6874 {
6875 expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6876 NULL_RTX, VOIDmode, EXPAND_NORMAL);
6877 free_temp_slots ();
6878 }
6879 /* Detect modification of read-only values.
6880 (Otherwise done by build_modify_expr.) */
6881 else
6882 {
6883 tree type = TREE_TYPE (o[i]);
6884 if (TREE_READONLY (o[i])
6885 || TYPE_READONLY (type)
6886 || ((TREE_CODE (type) == RECORD_TYPE
6887 || TREE_CODE (type) == UNION_TYPE)
6888 && C_TYPE_FIELDS_READONLY (type)))
6889 readonly_warning (o[i], "modification by `asm'");
6890 }
6891 }
6892
6893 /* Those MODIFY_EXPRs could do autoincrements. */
6894 emit_queue ();
6895}
6896
6897/* Expand a C `return' statement.
6898 RETVAL is the expression for what to return,
6899 or a null pointer for `return;' with no value. */
6900
6901void
6902c_expand_return (retval)
6903 tree retval;
6904{
6905 tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6906
6907 if (TREE_THIS_VOLATILE (current_function_decl))
6908 warning ("function declared `noreturn' has a `return' statement");
6909
6910 if (!retval)
6911 {
6912 current_function_returns_null = 1;
6913 if (warn_return_type && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6914 warning ("`return' with no value, in function returning non-void");
6915 expand_null_return ();
6916 }
6917 else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6918 {
6919 current_function_returns_null = 1;
6920 if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6921 pedwarn ("`return' with a value, in function returning void");
6922 expand_return (retval);
6923 }
6924 else
6925 {
| 6723 break;
6724 }
6725
6726 if (value)
6727 output_init_element (value, constructor_type, NULL_TREE, 1);
6728 constructor_fields = 0;
6729 break;
6730 }
6731
6732 /* If the (lexically) previous elments are not now saved,
6733 we can discard the storage for them. */
6734 if (constructor_incremental && constructor_pending_elts == 0 && value != 0
6735 && constructor_stack == 0)
6736 clear_momentary ();
6737}
6738
6739/* Expand an ASM statement with operands, handling output operands
6740 that are not variables or INDIRECT_REFS by transforming such
6741 cases into cases that expand_asm_operands can handle.
6742
6743 Arguments are same as for expand_asm_operands. */
6744
6745void
6746c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
6747 tree string, outputs, inputs, clobbers;
6748 int vol;
6749 char *filename;
6750 int line;
6751{
6752 int noutputs = list_length (outputs);
6753 register int i;
6754 /* o[I] is the place that output number I should be written. */
6755 register tree *o = (tree *) alloca (noutputs * sizeof (tree));
6756 register tree tail;
6757
6758 if (TREE_CODE (string) == ADDR_EXPR)
6759 string = TREE_OPERAND (string, 0);
6760 if (TREE_CODE (string) != STRING_CST)
6761 {
6762 error ("asm template is not a string constant");
6763 return;
6764 }
6765
6766 /* Record the contents of OUTPUTS before it is modified. */
6767 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6768 o[i] = TREE_VALUE (tail);
6769
6770 /* Perform default conversions on array and function inputs. */
6771 /* Don't do this for other types--
6772 it would screw up operands expected to be in memory. */
6773 for (i = 0, tail = inputs; tail; tail = TREE_CHAIN (tail), i++)
6774 if (TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == ARRAY_TYPE
6775 || TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == FUNCTION_TYPE)
6776 TREE_VALUE (tail) = default_conversion (TREE_VALUE (tail));
6777
6778 /* Generate the ASM_OPERANDS insn;
6779 store into the TREE_VALUEs of OUTPUTS some trees for
6780 where the values were actually stored. */
6781 expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
6782
6783 /* Copy all the intermediate outputs into the specified outputs. */
6784 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6785 {
6786 if (o[i] != TREE_VALUE (tail))
6787 {
6788 expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6789 NULL_RTX, VOIDmode, EXPAND_NORMAL);
6790 free_temp_slots ();
6791 }
6792 /* Detect modification of read-only values.
6793 (Otherwise done by build_modify_expr.) */
6794 else
6795 {
6796 tree type = TREE_TYPE (o[i]);
6797 if (TREE_READONLY (o[i])
6798 || TYPE_READONLY (type)
6799 || ((TREE_CODE (type) == RECORD_TYPE
6800 || TREE_CODE (type) == UNION_TYPE)
6801 && C_TYPE_FIELDS_READONLY (type)))
6802 readonly_warning (o[i], "modification by `asm'");
6803 }
6804 }
6805
6806 /* Those MODIFY_EXPRs could do autoincrements. */
6807 emit_queue ();
6808}
6809
6810/* Expand a C `return' statement.
6811 RETVAL is the expression for what to return,
6812 or a null pointer for `return;' with no value. */
6813
6814void
6815c_expand_return (retval)
6816 tree retval;
6817{
6818 tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6819
6820 if (TREE_THIS_VOLATILE (current_function_decl))
6821 warning ("function declared `noreturn' has a `return' statement");
6822
6823 if (!retval)
6824 {
6825 current_function_returns_null = 1;
6826 if (warn_return_type && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6827 warning ("`return' with no value, in function returning non-void");
6828 expand_null_return ();
6829 }
6830 else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6831 {
6832 current_function_returns_null = 1;
6833 if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6834 pedwarn ("`return' with a value, in function returning void");
6835 expand_return (retval);
6836 }
6837 else
6838 {
|
6926 tree t = convert_for_assignment (valtype, retval, "return",
| 6839 tree t = convert_for_assignment (valtype, retval, _("return"),
|
6927 NULL_TREE, NULL_TREE, 0);
6928 tree res = DECL_RESULT (current_function_decl);
6929 tree inner;
6930
6931 if (t == error_mark_node)
6932 return;
6933
6934 inner = t = convert (TREE_TYPE (res), t);
6935
6936 /* Strip any conversions, additions, and subtractions, and see if
6937 we are returning the address of a local variable. Warn if so. */
6938 while (1)
6939 {
6940 switch (TREE_CODE (inner))
6941 {
6942 case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR:
6943 case PLUS_EXPR:
6944 inner = TREE_OPERAND (inner, 0);
6945 continue;
6946
6947 case MINUS_EXPR:
6948 /* If the second operand of the MINUS_EXPR has a pointer
6949 type (or is converted from it), this may be valid, so
6950 don't give a warning. */
6951 {
6952 tree op1 = TREE_OPERAND (inner, 1);
6953
6954 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6955 && (TREE_CODE (op1) == NOP_EXPR
6956 || TREE_CODE (op1) == NON_LVALUE_EXPR
6957 || TREE_CODE (op1) == CONVERT_EXPR))
6958 op1 = TREE_OPERAND (op1, 0);
6959
6960 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6961 break;
6962
6963 inner = TREE_OPERAND (inner, 0);
6964 continue;
6965 }
6966
6967 case ADDR_EXPR:
6968 inner = TREE_OPERAND (inner, 0);
6969
6970 while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
6971 inner = TREE_OPERAND (inner, 0);
6972
6973 if (TREE_CODE (inner) == VAR_DECL
6974 && ! DECL_EXTERNAL (inner)
6975 && ! TREE_STATIC (inner)
6976 && DECL_CONTEXT (inner) == current_function_decl)
6977 warning ("function returns address of local variable");
6978 break;
6979
6980 default:
6981 break;
6982 }
6983
6984 break;
6985 }
6986
6987 t = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
6988 TREE_SIDE_EFFECTS (t) = 1;
6989 expand_return (t);
6990 current_function_returns_value = 1;
6991 }
6992}
6993
6994/* Start a C switch statement, testing expression EXP.
6995 Return EXP if it is valid, an error node otherwise. */
6996
6997tree
6998c_expand_start_case (exp)
6999 tree exp;
7000{
7001 register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
7002 tree type = TREE_TYPE (exp);
7003
7004 if (code != INTEGER_TYPE && code != ENUMERAL_TYPE && code != ERROR_MARK)
7005 {
7006 error ("switch quantity not an integer");
7007 exp = error_mark_node;
7008 }
7009 else
7010 {
7011 tree index;
7012 type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
7013
7014 if (warn_traditional
7015 && (type == long_integer_type_node
7016 || type == long_unsigned_type_node))
7017 pedwarn ("`long' switch expression not converted to `int' in ANSI C");
7018
7019 exp = default_conversion (exp);
7020 type = TREE_TYPE (exp);
7021 index = get_unwidened (exp, NULL_TREE);
7022 /* We can't strip a conversion from a signed type to an unsigned,
7023 because if we did, int_fits_type_p would do the wrong thing
7024 when checking case values for being in range,
7025 and it's too hard to do the right thing. */
7026 if (TREE_UNSIGNED (TREE_TYPE (exp))
7027 == TREE_UNSIGNED (TREE_TYPE (index)))
7028 exp = index;
7029 }
7030
7031 expand_start_case (1, exp, type, "switch statement");
7032
7033 return exp;
7034}
| 6840 NULL_TREE, NULL_TREE, 0);
6841 tree res = DECL_RESULT (current_function_decl);
6842 tree inner;
6843
6844 if (t == error_mark_node)
6845 return;
6846
6847 inner = t = convert (TREE_TYPE (res), t);
6848
6849 /* Strip any conversions, additions, and subtractions, and see if
6850 we are returning the address of a local variable. Warn if so. */
6851 while (1)
6852 {
6853 switch (TREE_CODE (inner))
6854 {
6855 case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR:
6856 case PLUS_EXPR:
6857 inner = TREE_OPERAND (inner, 0);
6858 continue;
6859
6860 case MINUS_EXPR:
6861 /* If the second operand of the MINUS_EXPR has a pointer
6862 type (or is converted from it), this may be valid, so
6863 don't give a warning. */
6864 {
6865 tree op1 = TREE_OPERAND (inner, 1);
6866
6867 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6868 && (TREE_CODE (op1) == NOP_EXPR
6869 || TREE_CODE (op1) == NON_LVALUE_EXPR
6870 || TREE_CODE (op1) == CONVERT_EXPR))
6871 op1 = TREE_OPERAND (op1, 0);
6872
6873 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6874 break;
6875
6876 inner = TREE_OPERAND (inner, 0);
6877 continue;
6878 }
6879
6880 case ADDR_EXPR:
6881 inner = TREE_OPERAND (inner, 0);
6882
6883 while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
6884 inner = TREE_OPERAND (inner, 0);
6885
6886 if (TREE_CODE (inner) == VAR_DECL
6887 && ! DECL_EXTERNAL (inner)
6888 && ! TREE_STATIC (inner)
6889 && DECL_CONTEXT (inner) == current_function_decl)
6890 warning ("function returns address of local variable");
6891 break;
6892
6893 default:
6894 break;
6895 }
6896
6897 break;
6898 }
6899
6900 t = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
6901 TREE_SIDE_EFFECTS (t) = 1;
6902 expand_return (t);
6903 current_function_returns_value = 1;
6904 }
6905}
6906
6907/* Start a C switch statement, testing expression EXP.
6908 Return EXP if it is valid, an error node otherwise. */
6909
6910tree
6911c_expand_start_case (exp)
6912 tree exp;
6913{
6914 register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
6915 tree type = TREE_TYPE (exp);
6916
6917 if (code != INTEGER_TYPE && code != ENUMERAL_TYPE && code != ERROR_MARK)
6918 {
6919 error ("switch quantity not an integer");
6920 exp = error_mark_node;
6921 }
6922 else
6923 {
6924 tree index;
6925 type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
6926
6927 if (warn_traditional
6928 && (type == long_integer_type_node
6929 || type == long_unsigned_type_node))
6930 pedwarn ("`long' switch expression not converted to `int' in ANSI C");
6931
6932 exp = default_conversion (exp);
6933 type = TREE_TYPE (exp);
6934 index = get_unwidened (exp, NULL_TREE);
6935 /* We can't strip a conversion from a signed type to an unsigned,
6936 because if we did, int_fits_type_p would do the wrong thing
6937 when checking case values for being in range,
6938 and it's too hard to do the right thing. */
6939 if (TREE_UNSIGNED (TREE_TYPE (exp))
6940 == TREE_UNSIGNED (TREE_TYPE (index)))
6941 exp = index;
6942 }
6943
6944 expand_start_case (1, exp, type, "switch statement");
6945
6946 return exp;
6947}
|