OSDN Git Service

c2eff9eb6c890f025d3f47a7aac57d455c415641
[pf3gnuchains/gcc-fork.git] / gcc / cp / typeck2.c
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
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
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
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
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 \f
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
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
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
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
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         inform (input_location, "\t%+#D", fn);
344       /* Now truncate the vector.  This leaves it non-null, so we know
345          there are pure virtuals, but empty so we don't list them out
346          again.  */
347       VEC_truncate (tree, pure, 0);
348     }
349   else
350     inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
351             "  since type %qT has pure virtual functions",
352             type);
353
354   return 1;
355 }
356
357 /* Wrapper for the above function in the common case of wanting errors.  */
358
359 int
360 abstract_virtuals_error (tree decl, tree type)
361 {
362   return abstract_virtuals_error_sfinae (decl, type, tf_warning_or_error);
363 }
364
365 /* Print an error message for invalid use of an incomplete type.
366    VALUE is the expression that was used (or 0 if that isn't known)
367    and TYPE is the type that was invalid.  DIAG_KIND indicates the
368    type of diagnostic (see diagnostic.def).  */
369
370 void
371 cxx_incomplete_type_diagnostic (const_tree value, const_tree type, 
372                                 diagnostic_t diag_kind)
373 {
374   int decl = 0;
375
376   gcc_assert (diag_kind == DK_WARNING 
377               || diag_kind == DK_PEDWARN 
378               || diag_kind == DK_ERROR);
379
380   /* Avoid duplicate error message.  */
381   if (TREE_CODE (type) == ERROR_MARK)
382     return;
383
384   if (value != 0 && (TREE_CODE (value) == VAR_DECL
385                      || TREE_CODE (value) == PARM_DECL
386                      || TREE_CODE (value) == FIELD_DECL))
387     {
388       emit_diagnostic (diag_kind, input_location, 0,
389                        "%q+D has incomplete type", value);
390       decl = 1;
391     }
392  retry:
393   /* We must print an error message.  Be clever about what it says.  */
394
395   switch (TREE_CODE (type))
396     {
397     case RECORD_TYPE:
398     case UNION_TYPE:
399     case ENUMERAL_TYPE:
400       if (!decl)
401         emit_diagnostic (diag_kind, input_location, 0,
402                          "invalid use of incomplete type %q#T", type);
403       if (!TYPE_TEMPLATE_INFO (type))
404         emit_diagnostic (diag_kind, input_location, 0,
405                          "forward declaration of %q+#T", type);
406       else
407         emit_diagnostic (diag_kind, input_location, 0,
408                          "declaration of %q+#T", type);
409       break;
410
411     case VOID_TYPE:
412       emit_diagnostic (diag_kind, input_location, 0,
413                        "invalid use of %qT", type);
414       break;
415
416     case ARRAY_TYPE:
417       if (TYPE_DOMAIN (type))
418         {
419           type = TREE_TYPE (type);
420           goto retry;
421         }
422       emit_diagnostic (diag_kind, input_location, 0,
423                        "invalid use of array with unspecified bounds");
424       break;
425
426     case OFFSET_TYPE:
427     bad_member:
428       emit_diagnostic (diag_kind, input_location, 0,
429                        "invalid use of member (did you forget the %<&%> ?)");
430       break;
431
432     case TEMPLATE_TYPE_PARM:
433       if (is_auto (type))
434         emit_diagnostic (diag_kind, input_location, 0,
435                          "invalid use of %<auto%>");
436       else
437         emit_diagnostic (diag_kind, input_location, 0,
438                          "invalid use of template type parameter %qT", type);
439       break;
440
441     case BOUND_TEMPLATE_TEMPLATE_PARM:
442       emit_diagnostic (diag_kind, input_location, 0,
443                        "invalid use of template template parameter %qT",
444                        TYPE_NAME (type));
445       break;
446
447     case TYPENAME_TYPE:
448       emit_diagnostic (diag_kind, input_location, 0,
449                        "invalid use of dependent type %qT", type);
450       break;
451
452     case LANG_TYPE:
453       gcc_assert (type == unknown_type_node);
454       if (value && TREE_CODE (value) == COMPONENT_REF)
455         goto bad_member;
456       else if (value && TREE_CODE (value) == ADDR_EXPR)
457         emit_diagnostic (diag_kind, input_location, 0,
458                          "address of overloaded function with no contextual "
459                          "type information");
460       else if (value && TREE_CODE (value) == OVERLOAD)
461         emit_diagnostic (diag_kind, input_location, 0,
462                          "overloaded function with no contextual type information");
463       else
464         emit_diagnostic (diag_kind, input_location, 0,
465                          "insufficient contextual information to determine type");
466       break;
467
468     default:
469       gcc_unreachable ();
470     }
471 }
472
473 /* Backward-compatibility interface to incomplete_type_diagnostic;
474    required by ../tree.c.  */
475 #undef cxx_incomplete_type_error
476 void
477 cxx_incomplete_type_error (const_tree value, const_tree type)
478 {
479   cxx_incomplete_type_diagnostic (value, type, DK_ERROR);
480 }
481
482 \f
483 /* The recursive part of split_nonconstant_init.  DEST is an lvalue
484    expression to which INIT should be assigned.  INIT is a CONSTRUCTOR.  */
485
486 static void
487 split_nonconstant_init_1 (tree dest, tree *initp)
488 {
489   unsigned HOST_WIDE_INT idx;
490   tree init = *initp;
491   tree field_index, value;
492   tree type = TREE_TYPE (dest);
493   tree inner_type = NULL;
494   bool array_type_p = false;
495   HOST_WIDE_INT num_type_elements, num_initialized_elements;
496
497   switch (TREE_CODE (type))
498     {
499     case ARRAY_TYPE:
500       inner_type = TREE_TYPE (type);
501       array_type_p = true;
502       /* FALLTHRU */
503
504     case RECORD_TYPE:
505     case UNION_TYPE:
506     case QUAL_UNION_TYPE:
507       num_initialized_elements = 0;
508       FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,
509                                 field_index, value)
510         {
511           /* The current implementation of this algorithm assumes that
512              the field was set for all the elements. This is usually done
513              by process_init_constructor.  */
514           gcc_assert (field_index);
515
516           if (!array_type_p)
517             inner_type = TREE_TYPE (field_index);
518
519           if (TREE_CODE (value) == CONSTRUCTOR)
520             {
521               tree sub;
522
523               if (array_type_p)
524                 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
525                               NULL_TREE, NULL_TREE);
526               else
527                 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
528                               NULL_TREE);
529
530               split_nonconstant_init_1 (sub, &value);
531             }
532           else if (!initializer_constant_valid_p (value, inner_type))
533             {
534               tree code;
535               tree sub;
536               HOST_WIDE_INT inner_elements;
537
538               /* FIXME: Ordered removal is O(1) so the whole function is
539                  worst-case quadratic. This could be fixed using an aside
540                  bitmap to record which elements must be removed and remove
541                  them all at the same time. Or by merging
542                  split_non_constant_init into process_init_constructor_array,
543                  that is separating constants from non-constants while building
544                  the vector.  */
545               VEC_ordered_remove (constructor_elt, CONSTRUCTOR_ELTS (init),
546                                   idx);
547               --idx;
548
549               if (array_type_p)
550                 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
551                               NULL_TREE, NULL_TREE);
552               else
553                 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
554                               NULL_TREE);
555
556               code = build2 (INIT_EXPR, inner_type, sub, value);
557               code = build_stmt (input_location, EXPR_STMT, code);
558               add_stmt (code);
559
560               inner_elements = count_type_elements (inner_type, true);
561               if (inner_elements < 0)
562                 num_initialized_elements = -1;
563               else if (num_initialized_elements >= 0)
564                 num_initialized_elements += inner_elements;
565               continue;
566             }
567         }
568
569       num_type_elements = count_type_elements (type, true);
570       /* If all elements of the initializer are non-constant and
571          have been split out, we don't need the empty CONSTRUCTOR.  */
572       if (num_type_elements > 0
573           && num_type_elements == num_initialized_elements)
574         *initp = NULL;
575       break;
576
577     case VECTOR_TYPE:
578       if (!initializer_constant_valid_p (init, type))
579         {
580           tree code;
581           tree cons = copy_node (init);
582           CONSTRUCTOR_ELTS (init) = NULL;
583           code = build2 (MODIFY_EXPR, type, dest, cons);
584           code = build_stmt (input_location, EXPR_STMT, code);
585           add_stmt (code);
586         }
587       break;
588
589     default:
590       gcc_unreachable ();
591     }
592
593   /* The rest of the initializer is now a constant. */
594   TREE_CONSTANT (init) = 1;
595 }
596
597 /* A subroutine of store_init_value.  Splits non-constant static
598    initializer INIT into a constant part and generates code to
599    perform the non-constant part of the initialization to DEST.
600    Returns the code for the runtime init.  */
601
602 static tree
603 split_nonconstant_init (tree dest, tree init)
604 {
605   tree code;
606
607   if (TREE_CODE (init) == CONSTRUCTOR)
608     {
609       code = push_stmt_list ();
610       split_nonconstant_init_1 (dest, &init);
611       code = pop_stmt_list (code);
612       DECL_INITIAL (dest) = init;
613       TREE_READONLY (dest) = 0;
614     }
615   else
616     code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
617
618   return code;
619 }
620
621 /* Perform appropriate conversions on the initial value of a variable,
622    store it in the declaration DECL,
623    and print any error messages that are appropriate.
624    If the init is invalid, store an ERROR_MARK.
625
626    C++: Note that INIT might be a TREE_LIST, which would mean that it is
627    a base class initializer for some aggregate type, hopefully compatible
628    with DECL.  If INIT is a single element, and DECL is an aggregate
629    type, we silently convert INIT into a TREE_LIST, allowing a constructor
630    to be called.
631
632    If INIT is a TREE_LIST and there is no constructor, turn INIT
633    into a CONSTRUCTOR and use standard initialization techniques.
634    Perhaps a warning should be generated?
635
636    Returns code to be executed if initialization could not be performed
637    for static variable.  In that case, caller must emit the code.  */
638
639 tree
640 store_init_value (tree decl, tree init, int flags)
641 {
642   tree value, type;
643
644   /* If variable's type was invalidly declared, just ignore it.  */
645
646   type = TREE_TYPE (decl);
647   if (TREE_CODE (type) == ERROR_MARK)
648     return NULL_TREE;
649
650   if (MAYBE_CLASS_TYPE_P (type))
651     {
652       if (TREE_CODE (init) == TREE_LIST)
653         {
654           error ("constructor syntax used, but no constructor declared "
655                  "for type %qT", type);
656           init = build_constructor_from_list (init_list_type_node, nreverse (init));
657         }
658     }
659   else if (TREE_CODE (init) == TREE_LIST
660            && TREE_TYPE (init) != unknown_type_node)
661     {
662       gcc_assert (TREE_CODE (decl) != RESULT_DECL);
663
664       if (TREE_CODE (init) == TREE_LIST
665                && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
666         {
667           error ("cannot initialize arrays using this syntax");
668           return NULL_TREE;
669         }
670       else
671         /* We get here with code like `int a (2);' */
672         init = build_x_compound_expr_from_list (init, ELK_INIT,
673                                                 tf_warning_or_error);
674     }
675
676   /* End of special C++ code.  */
677
678   if (flags & LOOKUP_ALREADY_DIGESTED)
679     value = init;
680   else
681     /* Digest the specified initializer into an expression.  */
682     value = digest_init_flags (type, init, flags);
683
684   /* In C++0x constant expression is a semantic, not syntactic, property.
685      In C++98, make sure that what we thought was a constant expression at
686      template definition time is still constant.  */
687   if ((cxx_dialect >= cxx0x
688        || DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
689       && (decl_maybe_constant_var_p (decl)
690           || TREE_STATIC (decl)))
691     {
692       bool const_init;
693       value = fold_non_dependent_expr (value);
694       value = maybe_constant_init (value);
695       if (DECL_DECLARED_CONSTEXPR_P (decl))
696         /* Diagnose a non-constant initializer for constexpr.  */
697         value = cxx_constant_value (value);
698       const_init = (reduced_constant_expression_p (value)
699                     || error_operand_p (value));
700       DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = const_init;
701       TREE_CONSTANT (decl) = const_init && decl_maybe_constant_var_p (decl);
702     }
703
704   /* If the initializer is not a constant, fill in DECL_INITIAL with
705      the bits that are constant, and then return an expression that
706      will perform the dynamic initialization.  */
707   if (value != error_mark_node
708       && (TREE_SIDE_EFFECTS (value)
709            || ! initializer_constant_valid_p (value, TREE_TYPE (value))))
710     return split_nonconstant_init (decl, value);
711   /* If the value is a constant, just put it in DECL_INITIAL.  If DECL
712      is an automatic variable, the middle end will turn this into a
713      dynamic initialization later.  */
714   DECL_INITIAL (decl) = value;
715   return NULL_TREE;
716 }
717
718 \f
719 /* Give errors about narrowing conversions within { }.  */
720
721 void
722 check_narrowing (tree type, tree init)
723 {
724   tree ftype = unlowered_expr_type (init);
725   bool ok = true;
726   REAL_VALUE_TYPE d;
727
728   if (!ARITHMETIC_TYPE_P (type))
729     return;
730
731   if (BRACE_ENCLOSED_INITIALIZER_P (init)
732       && TREE_CODE (type) == COMPLEX_TYPE)
733     {
734       tree elttype = TREE_TYPE (type);
735       check_narrowing (elttype, CONSTRUCTOR_ELT (init, 0)->value);
736       if (CONSTRUCTOR_NELTS (init) > 1)
737         check_narrowing (elttype, CONSTRUCTOR_ELT (init, 1)->value);
738       return;
739     }
740
741   init = maybe_constant_value (init);
742
743   if (TREE_CODE (type) == INTEGER_TYPE
744       && TREE_CODE (ftype) == REAL_TYPE)
745     ok = false;
746   else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
747            && CP_INTEGRAL_TYPE_P (type))
748     {
749       if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype)
750           && (TREE_CODE (init) != INTEGER_CST
751               || !int_fits_type_p (init, type)))
752         ok = false;
753     }
754   else if (TREE_CODE (ftype) == REAL_TYPE
755            && TREE_CODE (type) == REAL_TYPE)
756     {
757       if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype))
758         {
759           if (TREE_CODE (init) == REAL_CST)
760             {
761               /* Issue 703: Loss of precision is OK as long as the value is
762                  within the representable range of the new type.  */
763               REAL_VALUE_TYPE r;
764               d = TREE_REAL_CST (init);
765               real_convert (&r, TYPE_MODE (type), &d);
766               if (real_isinf (&r))
767                 ok = false;
768             }
769           else
770             ok = false;
771         }
772     }
773   else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
774            && TREE_CODE (type) == REAL_TYPE)
775     {
776       ok = false;
777       if (TREE_CODE (init) == INTEGER_CST)
778         {
779           d = real_value_from_int_cst (0, init);
780           if (exact_real_truncate (TYPE_MODE (type), &d))
781             ok = true;
782         }
783     }
784
785   if (!ok)
786     permerror (input_location, "narrowing conversion of %qE from %qT "
787                "to %qT inside { }", init, ftype, type);
788 }
789
790 /* Process the initializer INIT for a variable of type TYPE, emitting
791    diagnostics for invalid initializers and converting the initializer as
792    appropriate.
793
794    For aggregate types, it assumes that reshape_init has already run, thus the
795    initializer will have the right shape (brace elision has been undone).
796
797    NESTED is true iff we are being called for an element of a CONSTRUCTOR.  */
798
799 static tree
800 digest_init_r (tree type, tree init, bool nested, int flags,
801                tsubst_flags_t complain)
802 {
803   enum tree_code code = TREE_CODE (type);
804
805   if (error_operand_p (init))
806     return error_mark_node;
807
808   gcc_assert (init);
809
810   /* We must strip the outermost array type when completing the type,
811      because the its bounds might be incomplete at the moment.  */
812   if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE
813                               ? TREE_TYPE (type) : type, NULL_TREE))
814     return error_mark_node;
815
816   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
817      (g++.old-deja/g++.law/casts2.C).  */
818   if (TREE_CODE (init) == NON_LVALUE_EXPR)
819     init = TREE_OPERAND (init, 0);
820
821   /* Initialization of an array of chars from a string constant. The initializer
822      can be optionally enclosed in braces, but reshape_init has already removed
823      them if they were present.  */
824   if (code == ARRAY_TYPE)
825     {
826       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
827       if (char_type_p (typ1)
828           /*&& init */
829           && TREE_CODE (init) == STRING_CST)
830         {
831           tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
832
833           if (TYPE_PRECISION (typ1) == BITS_PER_UNIT)
834             {
835               if (char_type != char_type_node)
836                 {
837                   if (complain & tf_error)
838                     error ("char-array initialized from wide string");
839                   return error_mark_node;
840                 }
841             }
842           else
843             {
844               if (char_type == char_type_node)
845                 {
846                   if (complain & tf_error)
847                     error ("int-array initialized from non-wide string");
848                   return error_mark_node;
849                 }
850               else if (char_type != typ1)
851                 {
852                   if (complain & tf_error)
853                     error ("int-array initialized from incompatible "
854                            "wide string");
855                   return error_mark_node;
856                 }
857             }
858
859           TREE_TYPE (init) = type;
860           if (TYPE_DOMAIN (type) != 0 && TREE_CONSTANT (TYPE_SIZE (type)))
861             {
862               int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
863               size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
864               /* In C it is ok to subtract 1 from the length of the string
865                  because it's ok to ignore the terminating null char that is
866                  counted in the length of the constant, but in C++ this would
867                  be invalid.  */
868               if (size < TREE_STRING_LENGTH (init))
869                 permerror (input_location, "initializer-string for array "
870                            "of chars is too long");
871             }
872           return init;
873         }
874     }
875
876   /* Handle scalar types (including conversions) and references.  */
877   if ((TREE_CODE (type) != COMPLEX_TYPE
878        || BRACE_ENCLOSED_INITIALIZER_P (init))
879       && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE))
880     {
881       tree *exp;
882
883       if (cxx_dialect != cxx98 && nested)
884         check_narrowing (type, init);
885       init = convert_for_initialization (0, type, init, flags,
886                                          ICR_INIT, NULL_TREE, 0,
887                                          complain);
888       exp = &init;
889
890       /* Skip any conversions since we'll be outputting the underlying
891          constant.  */
892       while (CONVERT_EXPR_P (*exp)
893              || TREE_CODE (*exp) == NON_LVALUE_EXPR)
894         exp = &TREE_OPERAND (*exp, 0);
895
896       *exp = cplus_expand_constant (*exp);
897
898       return init;
899     }
900
901   /* Come here only for aggregates: records, arrays, unions, complex numbers
902      and vectors.  */
903   gcc_assert (TREE_CODE (type) == ARRAY_TYPE
904               || TREE_CODE (type) == VECTOR_TYPE
905               || TREE_CODE (type) == RECORD_TYPE
906               || TREE_CODE (type) == UNION_TYPE
907               || TREE_CODE (type) == COMPLEX_TYPE);
908
909   if (BRACE_ENCLOSED_INITIALIZER_P (init)
910       && !TYPE_NON_AGGREGATE_CLASS (type))
911     return process_init_constructor (type, init, complain);
912   else
913     {
914       if (COMPOUND_LITERAL_P (init) && TREE_CODE (type) == ARRAY_TYPE)
915         {
916           if (complain & tf_error)
917             error ("cannot initialize aggregate of type %qT with "
918                    "a compound literal", type);
919
920           return error_mark_node;
921         }
922
923       if (TREE_CODE (type) == ARRAY_TYPE
924           && !BRACE_ENCLOSED_INITIALIZER_P (init))
925         {
926           /* Allow the result of build_array_copy and of
927              build_value_init_noctor.  */
928           if ((TREE_CODE (init) == TARGET_EXPR
929                || TREE_CODE (init) == CONSTRUCTOR)
930               && (same_type_ignoring_top_level_qualifiers_p
931                   (type, TREE_TYPE (init))))
932             return init;
933
934           if (complain & tf_error)
935             error ("array must be initialized with a brace-enclosed"
936                    " initializer");
937           return error_mark_node;
938         }
939
940       return convert_for_initialization (NULL_TREE, type, init,
941                                          flags,
942                                          ICR_INIT, NULL_TREE, 0,
943                                          complain);
944     }
945 }
946
947 tree
948 digest_init (tree type, tree init, tsubst_flags_t complain)
949 {
950   return digest_init_r (type, init, false, LOOKUP_IMPLICIT, complain);
951 }
952
953 tree
954 digest_init_flags (tree type, tree init, int flags)
955 {
956   return digest_init_r (type, init, false, flags, tf_warning_or_error);
957 }
958 \f
959 /* Set of flags used within process_init_constructor to describe the
960    initializers.  */
961 #define PICFLAG_ERRONEOUS 1
962 #define PICFLAG_NOT_ALL_CONSTANT 2
963 #define PICFLAG_NOT_ALL_SIMPLE 4
964
965 /* Given an initializer INIT, return the flag (PICFLAG_*) which better
966    describe it.  */
967
968 static int
969 picflag_from_initializer (tree init)
970 {
971   if (init == error_mark_node)
972     return PICFLAG_ERRONEOUS;
973   else if (!TREE_CONSTANT (init))
974     return PICFLAG_NOT_ALL_CONSTANT;
975   else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
976     return PICFLAG_NOT_ALL_SIMPLE;
977   return 0;
978 }
979
980 /* Subroutine of process_init_constructor, which will process an initializer
981    INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
982    which describe the initializers.  */
983
984 static int
985 process_init_constructor_array (tree type, tree init,
986                                 tsubst_flags_t complain)
987 {
988   unsigned HOST_WIDE_INT i, len = 0;
989   int flags = 0;
990   bool unbounded = false;
991   constructor_elt *ce;
992   VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (init);
993
994   gcc_assert (TREE_CODE (type) == ARRAY_TYPE
995               || TREE_CODE (type) == VECTOR_TYPE);
996
997   if (TREE_CODE (type) == ARRAY_TYPE)
998     {
999       tree domain = TYPE_DOMAIN (type);
1000       if (domain)
1001         len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))
1002               - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))
1003               + 1);
1004       else
1005         unbounded = true;  /* Take as many as there are.  */
1006     }
1007   else
1008     /* Vectors are like simple fixed-size arrays.  */
1009     len = TYPE_VECTOR_SUBPARTS (type);
1010
1011   /* There must not be more initializers than needed.  */
1012   if (!unbounded && VEC_length (constructor_elt, v)  > len)
1013     {
1014       if (complain & tf_error)
1015         error ("too many initializers for %qT", type);
1016       else
1017         return PICFLAG_ERRONEOUS;
1018     }
1019
1020   FOR_EACH_VEC_ELT (constructor_elt, v, i, ce)
1021     {
1022       if (ce->index)
1023         {
1024           gcc_assert (TREE_CODE (ce->index) == INTEGER_CST);
1025           if (compare_tree_int (ce->index, i) != 0)
1026             {
1027               ce->value = error_mark_node;
1028               sorry ("non-trivial designated initializers not supported");
1029             }
1030         }
1031       else
1032         ce->index = size_int (i);
1033       gcc_assert (ce->value);
1034       ce->value = digest_init_r (TREE_TYPE (type), ce->value, true,
1035                                  LOOKUP_IMPLICIT, complain);
1036
1037       if (ce->value != error_mark_node)
1038         gcc_assert (same_type_ignoring_top_level_qualifiers_p
1039                       (TREE_TYPE (type), TREE_TYPE (ce->value)));
1040
1041       flags |= picflag_from_initializer (ce->value);
1042     }
1043
1044   /* No more initializers. If the array is unbounded, we are done. Otherwise,
1045      we must add initializers ourselves.  */
1046   if (!unbounded)
1047     for (; i < len; ++i)
1048       {
1049         tree next;
1050
1051         if (type_build_ctor_call (TREE_TYPE (type)))
1052           {
1053             /* If this type needs constructors run for default-initialization,
1054               we can't rely on the back end to do it for us, so build up
1055               TARGET_EXPRs.  If the type in question is a class, just build
1056               one up; if it's an array, recurse.  */
1057             if (MAYBE_CLASS_TYPE_P (TREE_TYPE (type)))
1058               next = build_functional_cast (TREE_TYPE (type), NULL_TREE,
1059                                             complain);
1060             else
1061               next = build_constructor (init_list_type_node, NULL);
1062             next = digest_init (TREE_TYPE (type), next, complain);
1063           }
1064         else if (!zero_init_p (TREE_TYPE (type)))
1065           next = build_zero_init (TREE_TYPE (type),
1066                                   /*nelts=*/NULL_TREE,
1067                                   /*static_storage_p=*/false);
1068         else
1069           /* The default zero-initialization is fine for us; don't
1070              add anything to the CONSTRUCTOR.  */
1071           break;
1072
1073         flags |= picflag_from_initializer (next);
1074         CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
1075       }
1076
1077   CONSTRUCTOR_ELTS (init) = v;
1078   return flags;
1079 }
1080
1081 /* Subroutine of process_init_constructor, which will process an initializer
1082    INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
1083    the initializers.  */
1084
1085 static int
1086 process_init_constructor_record (tree type, tree init,
1087                                  tsubst_flags_t complain)
1088 {
1089   VEC(constructor_elt,gc) *v = NULL;
1090   int flags = 0;
1091   tree field;
1092   unsigned HOST_WIDE_INT idx = 0;
1093
1094   gcc_assert (TREE_CODE (type) == RECORD_TYPE);
1095   gcc_assert (!CLASSTYPE_VBASECLASSES (type));
1096   gcc_assert (!TYPE_BINFO (type)
1097               || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
1098   gcc_assert (!TYPE_POLYMORPHIC_P (type));
1099
1100   /* Generally, we will always have an index for each initializer (which is
1101      a FIELD_DECL, put by reshape_init), but compound literals don't go trough
1102      reshape_init. So we need to handle both cases.  */
1103   for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
1104     {
1105       tree next;
1106       tree type;
1107
1108       if (!DECL_NAME (field) && DECL_C_BIT_FIELD (field))
1109         {
1110           flags |= picflag_from_initializer (integer_zero_node);
1111           CONSTRUCTOR_APPEND_ELT (v, field, integer_zero_node);
1112           continue;
1113         }
1114
1115       if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field))
1116         continue;
1117
1118       /* If this is a bitfield, first convert to the declared type.  */
1119       type = TREE_TYPE (field);
1120       if (DECL_BIT_FIELD_TYPE (field))
1121         type = DECL_BIT_FIELD_TYPE (field);
1122
1123       if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1124         {
1125           constructor_elt *ce = VEC_index (constructor_elt,
1126                                            CONSTRUCTOR_ELTS (init), idx);
1127           if (ce->index)
1128             {
1129               /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
1130                  latter case can happen in templates where lookup has to be
1131                  deferred.  */
1132               gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
1133                           || TREE_CODE (ce->index) == IDENTIFIER_NODE);
1134               if (ce->index != field
1135                   && ce->index != DECL_NAME (field))
1136                 {
1137                   ce->value = error_mark_node;
1138                   sorry ("non-trivial designated initializers not supported");
1139                 }
1140             }
1141
1142           gcc_assert (ce->value);
1143           next = digest_init_r (type, ce->value, true,
1144                                 LOOKUP_IMPLICIT, complain);
1145           ++idx;
1146         }
1147       else if (type_build_ctor_call (TREE_TYPE (field)))
1148         {
1149           /* If this type needs constructors run for
1150              default-initialization, we can't rely on the back end to do it
1151              for us, so build up TARGET_EXPRs.  If the type in question is
1152              a class, just build one up; if it's an array, recurse.  */
1153           next = build_constructor (init_list_type_node, NULL);
1154           if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field)))
1155             {
1156               next = finish_compound_literal (TREE_TYPE (field), next,
1157                                               complain);
1158               /* direct-initialize the target. No temporary is going
1159                   to be involved.  */
1160               if (TREE_CODE (next) == TARGET_EXPR)
1161                 TARGET_EXPR_DIRECT_INIT_P (next) = true;
1162             }
1163
1164           next = digest_init_r (TREE_TYPE (field), next, true,
1165                                 LOOKUP_IMPLICIT, complain);
1166
1167           /* Warn when some struct elements are implicitly initialized.  */
1168           warning (OPT_Wmissing_field_initializers,
1169                    "missing initializer for member %qD", field);
1170         }
1171       else
1172         {
1173           if (TREE_READONLY (field))
1174             {
1175               if (complain & tf_error)
1176                 error ("uninitialized const member %qD", field);
1177               else
1178                 return PICFLAG_ERRONEOUS;
1179             }
1180           else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1181             {
1182               if (complain & tf_error)
1183                 error ("member %qD with uninitialized const fields", field);
1184               else
1185                 return PICFLAG_ERRONEOUS;
1186             }
1187           else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1188             {
1189               if (complain & tf_error)
1190                 error ("member %qD is uninitialized reference", field);
1191               else
1192                 return PICFLAG_ERRONEOUS;
1193             }
1194
1195           /* Warn when some struct elements are implicitly initialized
1196              to zero.  */
1197           warning (OPT_Wmissing_field_initializers,
1198                    "missing initializer for member %qD", field);
1199
1200           if (!zero_init_p (TREE_TYPE (field)))
1201             next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
1202                                     /*static_storage_p=*/false);
1203           else
1204             /* The default zero-initialization is fine for us; don't
1205             add anything to the CONSTRUCTOR.  */
1206             continue;
1207         }
1208
1209       /* If this is a bitfield, now convert to the lowered type.  */
1210       if (type != TREE_TYPE (field))
1211         next = cp_convert_and_check (TREE_TYPE (field), next);
1212       flags |= picflag_from_initializer (next);
1213       CONSTRUCTOR_APPEND_ELT (v, field, next);
1214     }
1215
1216   if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1217     {
1218       if (complain & tf_error)
1219         error ("too many initializers for %qT", type);
1220       else
1221         return PICFLAG_ERRONEOUS;
1222     }
1223
1224   CONSTRUCTOR_ELTS (init) = v;
1225   return flags;
1226 }
1227
1228 /* Subroutine of process_init_constructor, which will process a single
1229    initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1230    which describe the initializer.  */
1231
1232 static int
1233 process_init_constructor_union (tree type, tree init,
1234                                 tsubst_flags_t complain)
1235 {
1236   constructor_elt *ce;
1237   int len;
1238
1239   /* If the initializer was empty, use default zero initialization.  */
1240   if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
1241     return 0;
1242
1243   len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
1244   if (len > 1)
1245     {
1246       if (!(complain & tf_error))
1247         return PICFLAG_ERRONEOUS;
1248       error ("too many initializers for %qT", type);
1249       VEC_block_remove (constructor_elt, CONSTRUCTOR_ELTS (init), 1, len-1);
1250     }
1251
1252   ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0);
1253
1254   /* If this element specifies a field, initialize via that field.  */
1255   if (ce->index)
1256     {
1257       if (TREE_CODE (ce->index) == FIELD_DECL)
1258         ;
1259       else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
1260         {
1261           /* This can happen within a cast, see g++.dg/opt/cse2.C.  */
1262           tree name = ce->index;
1263           tree field;
1264           for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1265             if (DECL_NAME (field) == name)
1266               break;
1267           if (!field)
1268             {
1269               if (complain & tf_error)
1270                 error ("no field %qD found in union being initialized",
1271                        field);
1272               ce->value = error_mark_node;
1273             }
1274           ce->index = field;
1275         }
1276       else
1277         {
1278           gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
1279                       || TREE_CODE (ce->index) == RANGE_EXPR);
1280           if (complain & tf_error)
1281             error ("index value instead of field name in union initializer");
1282           ce->value = error_mark_node;
1283         }
1284     }
1285   else
1286     {
1287       /* Find the first named field.  ANSI decided in September 1990
1288          that only named fields count here.  */
1289       tree field = TYPE_FIELDS (type);
1290       while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1291         field = TREE_CHAIN (field);
1292       if (field == NULL_TREE)
1293         {
1294           if (complain & tf_error)
1295             error ("too many initializers for %qT", type);
1296           ce->value = error_mark_node;
1297         }
1298       ce->index = field;
1299     }
1300
1301   if (ce->value && ce->value != error_mark_node)
1302     ce->value = digest_init_r (TREE_TYPE (ce->index), ce->value,
1303                                true, LOOKUP_IMPLICIT, complain);
1304
1305   return picflag_from_initializer (ce->value);
1306 }
1307
1308 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1309    constructor is a brace-enclosed initializer, and will be modified in-place.
1310
1311    Each element is converted to the right type through digest_init, and
1312    missing initializers are added following the language rules (zero-padding,
1313    etc.).
1314
1315    After the execution, the initializer will have TREE_CONSTANT if all elts are
1316    constant, and TREE_STATIC set if, in addition, all elts are simple enough
1317    constants that the assembler and linker can compute them.
1318
1319    The function returns the initializer itself, or error_mark_node in case
1320    of error.  */
1321
1322 static tree
1323 process_init_constructor (tree type, tree init, tsubst_flags_t complain)
1324 {
1325   int flags;
1326
1327   gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
1328
1329   if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
1330     flags = process_init_constructor_array (type, init, complain);
1331   else if (TREE_CODE (type) == RECORD_TYPE)
1332     flags = process_init_constructor_record (type, init, complain);
1333   else if (TREE_CODE (type) == UNION_TYPE)
1334     flags = process_init_constructor_union (type, init, complain);
1335   else
1336     gcc_unreachable ();
1337
1338   if (flags & PICFLAG_ERRONEOUS)
1339     return error_mark_node;
1340
1341   TREE_TYPE (init) = type;
1342   if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1343     cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
1344   if (!(flags & PICFLAG_NOT_ALL_CONSTANT))
1345     {
1346       TREE_CONSTANT (init) = 1;
1347       if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
1348         TREE_STATIC (init) = 1;
1349     }
1350   return init;
1351 }
1352 \f
1353 /* Given a structure or union value DATUM, construct and return
1354    the structure or union component which results from narrowing
1355    that value to the base specified in BASETYPE.  For example, given the
1356    hierarchy
1357
1358    class L { int ii; };
1359    class A : L { ... };
1360    class B : L { ... };
1361    class C : A, B { ... };
1362
1363    and the declaration
1364
1365    C x;
1366
1367    then the expression
1368
1369    x.A::ii refers to the ii member of the L part of
1370    the A part of the C object named by X.  In this case,
1371    DATUM would be x, and BASETYPE would be A.
1372
1373    I used to think that this was nonconformant, that the standard specified
1374    that first we look up ii in A, then convert x to an L& and pull out the
1375    ii part.  But in fact, it does say that we convert x to an A&; A here
1376    is known as the "naming class".  (jason 2000-12-19)
1377
1378    BINFO_P points to a variable initialized either to NULL_TREE or to the
1379    binfo for the specific base subobject we want to convert to.  */
1380
1381 tree
1382 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1383 {
1384   tree binfo;
1385
1386   if (datum == error_mark_node)
1387     return error_mark_node;
1388   if (*binfo_p)
1389     binfo = *binfo_p;
1390   else
1391     binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1392
1393   if (!binfo || binfo == error_mark_node)
1394     {
1395       *binfo_p = NULL_TREE;
1396       if (!binfo)
1397         error_not_base_type (basetype, TREE_TYPE (datum));
1398       return error_mark_node;
1399     }
1400
1401   *binfo_p = binfo;
1402   return build_base_path (PLUS_EXPR, datum, binfo, 1);
1403 }
1404
1405 /* Build a reference to an object specified by the C++ `->' operator.
1406    Usually this just involves dereferencing the object, but if the
1407    `->' operator is overloaded, then such overloads must be
1408    performed until an object which does not have the `->' operator
1409    overloaded is found.  An error is reported when circular pointer
1410    delegation is detected.  */
1411
1412 tree
1413 build_x_arrow (tree expr)
1414 {
1415   tree orig_expr = expr;
1416   tree type = TREE_TYPE (expr);
1417   tree last_rval = NULL_TREE;
1418   VEC(tree,gc) *types_memoized = NULL;
1419
1420   if (type == error_mark_node)
1421     return error_mark_node;
1422
1423   if (processing_template_decl)
1424     {
1425       if (type_dependent_expression_p (expr))
1426         return build_min_nt (ARROW_EXPR, expr);
1427       expr = build_non_dependent_expr (expr);
1428     }
1429
1430   if (MAYBE_CLASS_TYPE_P (type))
1431     {
1432       while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1433                                    NULL_TREE, NULL_TREE,
1434                                    /*overloaded_p=*/NULL, 
1435                                    tf_warning_or_error)))
1436         {
1437           if (expr == error_mark_node)
1438             return error_mark_node;
1439
1440           if (vec_member (TREE_TYPE (expr), types_memoized))
1441             {
1442               error ("circular pointer delegation detected");
1443               return error_mark_node;
1444             }
1445
1446           VEC_safe_push (tree, gc, types_memoized, TREE_TYPE (expr));
1447           last_rval = expr;
1448         }
1449
1450       if (last_rval == NULL_TREE)
1451         {
1452           error ("base operand of %<->%> has non-pointer type %qT", type);
1453           return error_mark_node;
1454         }
1455
1456       if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1457         last_rval = convert_from_reference (last_rval);
1458     }
1459   else
1460     last_rval = decay_conversion (expr);
1461
1462   if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1463     {
1464       if (processing_template_decl)
1465         {
1466           expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr);
1467           /* It will be dereferenced.  */
1468           TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval));
1469           return expr;
1470         }
1471
1472       return cp_build_indirect_ref (last_rval, RO_NULL, tf_warning_or_error);
1473     }
1474
1475   if (types_memoized)
1476     error ("result of %<operator->()%> yields non-pointer result");
1477   else
1478     error ("base operand of %<->%> is not a pointer");
1479   return error_mark_node;
1480 }
1481
1482 /* Return an expression for "DATUM .* COMPONENT".  DATUM has not
1483    already been checked out to be of aggregate type.  */
1484
1485 tree
1486 build_m_component_ref (tree datum, tree component)
1487 {
1488   tree ptrmem_type;
1489   tree objtype;
1490   tree type;
1491   tree binfo;
1492   tree ctype;
1493
1494   if (error_operand_p (datum) || error_operand_p (component))
1495     return error_mark_node;
1496
1497   datum = mark_lvalue_use (datum);
1498   component = mark_rvalue_use (component);
1499
1500   ptrmem_type = TREE_TYPE (component);
1501   if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1502     {
1503       error ("%qE cannot be used as a member pointer, since it is of "
1504              "type %qT",
1505              component, ptrmem_type);
1506       return error_mark_node;
1507     }
1508
1509   objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1510   if (! MAYBE_CLASS_TYPE_P (objtype))
1511     {
1512       error ("cannot apply member pointer %qE to %qE, which is of "
1513              "non-class type %qT",
1514              component, datum, objtype);
1515       return error_mark_node;
1516     }
1517
1518   type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1519   ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1520
1521   if (!COMPLETE_TYPE_P (ctype))
1522     {
1523       if (!same_type_p (ctype, objtype))
1524         goto mismatch;
1525       binfo = NULL;
1526     }
1527   else
1528     {
1529       binfo = lookup_base (objtype, ctype, ba_check, NULL);
1530
1531       if (!binfo)
1532         {
1533         mismatch:
1534           error ("pointer to member type %qT incompatible with object "
1535                  "type %qT",
1536                  type, objtype);
1537           return error_mark_node;
1538         }
1539       else if (binfo == error_mark_node)
1540         return error_mark_node;
1541     }
1542
1543   if (TYPE_PTRMEM_P (ptrmem_type))
1544     {
1545       tree ptype;
1546
1547       /* Compute the type of the field, as described in [expr.ref].
1548          There's no such thing as a mutable pointer-to-member, so
1549          things are not as complex as they are for references to
1550          non-static data members.  */
1551       type = cp_build_qualified_type (type,
1552                                       (cp_type_quals (type)
1553                                        | cp_type_quals (TREE_TYPE (datum))));
1554
1555       datum = build_address (datum);
1556
1557       /* Convert object to the correct base.  */
1558       if (binfo)
1559         datum = build_base_path (PLUS_EXPR, datum, binfo, 1);
1560
1561       /* Build an expression for "object + offset" where offset is the
1562          value stored in the pointer-to-data-member.  */
1563       ptype = build_pointer_type (type);
1564       datum = build2 (POINTER_PLUS_EXPR, ptype,
1565                       fold_convert (ptype, datum),
1566                       build_nop (sizetype, component));
1567       return cp_build_indirect_ref (datum, RO_NULL, tf_warning_or_error);
1568     }
1569   else
1570     return build2 (OFFSET_REF, type, datum, component);
1571 }
1572
1573 /* Return a tree node for the expression TYPENAME '(' PARMS ')'.  */
1574
1575 tree
1576 build_functional_cast (tree exp, tree parms, tsubst_flags_t complain)
1577 {
1578   /* This is either a call to a constructor,
1579      or a C cast in C++'s `functional' notation.  */
1580
1581   /* The type to which we are casting.  */
1582   tree type;
1583   VEC(tree,gc) *parmvec;
1584
1585   if (exp == error_mark_node || parms == error_mark_node)
1586     return error_mark_node;
1587
1588   if (TREE_CODE (exp) == TYPE_DECL)
1589     type = TREE_TYPE (exp);
1590   else
1591     type = exp;
1592
1593   /* We need to check this explicitly, since value-initialization of
1594      arrays is allowed in other situations.  */
1595   if (TREE_CODE (type) == ARRAY_TYPE)
1596     {
1597       if (complain & tf_error)
1598         error ("functional cast to array type %qT", type);
1599       return error_mark_node;
1600     }
1601
1602   if (processing_template_decl)
1603     {
1604       tree t;
1605
1606       /* Diagnose this even in a template.  We could also try harder
1607          to give all the usual errors when the type and args are
1608          non-dependent...  */
1609       if (TREE_CODE (type) == REFERENCE_TYPE && !parms)
1610         {
1611           if (complain & tf_error)
1612             error ("invalid value-initialization of reference type");
1613           return error_mark_node;
1614         }
1615
1616       t = build_min (CAST_EXPR, type, parms);
1617       /* We don't know if it will or will not have side effects.  */
1618       TREE_SIDE_EFFECTS (t) = 1;
1619       return t;
1620     }
1621
1622   if (! MAYBE_CLASS_TYPE_P (type))
1623     {
1624       if (parms == NULL_TREE)
1625         {
1626           if (VOID_TYPE_P (type))
1627             return void_zero_node;
1628           return build_value_init (type, complain);
1629         }
1630
1631       /* This must build a C cast.  */
1632       parms = build_x_compound_expr_from_list (parms, ELK_FUNC_CAST, complain);
1633       return cp_build_c_cast (type, parms, complain);
1634     }
1635
1636   /* Prepare to evaluate as a call to a constructor.  If this expression
1637      is actually used, for example,
1638
1639      return X (arg1, arg2, ...);
1640
1641      then the slot being initialized will be filled in.  */
1642
1643   if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
1644     return error_mark_node;
1645   if (abstract_virtuals_error_sfinae (NULL_TREE, type, complain))
1646     return error_mark_node;
1647
1648   /* [expr.type.conv]
1649
1650      If the expression list is a single-expression, the type
1651      conversion is equivalent (in definedness, and if defined in
1652      meaning) to the corresponding cast expression.  */
1653   if (parms && TREE_CHAIN (parms) == NULL_TREE)
1654     return cp_build_c_cast (type, TREE_VALUE (parms), complain);
1655
1656   /* [expr.type.conv]
1657
1658      The expression T(), where T is a simple-type-specifier for a
1659      non-array complete object type or the (possibly cv-qualified)
1660      void type, creates an rvalue of the specified type, which is
1661      value-initialized.  */
1662
1663   if (parms == NULL_TREE
1664       /* If there's a user-defined constructor, value-initialization is
1665          just calling the constructor, so fall through.  */
1666       && !TYPE_HAS_USER_CONSTRUCTOR (type))
1667     {
1668       exp = build_value_init (type, complain);
1669       exp = get_target_expr_sfinae (exp, complain);
1670       /* FIXME this is wrong */
1671       if (literal_type_p (type))
1672         TREE_CONSTANT (exp) = true;
1673       return exp;
1674     }
1675
1676   /* Call the constructor.  */
1677   parmvec = make_tree_vector ();
1678   for (; parms != NULL_TREE; parms = TREE_CHAIN (parms))
1679     VEC_safe_push (tree, gc, parmvec, TREE_VALUE (parms));
1680   exp = build_special_member_call (NULL_TREE, complete_ctor_identifier,
1681                                    &parmvec, type, LOOKUP_NORMAL, complain);
1682   release_tree_vector (parmvec);
1683
1684   if (exp == error_mark_node)
1685     return error_mark_node;
1686
1687   return build_cplus_new (type, exp, complain);
1688 }
1689 \f
1690
1691 /* Add new exception specifier SPEC, to the LIST we currently have.
1692    If it's already in LIST then do nothing.
1693    Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1694    know what we're doing.  */
1695
1696 tree
1697 add_exception_specifier (tree list, tree spec, int complain)
1698 {
1699   bool ok;
1700   tree core = spec;
1701   bool is_ptr;
1702   diagnostic_t diag_type = DK_UNSPECIFIED; /* none */
1703
1704   if (spec == error_mark_node)
1705     return list;
1706
1707   gcc_assert (spec && (!list || TREE_VALUE (list)));
1708
1709   /* [except.spec] 1, type in an exception specifier shall not be
1710      incomplete, or pointer or ref to incomplete other than pointer
1711      to cv void.  */
1712   is_ptr = TREE_CODE (core) == POINTER_TYPE;
1713   if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1714     core = TREE_TYPE (core);
1715   if (complain < 0)
1716     ok = true;
1717   else if (VOID_TYPE_P (core))
1718     ok = is_ptr;
1719   else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1720     ok = true;
1721   else if (processing_template_decl)
1722     ok = true;
1723   else
1724     {
1725       ok = true;
1726       /* 15.4/1 says that types in an exception specifier must be complete,
1727          but it seems more reasonable to only require this on definitions
1728          and calls.  So just give a pedwarn at this point; we will give an
1729          error later if we hit one of those two cases.  */
1730       if (!COMPLETE_TYPE_P (complete_type (core)))
1731         diag_type = DK_PEDWARN; /* pedwarn */
1732     }
1733
1734   if (ok)
1735     {
1736       tree probe;
1737
1738       for (probe = list; probe; probe = TREE_CHAIN (probe))
1739         if (same_type_p (TREE_VALUE (probe), spec))
1740           break;
1741       if (!probe)
1742         list = tree_cons (NULL_TREE, spec, list);
1743     }
1744   else
1745     diag_type = DK_ERROR; /* error */
1746
1747   if (diag_type != DK_UNSPECIFIED && complain)
1748     cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1749
1750   return list;
1751 }
1752
1753 /* Combine the two exceptions specifier lists LIST and ADD, and return
1754    their union.  */
1755
1756 tree
1757 merge_exception_specifiers (tree list, tree add)
1758 {
1759   /* No exception-specifier or noexcept(false) are less strict than
1760      anything else.  Prefer the newer variant (LIST).  */
1761   if (!list || list == noexcept_false_spec)
1762     return list;
1763   else if (!add || add == noexcept_false_spec)
1764     return add;
1765   /* For merging noexcept(true) and throw(), take the more recent one (LIST).
1766      Any other noexcept-spec should only be merged with an equivalent one.
1767      So the !TREE_VALUE code below is correct for all cases.  */
1768   else if (!TREE_VALUE (add))
1769     return list;
1770   else if (!TREE_VALUE (list))
1771     return add;
1772   else
1773     {
1774       tree orig_list = list;
1775
1776       for (; add; add = TREE_CHAIN (add))
1777         {
1778           tree spec = TREE_VALUE (add);
1779           tree probe;
1780
1781           for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1782             if (same_type_p (TREE_VALUE (probe), spec))
1783               break;
1784           if (!probe)
1785             {
1786               spec = build_tree_list (NULL_TREE, spec);
1787               TREE_CHAIN (spec) = list;
1788               list = spec;
1789             }
1790         }
1791     }
1792   return list;
1793 }
1794
1795 /* Subroutine of build_call.  Ensure that each of the types in the
1796    exception specification is complete.  Technically, 15.4/1 says that
1797    they need to be complete when we see a declaration of the function,
1798    but we should be able to get away with only requiring this when the
1799    function is defined or called.  See also add_exception_specifier.  */
1800
1801 void
1802 require_complete_eh_spec_types (tree fntype, tree decl)
1803 {
1804   tree raises;
1805   /* Don't complain about calls to op new.  */
1806   if (decl && DECL_ARTIFICIAL (decl))
1807     return;
1808   for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1809        raises = TREE_CHAIN (raises))
1810     {
1811       tree type = TREE_VALUE (raises);
1812       if (type && !COMPLETE_TYPE_P (type))
1813         {
1814           if (decl)
1815             error
1816               ("call to function %qD which throws incomplete type %q#T",
1817                decl, type);
1818           else
1819             error ("call to function which throws incomplete type %q#T",
1820                    decl);
1821         }
1822     }
1823 }
1824
1825 \f
1826 #include "gt-cp-typeck2.h"