1 /* Report error messages, build initializers, and perform
2 some front-end optimizations for C++ compiler.
3 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2004, 2005, 2006
5 Free Software Foundation, Inc.
6 Hacked by Michael Tiemann (tiemann@cygnus.com)
7
8 This file is part of GCC.
9
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, or (at your option)
13 any later version.
14
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING. If not, write to
22 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
23 Boston, MA 02110-1301, USA. */
24
25
26 /* This file is part of the C++ front end.
27 It contains routines to build C++ expressions given their operands,
28 including computing the types of the result, C and C++ specific error
29 checks, and some optimization. */
30
31 #include "config.h"
32 #include "system.h"
33 #include "coretypes.h"
34 #include "tm.h"
35 #include "tree.h"
36 #include "cp-tree.h"
37 #include "flags.h"
38 #include "toplev.h"
39 #include "output.h"
40 #include "diagnostic.h"
41
42 static tree
43 process_init_constructor (tree type, tree init);
44
45
46 /* Print an error message stemming from an attempt to use
47 BASETYPE as a base class for TYPE. */
48
49 tree
error_not_base_type(tree basetype,tree type)50 error_not_base_type (tree basetype, tree type)
51 {
52 if (TREE_CODE (basetype) == FUNCTION_DECL)
53 basetype = DECL_CONTEXT (basetype);
54 error ("type %qT is not a base type for type %qT", basetype, type);
55 return error_mark_node;
56 }
57
58 tree
binfo_or_else(tree base,tree type)59 binfo_or_else (tree base, tree type)
60 {
61 tree binfo = lookup_base (type, base, ba_unique, NULL);
62
63 if (binfo == error_mark_node)
64 return NULL_TREE;
65 else if (!binfo)
66 error_not_base_type (base, type);
67 return binfo;
68 }
69
70 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
71 value may not be changed thereafter. Thus, we emit hard errors for these,
72 rather than just pedwarns. If `SOFT' is 1, then we just pedwarn. (For
73 example, conversions to references.) */
74
75 void
readonly_error(tree arg,const char * string,int soft)76 readonly_error (tree arg, const char* string, int soft)
77 {
78 const char *fmt;
79 void (*fn) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
80
81 if (soft)
82 fn = pedwarn;
83 else
84 fn = error;
85
86 if (TREE_CODE (arg) == COMPONENT_REF)
87 {
88 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
89 fmt = "%s of data-member %qD in read-only structure";
90 else
91 fmt = "%s of read-only data-member %qD";
92 (*fn) (fmt, string, TREE_OPERAND (arg, 1));
93 }
94 else if (TREE_CODE (arg) == VAR_DECL)
95 {
96 if (DECL_LANG_SPECIFIC (arg)
97 && DECL_IN_AGGR_P (arg)
98 && !TREE_STATIC (arg))
99 fmt = "%s of constant field %qD";
100 else
101 fmt = "%s of read-only variable %qD";
102 (*fn) (fmt, string, arg);
103 }
104 else if (TREE_CODE (arg) == PARM_DECL)
105 (*fn) ("%s of read-only parameter %qD", string, arg);
106 else if (TREE_CODE (arg) == INDIRECT_REF
107 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE
108 && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL
109 || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
110 (*fn) ("%s of read-only reference %qD", string, TREE_OPERAND (arg, 0));
111 else if (TREE_CODE (arg) == RESULT_DECL)
112 (*fn) ("%s of read-only named return value %qD", string, arg);
113 else if (TREE_CODE (arg) == FUNCTION_DECL)
114 (*fn) ("%s of function %qD", string, arg);
115 else
116 (*fn) ("%s of read-only location", string);
117 }
118
119
120 /* Structure that holds information about declarations whose type was
121 incomplete and we could not check whether it was abstract or not. */
122
123 struct pending_abstract_type GTY((chain_next ("%h.next")))
124 {
125 /* Declaration which we are checking for abstractness. It is either
126 a DECL node, or an IDENTIFIER_NODE if we do not have a full
127 declaration available. */
128 tree decl;
129
130 /* Type which will be checked for abstractness. */
131 tree type;
132
133 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
134 because DECLs already carry locus information. */
135 location_t locus;
136
137 /* Link to the next element in list. */
138 struct pending_abstract_type* next;
139 };
140
141
142 /* Compute the hash value of the node VAL. This function is used by the
143 hash table abstract_pending_vars. */
144
145 static hashval_t
pat_calc_hash(const void * val)146 pat_calc_hash (const void* val)
147 {
148 const struct pending_abstract_type *pat =
149 (const struct pending_abstract_type *) val;
150 return (hashval_t) TYPE_UID (pat->type);
151 }
152
153
154 /* Compare node VAL1 with the type VAL2. This function is used by the
155 hash table abstract_pending_vars. */
156
157 static int
pat_compare(const void * val1,const void * val2)158 pat_compare (const void* val1, const void* val2)
159 {
160 const struct pending_abstract_type *pat1 =
161 (const struct pending_abstract_type *) val1;
162 tree type2 = (tree)val2;
163
164 return (pat1->type == type2);
165 }
166
167 /* Hash table that maintains pending_abstract_type nodes, for which we still
168 need to check for type abstractness. The key of the table is the type
169 of the declaration. */
170 static GTY ((param_is (struct pending_abstract_type)))
171 htab_t abstract_pending_vars = NULL;
172
173
174 /* This function is called after TYPE is completed, and will check if there
175 are pending declarations for which we still need to verify the abstractness
176 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
177 turned out to be incomplete. */
178
179 void
complete_type_check_abstract(tree type)180 complete_type_check_abstract (tree type)
181 {
182 void **slot;
183 struct pending_abstract_type *pat;
184 location_t cur_loc = input_location;
185
186 gcc_assert (COMPLETE_TYPE_P (type));
187
188 if (!abstract_pending_vars)
189 return;
190
191 /* Retrieve the list of pending declarations for this type. */
192 slot = htab_find_slot_with_hash (abstract_pending_vars, type,
193 (hashval_t)TYPE_UID (type), NO_INSERT);
194 if (!slot)
195 return;
196 pat = (struct pending_abstract_type*)*slot;
197 gcc_assert (pat);
198
199 /* If the type is not abstract, do not do anything. */
200 if (CLASSTYPE_PURE_VIRTUALS (type))
201 {
202 struct pending_abstract_type *prev = 0, *next;
203
204 /* Reverse the list to emit the errors in top-down order. */
205 for (; pat; pat = next)
206 {
207 next = pat->next;
208 pat->next = prev;
209 prev = pat;
210 }
211 pat = prev;
212
213 /* Go through the list, and call abstract_virtuals_error for each
214 element: it will issue a diagnostic if the type is abstract. */
215 while (pat)
216 {
217 gcc_assert (type == pat->type);
218
219 /* Tweak input_location so that the diagnostic appears at the correct
220 location. Notice that this is only needed if the decl is an
221 IDENTIFIER_NODE. */
222 input_location = pat->locus;
223 abstract_virtuals_error (pat->decl, pat->type);
224 pat = pat->next;
225 }
226 }
227
228 htab_clear_slot (abstract_pending_vars, slot);
229
230 input_location = cur_loc;
231 }
232
233
234 /* If TYPE has abstract virtual functions, issue an error about trying
235 to create an object of that type. DECL is the object declared, or
236 NULL_TREE if the declaration is unavailable. Returns 1 if an error
237 occurred; zero if all was well. */
238
239 int
abstract_virtuals_error(tree decl,tree type)240 abstract_virtuals_error (tree decl, tree type)
241 {
242 VEC(tree,gc) *pure;
243
244 /* This function applies only to classes. Any other entity can never
245 be abstract. */
246 if (!CLASS_TYPE_P (type))
247 return 0;
248
249 /* If the type is incomplete, we register it within a hash table,
250 so that we can check again once it is completed. This makes sense
251 only for objects for which we have a declaration or at least a
252 name. */
253 if (!COMPLETE_TYPE_P (type))
254 {
255 void **slot;
256 struct pending_abstract_type *pat;
257
258 gcc_assert (!decl || DECL_P (decl)
259 || TREE_CODE (decl) == IDENTIFIER_NODE);
260
261 if (!abstract_pending_vars)
262 abstract_pending_vars = htab_create_ggc (31, &pat_calc_hash,
263 &pat_compare, NULL);
264
265 slot = htab_find_slot_with_hash (abstract_pending_vars, type,
266 (hashval_t)TYPE_UID (type), INSERT);
267
268 pat = GGC_NEW (struct pending_abstract_type);
269 pat->type = type;
270 pat->decl = decl;
271 pat->locus = ((decl && DECL_P (decl))
272 ? DECL_SOURCE_LOCATION (decl)
273 : input_location);
274
275 pat->next = (struct pending_abstract_type *) *slot;
276 *slot = pat;
277
278 return 0;
279 }
280
281 if (!TYPE_SIZE (type))
282 /* TYPE is being defined, and during that time
283 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
284 return 0;
285
286 pure = CLASSTYPE_PURE_VIRTUALS (type);
287 if (!pure)
288 return 0;
289
290 if (decl)
291 {
292 if (TREE_CODE (decl) == RESULT_DECL)
293 return 0;
294
295 if (TREE_CODE (decl) == VAR_DECL)
296 error ("cannot declare variable %q+D to be of abstract "
297 "type %qT", decl, type);
298 else if (TREE_CODE (decl) == PARM_DECL)
299 error ("cannot declare parameter %q+D to be of abstract type %qT",
300 decl, type);
301 else if (TREE_CODE (decl) == FIELD_DECL)
302 error ("cannot declare field %q+D to be of abstract type %qT",
303 decl, type);
304 else if (TREE_CODE (decl) == FUNCTION_DECL
305 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
306 error ("invalid abstract return type for member function %q+#D", decl);
307 else if (TREE_CODE (decl) == FUNCTION_DECL)
308 error ("invalid abstract return type for function %q+#D", decl);
309 else if (TREE_CODE (decl) == IDENTIFIER_NODE)
310 /* Here we do not have location information. */
311 error ("invalid abstract type %qT for %qE", type, decl);
312 else
313 error ("invalid abstract type for %q+D", decl);
314 }
315 else
316 error ("cannot allocate an object of abstract type %qT", type);
317
318 /* Only go through this once. */
319 if (VEC_length (tree, pure))
320 {
321 unsigned ix;
322 tree fn;
323
324 inform ("%J because the following virtual functions are pure "
325 "within %qT:", TYPE_MAIN_DECL (type), type);
326
327 for (ix = 0; VEC_iterate (tree, pure, ix, fn); ix++)
328 inform ("\t%+#D", fn);
329 /* Now truncate the vector. This leaves it non-null, so we know
330 there are pure virtuals, but empty so we don't list them out
331 again. */
332 VEC_truncate (tree, pure, 0);
333 }
334 else
335 inform ("%J since type %qT has pure virtual functions",
336 TYPE_MAIN_DECL (type), type);
337
338 return 1;
339 }
340
341 /* Print an error message for invalid use of an incomplete type.
342 VALUE is the expression that was used (or 0 if that isn't known)
343 and TYPE is the type that was invalid. DIAG_TYPE indicates the
344 type of diagnostic: 0 for an error, 1 for a warning, 2 for a
345 pedwarn. */
346
347 void
cxx_incomplete_type_diagnostic(tree value,tree type,int diag_type)348 cxx_incomplete_type_diagnostic (tree value, tree type, int diag_type)
349 {
350 int decl = 0;
351 void (*p_msg) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
352
353 if (diag_type == 1)
354 p_msg = warning0;
355 else if (diag_type == 2)
356 p_msg = pedwarn;
357 else
358 p_msg = error;
359
360 /* Avoid duplicate error message. */
361 if (TREE_CODE (type) == ERROR_MARK)
362 return;
363
364 if (value != 0 && (TREE_CODE (value) == VAR_DECL
365 || TREE_CODE (value) == PARM_DECL
366 || TREE_CODE (value) == FIELD_DECL))
367 {
368 p_msg ("%q+D has incomplete type", value);
369 decl = 1;
370 }
371 retry:
372 /* We must print an error message. Be clever about what it says. */
373
374 switch (TREE_CODE (type))
375 {
376 case RECORD_TYPE:
377 case UNION_TYPE:
378 case ENUMERAL_TYPE:
379 if (!decl)
380 p_msg ("invalid use of incomplete type %q#T", type);
381 if (!TYPE_TEMPLATE_INFO (type))
382 p_msg ("forward declaration of %q+#T", type);
383 else
384 p_msg ("declaration of %q+#T", type);
385 break;
386
387 case VOID_TYPE:
388 p_msg ("invalid use of %qT", type);
389 break;
390
391 case ARRAY_TYPE:
392 if (TYPE_DOMAIN (type))
393 {
394 type = TREE_TYPE (type);
395 goto retry;
396 }
397 p_msg ("invalid use of array with unspecified bounds");
398 break;
399
400 case OFFSET_TYPE:
401 bad_member:
402 p_msg ("invalid use of member (did you forget the %<&%> ?)");
403 break;
404
405 case TEMPLATE_TYPE_PARM:
406 p_msg ("invalid use of template type parameter %qT", type);
407 break;
408
409 case BOUND_TEMPLATE_TEMPLATE_PARM:
410 p_msg ("invalid use of template template parameter %qT",
411 TYPE_NAME (type));
412 break;
413
414 case TYPENAME_TYPE:
415 p_msg ("invalid use of dependent type %qT", type);
416 break;
417
418 case UNKNOWN_TYPE:
419 if (value && TREE_CODE (value) == COMPONENT_REF)
420 goto bad_member;
421 else if (value && TREE_CODE (value) == ADDR_EXPR)
422 p_msg ("address of overloaded function with no contextual "
423 "type information");
424 else if (value && TREE_CODE (value) == OVERLOAD)
425 p_msg ("overloaded function with no contextual type information");
426 else
427 p_msg ("insufficient contextual information to determine type");
428 break;
429
430 default:
431 gcc_unreachable ();
432 }
433 }
434
435 /* Backward-compatibility interface to incomplete_type_diagnostic;
436 required by ../tree.c. */
437 #undef cxx_incomplete_type_error
438 void
cxx_incomplete_type_error(tree value,tree type)439 cxx_incomplete_type_error (tree value, tree type)
440 {
441 cxx_incomplete_type_diagnostic (value, type, 0);
442 }
443
444
445 /* The recursive part of split_nonconstant_init. DEST is an lvalue
446 expression to which INIT should be assigned. INIT is a CONSTRUCTOR. */
447
448 static void
split_nonconstant_init_1(tree dest,tree init)449 split_nonconstant_init_1 (tree dest, tree init)
450 {
451 unsigned HOST_WIDE_INT idx;
452 tree field_index, value;
453 tree type = TREE_TYPE (dest);
454 tree inner_type = NULL;
455 bool array_type_p = false;
456
457 switch (TREE_CODE (type))
458 {
459 case ARRAY_TYPE:
460 inner_type = TREE_TYPE (type);
461 array_type_p = true;
462 /* FALLTHRU */
463
464 case RECORD_TYPE:
465 case UNION_TYPE:
466 case QUAL_UNION_TYPE:
467 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,
468 field_index, value)
469 {
470 /* The current implementation of this algorithm assumes that
471 the field was set for all the elements. This is usually done
472 by process_init_constructor. */
473 gcc_assert (field_index);
474
475 if (!array_type_p)
476 inner_type = TREE_TYPE (field_index);
477
478 if (TREE_CODE (value) == CONSTRUCTOR)
479 {
480 tree sub;
481
482 if (array_type_p)
483 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
484 NULL_TREE, NULL_TREE);
485 else
486 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
487 NULL_TREE);
488
489 split_nonconstant_init_1 (sub, value);
490 }
491 else if (!initializer_constant_valid_p (value, inner_type))
492 {
493 tree code;
494 tree sub;
495
496 /* FIXME: Ordered removal is O(1) so the whole function is
497 worst-case quadratic. This could be fixed using an aside
498 bitmap to record which elements must be removed and remove
499 them all at the same time. Or by merging
500 split_non_constant_init into process_init_constructor_array,
501 that is separating constants from non-constants while building
502 the vector. */
503 VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init),
504 idx);
505 --idx;
506
507 if (array_type_p)
508 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
509 NULL_TREE, NULL_TREE);
510 else
511 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
512 NULL_TREE);
513
514 code = build2 (INIT_EXPR, inner_type, sub, value);
515 code = build_stmt (EXPR_STMT, code);
516 add_stmt (code);
517 continue;
518 }
519 }
520 break;
521
522 case VECTOR_TYPE:
523 if (!initializer_constant_valid_p (init, type))
524 {
525 tree code;
526 tree cons = copy_node (init);
527 CONSTRUCTOR_ELTS (init) = NULL;
528 code = build2 (MODIFY_EXPR, type, dest, cons);
529 code = build_stmt (EXPR_STMT, code);
530 add_stmt (code);
531 }
532 break;
533
534 default:
535 gcc_unreachable ();
536 }
537
538 /* The rest of the initializer is now a constant. */
539 TREE_CONSTANT (init) = 1;
540 }
541
542 /* A subroutine of store_init_value. Splits non-constant static
543 initializer INIT into a constant part and generates code to
544 perform the non-constant part of the initialization to DEST.
545 Returns the code for the runtime init. */
546
547 static tree
split_nonconstant_init(tree dest,tree init)548 split_nonconstant_init (tree dest, tree init)
549 {
550 tree code;
551
552 if (TREE_CODE (init) == CONSTRUCTOR)
553 {
554 code = push_stmt_list ();
555 split_nonconstant_init_1 (dest, init);
556 code = pop_stmt_list (code);
557 DECL_INITIAL (dest) = init;
558 TREE_READONLY (dest) = 0;
559 }
560 else
561 code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
562
563 return code;
564 }
565
566 /* Perform appropriate conversions on the initial value of a variable,
567 store it in the declaration DECL,
568 and print any error messages that are appropriate.
569 If the init is invalid, store an ERROR_MARK.
570
571 C++: Note that INIT might be a TREE_LIST, which would mean that it is
572 a base class initializer for some aggregate type, hopefully compatible
573 with DECL. If INIT is a single element, and DECL is an aggregate
574 type, we silently convert INIT into a TREE_LIST, allowing a constructor
575 to be called.
576
577 If INIT is a TREE_LIST and there is no constructor, turn INIT
578 into a CONSTRUCTOR and use standard initialization techniques.
579 Perhaps a warning should be generated?
580
581 Returns code to be executed if initialization could not be performed
582 for static variable. In that case, caller must emit the code. */
583
584 tree
store_init_value(tree decl,tree init)585 store_init_value (tree decl, tree init)
586 {
587 tree value, type;
588
589 /* If variable's type was invalidly declared, just ignore it. */
590
591 type = TREE_TYPE (decl);
592 if (TREE_CODE (type) == ERROR_MARK)
593 return NULL_TREE;
594
595 if (IS_AGGR_TYPE (type))
596 {
597 gcc_assert (TYPE_HAS_TRIVIAL_INIT_REF (type)
598 || TREE_CODE (init) == CONSTRUCTOR);
599
600 if (TREE_CODE (init) == TREE_LIST)
601 {
602 error ("constructor syntax used, but no constructor declared "
603 "for type %qT", type);
604 init = build_constructor_from_list (NULL_TREE, nreverse (init));
605 }
606 }
607 else if (TREE_CODE (init) == TREE_LIST
608 && TREE_TYPE (init) != unknown_type_node)
609 {
610 if (TREE_CODE (decl) == RESULT_DECL)
611 init = build_x_compound_expr_from_list (init,
612 "return value initializer");
613 else if (TREE_CODE (init) == TREE_LIST
614 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
615 {
616 error ("cannot initialize arrays using this syntax");
617 return NULL_TREE;
618 }
619 else
620 /* We get here with code like `int a (2);' */
621 init = build_x_compound_expr_from_list (init, "initializer");
622 }
623
624 /* End of special C++ code. */
625
626 /* Digest the specified initializer into an expression. */
627 value = digest_init (type, init);
628 /* If the initializer is not a constant, fill in DECL_INITIAL with
629 the bits that are constant, and then return an expression that
630 will perform the dynamic initialization. */
631 if (value != error_mark_node
632 && (TREE_SIDE_EFFECTS (value)
633 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
634 return split_nonconstant_init (decl, value);
635 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
636 is an automatic variable, the middle end will turn this into a
637 dynamic initialization later. */
638 DECL_INITIAL (decl) = value;
639 return NULL_TREE;
640 }
641
642
643 /* Process the initializer INIT for a variable of type TYPE, emitting
644 diagnostics for invalid initializers and converting the initializer as
645 appropriate.
646
647 For aggregate types, it assumes that reshape_init has already run, thus the
648 initializer will have the right shape (brace elision has been undone). */
649
650 tree
digest_init(tree type,tree init)651 digest_init (tree type, tree init)
652 {
653 enum tree_code code = TREE_CODE (type);
654
655 if (init == error_mark_node)
656 return error_mark_node;
657
658 gcc_assert (init);
659
660 /* We must strip the outermost array type when completing the type,
661 because the its bounds might be incomplete at the moment. */
662 if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
663 ? TREE_TYPE (type) : type, NULL_TREE))
664 return error_mark_node;
665
666 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
667 (g++.old-deja/g++.law/casts2.C). */
668 if (TREE_CODE (init) == NON_LVALUE_EXPR)
669 init = TREE_OPERAND (init, 0);
670
671 /* Initialization of an array of chars from a string constant. The initializer
672 can be optionally enclosed in braces, but reshape_init has already removed
673 them if they were present. */
674 if (code == ARRAY_TYPE)
675 {
676 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
677 if (char_type_p (typ1)
678 /*&& init */
679 && TREE_CODE (init) == STRING_CST)
680 {
681 tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
682
683 if (char_type != char_type_node
684 && TYPE_PRECISION (typ1) == BITS_PER_UNIT)
685 {
686 error ("char-array initialized from wide string");
687 return error_mark_node;
688 }
689 if (char_type == char_type_node
690 && TYPE_PRECISION (typ1) != BITS_PER_UNIT)
691 {
692 error ("int-array initialized from non-wide string");
693 return error_mark_node;
694 }
695
696 TREE_TYPE (init) = type;
697 if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type)))
698 {
699 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
700 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
701 /* In C it is ok to subtract 1 from the length of the string
702 because it's ok to ignore the terminating null char that is
703 counted in the length of the constant, but in C++ this would
704 be invalid. */
705 if (size < TREE_STRING_LENGTH (init))
706 pedwarn ("initializer-string for array of chars is too long");
707 }
708 return init;
709 }
710 }
711
712 /* Handle scalar types (including conversions) and references. */
713 if (TREE_CODE (type) != COMPLEX_TYPE
714 && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE))
715 return convert_for_initialization (0, type, init, LOOKUP_NORMAL,
716 "initialization", NULL_TREE, 0);
717
718 /* Come here only for aggregates: records, arrays, unions, complex numbers
719 and vectors. */
720 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
721 || TREE_CODE (type) == VECTOR_TYPE
722 || TREE_CODE (type) == RECORD_TYPE
723 || TREE_CODE (type) == UNION_TYPE
724 || TREE_CODE (type) == COMPLEX_TYPE);
725
726 if (BRACE_ENCLOSED_INITIALIZER_P (init))
727 return process_init_constructor (type, init);
728 else
729 {
730 if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE)
731 {
732 error ("cannot initialize aggregate of type %qT with "
733 "a compound literal", type);
734
735 return error_mark_node;
736 }
737
738 if (TREE_CODE (type) == ARRAY_TYPE
739 && TREE_CODE (init) != CONSTRUCTOR)
740 {
741 error ("array must be initialized with a brace-enclosed"
742 " initializer");
743 return error_mark_node;
744 }
745
746 return convert_for_initialization (NULL_TREE, type, init,
747 LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING,
748 "initialization", NULL_TREE, 0);
749 }
750 }
751
752
753 /* Set of flags used within process_init_constructor to describe the
754 initializers. */
755 #define PICFLAG_ERRONEOUS 1
756 #define PICFLAG_NOT_ALL_CONSTANT 2
757 #define PICFLAG_NOT_ALL_SIMPLE 4
758
759 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
760 describe it. */
761
762 static int
picflag_from_initializer(tree init)763 picflag_from_initializer (tree init)
764 {
765 if (init == error_mark_node)
766 return PICFLAG_ERRONEOUS;
767 else if (!TREE_CONSTANT (init))
768 return PICFLAG_NOT_ALL_CONSTANT;
769 else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
770 return PICFLAG_NOT_ALL_SIMPLE;
771 return 0;
772 }
773
774 /* Subroutine of process_init_constructor, which will process an initializer
775 INIT for a array or vector of type TYPE. Returns the flags (PICFLAG_*) which
776 describe the initializers. */
777
778 static int
process_init_constructor_array(tree type,tree init)779 process_init_constructor_array (tree type, tree init)
780 {
781 unsigned HOST_WIDE_INT i, len = 0;
782 int flags = 0;
783 bool unbounded = false;
784 constructor_elt *ce;
785 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init);
786
787 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
788 || TREE_CODE (type) == VECTOR_TYPE);
789
790 if (TREE_CODE (type) == ARRAY_TYPE)
791 {
792 tree domain = TYPE_DOMAIN (type);
793 if (domain)
794 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
795 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
796 + 1);
797 else
798 unbounded = true; /* Take as many as there are. */
799 }
800 else
801 /* Vectors are like simple fixed-size arrays. */
802 len = TYPE_VECTOR_SUBPARTS (type);
803
804 /* There cannot be more initializers than needed as otherwise
805 reshape_init would have already rejected the initializer. */
806 if (!unbounded)
807 gcc_assert (VEC_length (constructor_elt, v) <= len);
808
809 for (i = 0; VEC_iterate (constructor_elt, v, i, ce); ++i)
810 {
811 if (ce->index)
812 {
813 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST);
814 if (compare_tree_int (ce->index, i) != 0)
815 {
816 ce->value = error_mark_node;
817 sorry ("non-trivial designated initializers not supported");
818 }
819 }
820 else
821 ce->index = size_int (i);
822 gcc_assert (ce->value);
823 ce->value = digest_init (TREE_TYPE (type), ce->value);
824
825 if (ce->value != error_mark_node)
826 gcc_assert (same_type_ignoring_top_level_qualifiers_p
827 (TREE_TYPE (type), TREE_TYPE (ce->value)));
828
829 flags |= picflag_from_initializer (ce->value);
830 }
831
832 /* No more initializers. If the array is unbounded, we are done. Otherwise,
833 we must add initializers ourselves. */
834 if (!unbounded)
835 for (; i < len; ++i)
836 {
837 tree next;
838
839 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
840 {
841 /* If this type needs constructors run for default-initialization,
842 we can't rely on the backend to do it for us, so build up
843 TARGET_EXPRs. If the type in question is a class, just build
844 one up; if it's an array, recurse. */
845 if (IS_AGGR_TYPE (TREE_TYPE (type)))
846 next = build_functional_cast (TREE_TYPE (type), NULL_TREE);
847 else
848 next = build_constructor (NULL_TREE, NULL);
849 next = digest_init (TREE_TYPE (type), next);
850 }
851 else if (!zero_init_p (TREE_TYPE (type)))
852 next = build_zero_init (TREE_TYPE (type),
853 /*nelts=*/NULL_TREE,
854 /*static_storage_p=*/false);
855 else
856 /* The default zero-initialization is fine for us; don't
857 add anything to the CONSTRUCTOR. */
858 break;
859
860 flags |= picflag_from_initializer (next);
861 CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
862 }
863
864 CONSTRUCTOR_ELTS (init) = v;
865 return flags;
866 }
867
868 /* Subroutine of process_init_constructor, which will process an initializer
869 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
870 the initializers. */
871
872 static int
process_init_constructor_record(tree type,tree init)873 process_init_constructor_record (tree type, tree init)
874 {
875 VEC(constructor_elt,gc) *v = NULL;
876 int flags = 0;
877 tree field;
878 unsigned HOST_WIDE_INT idx = 0;
879
880 gcc_assert (TREE_CODE (type) == RECORD_TYPE);
881 gcc_assert (!CLASSTYPE_VBASECLASSES (type));
882 gcc_assert (!TYPE_BINFO (type)
883 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
884 gcc_assert (!TYPE_POLYMORPHIC_P (type));
885
886 /* Generally, we will always have an index for each initializer (which is
887 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
888 reshape_init. So we need to handle both cases. */
889 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
890 {
891 tree next;
892
893 if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field))
894 {
895 flags |= picflag_from_initializer (integer_zero_node);
896 CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node);
897 continue;
898 }
899
900 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
901 continue;
902
903 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
904 {
905 constructor_elt *ce = VEC_index (constructor_elt,
906 CONSTRUCTOR_ELTS (init), idx);
907 if (ce->index)
908 {
909 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
910 latter case can happen in templates where lookup has to be
911 deferred. */
912 gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
913 || TREE_CODE (ce->index) == IDENTIFIER_NODE);
914 if (ce->index != field
915 && ce->index != DECL_NAME (field))
916 {
917 ce->value = error_mark_node;
918 sorry ("non-trivial designated initializers not supported");
919 }
920 }
921
922 gcc_assert (ce->value);
923 next = digest_init (TREE_TYPE (field), ce->value);
924 ++idx;
925 }
926 else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
927 {
928 /* If this type needs constructors run for
929 default-initialization, we can't rely on the backend to do it
930 for us, so build up TARGET_EXPRs. If the type in question is
931 a class, just build one up; if it's an array, recurse. */
932 if (IS_AGGR_TYPE (TREE_TYPE (field)))
933 next = build_functional_cast (TREE_TYPE (field), NULL_TREE);
934 else
935 next = build_constructor (NULL_TREE, NULL);
936
937 next = digest_init (TREE_TYPE (field), next);
938
939 /* Warn when some struct elements are implicitly initialized. */
940 warning (OPT_Wmissing_field_initializers,
941 "missing initializer for member %qD", field);
942 }
943 else
944 {
945 if (TREE_READONLY (field))
946 error ("uninitialized const member %qD", field);
947 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
948 error ("member %qD with uninitialized const fields", field);
949 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
950 error ("member %qD is uninitialized reference", field);
951
952 /* Warn when some struct elements are implicitly initialized
953 to zero. */
954 warning (OPT_Wmissing_field_initializers,
955 "missing initializer for member %qD", field);
956
957 if (!zero_init_p (TREE_TYPE (field)))
958 next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
959 /*static_storage_p=*/false);
960 else
961 /* The default zero-initialization is fine for us; don't
962 add anything to the CONSTRUCTOR. */
963 continue;
964 }
965
966 flags |= picflag_from_initializer (next);
967 CONSTRUCTOR_APPEND_ELT (v, field, next);
968 }
969
970 CONSTRUCTOR_ELTS (init) = v;
971 return flags;
972 }
973
974 /* Subroutine of process_init_constructor, which will process a single
975 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
976 which describe the initializer. */
977
978 static int
process_init_constructor_union(tree type,tree init)979 process_init_constructor_union (tree type, tree init)
980 {
981 constructor_elt *ce;
982
983 /* If the initializer was empty, use default zero initialization. */
984 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
985 return 0;
986
987 gcc_assert (VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)) == 1);
988 ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0);
989
990 /* If this element specifies a field, initialize via that field. */
991 if (ce->index)
992 {
993 if (TREE_CODE (ce->index) == FIELD_DECL)
994 ;
995 else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
996 {
997 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
998 tree name = ce->index;
999 tree field;
1000 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1001 if (DECL_NAME (field) == name)
1002 break;
1003 if (!field)
1004 {
1005 error ("no field %qD found in union being initialized", field);
1006 ce->value = error_mark_node;
1007 }
1008 ce->index = field;
1009 }
1010 else
1011 {
1012 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
1013 || TREE_CODE (ce->index) == RANGE_EXPR);
1014 error ("index value instead of field name in union initializer");
1015 ce->value = error_mark_node;
1016 }
1017 }
1018 else
1019 {
1020 /* Find the first named field. ANSI decided in September 1990
1021 that only named fields count here. */
1022 tree field = TYPE_FIELDS (type);
1023 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1024 field = TREE_CHAIN (field);
1025 gcc_assert (field);
1026 ce->index = field;
1027 }
1028
1029 if (ce->value && ce->value != error_mark_node)
1030 ce->value = digest_init (TREE_TYPE (ce->index), ce->value);
1031
1032 return picflag_from_initializer (ce->value);
1033 }
1034
1035 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1036 constructor is a brace-enclosed initializer, and will be modified in-place.
1037
1038 Each element is converted to the right type through digest_init, and
1039 missing initializers are added following the language rules (zero-padding,
1040 etc.).
1041
1042 After the execution, the initializer will have TREE_CONSTANT if all elts are
1043 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1044 constants that the assembler and linker can compute them.
1045
1046 The function returns the initializer itself, or error_mark_node in case
1047 of error. */
1048
1049 static tree
process_init_constructor(tree type,tree init)1050 process_init_constructor (tree type, tree init)
1051 {
1052 int flags;
1053
1054 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
1055
1056 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
1057 flags = process_init_constructor_array (type, init);
1058 else if (TREE_CODE (type) == RECORD_TYPE)
1059 flags = process_init_constructor_record (type, init);
1060 else if (TREE_CODE (type) == UNION_TYPE)
1061 flags = process_init_constructor_union (type, init);
1062 else
1063 gcc_unreachable ();
1064
1065 if (flags & PICFLAG_ERRONEOUS)
1066 return error_mark_node;
1067
1068 TREE_TYPE (init) = type;
1069 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1070 cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
1071 if (!(flags & PICFLAG_NOT_ALL_CONSTANT))
1072 {
1073 TREE_CONSTANT (init) = 1;
1074 TREE_INVARIANT (init) = 1;
1075 if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
1076 TREE_STATIC (init) = 1;
1077 }
1078 return init;
1079 }
1080
1081 /* Given a structure or union value DATUM, construct and return
1082 the structure or union component which results from narrowing
1083 that value to the base specified in BASETYPE. For example, given the
1084 hierarchy
1085
1086 class L { int ii; };
1087 class A : L { ... };
1088 class B : L { ... };
1089 class C : A, B { ... };
1090
1091 and the declaration
1092
1093 C x;
1094
1095 then the expression
1096
1097 x.A::ii refers to the ii member of the L part of
1098 the A part of the C object named by X. In this case,
1099 DATUM would be x, and BASETYPE would be A.
1100
1101 I used to think that this was nonconformant, that the standard specified
1102 that first we look up ii in A, then convert x to an L& and pull out the
1103 ii part. But in fact, it does say that we convert x to an A&; A here
1104 is known as the "naming class". (jason 2000-12-19)
1105
1106 BINFO_P points to a variable initialized either to NULL_TREE or to the
1107 binfo for the specific base subobject we want to convert to. */
1108
1109 tree
build_scoped_ref(tree datum,tree basetype,tree * binfo_p)1110 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1111 {
1112 tree binfo;
1113
1114 if (datum == error_mark_node)
1115 return error_mark_node;
1116 if (*binfo_p)
1117 binfo = *binfo_p;
1118 else
1119 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1120
1121 if (!binfo || binfo == error_mark_node)
1122 {
1123 *binfo_p = NULL_TREE;
1124 if (!binfo)
1125 error_not_base_type (basetype, TREE_TYPE (datum));
1126 return error_mark_node;
1127 }
1128
1129 *binfo_p = binfo;
1130 return build_base_path (PLUS_EXPR, datum, binfo, 1);
1131 }
1132
1133 /* Build a reference to an object specified by the C++ `->' operator.
1134 Usually this just involves dereferencing the object, but if the
1135 `->' operator is overloaded, then such overloads must be
1136 performed until an object which does not have the `->' operator
1137 overloaded is found. An error is reported when circular pointer
1138 delegation is detected. */
1139
1140 tree
build_x_arrow(tree expr)1141 build_x_arrow (tree expr)
1142 {
1143 tree orig_expr = expr;
1144 tree types_memoized = NULL_TREE;
1145 tree type = TREE_TYPE (expr);
1146 tree last_rval = NULL_TREE;
1147
1148 if (type == error_mark_node)
1149 return error_mark_node;
1150
1151 if (processing_template_decl)
1152 {
1153 if (type_dependent_expression_p (expr))
1154 return build_min_nt (ARROW_EXPR, expr);
1155 expr = build_non_dependent_expr (expr);
1156 }
1157
1158 if (IS_AGGR_TYPE (type))
1159 {
1160 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1161 NULL_TREE, NULL_TREE,
1162 /*overloaded_p=*/NULL)))
1163 {
1164 if (expr == error_mark_node)
1165 return error_mark_node;
1166
1167 if (value_member (TREE_TYPE (expr), types_memoized))
1168 {
1169 error ("circular pointer delegation detected");
1170 return error_mark_node;
1171 }
1172 else
1173 {
1174 types_memoized = tree_cons (NULL_TREE, TREE_TYPE (expr),
1175 types_memoized);
1176 }
1177 last_rval = expr;
1178 }
1179
1180 if (last_rval == NULL_TREE)
1181 {
1182 error ("base operand of %<->%> has non-pointer type %qT", type);
1183 return error_mark_node;
1184 }
1185
1186 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1187 last_rval = convert_from_reference (last_rval);
1188 }
1189 else
1190 last_rval = decay_conversion (expr);
1191
1192 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1193 {
1194 if (processing_template_decl)
1195 {
1196 expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr);
1197 /* It will be dereferenced. */
1198 TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval));
1199 return expr;
1200 }
1201
1202 return build_indirect_ref (last_rval, NULL);
1203 }
1204
1205 if (types_memoized)
1206 error ("result of %<operator->()%> yields non-pointer result");
1207 else
1208 error ("base operand of %<->%> is not a pointer");
1209 return error_mark_node;
1210 }
1211
1212 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1213 already been checked out to be of aggregate type. */
1214
1215 tree
build_m_component_ref(tree datum,tree component)1216 build_m_component_ref (tree datum, tree component)
1217 {
1218 tree ptrmem_type;
1219 tree objtype;
1220 tree type;
1221 tree binfo;
1222 tree ctype;
1223
1224 if (error_operand_p (datum) || error_operand_p (component))
1225 return error_mark_node;
1226
1227 ptrmem_type = TREE_TYPE (component);
1228 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1229 {
1230 error ("%qE cannot be used as a member pointer, since it is of "
1231 "type %qT",
1232 component, ptrmem_type);
1233 return error_mark_node;
1234 }
1235
1236 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1237 if (! IS_AGGR_TYPE (objtype))
1238 {
1239 error ("cannot apply member pointer %qE to %qE, which is of "
1240 "non-class type %qT",
1241 component, datum, objtype);
1242 return error_mark_node;
1243 }
1244
1245 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1246 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1247
1248 if (!COMPLETE_TYPE_P (ctype))
1249 {
1250 if (!same_type_p (ctype, objtype))
1251 goto mismatch;
1252 binfo = NULL;
1253 }
1254 else
1255 {
1256 binfo = lookup_base (objtype, ctype, ba_check, NULL);
1257
1258 if (!binfo)
1259 {
1260 mismatch:
1261 error ("pointer to member type %qT incompatible with object "
1262 "type %qT",
1263 type, objtype);
1264 return error_mark_node;
1265 }
1266 else if (binfo == error_mark_node)
1267 return error_mark_node;
1268 }
1269
1270 if (TYPE_PTRMEM_P (ptrmem_type))
1271 {
1272 /* Compute the type of the field, as described in [expr.ref].
1273 There's no such thing as a mutable pointer-to-member, so
1274 things are not as complex as they are for references to
1275 non-static data members. */
1276 type = cp_build_qualified_type (type,
1277 (cp_type_quals (type)
1278 | cp_type_quals (TREE_TYPE (datum))));
1279
1280 datum = build_address (datum);
1281
1282 /* Convert object to the correct base. */
1283 if (binfo)
1284 datum = build_base_path (PLUS_EXPR, datum, binfo, 1);
1285
1286 /* Build an expression for "object + offset" where offset is the
1287 value stored in the pointer-to-data-member. */
1288 datum = build2 (PLUS_EXPR, build_pointer_type (type),
1289 datum, build_nop (ptrdiff_type_node, component));
1290 return build_indirect_ref (datum, 0);
1291 }
1292 else
1293 return build2 (OFFSET_REF, type, datum, component);
1294 }
1295
1296 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1297
1298 tree
build_functional_cast(tree exp,tree parms)1299 build_functional_cast (tree exp, tree parms)
1300 {
1301 /* This is either a call to a constructor,
1302 or a C cast in C++'s `functional' notation. */
1303 tree type;
1304
1305 if (exp == error_mark_node || parms == error_mark_node)
1306 return error_mark_node;
1307
1308 if (TREE_CODE (exp) == TYPE_DECL)
1309 type = TREE_TYPE (exp);
1310 else
1311 type = exp;
1312
1313 if (processing_template_decl)
1314 {
1315 tree t = build_min (CAST_EXPR, type, parms);
1316 /* We don't know if it will or will not have side effects. */
1317 TREE_SIDE_EFFECTS (t) = 1;
1318 return t;
1319 }
1320
1321 if (! IS_AGGR_TYPE (type))
1322 {
1323 if (parms == NULL_TREE)
1324 return cp_convert (type, integer_zero_node);
1325
1326 /* This must build a C cast. */
1327 parms = build_x_compound_expr_from_list (parms, "functional cast");
1328 return build_c_cast (type, parms);
1329 }
1330
1331 /* Prepare to evaluate as a call to a constructor. If this expression
1332 is actually used, for example,
1333
1334 return X (arg1, arg2, ...);
1335
1336 then the slot being initialized will be filled in. */
1337
1338 if (!complete_type_or_else (type, NULL_TREE))
1339 return error_mark_node;
1340 if (abstract_virtuals_error (NULL_TREE, type))
1341 return error_mark_node;
1342
1343 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1344 return build_c_cast (type, TREE_VALUE (parms));
1345
1346 /* We need to zero-initialize POD types. */
1347 if (parms == NULL_TREE
1348 && !CLASSTYPE_NON_POD_P (type)
1349 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
1350 {
1351 exp = build_zero_init (type,
1352 /*nelts=*/NULL_TREE,
1353 /*static_storage_p=*/false);
1354 return get_target_expr (exp);
1355 }
1356
1357 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, parms,
1358 type, LOOKUP_NORMAL);
1359
1360 if (exp == error_mark_node)
1361 return error_mark_node;
1362
1363 return build_cplus_new (type, exp);
1364 }
1365
1366
1367 /* Add new exception specifier SPEC, to the LIST we currently have.
1368 If it's already in LIST then do nothing.
1369 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1370 know what we're doing. */
1371
1372 tree
add_exception_specifier(tree list,tree spec,int complain)1373 add_exception_specifier (tree list, tree spec, int complain)
1374 {
1375 bool ok;
1376 tree core = spec;
1377 bool is_ptr;
1378 int diag_type = -1; /* none */
1379
1380 if (spec == error_mark_node)
1381 return list;
1382
1383 gcc_assert (spec && (!list || TREE_VALUE (list)));
1384
1385 /* [except.spec] 1, type in an exception specifier shall not be
1386 incomplete, or pointer or ref to incomplete other than pointer
1387 to cv void. */
1388 is_ptr = TREE_CODE (core) == POINTER_TYPE;
1389 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1390 core = TREE_TYPE (core);
1391 if (complain < 0)
1392 ok = true;
1393 else if (VOID_TYPE_P (core))
1394 ok = is_ptr;
1395 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1396 ok = true;
1397 else if (processing_template_decl)
1398 ok = true;
1399 else
1400 {
1401 ok = true;
1402 /* 15.4/1 says that types in an exception specifier must be complete,
1403 but it seems more reasonable to only require this on definitions
1404 and calls. So just give a pedwarn at this point; we will give an
1405 error later if we hit one of those two cases. */
1406 if (!COMPLETE_TYPE_P (complete_type (core)))
1407 diag_type = 2; /* pedwarn */
1408 }
1409
1410 if (ok)
1411 {
1412 tree probe;
1413
1414 for (probe = list; probe; probe = TREE_CHAIN (probe))
1415 if (same_type_p (TREE_VALUE (probe), spec))
1416 break;
1417 if (!probe)
1418 list = tree_cons (NULL_TREE, spec, list);
1419 }
1420 else
1421 diag_type = 0; /* error */
1422
1423 if (diag_type >= 0 && complain)
1424 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1425
1426 return list;
1427 }
1428
1429 /* Combine the two exceptions specifier lists LIST and ADD, and return
1430 their union. */
1431
1432 tree
merge_exception_specifiers(tree list,tree add)1433 merge_exception_specifiers (tree list, tree add)
1434 {
1435 if (!list || !add)
1436 return NULL_TREE;
1437 else if (!TREE_VALUE (list))
1438 return add;
1439 else if (!TREE_VALUE (add))
1440 return list;
1441 else
1442 {
1443 tree orig_list = list;
1444
1445 for (; add; add = TREE_CHAIN (add))
1446 {
1447 tree spec = TREE_VALUE (add);
1448 tree probe;
1449
1450 for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1451 if (same_type_p (TREE_VALUE (probe), spec))
1452 break;
1453 if (!probe)
1454 {
1455 spec = build_tree_list (NULL_TREE, spec);
1456 TREE_CHAIN (spec) = list;
1457 list = spec;
1458 }
1459 }
1460 }
1461 return list;
1462 }
1463
1464 /* Subroutine of build_call. Ensure that each of the types in the
1465 exception specification is complete. Technically, 15.4/1 says that
1466 they need to be complete when we see a declaration of the function,
1467 but we should be able to get away with only requiring this when the
1468 function is defined or called. See also add_exception_specifier. */
1469
1470 void
require_complete_eh_spec_types(tree fntype,tree decl)1471 require_complete_eh_spec_types (tree fntype, tree decl)
1472 {
1473 tree raises;
1474 /* Don't complain about calls to op new. */
1475 if (decl && DECL_ARTIFICIAL (decl))
1476 return;
1477 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1478 raises = TREE_CHAIN (raises))
1479 {
1480 tree type = TREE_VALUE (raises);
1481 if (type && !COMPLETE_TYPE_P (type))
1482 {
1483 if (decl)
1484 error
1485 ("call to function %qD which throws incomplete type %q#T",
1486 decl, type);
1487 else
1488 error ("call to function which throws incomplete type %q#T",
1489 decl);
1490 }
1491 }
1492 }
1493
1494
1495 #include "gt-cp-typeck2.h"
1496