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, 2007, 2008, 2009, 2010, 2011
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 3, 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 COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
23
24
25 /* This file is part of the C++ front end.
26 It contains routines to build C++ expressions given their operands,
27 including computing the types of the result, C and C++ specific error
28 checks, and some optimization. */
29
30 #include "config.h"
31 #include "system.h"
32 #include "coretypes.h"
33 #include "tm.h"
34 #include "tree.h"
35 #include "intl.h"
36 #include "cp-tree.h"
37 #include "flags.h"
38 #include "output.h"
39 #include "diagnostic-core.h"
40
41 static tree
42 process_init_constructor (tree type, tree init, tsubst_flags_t complain);
43
44
45 /* Print an error message stemming from an attempt to use
46 BASETYPE as a base class for TYPE. */
47
48 tree
error_not_base_type(tree basetype,tree type)49 error_not_base_type (tree basetype, tree type)
50 {
51 if (TREE_CODE (basetype) == FUNCTION_DECL)
52 basetype = DECL_CONTEXT (basetype);
53 error ("type %qT is not a base type for type %qT", basetype, type);
54 return error_mark_node;
55 }
56
57 tree
binfo_or_else(tree base,tree type)58 binfo_or_else (tree base, tree type)
59 {
60 tree binfo = lookup_base (type, base, ba_unique, NULL);
61
62 if (binfo == error_mark_node)
63 return NULL_TREE;
64 else if (!binfo)
65 error_not_base_type (base, type);
66 return binfo;
67 }
68
69 /* According to ARM $7.1.6, "A `const' object may be initialized, but its
70 value may not be changed thereafter. */
71
72 void
cxx_readonly_error(tree arg,enum lvalue_use errstring)73 cxx_readonly_error (tree arg, enum lvalue_use errstring)
74 {
75
76 /* This macro is used to emit diagnostics to ensure that all format
77 strings are complete sentences, visible to gettext and checked at
78 compile time. */
79
80 #define ERROR_FOR_ASSIGNMENT(AS, ASM, IN, DE, ARG) \
81 do { \
82 switch (errstring) \
83 { \
84 case lv_assign: \
85 error(AS, ARG); \
86 break; \
87 case lv_asm: \
88 error(ASM, ARG); \
89 break; \
90 case lv_increment: \
91 error (IN, ARG); \
92 break; \
93 case lv_decrement: \
94 error (DE, ARG); \
95 break; \
96 default: \
97 gcc_unreachable (); \
98 } \
99 } while (0)
100
101 /* Handle C++-specific things first. */
102
103 if (TREE_CODE (arg) == VAR_DECL
104 && DECL_LANG_SPECIFIC (arg)
105 && DECL_IN_AGGR_P (arg)
106 && !TREE_STATIC (arg))
107 ERROR_FOR_ASSIGNMENT (G_("assignment of "
108 "constant field %qD"),
109 G_("constant field %qD "
110 "used as %<asm%> output"),
111 G_("increment of "
112 "constant field %qD"),
113 G_("decrement of "
114 "constant field %qD"),
115 arg);
116 else if (TREE_CODE (arg) == INDIRECT_REF
117 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE
118 && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL
119 || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
120 ERROR_FOR_ASSIGNMENT (G_("assignment of "
121 "read-only reference %qD"),
122 G_("read-only reference %qD "
123 "used as %<asm%> output"),
124 G_("increment of "
125 "read-only reference %qD"),
126 G_("decrement of "
127 "read-only reference %qD"),
128 TREE_OPERAND (arg, 0));
129 else
130 readonly_error (arg, errstring);
131 }
132
133
134 /* Structure that holds information about declarations whose type was
135 incomplete and we could not check whether it was abstract or not. */
136
137 struct GTY((chain_next ("%h.next"))) pending_abstract_type {
138 /* Declaration which we are checking for abstractness. It is either
139 a DECL node, or an IDENTIFIER_NODE if we do not have a full
140 declaration available. */
141 tree decl;
142
143 /* Type which will be checked for abstractness. */
144 tree type;
145
146 /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
147 because DECLs already carry locus information. */
148 location_t locus;
149
150 /* Link to the next element in list. */
151 struct pending_abstract_type* next;
152 };
153
154
155 /* Compute the hash value of the node VAL. This function is used by the
156 hash table abstract_pending_vars. */
157
158 static hashval_t
pat_calc_hash(const void * val)159 pat_calc_hash (const void* val)
160 {
161 const struct pending_abstract_type *pat =
162 (const struct pending_abstract_type *) val;
163 return (hashval_t) TYPE_UID (pat->type);
164 }
165
166
167 /* Compare node VAL1 with the type VAL2. This function is used by the
168 hash table abstract_pending_vars. */
169
170 static int
pat_compare(const void * val1,const void * val2)171 pat_compare (const void* val1, const void* val2)
172 {
173 const struct pending_abstract_type *const pat1 =
174 (const struct pending_abstract_type *) val1;
175 const_tree const type2 = (const_tree)val2;
176
177 return (pat1->type == type2);
178 }
179
180 /* Hash table that maintains pending_abstract_type nodes, for which we still
181 need to check for type abstractness. The key of the table is the type
182 of the declaration. */
183 static GTY ((param_is (struct pending_abstract_type)))
184 htab_t abstract_pending_vars = NULL;
185
186
187 /* This function is called after TYPE is completed, and will check if there
188 are pending declarations for which we still need to verify the abstractness
189 of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
190 turned out to be incomplete. */
191
192 void
complete_type_check_abstract(tree type)193 complete_type_check_abstract (tree type)
194 {
195 void **slot;
196 struct pending_abstract_type *pat;
197 location_t cur_loc = input_location;
198
199 gcc_assert (COMPLETE_TYPE_P (type));
200
201 if (!abstract_pending_vars)
202 return;
203
204 /* Retrieve the list of pending declarations for this type. */
205 slot = htab_find_slot_with_hash (abstract_pending_vars, type,
206 (hashval_t)TYPE_UID (type), NO_INSERT);
207 if (!slot)
208 return;
209 pat = (struct pending_abstract_type*)*slot;
210 gcc_assert (pat);
211
212 /* If the type is not abstract, do not do anything. */
213 if (CLASSTYPE_PURE_VIRTUALS (type))
214 {
215 struct pending_abstract_type *prev = 0, *next;
216
217 /* Reverse the list to emit the errors in top-down order. */
218 for (; pat; pat = next)
219 {
220 next = pat->next;
221 pat->next = prev;
222 prev = pat;
223 }
224 pat = prev;
225
226 /* Go through the list, and call abstract_virtuals_error for each
227 element: it will issue a diagnostic if the type is abstract. */
228 while (pat)
229 {
230 gcc_assert (type == pat->type);
231
232 /* Tweak input_location so that the diagnostic appears at the correct
233 location. Notice that this is only needed if the decl is an
234 IDENTIFIER_NODE. */
235 input_location = pat->locus;
236 abstract_virtuals_error (pat->decl, pat->type);
237 pat = pat->next;
238 }
239 }
240
241 htab_clear_slot (abstract_pending_vars, slot);
242
243 input_location = cur_loc;
244 }
245
246
247 /* If TYPE has abstract virtual functions, issue an error about trying
248 to create an object of that type. DECL is the object declared, or
249 NULL_TREE if the declaration is unavailable. Returns 1 if an error
250 occurred; zero if all was well. */
251
252 int
abstract_virtuals_error_sfinae(tree decl,tree type,tsubst_flags_t complain)253 abstract_virtuals_error_sfinae (tree decl, tree type, tsubst_flags_t complain)
254 {
255 VEC(tree,gc) *pure;
256
257 /* This function applies only to classes. Any other entity can never
258 be abstract. */
259 if (!CLASS_TYPE_P (type))
260 return 0;
261 type = TYPE_MAIN_VARIANT (type);
262
263 /* If the type is incomplete, we register it within a hash table,
264 so that we can check again once it is completed. This makes sense
265 only for objects for which we have a declaration or at least a
266 name. */
267 if (!COMPLETE_TYPE_P (type))
268 {
269 void **slot;
270 struct pending_abstract_type *pat;
271
272 gcc_assert (!decl || DECL_P (decl)
273 || TREE_CODE (decl) == IDENTIFIER_NODE);
274
275 if (!abstract_pending_vars)
276 abstract_pending_vars = htab_create_ggc (31, &pat_calc_hash,
277 &pat_compare, NULL);
278
279 slot = htab_find_slot_with_hash (abstract_pending_vars, type,
280 (hashval_t)TYPE_UID (type), INSERT);
281
282 pat = ggc_alloc_pending_abstract_type ();
283 pat->type = type;
284 pat->decl = decl;
285 pat->locus = ((decl && DECL_P (decl))
286 ? DECL_SOURCE_LOCATION (decl)
287 : input_location);
288
289 pat->next = (struct pending_abstract_type *) *slot;
290 *slot = pat;
291
292 return 0;
293 }
294
295 if (!TYPE_SIZE (type))
296 /* TYPE is being defined, and during that time
297 CLASSTYPE_PURE_VIRTUALS holds the inline friends. */
298 return 0;
299
300 pure = CLASSTYPE_PURE_VIRTUALS (type);
301 if (!pure)
302 return 0;
303
304 if (!(complain & tf_error))
305 return 1;
306
307 if (decl)
308 {
309 if (TREE_CODE (decl) == VAR_DECL)
310 error ("cannot declare variable %q+D to be of abstract "
311 "type %qT", decl, type);
312 else if (TREE_CODE (decl) == PARM_DECL)
313 error ("cannot declare parameter %q+D to be of abstract type %qT",
314 decl, type);
315 else if (TREE_CODE (decl) == FIELD_DECL)
316 error ("cannot declare field %q+D to be of abstract type %qT",
317 decl, type);
318 else if (TREE_CODE (decl) == FUNCTION_DECL
319 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
320 error ("invalid abstract return type for member function %q+#D", decl);
321 else if (TREE_CODE (decl) == FUNCTION_DECL)
322 error ("invalid abstract return type for function %q+#D", decl);
323 else if (TREE_CODE (decl) == IDENTIFIER_NODE)
324 /* Here we do not have location information. */
325 error ("invalid abstract type %qT for %qE", type, decl);
326 else
327 error ("invalid abstract type for %q+D", decl);
328 }
329 else
330 error ("cannot allocate an object of abstract type %qT", type);
331
332 /* Only go through this once. */
333 if (VEC_length (tree, pure))
334 {
335 unsigned ix;
336 tree fn;
337
338 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
339 " because the following virtual functions are pure within %qT:",
340 type);
341
342 FOR_EACH_VEC_ELT (tree, pure, ix, fn)
343 if (! DECL_CLONED_FUNCTION_P (fn)
344 || DECL_COMPLETE_DESTRUCTOR_P (fn))
345 inform (input_location, "\t%+#D", fn);
346
347 /* Now truncate the vector. This leaves it non-null, so we know
348 there are pure virtuals, but empty so we don't list them out
349 again. */
350 VEC_truncate (tree, pure, 0);
351 }
352 else
353 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
354 " since type %qT has pure virtual functions",
355 type);
356
357 return 1;
358 }
359
360 /* Wrapper for the above function in the common case of wanting errors. */
361
362 int
abstract_virtuals_error(tree decl,tree type)363 abstract_virtuals_error (tree decl, tree type)
364 {
365 return abstract_virtuals_error_sfinae (decl, type, tf_warning_or_error);
366 }
367
368 /* Print an error message for invalid use of an incomplete type.
369 VALUE is the expression that was used (or 0 if that isn't known)
370 and TYPE is the type that was invalid. DIAG_KIND indicates the
371 type of diagnostic (see diagnostic.def). */
372
373 void
cxx_incomplete_type_diagnostic(const_tree value,const_tree type,diagnostic_t diag_kind)374 cxx_incomplete_type_diagnostic (const_tree value, const_tree type,
375 diagnostic_t diag_kind)
376 {
377 int decl = 0;
378
379 gcc_assert (diag_kind == DK_WARNING
380 || diag_kind == DK_PEDWARN
381 || diag_kind == DK_ERROR);
382
383 /* Avoid duplicate error message. */
384 if (TREE_CODE (type) == ERROR_MARK)
385 return;
386
387 if (value != 0 && (TREE_CODE (value) == VAR_DECL
388 || TREE_CODE (value) == PARM_DECL
389 || TREE_CODE (value) == FIELD_DECL))
390 {
391 emit_diagnostic (diag_kind, input_location, 0,
392 "%q+D has incomplete type", value);
393 decl = 1;
394 }
395 retry:
396 /* We must print an error message. Be clever about what it says. */
397
398 switch (TREE_CODE (type))
399 {
400 case RECORD_TYPE:
401 case UNION_TYPE:
402 case ENUMERAL_TYPE:
403 if (!decl)
404 emit_diagnostic (diag_kind, input_location, 0,
405 "invalid use of incomplete type %q#T", type);
406 if (!TYPE_TEMPLATE_INFO (type))
407 emit_diagnostic (diag_kind, input_location, 0,
408 "forward declaration of %q+#T", type);
409 else
410 emit_diagnostic (diag_kind, input_location, 0,
411 "declaration of %q+#T", type);
412 break;
413
414 case VOID_TYPE:
415 emit_diagnostic (diag_kind, input_location, 0,
416 "invalid use of %qT", type);
417 break;
418
419 case ARRAY_TYPE:
420 if (TYPE_DOMAIN (type))
421 {
422 type = TREE_TYPE (type);
423 goto retry;
424 }
425 emit_diagnostic (diag_kind, input_location, 0,
426 "invalid use of array with unspecified bounds");
427 break;
428
429 case OFFSET_TYPE:
430 bad_member:
431 {
432 tree member = TREE_OPERAND (value, 1);
433 if (is_overloaded_fn (member))
434 member = get_first_fn (member);
435 if (DECL_FUNCTION_MEMBER_P (member)
436 && ! flag_ms_extensions)
437 emit_diagnostic (diag_kind, input_location, 0,
438 "invalid use of member function "
439 "(did you forget the %<()%> ?)");
440 else
441 emit_diagnostic (diag_kind, input_location, 0,
442 "invalid use of member "
443 "(did you forget the %<&%> ?)");
444 }
445 break;
446
447 case TEMPLATE_TYPE_PARM:
448 if (is_auto (type))
449 emit_diagnostic (diag_kind, input_location, 0,
450 "invalid use of %<auto%>");
451 else
452 emit_diagnostic (diag_kind, input_location, 0,
453 "invalid use of template type parameter %qT", type);
454 break;
455
456 case BOUND_TEMPLATE_TEMPLATE_PARM:
457 emit_diagnostic (diag_kind, input_location, 0,
458 "invalid use of template template parameter %qT",
459 TYPE_NAME (type));
460 break;
461
462 case TYPENAME_TYPE:
463 emit_diagnostic (diag_kind, input_location, 0,
464 "invalid use of dependent type %qT", type);
465 break;
466
467 case LANG_TYPE:
468 if (type == init_list_type_node)
469 {
470 emit_diagnostic (diag_kind, input_location, 0,
471 "invalid use of brace-enclosed initializer list");
472 break;
473 }
474 gcc_assert (type == unknown_type_node);
475 if (value && TREE_CODE (value) == COMPONENT_REF)
476 goto bad_member;
477 else if (value && TREE_CODE (value) == ADDR_EXPR)
478 emit_diagnostic (diag_kind, input_location, 0,
479 "address of overloaded function with no contextual "
480 "type information");
481 else if (value && TREE_CODE (value) == OVERLOAD)
482 emit_diagnostic (diag_kind, input_location, 0,
483 "overloaded function with no contextual type information");
484 else
485 emit_diagnostic (diag_kind, input_location, 0,
486 "insufficient contextual information to determine type");
487 break;
488
489 default:
490 gcc_unreachable ();
491 }
492 }
493
494 /* Backward-compatibility interface to incomplete_type_diagnostic;
495 required by ../tree.c. */
496 #undef cxx_incomplete_type_error
497 void
cxx_incomplete_type_error(const_tree value,const_tree type)498 cxx_incomplete_type_error (const_tree value, const_tree type)
499 {
500 cxx_incomplete_type_diagnostic (value, type, DK_ERROR);
501 }
502
503
504 /* The recursive part of split_nonconstant_init. DEST is an lvalue
505 expression to which INIT should be assigned. INIT is a CONSTRUCTOR.
506 Return true if the whole of the value was initialized by the
507 generated statements. */
508
509 static bool
split_nonconstant_init_1(tree dest,tree init)510 split_nonconstant_init_1 (tree dest, tree init)
511 {
512 unsigned HOST_WIDE_INT idx;
513 tree field_index, value;
514 tree type = TREE_TYPE (dest);
515 tree inner_type = NULL;
516 bool array_type_p = false;
517 bool complete_p = true;
518 HOST_WIDE_INT num_split_elts = 0;
519
520 switch (TREE_CODE (type))
521 {
522 case ARRAY_TYPE:
523 inner_type = TREE_TYPE (type);
524 array_type_p = true;
525 /* FALLTHRU */
526
527 case RECORD_TYPE:
528 case UNION_TYPE:
529 case QUAL_UNION_TYPE:
530 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,
531 field_index, value)
532 {
533 /* The current implementation of this algorithm assumes that
534 the field was set for all the elements. This is usually done
535 by process_init_constructor. */
536 gcc_assert (field_index);
537
538 if (!array_type_p)
539 inner_type = TREE_TYPE (field_index);
540
541 if (TREE_CODE (value) == CONSTRUCTOR)
542 {
543 tree sub;
544
545 if (array_type_p)
546 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
547 NULL_TREE, NULL_TREE);
548 else
549 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
550 NULL_TREE);
551
552 if (!split_nonconstant_init_1 (sub, value))
553 complete_p = false;
554 num_split_elts++;
555 }
556 else if (!initializer_constant_valid_p (value, inner_type))
557 {
558 tree code;
559 tree sub;
560
561 /* FIXME: Ordered removal is O(1) so the whole function is
562 worst-case quadratic. This could be fixed using an aside
563 bitmap to record which elements must be removed and remove
564 them all at the same time. Or by merging
565 split_non_constant_init into process_init_constructor_array,
566 that is separating constants from non-constants while building
567 the vector. */
568 VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init),
569 idx);
570 --idx;
571
572 if (array_type_p)
573 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
574 NULL_TREE, NULL_TREE);
575 else
576 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
577 NULL_TREE);
578
579 code = build2 (INIT_EXPR, inner_type, sub, value);
580 code = build_stmt (input_location, EXPR_STMT, code);
581 code = maybe_cleanup_point_expr_void (code);
582 add_stmt (code);
583 if (!TYPE_HAS_TRIVIAL_DESTRUCTOR (inner_type))
584 {
585 code = (build_special_member_call
586 (sub, complete_dtor_identifier, NULL, inner_type,
587 LOOKUP_NORMAL, tf_warning_or_error));
588 finish_eh_cleanup (code);
589 }
590
591 num_split_elts++;
592 }
593 }
594 break;
595
596 case VECTOR_TYPE:
597 if (!initializer_constant_valid_p (init, type))
598 {
599 tree code;
600 tree cons = copy_node (init);
601 CONSTRUCTOR_ELTS (init) = NULL;
602 code = build2 (MODIFY_EXPR, type, dest, cons);
603 code = build_stmt (input_location, EXPR_STMT, code);
604 add_stmt (code);
605 num_split_elts += CONSTRUCTOR_NELTS (init);
606 }
607 break;
608
609 default:
610 gcc_unreachable ();
611 }
612
613 /* The rest of the initializer is now a constant. */
614 TREE_CONSTANT (init) = 1;
615 return complete_p && complete_ctor_at_level_p (TREE_TYPE (init),
616 num_split_elts, inner_type);
617 }
618
619 /* A subroutine of store_init_value. Splits non-constant static
620 initializer INIT into a constant part and generates code to
621 perform the non-constant part of the initialization to DEST.
622 Returns the code for the runtime init. */
623
624 static tree
split_nonconstant_init(tree dest,tree init)625 split_nonconstant_init (tree dest, tree init)
626 {
627 tree code;
628
629 if (TREE_CODE (init) == CONSTRUCTOR)
630 {
631 code = push_stmt_list ();
632 if (split_nonconstant_init_1 (dest, init))
633 init = NULL_TREE;
634 code = pop_stmt_list (code);
635 DECL_INITIAL (dest) = init;
636 TREE_READONLY (dest) = 0;
637 }
638 else
639 code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
640
641 return code;
642 }
643
644 /* Perform appropriate conversions on the initial value of a variable,
645 store it in the declaration DECL,
646 and print any error messages that are appropriate.
647 If the init is invalid, store an ERROR_MARK.
648
649 C++: Note that INIT might be a TREE_LIST, which would mean that it is
650 a base class initializer for some aggregate type, hopefully compatible
651 with DECL. If INIT is a single element, and DECL is an aggregate
652 type, we silently convert INIT into a TREE_LIST, allowing a constructor
653 to be called.
654
655 If INIT is a TREE_LIST and there is no constructor, turn INIT
656 into a CONSTRUCTOR and use standard initialization techniques.
657 Perhaps a warning should be generated?
658
659 Returns code to be executed if initialization could not be performed
660 for static variable. In that case, caller must emit the code. */
661
662 tree
store_init_value(tree decl,tree init,VEC (tree,gc)** cleanups,int flags)663 store_init_value (tree decl, tree init, VEC(tree,gc)** cleanups, int flags)
664 {
665 tree value, type;
666
667 /* If variable's type was invalidly declared, just ignore it. */
668
669 type = TREE_TYPE (decl);
670 if (TREE_CODE (type) == ERROR_MARK)
671 return NULL_TREE;
672
673 if (MAYBE_CLASS_TYPE_P (type))
674 {
675 if (TREE_CODE (init) == TREE_LIST)
676 {
677 error ("constructor syntax used, but no constructor declared "
678 "for type %qT", type);
679 init = build_constructor_from_list (init_list_type_node, nreverse (init));
680 }
681 }
682 else if (TREE_CODE (init) == TREE_LIST
683 && TREE_TYPE (init) != unknown_type_node)
684 {
685 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
686
687 if (TREE_CODE (init) == TREE_LIST
688 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
689 {
690 error ("cannot initialize arrays using this syntax");
691 return NULL_TREE;
692 }
693 else
694 /* We get here with code like `int a (2);' */
695 init = build_x_compound_expr_from_list (init, ELK_INIT,
696 tf_warning_or_error);
697 }
698
699 /* End of special C++ code. */
700
701 if (flags & LOOKUP_ALREADY_DIGESTED)
702 value = init;
703 else
704 /* Digest the specified initializer into an expression. */
705 value = digest_init_flags (type, init, flags);
706
707 value = extend_ref_init_temps (decl, value, cleanups);
708
709 /* In C++0x constant expression is a semantic, not syntactic, property.
710 In C++98, make sure that what we thought was a constant expression at
711 template definition time is still constant. */
712 if ((cxx_dialect >= cxx0x
713 || DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
714 && (decl_maybe_constant_var_p (decl)
715 || TREE_STATIC (decl)))
716 {
717 bool const_init;
718 value = fold_non_dependent_expr (value);
719 value = maybe_constant_init (value);
720 if (DECL_DECLARED_CONSTEXPR_P (decl))
721 {
722 /* Diagnose a non-constant initializer for constexpr. */
723 if (processing_template_decl
724 && !require_potential_constant_expression (value))
725 value = error_mark_node;
726 else
727 value = cxx_constant_value (value);
728 }
729 const_init = (reduced_constant_expression_p (value)
730 || error_operand_p (value));
731 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = const_init;
732 TREE_CONSTANT (decl) = const_init && decl_maybe_constant_var_p (decl);
733 }
734
735 /* If the initializer is not a constant, fill in DECL_INITIAL with
736 the bits that are constant, and then return an expression that
737 will perform the dynamic initialization. */
738 if (value != error_mark_node
739 && (TREE_SIDE_EFFECTS (value)
740 || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
741 {
742 if (TREE_CODE (type) == ARRAY_TYPE
743 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (type)))
744 /* For an array, we only need/want a single cleanup region rather
745 than one per element. */
746 return build_vec_init (decl, NULL_TREE, value, false, 1,
747 tf_warning_or_error);
748 else
749 return split_nonconstant_init (decl, value);
750 }
751 /* If the value is a constant, just put it in DECL_INITIAL. If DECL
752 is an automatic variable, the middle end will turn this into a
753 dynamic initialization later. */
754 DECL_INITIAL (decl) = value;
755 return NULL_TREE;
756 }
757
758
759 /* Give errors about narrowing conversions within { }. */
760
761 void
check_narrowing(tree type,tree init)762 check_narrowing (tree type, tree init)
763 {
764 tree ftype = unlowered_expr_type (init);
765 bool ok = true;
766 REAL_VALUE_TYPE d;
767
768 if (!warn_narrowing || !ARITHMETIC_TYPE_P (type))
769 return;
770
771 if (BRACE_ENCLOSED_INITIALIZER_P (init)
772 && TREE_CODE (type) == COMPLEX_TYPE)
773 {
774 tree elttype = TREE_TYPE (type);
775 check_narrowing (elttype, CONSTRUCTOR_ELT (init, 0)->value);
776 if (CONSTRUCTOR_NELTS (init) > 1)
777 check_narrowing (elttype, CONSTRUCTOR_ELT (init, 1)->value);
778 return;
779 }
780
781 init = maybe_constant_value (init);
782
783 if (TREE_CODE (type) == INTEGER_TYPE
784 && TREE_CODE (ftype) == REAL_TYPE)
785 ok = false;
786 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
787 && CP_INTEGRAL_TYPE_P (type))
788 {
789 if (TREE_CODE (ftype) == ENUMERAL_TYPE)
790 /* Check for narrowing based on the values of the enumeration. */
791 ftype = ENUM_UNDERLYING_TYPE (ftype);
792 if ((tree_int_cst_lt (TYPE_MAX_VALUE (type),
793 TYPE_MAX_VALUE (ftype))
794 || tree_int_cst_lt (TYPE_MIN_VALUE (ftype),
795 TYPE_MIN_VALUE (type)))
796 && (TREE_CODE (init) != INTEGER_CST
797 || !int_fits_type_p (init, type)))
798 ok = false;
799 }
800 else if (TREE_CODE (ftype) == REAL_TYPE
801 && TREE_CODE (type) == REAL_TYPE)
802 {
803 if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype))
804 {
805 if (TREE_CODE (init) == REAL_CST)
806 {
807 /* Issue 703: Loss of precision is OK as long as the value is
808 within the representable range of the new type. */
809 REAL_VALUE_TYPE r;
810 d = TREE_REAL_CST (init);
811 real_convert (&r, TYPE_MODE (type), &d);
812 if (real_isinf (&r))
813 ok = false;
814 }
815 else
816 ok = false;
817 }
818 }
819 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
820 && TREE_CODE (type) == REAL_TYPE)
821 {
822 ok = false;
823 if (TREE_CODE (init) == INTEGER_CST)
824 {
825 d = real_value_from_int_cst (0, init);
826 if (exact_real_truncate (TYPE_MODE (type), &d))
827 ok = true;
828 }
829 }
830
831 if (!ok)
832 {
833 if (cxx_dialect >= cxx0x)
834 pedwarn (EXPR_LOC_OR_HERE (init), OPT_Wnarrowing,
835 "narrowing conversion of %qE from %qT to %qT inside { }",
836 init, ftype, type);
837 else
838 warning_at (EXPR_LOC_OR_HERE (init), OPT_Wnarrowing,
839 "narrowing conversion of %qE from %qT to %qT inside { } "
840 "is ill-formed in C++11", init, ftype, type);
841 }
842 }
843
844 /* Process the initializer INIT for a variable of type TYPE, emitting
845 diagnostics for invalid initializers and converting the initializer as
846 appropriate.
847
848 For aggregate types, it assumes that reshape_init has already run, thus the
849 initializer will have the right shape (brace elision has been undone).
850
851 NESTED is true iff we are being called for an element of a CONSTRUCTOR. */
852
853 static tree
digest_init_r(tree type,tree init,bool nested,int flags,tsubst_flags_t complain)854 digest_init_r (tree type, tree init, bool nested, int flags,
855 tsubst_flags_t complain)
856 {
857 enum tree_code code = TREE_CODE (type);
858
859 if (error_operand_p (init))
860 return error_mark_node;
861
862 gcc_assert (init);
863
864 /* We must strip the outermost array type when completing the type,
865 because the its bounds might be incomplete at the moment. */
866 if (!complete_type_or_maybe_complain (TREE_CODE (type) == ARRAY_TYPE
867 ? TREE_TYPE (type) : type, NULL_TREE,
868 complain))
869 return error_mark_node;
870
871 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
872 (g++.old-deja/g++.law/casts2.C). */
873 if (TREE_CODE (init) == NON_LVALUE_EXPR)
874 init = TREE_OPERAND (init, 0);
875
876 /* Initialization of an array of chars from a string constant. The initializer
877 can be optionally enclosed in braces, but reshape_init has already removed
878 them if they were present. */
879 if (code == ARRAY_TYPE)
880 {
881 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
882 if (char_type_p (typ1)
883 /*&& init */
884 && TREE_CODE (init) == STRING_CST)
885 {
886 tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
887
888 if (TYPE_PRECISION (typ1) == BITS_PER_UNIT)
889 {
890 if (char_type != char_type_node)
891 {
892 if (complain & tf_error)
893 error ("char-array initialized from wide string");
894 return error_mark_node;
895 }
896 }
897 else
898 {
899 if (char_type == char_type_node)
900 {
901 if (complain & tf_error)
902 error ("int-array initialized from non-wide string");
903 return error_mark_node;
904 }
905 else if (char_type != typ1)
906 {
907 if (complain & tf_error)
908 error ("int-array initialized from incompatible "
909 "wide string");
910 return error_mark_node;
911 }
912 }
913
914 if (type != TREE_TYPE (init))
915 {
916 init = copy_node (init);
917 TREE_TYPE (init) = type;
918 }
919 if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type)))
920 {
921 int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
922 size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
923 /* In C it is ok to subtract 1 from the length of the string
924 because it's ok to ignore the terminating null char that is
925 counted in the length of the constant, but in C++ this would
926 be invalid. */
927 if (size < TREE_STRING_LENGTH (init))
928 permerror (input_location, "initializer-string for array "
929 "of chars is too long");
930 }
931 return init;
932 }
933 }
934
935 /* Handle scalar types (including conversions) and references. */
936 if ((TREE_CODE (type) != COMPLEX_TYPE
937 || BRACE_ENCLOSED_INITIALIZER_P (init))
938 && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE))
939 {
940 tree *exp;
941
942 if (nested)
943 check_narrowing (type, init);
944 init = convert_for_initialization (0, type, init, flags,
945 ICR_INIT, NULL_TREE, 0,
946 complain);
947 exp = &init;
948
949 /* Skip any conversions since we'll be outputting the underlying
950 constant. */
951 while (CONVERT_EXPR_P (*exp)
952 || TREE_CODE (*exp) == NON_LVALUE_EXPR)
953 exp = &TREE_OPERAND (*exp, 0);
954
955 *exp = cplus_expand_constant (*exp);
956
957 return init;
958 }
959
960 /* Come here only for aggregates: records, arrays, unions, complex numbers
961 and vectors. */
962 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
963 || TREE_CODE (type) == VECTOR_TYPE
964 || TREE_CODE (type) == RECORD_TYPE
965 || TREE_CODE (type) == UNION_TYPE
966 || TREE_CODE (type) == COMPLEX_TYPE);
967
968 if (BRACE_ENCLOSED_INITIALIZER_P (init)
969 && !TYPE_NON_AGGREGATE_CLASS (type))
970 return process_init_constructor (type, init, complain);
971 else
972 {
973 if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE)
974 {
975 if (complain & tf_error)
976 error ("cannot initialize aggregate of type %qT with "
977 "a compound literal", type);
978
979 return error_mark_node;
980 }
981
982 if (TREE_CODE (type) == ARRAY_TYPE
983 && !BRACE_ENCLOSED_INITIALIZER_P (init))
984 {
985 /* Allow the result of build_array_copy and of
986 build_value_init_noctor. */
987 if ((TREE_CODE (init) == VEC_INIT_EXPR
988 || TREE_CODE (init) == CONSTRUCTOR)
989 && (same_type_ignoring_top_level_qualifiers_p
990 (type, TREE_TYPE (init))))
991 return init;
992
993 if (complain & tf_error)
994 error ("array must be initialized with a brace-enclosed"
995 " initializer");
996 return error_mark_node;
997 }
998
999 return convert_for_initialization (NULL_TREE, type, init,
1000 flags,
1001 ICR_INIT, NULL_TREE, 0,
1002 complain);
1003 }
1004 }
1005
1006 tree
digest_init(tree type,tree init,tsubst_flags_t complain)1007 digest_init (tree type, tree init, tsubst_flags_t complain)
1008 {
1009 return digest_init_r (type, init, false, LOOKUP_IMPLICIT, complain);
1010 }
1011
1012 tree
digest_init_flags(tree type,tree init,int flags)1013 digest_init_flags (tree type, tree init, int flags)
1014 {
1015 return digest_init_r (type, init, false, flags, tf_warning_or_error);
1016 }
1017
1018 /* Set of flags used within process_init_constructor to describe the
1019 initializers. */
1020 #define PICFLAG_ERRONEOUS 1
1021 #define PICFLAG_NOT_ALL_CONSTANT 2
1022 #define PICFLAG_NOT_ALL_SIMPLE 4
1023
1024 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
1025 describe it. */
1026
1027 static int
picflag_from_initializer(tree init)1028 picflag_from_initializer (tree init)
1029 {
1030 if (init == error_mark_node)
1031 return PICFLAG_ERRONEOUS;
1032 else if (!TREE_CONSTANT (init))
1033 return PICFLAG_NOT_ALL_CONSTANT;
1034 else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
1035 return PICFLAG_NOT_ALL_SIMPLE;
1036 return 0;
1037 }
1038
1039 /* Subroutine of process_init_constructor, which will process an initializer
1040 INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
1041 which describe the initializers. */
1042
1043 static int
process_init_constructor_array(tree type,tree init,tsubst_flags_t complain)1044 process_init_constructor_array (tree type, tree init,
1045 tsubst_flags_t complain)
1046 {
1047 unsigned HOST_WIDE_INT i, len = 0;
1048 int flags = 0;
1049 bool unbounded = false;
1050 constructor_elt *ce;
1051 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init);
1052
1053 gcc_assert (TREE_CODE (type) == ARRAY_TYPE
1054 || TREE_CODE (type) == VECTOR_TYPE);
1055
1056 if (TREE_CODE (type) == ARRAY_TYPE)
1057 {
1058 tree domain = TYPE_DOMAIN (type);
1059 if (domain)
1060 len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
1061 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
1062 + 1);
1063 else
1064 unbounded = true; /* Take as many as there are. */
1065 }
1066 else
1067 /* Vectors are like simple fixed-size arrays. */
1068 len = TYPE_VECTOR_SUBPARTS (type);
1069
1070 /* There must not be more initializers than needed. */
1071 if (!unbounded && VEC_length (constructor_elt, v) > len)
1072 {
1073 if (complain & tf_error)
1074 error ("too many initializers for %qT", type);
1075 else
1076 return PICFLAG_ERRONEOUS;
1077 }
1078
1079 FOR_EACH_VEC_ELT (constructor_elt, v, i, ce)
1080 {
1081 if (ce->index)
1082 {
1083 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST);
1084 if (compare_tree_int (ce->index, i) != 0)
1085 {
1086 ce->value = error_mark_node;
1087 sorry ("non-trivial designated initializers not supported");
1088 }
1089 }
1090 else
1091 ce->index = size_int (i);
1092 gcc_assert (ce->value);
1093 ce->value = digest_init_r (TREE_TYPE (type), ce->value, true,
1094 LOOKUP_IMPLICIT, complain);
1095
1096 if (ce->value != error_mark_node)
1097 gcc_assert (same_type_ignoring_top_level_qualifiers_p
1098 (TREE_TYPE (type), TREE_TYPE (ce->value)));
1099
1100 flags |= picflag_from_initializer (ce->value);
1101 }
1102
1103 /* No more initializers. If the array is unbounded, we are done. Otherwise,
1104 we must add initializers ourselves. */
1105 if (!unbounded)
1106 for (; i < len; ++i)
1107 {
1108 tree next;
1109
1110 if (type_build_ctor_call (TREE_TYPE (type)))
1111 {
1112 /* If this type needs constructors run for default-initialization,
1113 we can't rely on the back end to do it for us, so make the
1114 initialization explicit by list-initializing from {}. */
1115 next = build_constructor (init_list_type_node, NULL);
1116 next = digest_init (TREE_TYPE (type), next, complain);
1117 }
1118 else if (!zero_init_p (TREE_TYPE (type)))
1119 next = build_zero_init (TREE_TYPE (type),
1120 /*nelts=*/NULL_TREE,
1121 /*static_storage_p=*/false);
1122 else
1123 /* The default zero-initialization is fine for us; don't
1124 add anything to the CONSTRUCTOR. */
1125 break;
1126
1127 flags |= picflag_from_initializer (next);
1128 CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
1129 }
1130
1131 CONSTRUCTOR_ELTS (init) = v;
1132 return flags;
1133 }
1134
1135 /* Subroutine of process_init_constructor, which will process an initializer
1136 INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1137 the initializers. */
1138
1139 static int
process_init_constructor_record(tree type,tree init,tsubst_flags_t complain)1140 process_init_constructor_record (tree type, tree init,
1141 tsubst_flags_t complain)
1142 {
1143 VEC(constructor_elt,gc) *v = NULL;
1144 int flags = 0;
1145 tree field;
1146 unsigned HOST_WIDE_INT idx = 0;
1147
1148 gcc_assert (TREE_CODE (type) == RECORD_TYPE);
1149 gcc_assert (!CLASSTYPE_VBASECLASSES (type));
1150 gcc_assert (!TYPE_BINFO (type)
1151 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
1152 gcc_assert (!TYPE_POLYMORPHIC_P (type));
1153
1154 /* Generally, we will always have an index for each initializer (which is
1155 a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1156 reshape_init. So we need to handle both cases. */
1157 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
1158 {
1159 tree next;
1160 tree type;
1161
1162 if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field))
1163 {
1164 flags |= picflag_from_initializer (integer_zero_node);
1165 CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node);
1166 continue;
1167 }
1168
1169 if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1170 continue;
1171
1172 /* If this is a bitfield, first convert to the declared type. */
1173 type = TREE_TYPE (field);
1174 if (DECL_BIT_FIELD_TYPE (field))
1175 type = DECL_BIT_FIELD_TYPE (field);
1176
1177 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1178 {
1179 constructor_elt *ce = VEC_index (constructor_elt,
1180 CONSTRUCTOR_ELTS (init), idx);
1181 if (ce->index)
1182 {
1183 /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1184 latter case can happen in templates where lookup has to be
1185 deferred. */
1186 gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
1187 || TREE_CODE (ce->index) == IDENTIFIER_NODE);
1188 if (ce->index != field
1189 && ce->index != DECL_NAME (field))
1190 {
1191 ce->value = error_mark_node;
1192 sorry ("non-trivial designated initializers not supported");
1193 }
1194 }
1195
1196 gcc_assert (ce->value);
1197 next = digest_init_r (type, ce->value, true,
1198 LOOKUP_IMPLICIT, complain);
1199 ++idx;
1200 }
1201 else if (type_build_ctor_call (TREE_TYPE (field)))
1202 {
1203 /* If this type needs constructors run for
1204 default-initialization, we can't rely on the back end to do it
1205 for us, so build up TARGET_EXPRs. If the type in question is
1206 a class, just build one up; if it's an array, recurse. */
1207 next = build_constructor (init_list_type_node, NULL);
1208 if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field)))
1209 {
1210 next = finish_compound_literal (TREE_TYPE (field), next,
1211 complain);
1212 /* direct-initialize the target. No temporary is going
1213 to be involved. */
1214 if (TREE_CODE (next) == TARGET_EXPR)
1215 TARGET_EXPR_DIRECT_INIT_P (next) = true;
1216 }
1217
1218 next = digest_init_r (TREE_TYPE (field), next, true,
1219 LOOKUP_IMPLICIT, complain);
1220
1221 /* Warn when some struct elements are implicitly initialized. */
1222 warning (OPT_Wmissing_field_initializers,
1223 "missing initializer for member %qD", field);
1224 }
1225 else
1226 {
1227 if (TREE_READONLY (field))
1228 {
1229 if (complain & tf_error)
1230 error ("uninitialized const member %qD", field);
1231 else
1232 return PICFLAG_ERRONEOUS;
1233 }
1234 else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1235 {
1236 if (complain & tf_error)
1237 error ("member %qD with uninitialized const fields", field);
1238 else
1239 return PICFLAG_ERRONEOUS;
1240 }
1241 else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1242 {
1243 if (complain & tf_error)
1244 error ("member %qD is uninitialized reference", field);
1245 else
1246 return PICFLAG_ERRONEOUS;
1247 }
1248
1249 /* Warn when some struct elements are implicitly initialized
1250 to zero. */
1251 warning (OPT_Wmissing_field_initializers,
1252 "missing initializer for member %qD", field);
1253
1254 if (!zero_init_p (TREE_TYPE (field)))
1255 next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
1256 /*static_storage_p=*/false);
1257 else
1258 /* The default zero-initialization is fine for us; don't
1259 add anything to the CONSTRUCTOR. */
1260 continue;
1261 }
1262
1263 /* If this is a bitfield, now convert to the lowered type. */
1264 if (type != TREE_TYPE (field))
1265 next = cp_convert_and_check (TREE_TYPE (field), next);
1266 flags |= picflag_from_initializer (next);
1267 CONSTRUCTOR_APPEND_ELT (v, field, next);
1268 }
1269
1270 if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1271 {
1272 if (complain & tf_error)
1273 error ("too many initializers for %qT", type);
1274 else
1275 return PICFLAG_ERRONEOUS;
1276 }
1277
1278 CONSTRUCTOR_ELTS (init) = v;
1279 return flags;
1280 }
1281
1282 /* Subroutine of process_init_constructor, which will process a single
1283 initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1284 which describe the initializer. */
1285
1286 static int
process_init_constructor_union(tree type,tree init,tsubst_flags_t complain)1287 process_init_constructor_union (tree type, tree init,
1288 tsubst_flags_t complain)
1289 {
1290 constructor_elt *ce;
1291 int len;
1292
1293 /* If the initializer was empty, use default zero initialization. */
1294 if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
1295 return 0;
1296
1297 len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
1298 if (len > 1)
1299 {
1300 if (!(complain & tf_error))
1301 return PICFLAG_ERRONEOUS;
1302 error ("too many initializers for %qT", type);
1303 VEC_block_remove (constructor_elt, CONSTRUCTOR_ELTS (init), 1, len-1);
1304 }
1305
1306 ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0);
1307
1308 /* If this element specifies a field, initialize via that field. */
1309 if (ce->index)
1310 {
1311 if (TREE_CODE (ce->index) == FIELD_DECL)
1312 ;
1313 else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
1314 {
1315 /* This can happen within a cast, see g++.dg/opt/cse2.C. */
1316 tree name = ce->index;
1317 tree field;
1318 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1319 if (DECL_NAME (field) == name)
1320 break;
1321 if (!field)
1322 {
1323 if (complain & tf_error)
1324 error ("no field %qD found in union being initialized",
1325 field);
1326 ce->value = error_mark_node;
1327 }
1328 ce->index = field;
1329 }
1330 else
1331 {
1332 gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
1333 || TREE_CODE (ce->index) == RANGE_EXPR);
1334 if (complain & tf_error)
1335 error ("index value instead of field name in union initializer");
1336 ce->value = error_mark_node;
1337 }
1338 }
1339 else
1340 {
1341 /* Find the first named field. ANSI decided in September 1990
1342 that only named fields count here. */
1343 tree field = TYPE_FIELDS (type);
1344 while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1345 field = TREE_CHAIN (field);
1346 if (field == NULL_TREE)
1347 {
1348 if (complain & tf_error)
1349 error ("too many initializers for %qT", type);
1350 ce->value = error_mark_node;
1351 }
1352 ce->index = field;
1353 }
1354
1355 if (ce->value && ce->value != error_mark_node)
1356 ce->value = digest_init_r (TREE_TYPE (ce->index), ce->value,
1357 true, LOOKUP_IMPLICIT, complain);
1358
1359 return picflag_from_initializer (ce->value);
1360 }
1361
1362 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1363 constructor is a brace-enclosed initializer, and will be modified in-place.
1364
1365 Each element is converted to the right type through digest_init, and
1366 missing initializers are added following the language rules (zero-padding,
1367 etc.).
1368
1369 After the execution, the initializer will have TREE_CONSTANT if all elts are
1370 constant, and TREE_STATIC set if, in addition, all elts are simple enough
1371 constants that the assembler and linker can compute them.
1372
1373 The function returns the initializer itself, or error_mark_node in case
1374 of error. */
1375
1376 static tree
process_init_constructor(tree type,tree init,tsubst_flags_t complain)1377 process_init_constructor (tree type, tree init, tsubst_flags_t complain)
1378 {
1379 int flags;
1380
1381 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
1382
1383 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
1384 flags = process_init_constructor_array (type, init, complain);
1385 else if (TREE_CODE (type) == RECORD_TYPE)
1386 flags = process_init_constructor_record (type, init, complain);
1387 else if (TREE_CODE (type) == UNION_TYPE)
1388 flags = process_init_constructor_union (type, init, complain);
1389 else
1390 gcc_unreachable ();
1391
1392 if (flags & PICFLAG_ERRONEOUS)
1393 return error_mark_node;
1394
1395 TREE_TYPE (init) = type;
1396 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1397 cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
1398 if (!(flags & PICFLAG_NOT_ALL_CONSTANT))
1399 {
1400 TREE_CONSTANT (init) = 1;
1401 if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
1402 TREE_STATIC (init) = 1;
1403 }
1404 return init;
1405 }
1406
1407 /* Given a structure or union value DATUM, construct and return
1408 the structure or union component which results from narrowing
1409 that value to the base specified in BASETYPE. For example, given the
1410 hierarchy
1411
1412 class L { int ii; };
1413 class A : L { ... };
1414 class B : L { ... };
1415 class C : A, B { ... };
1416
1417 and the declaration
1418
1419 C x;
1420
1421 then the expression
1422
1423 x.A::ii refers to the ii member of the L part of
1424 the A part of the C object named by X. In this case,
1425 DATUM would be x, and BASETYPE would be A.
1426
1427 I used to think that this was nonconformant, that the standard specified
1428 that first we look up ii in A, then convert x to an L& and pull out the
1429 ii part. But in fact, it does say that we convert x to an A&; A here
1430 is known as the "naming class". (jason 2000-12-19)
1431
1432 BINFO_P points to a variable initialized either to NULL_TREE or to the
1433 binfo for the specific base subobject we want to convert to. */
1434
1435 tree
build_scoped_ref(tree datum,tree basetype,tree * binfo_p)1436 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1437 {
1438 tree binfo;
1439
1440 if (datum == error_mark_node)
1441 return error_mark_node;
1442 if (*binfo_p)
1443 binfo = *binfo_p;
1444 else
1445 binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1446
1447 if (!binfo || binfo == error_mark_node)
1448 {
1449 *binfo_p = NULL_TREE;
1450 if (!binfo)
1451 error_not_base_type (basetype, TREE_TYPE (datum));
1452 return error_mark_node;
1453 }
1454
1455 *binfo_p = binfo;
1456 return build_base_path (PLUS_EXPR, datum, binfo, 1,
1457 tf_warning_or_error);
1458 }
1459
1460 /* Build a reference to an object specified by the C++ `->' operator.
1461 Usually this just involves dereferencing the object, but if the
1462 `->' operator is overloaded, then such overloads must be
1463 performed until an object which does not have the `->' operator
1464 overloaded is found. An error is reported when circular pointer
1465 delegation is detected. */
1466
1467 tree
build_x_arrow(tree expr)1468 build_x_arrow (tree expr)
1469 {
1470 tree orig_expr = expr;
1471 tree type = TREE_TYPE (expr);
1472 tree last_rval = NULL_TREE;
1473 VEC(tree,gc) *types_memoized = NULL;
1474
1475 if (type == error_mark_node)
1476 return error_mark_node;
1477
1478 if (processing_template_decl)
1479 {
1480 if (type_dependent_expression_p (expr))
1481 return build_min_nt (ARROW_EXPR, expr);
1482 expr = build_non_dependent_expr (expr);
1483 }
1484
1485 if (MAYBE_CLASS_TYPE_P (type))
1486 {
1487 struct tinst_level *actual_inst = current_instantiation ();
1488 tree fn = NULL;
1489
1490 while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1491 NULL_TREE, NULL_TREE,
1492 &fn, tf_warning_or_error)))
1493 {
1494 if (expr == error_mark_node)
1495 return error_mark_node;
1496
1497 if (fn && DECL_USE_TEMPLATE (fn))
1498 push_tinst_level (fn);
1499 fn = NULL;
1500
1501 if (vec_member (TREE_TYPE (expr), types_memoized))
1502 {
1503 error ("circular pointer delegation detected");
1504 return error_mark_node;
1505 }
1506
1507 VEC_safe_push (tree, gc, types_memoized, TREE_TYPE (expr));
1508 last_rval = expr;
1509 }
1510
1511 while (current_instantiation () != actual_inst)
1512 pop_tinst_level ();
1513
1514 if (last_rval == NULL_TREE)
1515 {
1516 error ("base operand of %<->%> has non-pointer type %qT", type);
1517 return error_mark_node;
1518 }
1519
1520 if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1521 last_rval = convert_from_reference (last_rval);
1522 }
1523 else
1524 last_rval = decay_conversion (expr);
1525
1526 if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1527 {
1528 if (processing_template_decl)
1529 {
1530 expr = build_min (ARROW_EXPR, TREE_TYPE (TREE_TYPE (last_rval)),
1531 orig_expr);
1532 TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (last_rval);
1533 return expr;
1534 }
1535
1536 return cp_build_indirect_ref (last_rval, RO_NULL, tf_warning_or_error);
1537 }
1538
1539 if (types_memoized)
1540 error ("result of %<operator->()%> yields non-pointer result");
1541 else
1542 error ("base operand of %<->%> is not a pointer");
1543 return error_mark_node;
1544 }
1545
1546 /* Return an expression for "DATUM .* COMPONENT". DATUM has not
1547 already been checked out to be of aggregate type. */
1548
1549 tree
build_m_component_ref(tree datum,tree component)1550 build_m_component_ref (tree datum, tree component)
1551 {
1552 tree ptrmem_type;
1553 tree objtype;
1554 tree type;
1555 tree binfo;
1556 tree ctype;
1557
1558 if (error_operand_p (datum) || error_operand_p (component))
1559 return error_mark_node;
1560
1561 datum = mark_lvalue_use (datum);
1562 component = mark_rvalue_use (component);
1563
1564 ptrmem_type = TREE_TYPE (component);
1565 if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1566 {
1567 error ("%qE cannot be used as a member pointer, since it is of "
1568 "type %qT",
1569 component, ptrmem_type);
1570 return error_mark_node;
1571 }
1572
1573 objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1574 if (! MAYBE_CLASS_TYPE_P (objtype))
1575 {
1576 error ("cannot apply member pointer %qE to %qE, which is of "
1577 "non-class type %qT",
1578 component, datum, objtype);
1579 return error_mark_node;
1580 }
1581
1582 type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1583 ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1584
1585 if (!COMPLETE_TYPE_P (ctype))
1586 {
1587 if (!same_type_p (ctype, objtype))
1588 goto mismatch;
1589 binfo = NULL;
1590 }
1591 else
1592 {
1593 binfo = lookup_base (objtype, ctype, ba_check, NULL);
1594
1595 if (!binfo)
1596 {
1597 mismatch:
1598 error ("pointer to member type %qT incompatible with object "
1599 "type %qT",
1600 type, objtype);
1601 return error_mark_node;
1602 }
1603 else if (binfo == error_mark_node)
1604 return error_mark_node;
1605 }
1606
1607 if (TYPE_PTRMEM_P (ptrmem_type))
1608 {
1609 bool is_lval = real_lvalue_p (datum);
1610 tree ptype;
1611
1612 /* Compute the type of the field, as described in [expr.ref].
1613 There's no such thing as a mutable pointer-to-member, so
1614 things are not as complex as they are for references to
1615 non-static data members. */
1616 type = cp_build_qualified_type (type,
1617 (cp_type_quals (type)
1618 | cp_type_quals (TREE_TYPE (datum))));
1619
1620 datum = build_address (datum);
1621
1622 /* Convert object to the correct base. */
1623 if (binfo)
1624 datum = build_base_path (PLUS_EXPR, datum, binfo, 1,
1625 tf_warning_or_error);
1626
1627 /* Build an expression for "object + offset" where offset is the
1628 value stored in the pointer-to-data-member. */
1629 ptype = build_pointer_type (type);
1630 datum = fold_build_pointer_plus (fold_convert (ptype, datum), component);
1631 datum = cp_build_indirect_ref (datum, RO_NULL, tf_warning_or_error);
1632 /* If the object expression was an rvalue, return an rvalue. */
1633 if (!is_lval)
1634 datum = move (datum);
1635 return datum;
1636 }
1637 else
1638 return build2 (OFFSET_REF, type, datum, component);
1639 }
1640
1641 /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */
1642
1643 tree
build_functional_cast(tree exp,tree parms,tsubst_flags_t complain)1644 build_functional_cast (tree exp, tree parms, tsubst_flags_t complain)
1645 {
1646 /* This is either a call to a constructor,
1647 or a C cast in C++'s `functional' notation. */
1648
1649 /* The type to which we are casting. */
1650 tree type;
1651 VEC(tree,gc) *parmvec;
1652
1653 if (exp == error_mark_node || parms == error_mark_node)
1654 return error_mark_node;
1655
1656 if (TREE_CODE (exp) == TYPE_DECL)
1657 type = TREE_TYPE (exp);
1658 else
1659 type = exp;
1660
1661 /* We need to check this explicitly, since value-initialization of
1662 arrays is allowed in other situations. */
1663 if (TREE_CODE (type) == ARRAY_TYPE)
1664 {
1665 if (complain & tf_error)
1666 error ("functional cast to array type %qT", type);
1667 return error_mark_node;
1668 }
1669
1670 if (type_uses_auto (type))
1671 {
1672 if (complain & tf_error)
1673 error ("invalid use of %<auto%>");
1674 return error_mark_node;
1675 }
1676
1677 if (processing_template_decl)
1678 {
1679 tree t;
1680
1681 /* Diagnose this even in a template. We could also try harder
1682 to give all the usual errors when the type and args are
1683 non-dependent... */
1684 if (TREE_CODE (type) == REFERENCE_TYPE && !parms)
1685 {
1686 if (complain & tf_error)
1687 error ("invalid value-initialization of reference type");
1688 return error_mark_node;
1689 }
1690
1691 t = build_min (CAST_EXPR, type, parms);
1692 /* We don't know if it will or will not have side effects. */
1693 TREE_SIDE_EFFECTS (t) = 1;
1694 return t;
1695 }
1696
1697 if (! MAYBE_CLASS_TYPE_P (type))
1698 {
1699 if (parms == NULL_TREE)
1700 {
1701 if (VOID_TYPE_P (type))
1702 return void_zero_node;
1703 return build_value_init (cv_unqualified (type), complain);
1704 }
1705
1706 /* This must build a C cast. */
1707 parms = build_x_compound_expr_from_list (parms, ELK_FUNC_CAST, complain);
1708 return cp_build_c_cast (type, parms, complain);
1709 }
1710
1711 /* Prepare to evaluate as a call to a constructor. If this expression
1712 is actually used, for example,
1713
1714 return X (arg1, arg2, ...);
1715
1716 then the slot being initialized will be filled in. */
1717
1718 if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
1719 return error_mark_node;
1720 if (abstract_virtuals_error_sfinae (NULL_TREE, type, complain))
1721 return error_mark_node;
1722
1723 /* [expr.type.conv]
1724
1725 If the expression list is a single-expression, the type
1726 conversion is equivalent (in definedness, and if defined in
1727 meaning) to the corresponding cast expression. */
1728 if (parms && TREE_CHAIN (parms) == NULL_TREE)
1729 return cp_build_c_cast (type, TREE_VALUE (parms), complain);
1730
1731 /* [expr.type.conv]
1732
1733 The expression T(), where T is a simple-type-specifier for a
1734 non-array complete object type or the (possibly cv-qualified)
1735 void type, creates an rvalue of the specified type, which is
1736 value-initialized. */
1737
1738 if (parms == NULL_TREE)
1739 {
1740 exp = build_value_init (type, complain);
1741 exp = get_target_expr_sfinae (exp, complain);
1742 return exp;
1743 }
1744
1745 /* Call the constructor. */
1746 parmvec = make_tree_vector ();
1747 for (; parms != NULL_TREE; parms = TREE_CHAIN (parms))
1748 VEC_safe_push (tree, gc, parmvec, TREE_VALUE (parms));
1749 exp = build_special_member_call (NULL_TREE, complete_ctor_identifier,
1750 &parmvec, type, LOOKUP_NORMAL, complain);
1751 release_tree_vector (parmvec);
1752
1753 if (exp == error_mark_node)
1754 return error_mark_node;
1755
1756 return build_cplus_new (type, exp, complain);
1757 }
1758
1759
1760 /* Add new exception specifier SPEC, to the LIST we currently have.
1761 If it's already in LIST then do nothing.
1762 Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1763 know what we're doing. */
1764
1765 tree
add_exception_specifier(tree list,tree spec,int complain)1766 add_exception_specifier (tree list, tree spec, int complain)
1767 {
1768 bool ok;
1769 tree core = spec;
1770 bool is_ptr;
1771 diagnostic_t diag_type = DK_UNSPECIFIED; /* none */
1772
1773 if (spec == error_mark_node)
1774 return list;
1775
1776 gcc_assert (spec && (!list || TREE_VALUE (list)));
1777
1778 /* [except.spec] 1, type in an exception specifier shall not be
1779 incomplete, or pointer or ref to incomplete other than pointer
1780 to cv void. */
1781 is_ptr = TREE_CODE (core) == POINTER_TYPE;
1782 if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1783 core = TREE_TYPE (core);
1784 if (complain < 0)
1785 ok = true;
1786 else if (VOID_TYPE_P (core))
1787 ok = is_ptr;
1788 else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1789 ok = true;
1790 else if (processing_template_decl)
1791 ok = true;
1792 else
1793 {
1794 ok = true;
1795 /* 15.4/1 says that types in an exception specifier must be complete,
1796 but it seems more reasonable to only require this on definitions
1797 and calls. So just give a pedwarn at this point; we will give an
1798 error later if we hit one of those two cases. */
1799 if (!COMPLETE_TYPE_P (complete_type (core)))
1800 diag_type = DK_PEDWARN; /* pedwarn */
1801 }
1802
1803 if (ok)
1804 {
1805 tree probe;
1806
1807 for (probe = list; probe; probe = TREE_CHAIN (probe))
1808 if (same_type_p (TREE_VALUE (probe), spec))
1809 break;
1810 if (!probe)
1811 list = tree_cons (NULL_TREE, spec, list);
1812 }
1813 else
1814 diag_type = DK_ERROR; /* error */
1815
1816 if (diag_type != DK_UNSPECIFIED && complain)
1817 cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1818
1819 return list;
1820 }
1821
1822 /* Like nothrow_spec_p, but don't abort on deferred noexcept. */
1823
1824 static bool
nothrow_spec_p_uninst(const_tree spec)1825 nothrow_spec_p_uninst (const_tree spec)
1826 {
1827 if (DEFERRED_NOEXCEPT_SPEC_P (spec))
1828 return false;
1829 return nothrow_spec_p (spec);
1830 }
1831
1832 /* Combine the two exceptions specifier lists LIST and ADD, and return
1833 their union. If FN is non-null, it's the source of ADD. */
1834
1835 tree
merge_exception_specifiers(tree list,tree add,tree fn)1836 merge_exception_specifiers (tree list, tree add, tree fn)
1837 {
1838 tree noex, orig_list;
1839
1840 /* No exception-specifier or noexcept(false) are less strict than
1841 anything else. Prefer the newer variant (LIST). */
1842 if (!list || list == noexcept_false_spec)
1843 return list;
1844 else if (!add || add == noexcept_false_spec)
1845 return add;
1846
1847 /* noexcept(true) and throw() are stricter than anything else.
1848 As above, prefer the more recent one (LIST). */
1849 if (nothrow_spec_p_uninst (add))
1850 return list;
1851
1852 noex = TREE_PURPOSE (list);
1853 if (DEFERRED_NOEXCEPT_SPEC_P (add))
1854 {
1855 /* If ADD is a deferred noexcept, we must have been called from
1856 process_subob_fn. For implicitly declared functions, we build up
1857 a list of functions to consider at instantiation time. */
1858 if (noex && operand_equal_p (noex, boolean_true_node, 0))
1859 noex = NULL_TREE;
1860 gcc_assert (fn && (!noex || is_overloaded_fn (noex)));
1861 noex = build_overload (fn, noex);
1862 }
1863 else if (nothrow_spec_p_uninst (list))
1864 return add;
1865 else
1866 gcc_checking_assert (!TREE_PURPOSE (add)
1867 || cp_tree_equal (noex, TREE_PURPOSE (add)));
1868
1869 /* Combine the dynamic-exception-specifiers, if any. */
1870 orig_list = list;
1871 for (; add && TREE_VALUE (add); add = TREE_CHAIN (add))
1872 {
1873 tree spec = TREE_VALUE (add);
1874 tree probe;
1875
1876 for (probe = orig_list; probe && TREE_VALUE (probe);
1877 probe = TREE_CHAIN (probe))
1878 if (same_type_p (TREE_VALUE (probe), spec))
1879 break;
1880 if (!probe)
1881 {
1882 spec = build_tree_list (NULL_TREE, spec);
1883 TREE_CHAIN (spec) = list;
1884 list = spec;
1885 }
1886 }
1887
1888 /* Keep the noexcept-specifier at the beginning of the list. */
1889 if (noex != TREE_PURPOSE (list))
1890 list = tree_cons (noex, TREE_VALUE (list), TREE_CHAIN (list));
1891
1892 return list;
1893 }
1894
1895 /* Subroutine of build_call. Ensure that each of the types in the
1896 exception specification is complete. Technically, 15.4/1 says that
1897 they need to be complete when we see a declaration of the function,
1898 but we should be able to get away with only requiring this when the
1899 function is defined or called. See also add_exception_specifier. */
1900
1901 void
require_complete_eh_spec_types(tree fntype,tree decl)1902 require_complete_eh_spec_types (tree fntype, tree decl)
1903 {
1904 tree raises;
1905 /* Don't complain about calls to op new. */
1906 if (decl && DECL_ARTIFICIAL (decl))
1907 return;
1908 for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1909 raises = TREE_CHAIN (raises))
1910 {
1911 tree type = TREE_VALUE (raises);
1912 if (type && !COMPLETE_TYPE_P (type))
1913 {
1914 if (decl)
1915 error
1916 ("call to function %qD which throws incomplete type %q#T",
1917 decl, type);
1918 else
1919 error ("call to function which throws incomplete type %q#T",
1920 decl);
1921 }
1922 }
1923 }
1924
1925
1926 #include "gt-cp-typeck2.h"
1927