OSDN Git Service

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