OSDN Git Service

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