OSDN Git Service

2610b28eca7e14bcaeb96ea149cffc96cfe82f1a
[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             next = build_functional_cast (TREE_TYPE (field), NULL_TREE,
1170                                           tf_warning_or_error);
1171           else
1172             next = build_constructor (init_list_type_node, NULL);
1173
1174           next = digest_init_r (TREE_TYPE (field), next, true, LOOKUP_IMPLICIT);
1175
1176           /* Warn when some struct elements are implicitly initialized.  */
1177           warning (OPT_Wmissing_field_initializers,
1178                    "missing initializer for member %qD", field);
1179         }
1180       else
1181         {
1182           if (TREE_READONLY (field))
1183             error ("uninitialized const member %qD", field);
1184           else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field)))
1185             error ("member %qD with uninitialized const fields", field);
1186           else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE)
1187             error ("member %qD is uninitialized reference", field);
1188
1189           /* Warn when some struct elements are implicitly initialized
1190              to zero.  */
1191           warning (OPT_Wmissing_field_initializers,
1192                    "missing initializer for member %qD", field);
1193
1194           if (!zero_init_p (TREE_TYPE (field)))
1195             next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
1196                                     /*static_storage_p=*/false);
1197           else
1198             /* The default zero-initialization is fine for us; don't
1199             add anything to the CONSTRUCTOR.  */
1200             continue;
1201         }
1202
1203       /* If this is a bitfield, now convert to the lowered type.  */
1204       if (type != TREE_TYPE (field))
1205         next = cp_convert_and_check (TREE_TYPE (field), next);
1206       flags |= picflag_from_initializer (next);
1207       CONSTRUCTOR_APPEND_ELT (v, field, next);
1208     }
1209
1210   if (idx < VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)))
1211     error ("too many initializers for %qT", type);
1212     
1213   CONSTRUCTOR_ELTS (init) = v;
1214   return flags;
1215 }
1216
1217 /* Subroutine of process_init_constructor, which will process a single
1218    initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
1219    which describe the initializer.  */
1220
1221 static int
1222 process_init_constructor_union (tree type, tree init)
1223 {
1224   constructor_elt *ce;
1225   int len;
1226
1227   /* If the initializer was empty, use default zero initialization.  */
1228   if (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init)))
1229     return 0;
1230
1231   len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
1232   if (len > 1)
1233     {
1234       error ("too many initializers for %qT", type);
1235       VEC_block_remove (constructor_elt, CONSTRUCTOR_ELTS (init), 1, len-1);
1236     }
1237
1238   ce = VEC_index (constructor_elt, CONSTRUCTOR_ELTS (init), 0);
1239
1240   /* If this element specifies a field, initialize via that field.  */
1241   if (ce->index)
1242     {
1243       if (TREE_CODE (ce->index) == FIELD_DECL)
1244         ;
1245       else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
1246         {
1247           /* This can happen within a cast, see g++.dg/opt/cse2.C.  */
1248           tree name = ce->index;
1249           tree field;
1250           for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1251             if (DECL_NAME (field) == name)
1252               break;
1253           if (!field)
1254             {
1255               error ("no field %qD found in union being initialized", field);
1256               ce->value = error_mark_node;
1257             }
1258           ce->index = field;
1259         }
1260       else
1261         {
1262           gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
1263                       || TREE_CODE (ce->index) == RANGE_EXPR);
1264           error ("index value instead of field name in union initializer");
1265           ce->value = error_mark_node;
1266         }
1267     }
1268   else
1269     {
1270       /* Find the first named field.  ANSI decided in September 1990
1271          that only named fields count here.  */
1272       tree field = TYPE_FIELDS (type);
1273       while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
1274         field = TREE_CHAIN (field);
1275       if (field == NULL_TREE)
1276         {
1277           error ("too many initializers for %qT", type);
1278           ce->value = error_mark_node;
1279         }
1280       ce->index = field;
1281     }
1282
1283   if (ce->value && ce->value != error_mark_node)
1284     ce->value = digest_init_r (TREE_TYPE (ce->index), ce->value, true, LOOKUP_IMPLICIT);
1285
1286   return picflag_from_initializer (ce->value);
1287 }
1288
1289 /* Process INIT, a constructor for a variable of aggregate type TYPE. The
1290    constructor is a brace-enclosed initializer, and will be modified in-place.
1291
1292    Each element is converted to the right type through digest_init, and
1293    missing initializers are added following the language rules (zero-padding,
1294    etc.).
1295
1296    After the execution, the initializer will have TREE_CONSTANT if all elts are
1297    constant, and TREE_STATIC set if, in addition, all elts are simple enough
1298    constants that the assembler and linker can compute them.
1299
1300    The function returns the initializer itself, or error_mark_node in case
1301    of error.  */
1302
1303 static tree
1304 process_init_constructor (tree type, tree init)
1305 {
1306   int flags;
1307
1308   gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
1309
1310   if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)
1311     flags = process_init_constructor_array (type, init);
1312   else if (TREE_CODE (type) == RECORD_TYPE)
1313     flags = process_init_constructor_record (type, init);
1314   else if (TREE_CODE (type) == UNION_TYPE)
1315     flags = process_init_constructor_union (type, init);
1316   else
1317     gcc_unreachable ();
1318
1319   if (flags & PICFLAG_ERRONEOUS)
1320     return error_mark_node;
1321
1322   TREE_TYPE (init) = type;
1323   if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
1324     cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
1325   if (!(flags & PICFLAG_NOT_ALL_CONSTANT))
1326     {
1327       TREE_CONSTANT (init) = 1;
1328       if (!(flags & PICFLAG_NOT_ALL_SIMPLE))
1329         TREE_STATIC (init) = 1;
1330     }
1331   return init;
1332 }
1333 \f
1334 /* Given a structure or union value DATUM, construct and return
1335    the structure or union component which results from narrowing
1336    that value to the base specified in BASETYPE.  For example, given the
1337    hierarchy
1338
1339    class L { int ii; };
1340    class A : L { ... };
1341    class B : L { ... };
1342    class C : A, B { ... };
1343
1344    and the declaration
1345
1346    C x;
1347
1348    then the expression
1349
1350    x.A::ii refers to the ii member of the L part of
1351    the A part of the C object named by X.  In this case,
1352    DATUM would be x, and BASETYPE would be A.
1353
1354    I used to think that this was nonconformant, that the standard specified
1355    that first we look up ii in A, then convert x to an L& and pull out the
1356    ii part.  But in fact, it does say that we convert x to an A&; A here
1357    is known as the "naming class".  (jason 2000-12-19)
1358
1359    BINFO_P points to a variable initialized either to NULL_TREE or to the
1360    binfo for the specific base subobject we want to convert to.  */
1361
1362 tree
1363 build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
1364 {
1365   tree binfo;
1366
1367   if (datum == error_mark_node)
1368     return error_mark_node;
1369   if (*binfo_p)
1370     binfo = *binfo_p;
1371   else
1372     binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL);
1373
1374   if (!binfo || binfo == error_mark_node)
1375     {
1376       *binfo_p = NULL_TREE;
1377       if (!binfo)
1378         error_not_base_type (basetype, TREE_TYPE (datum));
1379       return error_mark_node;
1380     }
1381
1382   *binfo_p = binfo;
1383   return build_base_path (PLUS_EXPR, datum, binfo, 1);
1384 }
1385
1386 /* Build a reference to an object specified by the C++ `->' operator.
1387    Usually this just involves dereferencing the object, but if the
1388    `->' operator is overloaded, then such overloads must be
1389    performed until an object which does not have the `->' operator
1390    overloaded is found.  An error is reported when circular pointer
1391    delegation is detected.  */
1392
1393 tree
1394 build_x_arrow (tree expr)
1395 {
1396   tree orig_expr = expr;
1397   tree types_memoized = NULL_TREE;
1398   tree type = TREE_TYPE (expr);
1399   tree last_rval = NULL_TREE;
1400
1401   if (type == error_mark_node)
1402     return error_mark_node;
1403
1404   if (processing_template_decl)
1405     {
1406       if (type_dependent_expression_p (expr))
1407         return build_min_nt (ARROW_EXPR, expr);
1408       expr = build_non_dependent_expr (expr);
1409     }
1410
1411   if (MAYBE_CLASS_TYPE_P (type))
1412     {
1413       while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr,
1414                                    NULL_TREE, NULL_TREE,
1415                                    /*overloaded_p=*/NULL, 
1416                                    tf_warning_or_error)))
1417         {
1418           if (expr == error_mark_node)
1419             return error_mark_node;
1420
1421           if (value_member (TREE_TYPE (expr), types_memoized))
1422             {
1423               error ("circular pointer delegation detected");
1424               return error_mark_node;
1425             }
1426           else
1427             {
1428               types_memoized = tree_cons (NULL_TREE, TREE_TYPE (expr),
1429                                           types_memoized);
1430             }
1431           last_rval = expr;
1432         }
1433
1434       if (last_rval == NULL_TREE)
1435         {
1436           error ("base operand of %<->%> has non-pointer type %qT", type);
1437           return error_mark_node;
1438         }
1439
1440       if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE)
1441         last_rval = convert_from_reference (last_rval);
1442     }
1443   else
1444     last_rval = decay_conversion (expr);
1445
1446   if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE)
1447     {
1448       if (processing_template_decl)
1449         {
1450           expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr);
1451           /* It will be dereferenced.  */
1452           TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval));
1453           return expr;
1454         }
1455
1456       return cp_build_indirect_ref (last_rval, RO_NULL, tf_warning_or_error);
1457     }
1458
1459   if (types_memoized)
1460     error ("result of %<operator->()%> yields non-pointer result");
1461   else
1462     error ("base operand of %<->%> is not a pointer");
1463   return error_mark_node;
1464 }
1465
1466 /* Return an expression for "DATUM .* COMPONENT".  DATUM has not
1467    already been checked out to be of aggregate type.  */
1468
1469 tree
1470 build_m_component_ref (tree datum, tree component)
1471 {
1472   tree ptrmem_type;
1473   tree objtype;
1474   tree type;
1475   tree binfo;
1476   tree ctype;
1477
1478   if (error_operand_p (datum) || error_operand_p (component))
1479     return error_mark_node;
1480
1481   ptrmem_type = TREE_TYPE (component);
1482   if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type))
1483     {
1484       error ("%qE cannot be used as a member pointer, since it is of "
1485              "type %qT",
1486              component, ptrmem_type);
1487       return error_mark_node;
1488     }
1489
1490   objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
1491   if (! MAYBE_CLASS_TYPE_P (objtype))
1492     {
1493       error ("cannot apply member pointer %qE to %qE, which is of "
1494              "non-class type %qT",
1495              component, datum, objtype);
1496       return error_mark_node;
1497     }
1498
1499   type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
1500   ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
1501
1502   if (!COMPLETE_TYPE_P (ctype))
1503     {
1504       if (!same_type_p (ctype, objtype))
1505         goto mismatch;
1506       binfo = NULL;
1507     }
1508   else
1509     {
1510       binfo = lookup_base (objtype, ctype, ba_check, NULL);
1511
1512       if (!binfo)
1513         {
1514         mismatch:
1515           error ("pointer to member type %qT incompatible with object "
1516                  "type %qT",
1517                  type, objtype);
1518           return error_mark_node;
1519         }
1520       else if (binfo == error_mark_node)
1521         return error_mark_node;
1522     }
1523
1524   if (TYPE_PTRMEM_P (ptrmem_type))
1525     {
1526       tree ptype;
1527
1528       /* Compute the type of the field, as described in [expr.ref].
1529          There's no such thing as a mutable pointer-to-member, so
1530          things are not as complex as they are for references to
1531          non-static data members.  */
1532       type = cp_build_qualified_type (type,
1533                                       (cp_type_quals (type)
1534                                        | cp_type_quals (TREE_TYPE (datum))));
1535
1536       datum = build_address (datum);
1537
1538       /* Convert object to the correct base.  */
1539       if (binfo)
1540         datum = build_base_path (PLUS_EXPR, datum, binfo, 1);
1541
1542       /* Build an expression for "object + offset" where offset is the
1543          value stored in the pointer-to-data-member.  */
1544       ptype = build_pointer_type (type);
1545       datum = build2 (POINTER_PLUS_EXPR, ptype,
1546                       fold_convert (ptype, datum),
1547                       build_nop (sizetype, component));
1548       return cp_build_indirect_ref (datum, RO_NULL, tf_warning_or_error);
1549     }
1550   else
1551     return build2 (OFFSET_REF, type, datum, component);
1552 }
1553
1554 /* Return a tree node for the expression TYPENAME '(' PARMS ')'.  */
1555
1556 tree
1557 build_functional_cast (tree exp, tree parms, tsubst_flags_t complain)
1558 {
1559   /* This is either a call to a constructor,
1560      or a C cast in C++'s `functional' notation.  */
1561
1562   /* The type to which we are casting.  */
1563   tree type;
1564   VEC(tree,gc) *parmvec;
1565
1566   if (exp == error_mark_node || parms == error_mark_node)
1567     return error_mark_node;
1568
1569   if (TREE_CODE (exp) == TYPE_DECL)
1570     type = TREE_TYPE (exp);
1571   else
1572     type = exp;
1573
1574   if (TREE_CODE (type) == REFERENCE_TYPE && !parms)
1575     {
1576       error ("invalid value-initialization of reference types");
1577       return error_mark_node;
1578     }
1579
1580   if (processing_template_decl)
1581     {
1582       tree t = build_min (CAST_EXPR, type, parms);
1583       /* We don't know if it will or will not have side effects.  */
1584       TREE_SIDE_EFFECTS (t) = 1;
1585       return t;
1586     }
1587
1588   if (! MAYBE_CLASS_TYPE_P (type))
1589     {
1590       if (parms == NULL_TREE)
1591         return cp_convert (type, integer_zero_node);
1592
1593       /* This must build a C cast.  */
1594       parms = build_x_compound_expr_from_list (parms, "functional cast");
1595       return cp_build_c_cast (type, parms, complain);
1596     }
1597
1598   /* Prepare to evaluate as a call to a constructor.  If this expression
1599      is actually used, for example,
1600
1601      return X (arg1, arg2, ...);
1602
1603      then the slot being initialized will be filled in.  */
1604
1605   if (!complete_type_or_else (type, NULL_TREE))
1606     return error_mark_node;
1607   if (abstract_virtuals_error (NULL_TREE, type))
1608     return error_mark_node;
1609
1610   /* [expr.type.conv]
1611
1612      If the expression list is a single-expression, the type
1613      conversion is equivalent (in definedness, and if defined in
1614      meaning) to the corresponding cast expression.  */
1615   if (parms && TREE_CHAIN (parms) == NULL_TREE)
1616     return cp_build_c_cast (type, TREE_VALUE (parms), complain);
1617
1618   /* [expr.type.conv]
1619
1620      The expression T(), where T is a simple-type-specifier for a
1621      non-array complete object type or the (possibly cv-qualified)
1622      void type, creates an rvalue of the specified type, which is
1623      value-initialized.  */
1624
1625   if (parms == NULL_TREE
1626       /* If there's a user-defined constructor, value-initialization is
1627          just calling the constructor, so fall through.  */
1628       && !TYPE_HAS_USER_CONSTRUCTOR (type))
1629     {
1630       exp = build_value_init (type);
1631       return get_target_expr (exp);
1632     }
1633
1634   /* Call the constructor.  */
1635   parmvec = make_tree_vector ();
1636   for (; parms != NULL_TREE; parms = TREE_CHAIN (parms))
1637     VEC_safe_push (tree, gc, parmvec, TREE_VALUE (parms));
1638   exp = build_special_member_call (NULL_TREE, complete_ctor_identifier,
1639                                    &parmvec, type, LOOKUP_NORMAL, complain);
1640   release_tree_vector (parmvec);
1641
1642   if (exp == error_mark_node)
1643     return error_mark_node;
1644
1645   return build_cplus_new (type, exp);
1646 }
1647 \f
1648
1649 /* Add new exception specifier SPEC, to the LIST we currently have.
1650    If it's already in LIST then do nothing.
1651    Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
1652    know what we're doing.  */
1653
1654 tree
1655 add_exception_specifier (tree list, tree spec, int complain)
1656 {
1657   bool ok;
1658   tree core = spec;
1659   bool is_ptr;
1660   diagnostic_t diag_type = DK_UNSPECIFIED; /* none */
1661
1662   if (spec == error_mark_node)
1663     return list;
1664
1665   gcc_assert (spec && (!list || TREE_VALUE (list)));
1666
1667   /* [except.spec] 1, type in an exception specifier shall not be
1668      incomplete, or pointer or ref to incomplete other than pointer
1669      to cv void.  */
1670   is_ptr = TREE_CODE (core) == POINTER_TYPE;
1671   if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE)
1672     core = TREE_TYPE (core);
1673   if (complain < 0)
1674     ok = true;
1675   else if (VOID_TYPE_P (core))
1676     ok = is_ptr;
1677   else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
1678     ok = true;
1679   else if (processing_template_decl)
1680     ok = true;
1681   else
1682     {
1683       ok = true;
1684       /* 15.4/1 says that types in an exception specifier must be complete,
1685          but it seems more reasonable to only require this on definitions
1686          and calls.  So just give a pedwarn at this point; we will give an
1687          error later if we hit one of those two cases.  */
1688       if (!COMPLETE_TYPE_P (complete_type (core)))
1689         diag_type = DK_PEDWARN; /* pedwarn */
1690     }
1691
1692   if (ok)
1693     {
1694       tree probe;
1695
1696       for (probe = list; probe; probe = TREE_CHAIN (probe))
1697         if (same_type_p (TREE_VALUE (probe), spec))
1698           break;
1699       if (!probe)
1700         list = tree_cons (NULL_TREE, spec, list);
1701     }
1702   else
1703     diag_type = DK_ERROR; /* error */
1704
1705   if (diag_type != DK_UNSPECIFIED && complain)
1706     cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
1707
1708   return list;
1709 }
1710
1711 /* Combine the two exceptions specifier lists LIST and ADD, and return
1712    their union.  */
1713
1714 tree
1715 merge_exception_specifiers (tree list, tree add)
1716 {
1717   if (!list || !add)
1718     return NULL_TREE;
1719   else if (!TREE_VALUE (list))
1720     return add;
1721   else if (!TREE_VALUE (add))
1722     return list;
1723   else
1724     {
1725       tree orig_list = list;
1726
1727       for (; add; add = TREE_CHAIN (add))
1728         {
1729           tree spec = TREE_VALUE (add);
1730           tree probe;
1731
1732           for (probe = orig_list; probe; probe = TREE_CHAIN (probe))
1733             if (same_type_p (TREE_VALUE (probe), spec))
1734               break;
1735           if (!probe)
1736             {
1737               spec = build_tree_list (NULL_TREE, spec);
1738               TREE_CHAIN (spec) = list;
1739               list = spec;
1740             }
1741         }
1742     }
1743   return list;
1744 }
1745
1746 /* Subroutine of build_call.  Ensure that each of the types in the
1747    exception specification is complete.  Technically, 15.4/1 says that
1748    they need to be complete when we see a declaration of the function,
1749    but we should be able to get away with only requiring this when the
1750    function is defined or called.  See also add_exception_specifier.  */
1751
1752 void
1753 require_complete_eh_spec_types (tree fntype, tree decl)
1754 {
1755   tree raises;
1756   /* Don't complain about calls to op new.  */
1757   if (decl && DECL_ARTIFICIAL (decl))
1758     return;
1759   for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
1760        raises = TREE_CHAIN (raises))
1761     {
1762       tree type = TREE_VALUE (raises);
1763       if (type && !COMPLETE_TYPE_P (type))
1764         {
1765           if (decl)
1766             error
1767               ("call to function %qD which throws incomplete type %q#T",
1768                decl, type);
1769           else
1770             error ("call to function which throws incomplete type %q#T",
1771                    decl);
1772         }
1773     }
1774 }
1775
1776 \f
1777 #include "gt-cp-typeck2.h"