OSDN Git Service

PR c++/48322
[pf3gnuchains/gcc-fork.git] / gcc / cp / tree.c
1 /* Language-dependent node constructors for parse phase of GNU compiler.
2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
4    Free Software Foundation, Inc.
5    Hacked by Michael Tiemann (tiemann@cygnus.com)
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
12 any later version.
13
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3.  If not see
21 <http://www.gnu.org/licenses/>.  */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "tree.h"
28 #include "cp-tree.h"
29 #include "flags.h"
30 #include "tree-inline.h"
31 #include "debug.h"
32 #include "convert.h"
33 #include "cgraph.h"
34 #include "splay-tree.h"
35 #include "gimple.h" /* gimple_has_body_p */
36
37 static tree bot_manip (tree *, int *, void *);
38 static tree bot_replace (tree *, int *, void *);
39 static int list_hash_eq (const void *, const void *);
40 static hashval_t list_hash_pieces (tree, tree, tree);
41 static hashval_t list_hash (const void *);
42 static tree build_target_expr (tree, tree, tsubst_flags_t);
43 static tree count_trees_r (tree *, int *, void *);
44 static tree verify_stmt_tree_r (tree *, int *, void *);
45 static tree build_local_temp (tree);
46
47 static tree handle_java_interface_attribute (tree *, tree, tree, int, bool *);
48 static tree handle_com_interface_attribute (tree *, tree, tree, int, bool *);
49 static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *);
50
51 /* If REF is an lvalue, returns the kind of lvalue that REF is.
52    Otherwise, returns clk_none.  */
53
54 cp_lvalue_kind
55 lvalue_kind (const_tree ref)
56 {
57   cp_lvalue_kind op1_lvalue_kind = clk_none;
58   cp_lvalue_kind op2_lvalue_kind = clk_none;
59
60   /* Expressions of reference type are sometimes wrapped in
61      INDIRECT_REFs.  INDIRECT_REFs are just internal compiler
62      representation, not part of the language, so we have to look
63      through them.  */
64   if (REFERENCE_REF_P (ref))
65     return lvalue_kind (TREE_OPERAND (ref, 0));
66
67   if (TREE_TYPE (ref)
68       && TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
69     {
70       /* unnamed rvalue references are rvalues */
71       if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref))
72           && TREE_CODE (ref) != PARM_DECL
73           && TREE_CODE (ref) != VAR_DECL
74           && TREE_CODE (ref) != COMPONENT_REF
75           /* Functions are always lvalues.  */
76           && TREE_CODE (TREE_TYPE (TREE_TYPE (ref))) != FUNCTION_TYPE)
77         return clk_rvalueref;
78
79       /* lvalue references and named rvalue references are lvalues.  */
80       return clk_ordinary;
81     }
82
83   if (ref == current_class_ptr)
84     return clk_none;
85
86   switch (TREE_CODE (ref))
87     {
88     case SAVE_EXPR:
89       return clk_none;
90       /* preincrements and predecrements are valid lvals, provided
91          what they refer to are valid lvals.  */
92     case PREINCREMENT_EXPR:
93     case PREDECREMENT_EXPR:
94     case TRY_CATCH_EXPR:
95     case WITH_CLEANUP_EXPR:
96     case REALPART_EXPR:
97     case IMAGPART_EXPR:
98       return lvalue_kind (TREE_OPERAND (ref, 0));
99
100     case COMPONENT_REF:
101       op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0));
102       /* Look at the member designator.  */
103       if (!op1_lvalue_kind)
104         ;
105       else if (is_overloaded_fn (TREE_OPERAND (ref, 1)))
106         /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
107            situations.  If we're seeing a COMPONENT_REF, it's a non-static
108            member, so it isn't an lvalue. */
109         op1_lvalue_kind = clk_none;
110       else if (TREE_CODE (TREE_OPERAND (ref, 1)) != FIELD_DECL)
111         /* This can be IDENTIFIER_NODE in a template.  */;
112       else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref, 1)))
113         {
114           /* Clear the ordinary bit.  If this object was a class
115              rvalue we want to preserve that information.  */
116           op1_lvalue_kind &= ~clk_ordinary;
117           /* The lvalue is for a bitfield.  */
118           op1_lvalue_kind |= clk_bitfield;
119         }
120       else if (DECL_PACKED (TREE_OPERAND (ref, 1)))
121         op1_lvalue_kind |= clk_packed;
122
123       return op1_lvalue_kind;
124
125     case STRING_CST:
126     case COMPOUND_LITERAL_EXPR:
127       return clk_ordinary;
128
129     case CONST_DECL:
130       /* CONST_DECL without TREE_STATIC are enumeration values and
131          thus not lvalues.  With TREE_STATIC they are used by ObjC++
132          in objc_build_string_object and need to be considered as
133          lvalues.  */
134       if (! TREE_STATIC (ref))
135         return clk_none;
136     case VAR_DECL:
137       if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
138           && DECL_LANG_SPECIFIC (ref)
139           && DECL_IN_AGGR_P (ref))
140         return clk_none;
141     case INDIRECT_REF:
142     case ARROW_EXPR:
143     case ARRAY_REF:
144     case PARM_DECL:
145     case RESULT_DECL:
146       if (TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
147         return clk_ordinary;
148       break;
149
150       /* A scope ref in a template, left as SCOPE_REF to support later
151          access checking.  */
152     case SCOPE_REF:
153       gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE(ref)));
154       return lvalue_kind (TREE_OPERAND (ref, 1));
155
156     case MAX_EXPR:
157     case MIN_EXPR:
158       /* Disallow <? and >? as lvalues if either argument side-effects.  */
159       if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 0))
160           || TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 1)))
161         return clk_none;
162       op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0));
163       op2_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 1));
164       break;
165
166     case COND_EXPR:
167       op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 1)
168                                     ? TREE_OPERAND (ref, 1)
169                                     : TREE_OPERAND (ref, 0));
170       op2_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 2));
171       break;
172
173     case MODIFY_EXPR:
174     case TYPEID_EXPR:
175       return clk_ordinary;
176
177     case COMPOUND_EXPR:
178       return lvalue_kind (TREE_OPERAND (ref, 1));
179
180     case TARGET_EXPR:
181       return clk_class;
182
183     case VA_ARG_EXPR:
184       return (CLASS_TYPE_P (TREE_TYPE (ref)) ? clk_class : clk_none);
185
186     case CALL_EXPR:
187       /* We can see calls outside of TARGET_EXPR in templates.  */
188       if (CLASS_TYPE_P (TREE_TYPE (ref)))
189         return clk_class;
190       return clk_none;
191
192     case FUNCTION_DECL:
193       /* All functions (except non-static-member functions) are
194          lvalues.  */
195       return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref)
196               ? clk_none : clk_ordinary);
197
198     case BASELINK:
199       /* We now represent a reference to a single static member function
200          with a BASELINK.  */
201       /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
202          its argument unmodified and we assign it to a const_tree.  */
203       return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref)));
204
205     case NON_DEPENDENT_EXPR:
206       /* We just return clk_ordinary for NON_DEPENDENT_EXPR in C++98, but
207          in C++11 lvalues don't bind to rvalue references, so we need to
208          work harder to avoid bogus errors (c++/44870).  */
209       if (cxx_dialect < cxx0x)
210         return clk_ordinary;
211       else
212         return lvalue_kind (TREE_OPERAND (ref, 0));
213
214     default:
215       if (!TREE_TYPE (ref))
216         return clk_none;
217       if (CLASS_TYPE_P (TREE_TYPE (ref)))
218         return clk_class;
219       break;
220     }
221
222   /* If one operand is not an lvalue at all, then this expression is
223      not an lvalue.  */
224   if (!op1_lvalue_kind || !op2_lvalue_kind)
225     return clk_none;
226
227   /* Otherwise, it's an lvalue, and it has all the odd properties
228      contributed by either operand.  */
229   op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind;
230   /* It's not an ordinary lvalue if it involves any other kind.  */
231   if ((op1_lvalue_kind & ~clk_ordinary) != clk_none)
232     op1_lvalue_kind &= ~clk_ordinary;
233   /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
234      A COND_EXPR of those should be wrapped in a TARGET_EXPR.  */
235   if ((op1_lvalue_kind & (clk_rvalueref|clk_class))
236       && (op1_lvalue_kind & (clk_bitfield|clk_packed)))
237     op1_lvalue_kind = clk_none;
238   return op1_lvalue_kind;
239 }
240
241 /* Returns the kind of lvalue that REF is, in the sense of
242    [basic.lval].  This function should really be named lvalue_p; it
243    computes the C++ definition of lvalue.  */
244
245 cp_lvalue_kind
246 real_lvalue_p (const_tree ref)
247 {
248   cp_lvalue_kind kind = lvalue_kind (ref);
249   if (kind & (clk_rvalueref|clk_class))
250     return clk_none;
251   else
252     return kind;
253 }
254
255 /* This differs from real_lvalue_p in that class rvalues are considered
256    lvalues.  */
257
258 bool
259 lvalue_p (const_tree ref)
260 {
261   return (lvalue_kind (ref) != clk_none);
262 }
263
264 /* This differs from real_lvalue_p in that rvalues formed by dereferencing
265    rvalue references are considered rvalues.  */
266
267 bool
268 lvalue_or_rvalue_with_address_p (const_tree ref)
269 {
270   cp_lvalue_kind kind = lvalue_kind (ref);
271   if (kind & clk_class)
272     return false;
273   else
274     return (kind != clk_none);
275 }
276
277 /* Test whether DECL is a builtin that may appear in a
278    constant-expression. */
279
280 bool
281 builtin_valid_in_constant_expr_p (const_tree decl)
282 {
283   /* At present BUILT_IN_CONSTANT_P is the only builtin we're allowing
284      in constant-expressions.  We may want to add other builtins later. */
285   return DECL_IS_BUILTIN_CONSTANT_P (decl);
286 }
287
288 /* Build a TARGET_EXPR, initializing the DECL with the VALUE.  */
289
290 static tree
291 build_target_expr (tree decl, tree value, tsubst_flags_t complain)
292 {
293   tree t;
294   tree type = TREE_TYPE (decl);
295
296 #ifdef ENABLE_CHECKING
297   gcc_assert (VOID_TYPE_P (TREE_TYPE (value))
298               || TREE_TYPE (decl) == TREE_TYPE (value)
299               /* On ARM ctors return 'this'.  */
300               || (TREE_CODE (TREE_TYPE (value)) == POINTER_TYPE
301                   && TREE_CODE (value) == CALL_EXPR)
302               || useless_type_conversion_p (TREE_TYPE (decl),
303                                             TREE_TYPE (value)));
304 #endif
305
306   t = cxx_maybe_build_cleanup (decl, complain);
307   if (t == error_mark_node)
308     return error_mark_node;
309   t = build4 (TARGET_EXPR, type, decl, value, t, NULL_TREE);
310   /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
311      ignore the TARGET_EXPR.  If there really turn out to be no
312      side-effects, then the optimizer should be able to get rid of
313      whatever code is generated anyhow.  */
314   TREE_SIDE_EFFECTS (t) = 1;
315   if (literal_type_p (type))
316     TREE_CONSTANT (t) = TREE_CONSTANT (value);
317
318   return t;
319 }
320
321 /* Return an undeclared local temporary of type TYPE for use in building a
322    TARGET_EXPR.  */
323
324 static tree
325 build_local_temp (tree type)
326 {
327   tree slot = build_decl (input_location,
328                           VAR_DECL, NULL_TREE, type);
329   DECL_ARTIFICIAL (slot) = 1;
330   DECL_IGNORED_P (slot) = 1;
331   DECL_CONTEXT (slot) = current_function_decl;
332   layout_decl (slot, 0);
333   return slot;
334 }
335
336 /* Set various status flags when building an AGGR_INIT_EXPR object T.  */
337
338 static void
339 process_aggr_init_operands (tree t)
340 {
341   bool side_effects;
342
343   side_effects = TREE_SIDE_EFFECTS (t);
344   if (!side_effects)
345     {
346       int i, n;
347       n = TREE_OPERAND_LENGTH (t);
348       for (i = 1; i < n; i++)
349         {
350           tree op = TREE_OPERAND (t, i);
351           if (op && TREE_SIDE_EFFECTS (op))
352             {
353               side_effects = 1;
354               break;
355             }
356         }
357     }
358   TREE_SIDE_EFFECTS (t) = side_effects;
359 }
360
361 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
362    FN, and SLOT.  NARGS is the number of call arguments which are specified
363    as a tree array ARGS.  */
364
365 static tree
366 build_aggr_init_array (tree return_type, tree fn, tree slot, int nargs,
367                        tree *args)
368 {
369   tree t;
370   int i;
371
372   t = build_vl_exp (AGGR_INIT_EXPR, nargs + 3);
373   TREE_TYPE (t) = return_type;
374   AGGR_INIT_EXPR_FN (t) = fn;
375   AGGR_INIT_EXPR_SLOT (t) = slot;
376   for (i = 0; i < nargs; i++)
377     AGGR_INIT_EXPR_ARG (t, i) = args[i];
378   process_aggr_init_operands (t);
379   return t;
380 }
381
382 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
383    target.  TYPE is the type to be initialized.
384
385    Build an AGGR_INIT_EXPR to represent the initialization.  This function
386    differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
387    to initialize another object, whereas a TARGET_EXPR can either
388    initialize another object or create its own temporary object, and as a
389    result building up a TARGET_EXPR requires that the type's destructor be
390    callable.  */
391
392 tree
393 build_aggr_init_expr (tree type, tree init, tsubst_flags_t complain)
394 {
395   tree fn;
396   tree slot;
397   tree rval;
398   int is_ctor;
399
400   /* Make sure that we're not trying to create an instance of an
401      abstract class.  */
402   if (abstract_virtuals_error_sfinae (NULL_TREE, type, complain))
403     return error_mark_node;
404
405   if (TREE_CODE (init) == CALL_EXPR)
406     fn = CALL_EXPR_FN (init);
407   else if (TREE_CODE (init) == AGGR_INIT_EXPR)
408     fn = AGGR_INIT_EXPR_FN (init);
409   else
410     return convert (type, init);
411
412   is_ctor = (TREE_CODE (fn) == ADDR_EXPR
413              && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
414              && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0)));
415
416   /* We split the CALL_EXPR into its function and its arguments here.
417      Then, in expand_expr, we put them back together.  The reason for
418      this is that this expression might be a default argument
419      expression.  In that case, we need a new temporary every time the
420      expression is used.  That's what break_out_target_exprs does; it
421      replaces every AGGR_INIT_EXPR with a copy that uses a fresh
422      temporary slot.  Then, expand_expr builds up a call-expression
423      using the new slot.  */
424
425   /* If we don't need to use a constructor to create an object of this
426      type, don't mess with AGGR_INIT_EXPR.  */
427   if (is_ctor || TREE_ADDRESSABLE (type))
428     {
429       slot = build_local_temp (type);
430
431       if (TREE_CODE(init) == CALL_EXPR)
432         rval = build_aggr_init_array (void_type_node, fn, slot,
433                                       call_expr_nargs (init),
434                                       CALL_EXPR_ARGP (init));
435       else
436         rval = build_aggr_init_array (void_type_node, fn, slot,
437                                       aggr_init_expr_nargs (init),
438                                       AGGR_INIT_EXPR_ARGP (init));
439       TREE_SIDE_EFFECTS (rval) = 1;
440       AGGR_INIT_VIA_CTOR_P (rval) = is_ctor;
441       TREE_NOTHROW (rval) = TREE_NOTHROW (init);
442     }
443   else
444     rval = init;
445
446   return rval;
447 }
448
449 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
450    target.  TYPE is the type that this initialization should appear to
451    have.
452
453    Build an encapsulation of the initialization to perform
454    and return it so that it can be processed by language-independent
455    and language-specific expression expanders.  */
456
457 tree
458 build_cplus_new (tree type, tree init, tsubst_flags_t complain)
459 {
460   tree rval = build_aggr_init_expr (type, init, complain);
461   tree slot;
462
463   if (TREE_CODE (rval) == AGGR_INIT_EXPR)
464     slot = AGGR_INIT_EXPR_SLOT (rval);
465   else if (TREE_CODE (rval) == CALL_EXPR
466            || TREE_CODE (rval) == CONSTRUCTOR)
467     slot = build_local_temp (type);
468   else
469     return rval;
470
471   rval = build_target_expr (slot, rval, complain);
472
473   if (rval != error_mark_node)
474     TARGET_EXPR_IMPLICIT_P (rval) = 1;
475
476   return rval;
477 }
478
479 /* Subroutine of build_vec_init_expr: Build up a single element
480    intialization as a proxy for the full array initialization to get things
481    marked as used and any appropriate diagnostics.
482
483    Since we're deferring building the actual constructor calls until
484    gimplification time, we need to build one now and throw it away so
485    that the relevant constructor gets mark_used before cgraph decides
486    what functions are needed.  Here we assume that init is either
487    NULL_TREE, void_type_node (indicating value-initialization), or
488    another array to copy.  */
489
490 static tree
491 build_vec_init_elt (tree type, tree init, tsubst_flags_t complain)
492 {
493   tree inner_type = strip_array_types (type);
494   VEC(tree,gc) *argvec;
495
496   if (integer_zerop (array_type_nelts_total (type))
497       || !CLASS_TYPE_P (inner_type))
498     /* No interesting initialization to do.  */
499     return integer_zero_node;
500   else if (init == void_type_node)
501     return build_value_init (inner_type, complain);
502
503   gcc_assert (init == NULL_TREE
504               || (same_type_ignoring_top_level_qualifiers_p
505                   (type, TREE_TYPE (init))));
506
507   argvec = make_tree_vector ();
508   if (init)
509     {
510       tree dummy = build_dummy_object (inner_type);
511       if (!real_lvalue_p (init))
512         dummy = move (dummy);
513       VEC_quick_push (tree, argvec, dummy);
514     }
515   init = build_special_member_call (NULL_TREE, complete_ctor_identifier,
516                                     &argvec, inner_type, LOOKUP_NORMAL,
517                                     complain);
518   release_tree_vector (argvec);
519
520   /* For a trivial constructor, build_over_call creates a TARGET_EXPR.  But
521      we don't want one here because we aren't creating a temporary.  */
522   if (TREE_CODE (init) == TARGET_EXPR)
523     init = TARGET_EXPR_INITIAL (init);
524
525   return init;
526 }
527
528 /* Return a TARGET_EXPR which expresses the initialization of an array to
529    be named later, either default-initialization or copy-initialization
530    from another array of the same type.  */
531
532 tree
533 build_vec_init_expr (tree type, tree init, tsubst_flags_t complain)
534 {
535   tree slot;
536   bool value_init = false;
537   tree elt_init = build_vec_init_elt (type, init, complain);
538
539   if (init == void_type_node)
540     {
541       value_init = true;
542       init = NULL_TREE;
543     }
544
545   slot = build_local_temp (type);
546   init = build2 (VEC_INIT_EXPR, type, slot, init);
547   TREE_SIDE_EFFECTS (init) = true;
548   SET_EXPR_LOCATION (init, input_location);
549
550   if (cxx_dialect >= cxx0x
551       && potential_constant_expression (elt_init))
552     VEC_INIT_EXPR_IS_CONSTEXPR (init) = true;
553   VEC_INIT_EXPR_VALUE_INIT (init) = value_init;
554
555   return init;
556 }
557
558 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
559    that requires a constant expression.  */
560
561 void
562 diagnose_non_constexpr_vec_init (tree expr)
563 {
564   tree type = TREE_TYPE (VEC_INIT_EXPR_SLOT (expr));
565   tree init, elt_init;
566   if (VEC_INIT_EXPR_VALUE_INIT (expr))
567     init = void_zero_node;
568   else
569     init = VEC_INIT_EXPR_INIT (expr);
570
571   elt_init = build_vec_init_elt (type, init, tf_warning_or_error);
572   require_potential_constant_expression (elt_init);
573 }
574
575 tree
576 build_array_copy (tree init)
577 {
578   return build_vec_init_expr (TREE_TYPE (init), init, tf_warning_or_error);
579 }
580
581 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
582    indicated TYPE.  */
583
584 tree
585 build_target_expr_with_type (tree init, tree type, tsubst_flags_t complain)
586 {
587   gcc_assert (!VOID_TYPE_P (type));
588
589   if (TREE_CODE (init) == TARGET_EXPR
590       || init == error_mark_node)
591     return init;
592   else if (CLASS_TYPE_P (type) && type_has_nontrivial_copy_init (type)
593            && !VOID_TYPE_P (TREE_TYPE (init))
594            && TREE_CODE (init) != COND_EXPR
595            && TREE_CODE (init) != CONSTRUCTOR
596            && TREE_CODE (init) != VA_ARG_EXPR)
597     /* We need to build up a copy constructor call.  A void initializer
598        means we're being called from bot_manip.  COND_EXPR is a special
599        case because we already have copies on the arms and we don't want
600        another one here.  A CONSTRUCTOR is aggregate initialization, which
601        is handled separately.  A VA_ARG_EXPR is magic creation of an
602        aggregate; there's no additional work to be done.  */
603     return force_rvalue (init, complain);
604
605   return force_target_expr (type, init, complain);
606 }
607
608 /* Like the above function, but without the checking.  This function should
609    only be used by code which is deliberately trying to subvert the type
610    system, such as call_builtin_trap.  Or build_over_call, to avoid
611    infinite recursion.  */
612
613 tree
614 force_target_expr (tree type, tree init, tsubst_flags_t complain)
615 {
616   tree slot;
617
618   gcc_assert (!VOID_TYPE_P (type));
619
620   slot = build_local_temp (type);
621   return build_target_expr (slot, init, complain);
622 }
623
624 /* Like build_target_expr_with_type, but use the type of INIT.  */
625
626 tree
627 get_target_expr_sfinae (tree init, tsubst_flags_t complain)
628 {
629   if (TREE_CODE (init) == AGGR_INIT_EXPR)
630     return build_target_expr (AGGR_INIT_EXPR_SLOT (init), init, complain);
631   else if (TREE_CODE (init) == VEC_INIT_EXPR)
632     return build_target_expr (VEC_INIT_EXPR_SLOT (init), init, complain);
633   else
634     return build_target_expr_with_type (init, TREE_TYPE (init), complain);
635 }
636
637 tree
638 get_target_expr (tree init)
639 {
640   return get_target_expr_sfinae (init, tf_warning_or_error);
641 }
642
643 /* If EXPR is a bitfield reference, convert it to the declared type of
644    the bitfield, and return the resulting expression.  Otherwise,
645    return EXPR itself.  */
646
647 tree
648 convert_bitfield_to_declared_type (tree expr)
649 {
650   tree bitfield_type;
651
652   bitfield_type = is_bitfield_expr_with_lowered_type (expr);
653   if (bitfield_type)
654     expr = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type),
655                                expr);
656   return expr;
657 }
658
659 /* EXPR is being used in an rvalue context.  Return a version of EXPR
660    that is marked as an rvalue.  */
661
662 tree
663 rvalue (tree expr)
664 {
665   tree type;
666
667   if (error_operand_p (expr))
668     return expr;
669
670   expr = mark_rvalue_use (expr);
671
672   /* [basic.lval]
673
674      Non-class rvalues always have cv-unqualified types.  */
675   type = TREE_TYPE (expr);
676   if (!CLASS_TYPE_P (type) && cv_qualified_p (type))
677     type = cv_unqualified (type);
678
679   /* We need to do this for rvalue refs as well to get the right answer
680      from decltype; see c++/36628.  */
681   if (!processing_template_decl && lvalue_or_rvalue_with_address_p (expr))
682     expr = build1 (NON_LVALUE_EXPR, type, expr);
683   else if (type != TREE_TYPE (expr))
684     expr = build_nop (type, expr);
685
686   return expr;
687 }
688
689 \f
690 /* Hash an ARRAY_TYPE.  K is really of type `tree'.  */
691
692 static hashval_t
693 cplus_array_hash (const void* k)
694 {
695   hashval_t hash;
696   const_tree const t = (const_tree) k;
697
698   hash = TYPE_UID (TREE_TYPE (t));
699   if (TYPE_DOMAIN (t))
700     hash ^= TYPE_UID (TYPE_DOMAIN (t));
701   return hash;
702 }
703
704 typedef struct cplus_array_info {
705   tree type;
706   tree domain;
707 } cplus_array_info;
708
709 /* Compare two ARRAY_TYPEs.  K1 is really of type `tree', K2 is really
710    of type `cplus_array_info*'. */
711
712 static int
713 cplus_array_compare (const void * k1, const void * k2)
714 {
715   const_tree const t1 = (const_tree) k1;
716   const cplus_array_info *const t2 = (const cplus_array_info*) k2;
717
718   return (TREE_TYPE (t1) == t2->type && TYPE_DOMAIN (t1) == t2->domain);
719 }
720
721 /* Hash table containing dependent array types, which are unsuitable for
722    the language-independent type hash table.  */
723 static GTY ((param_is (union tree_node))) htab_t cplus_array_htab;
724
725 /* Like build_array_type, but handle special C++ semantics.  */
726
727 tree
728 build_cplus_array_type (tree elt_type, tree index_type)
729 {
730   tree t;
731
732   if (elt_type == error_mark_node || index_type == error_mark_node)
733     return error_mark_node;
734
735   if (processing_template_decl
736       && (dependent_type_p (elt_type)
737           || (index_type && !TREE_CONSTANT (TYPE_MAX_VALUE (index_type)))))
738     {
739       void **e;
740       cplus_array_info cai;
741       hashval_t hash;
742
743       if (cplus_array_htab == NULL)
744         cplus_array_htab = htab_create_ggc (61, &cplus_array_hash,
745                                             &cplus_array_compare, NULL);
746       
747       hash = TYPE_UID (elt_type);
748       if (index_type)
749         hash ^= TYPE_UID (index_type);
750       cai.type = elt_type;
751       cai.domain = index_type;
752
753       e = htab_find_slot_with_hash (cplus_array_htab, &cai, hash, INSERT); 
754       if (*e)
755         /* We have found the type: we're done.  */
756         return (tree) *e;
757       else
758         {
759           /* Build a new array type.  */
760           t = cxx_make_type (ARRAY_TYPE);
761           TREE_TYPE (t) = elt_type;
762           TYPE_DOMAIN (t) = index_type;
763
764           /* Store it in the hash table. */
765           *e = t;
766
767           /* Set the canonical type for this new node.  */
768           if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
769               || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
770             SET_TYPE_STRUCTURAL_EQUALITY (t);
771           else if (TYPE_CANONICAL (elt_type) != elt_type
772                    || (index_type 
773                        && TYPE_CANONICAL (index_type) != index_type))
774             TYPE_CANONICAL (t)
775                 = build_cplus_array_type 
776                    (TYPE_CANONICAL (elt_type),
777                     index_type ? TYPE_CANONICAL (index_type) : index_type);
778           else
779             TYPE_CANONICAL (t) = t;
780         }
781     }
782   else
783     t = build_array_type (elt_type, index_type);
784
785   /* We want TYPE_MAIN_VARIANT of an array to strip cv-quals from the
786      element type as well, so fix it up if needed.  */
787   if (elt_type != TYPE_MAIN_VARIANT (elt_type))
788     {
789       tree m = build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type),
790                                        index_type);
791       if (TYPE_MAIN_VARIANT (t) != m)
792         {
793           TYPE_MAIN_VARIANT (t) = m;
794           TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
795           TYPE_NEXT_VARIANT (m) = t;
796         }
797     }
798
799   /* Push these needs up so that initialization takes place
800      more easily.  */
801   TYPE_NEEDS_CONSTRUCTING (t)
802     = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
803   TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
804     = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
805   return t;
806 }
807
808 /* Return an ARRAY_TYPE with element type ELT and length N.  */
809
810 tree
811 build_array_of_n_type (tree elt, int n)
812 {
813   return build_cplus_array_type (elt, build_index_type (size_int (n - 1)));
814 }
815
816 /* Return a reference type node referring to TO_TYPE.  If RVAL is
817    true, return an rvalue reference type, otherwise return an lvalue
818    reference type.  If a type node exists, reuse it, otherwise create
819    a new one.  */
820 tree
821 cp_build_reference_type (tree to_type, bool rval)
822 {
823   tree lvalue_ref, t;
824   lvalue_ref = build_reference_type (to_type);
825   if (!rval)
826     return lvalue_ref;
827
828   /* This code to create rvalue reference types is based on and tied
829      to the code creating lvalue reference types in the middle-end
830      functions build_reference_type_for_mode and build_reference_type.
831
832      It works by putting the rvalue reference type nodes after the
833      lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
834      they will effectively be ignored by the middle end.  */
835
836   for (t = lvalue_ref; (t = TYPE_NEXT_REF_TO (t)); )
837     if (TYPE_REF_IS_RVALUE (t))
838       return t;
839
840   t = build_distinct_type_copy (lvalue_ref);
841
842   TYPE_REF_IS_RVALUE (t) = true;
843   TYPE_NEXT_REF_TO (t) = TYPE_NEXT_REF_TO (lvalue_ref);
844   TYPE_NEXT_REF_TO (lvalue_ref) = t;
845
846   if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
847     SET_TYPE_STRUCTURAL_EQUALITY (t);
848   else if (TYPE_CANONICAL (to_type) != to_type)
849     TYPE_CANONICAL (t) 
850       = cp_build_reference_type (TYPE_CANONICAL (to_type), rval);
851   else
852     TYPE_CANONICAL (t) = t;
853
854   layout_type (t);
855
856   return t;
857
858 }
859
860 /* Returns EXPR cast to rvalue reference type, like std::move.  */
861
862 tree
863 move (tree expr)
864 {
865   tree type = TREE_TYPE (expr);
866   gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
867   type = cp_build_reference_type (type, /*rval*/true);
868   return build_static_cast (type, expr, tf_warning_or_error);
869 }
870
871 /* Used by the C++ front end to build qualified array types.  However,
872    the C version of this function does not properly maintain canonical
873    types (which are not used in C).  */
874 tree
875 c_build_qualified_type (tree type, int type_quals)
876 {
877   return cp_build_qualified_type (type, type_quals);
878 }
879
880 \f
881 /* Make a variant of TYPE, qualified with the TYPE_QUALS.  Handles
882    arrays correctly.  In particular, if TYPE is an array of T's, and
883    TYPE_QUALS is non-empty, returns an array of qualified T's.
884
885    FLAGS determines how to deal with ill-formed qualifications. If
886    tf_ignore_bad_quals is set, then bad qualifications are dropped
887    (this is permitted if TYPE was introduced via a typedef or template
888    type parameter). If bad qualifications are dropped and tf_warning
889    is set, then a warning is issued for non-const qualifications.  If
890    tf_ignore_bad_quals is not set and tf_error is not set, we
891    return error_mark_node. Otherwise, we issue an error, and ignore
892    the qualifications.
893
894    Qualification of a reference type is valid when the reference came
895    via a typedef or template type argument. [dcl.ref] No such
896    dispensation is provided for qualifying a function type.  [dcl.fct]
897    DR 295 queries this and the proposed resolution brings it into line
898    with qualifying a reference.  We implement the DR.  We also behave
899    in a similar manner for restricting non-pointer types.  */
900
901 tree
902 cp_build_qualified_type_real (tree type,
903                               int type_quals,
904                               tsubst_flags_t complain)
905 {
906   tree result;
907   int bad_quals = TYPE_UNQUALIFIED;
908
909   if (type == error_mark_node)
910     return type;
911
912   if (type_quals == cp_type_quals (type))
913     return type;
914
915   if (TREE_CODE (type) == ARRAY_TYPE)
916     {
917       /* In C++, the qualification really applies to the array element
918          type.  Obtain the appropriately qualified element type.  */
919       tree t;
920       tree element_type
921         = cp_build_qualified_type_real (TREE_TYPE (type),
922                                         type_quals,
923                                         complain);
924
925       if (element_type == error_mark_node)
926         return error_mark_node;
927
928       /* See if we already have an identically qualified type.  Tests
929          should be equivalent to those in check_qualified_type.  */
930       for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
931         if (TREE_TYPE (t) == element_type
932             && TYPE_NAME (t) == TYPE_NAME (type)
933             && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
934             && attribute_list_equal (TYPE_ATTRIBUTES (t),
935                                      TYPE_ATTRIBUTES (type)))
936           break;
937
938       if (!t)
939         {
940           t = build_cplus_array_type (element_type, TYPE_DOMAIN (type));
941
942           /* Keep the typedef name.  */
943           if (TYPE_NAME (t) != TYPE_NAME (type))
944             {
945               t = build_variant_type_copy (t);
946               TYPE_NAME (t) = TYPE_NAME (type);
947             }
948         }
949
950       /* Even if we already had this variant, we update
951          TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
952          they changed since the variant was originally created.
953
954          This seems hokey; if there is some way to use a previous
955          variant *without* coming through here,
956          TYPE_NEEDS_CONSTRUCTING will never be updated.  */
957       TYPE_NEEDS_CONSTRUCTING (t)
958         = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));
959       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
960         = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));
961       return t;
962     }
963   else if (TYPE_PTRMEMFUNC_P (type))
964     {
965       /* For a pointer-to-member type, we can't just return a
966          cv-qualified version of the RECORD_TYPE.  If we do, we
967          haven't changed the field that contains the actual pointer to
968          a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong.  */
969       tree t;
970
971       t = TYPE_PTRMEMFUNC_FN_TYPE (type);
972       t = cp_build_qualified_type_real (t, type_quals, complain);
973       return build_ptrmemfunc_type (t);
974     }
975   else if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
976     {
977       tree t = PACK_EXPANSION_PATTERN (type);
978
979       t = cp_build_qualified_type_real (t, type_quals, complain);
980       return make_pack_expansion (t);
981     }
982
983   /* A reference or method type shall not be cv-qualified.
984      [dcl.ref], [dcl.fct].  This used to be an error, but as of DR 295
985      (in CD1) we always ignore extra cv-quals on functions.  */
986   if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)
987       && (TREE_CODE (type) == REFERENCE_TYPE
988           || TREE_CODE (type) == FUNCTION_TYPE
989           || TREE_CODE (type) == METHOD_TYPE))
990     {
991       if (TREE_CODE (type) == REFERENCE_TYPE)
992         bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
993       type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
994     }
995
996   /* But preserve any function-cv-quals on a FUNCTION_TYPE.  */
997   if (TREE_CODE (type) == FUNCTION_TYPE)
998     type_quals |= type_memfn_quals (type);
999
1000   /* A restrict-qualified type must be a pointer (or reference)
1001      to object or incomplete type. */
1002   if ((type_quals & TYPE_QUAL_RESTRICT)
1003       && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1004       && TREE_CODE (type) != TYPENAME_TYPE
1005       && !POINTER_TYPE_P (type))
1006     {
1007       bad_quals |= TYPE_QUAL_RESTRICT;
1008       type_quals &= ~TYPE_QUAL_RESTRICT;
1009     }
1010
1011   if (bad_quals == TYPE_UNQUALIFIED
1012       || (complain & tf_ignore_bad_quals))
1013     /*OK*/;
1014   else if (!(complain & tf_error))
1015     return error_mark_node;
1016   else
1017     {
1018       tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
1019       error ("%qV qualifiers cannot be applied to %qT",
1020              bad_type, type);
1021     }
1022
1023   /* Retrieve (or create) the appropriately qualified variant.  */
1024   result = build_qualified_type (type, type_quals);
1025
1026   /* If this was a pointer-to-method type, and we just made a copy,
1027      then we need to unshare the record that holds the cached
1028      pointer-to-member-function type, because these will be distinct
1029      between the unqualified and qualified types.  */
1030   if (result != type
1031       && TREE_CODE (type) == POINTER_TYPE
1032       && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
1033       && TYPE_LANG_SPECIFIC (result) == TYPE_LANG_SPECIFIC (type))
1034     TYPE_LANG_SPECIFIC (result) = NULL;
1035
1036   /* We may also have ended up building a new copy of the canonical
1037      type of a pointer-to-method type, which could have the same
1038      sharing problem described above.  */
1039   if (TYPE_CANONICAL (result) != TYPE_CANONICAL (type)
1040       && TREE_CODE (type) == POINTER_TYPE
1041       && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
1042       && (TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result)) 
1043           == TYPE_LANG_SPECIFIC (TYPE_CANONICAL (type))))
1044     TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result)) = NULL;
1045
1046   return result;
1047 }
1048
1049 /* Return TYPE with const and volatile removed.  */
1050
1051 tree
1052 cv_unqualified (tree type)
1053 {
1054   int quals;
1055
1056   if (type == error_mark_node)
1057     return type;
1058
1059   quals = cp_type_quals (type);
1060   quals &= ~(TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE);
1061   return cp_build_qualified_type (type, quals);
1062 }
1063
1064 /* Builds a qualified variant of T that is not a typedef variant.
1065    E.g. consider the following declarations:
1066      typedef const int ConstInt;
1067      typedef ConstInt* PtrConstInt;
1068    If T is PtrConstInt, this function returns a type representing
1069      const int*.
1070    In other words, if T is a typedef, the function returns the underlying type.
1071    The cv-qualification and attributes of the type returned match the
1072    input type.
1073    They will always be compatible types.
1074    The returned type is built so that all of its subtypes
1075    recursively have their typedefs stripped as well.
1076
1077    This is different from just returning TYPE_CANONICAL (T)
1078    Because of several reasons:
1079     * If T is a type that needs structural equality
1080       its TYPE_CANONICAL (T) will be NULL.
1081     * TYPE_CANONICAL (T) desn't carry type attributes
1082       and looses template parameter names.   */
1083
1084 tree
1085 strip_typedefs (tree t)
1086 {
1087   tree result = NULL, type = NULL, t0 = NULL;
1088
1089   if (!t || t == error_mark_node || t == TYPE_CANONICAL (t))
1090     return t;
1091
1092   gcc_assert (TYPE_P (t));
1093
1094   switch (TREE_CODE (t))
1095     {
1096     case POINTER_TYPE:
1097       type = strip_typedefs (TREE_TYPE (t));
1098       result = build_pointer_type (type);
1099       break;
1100     case REFERENCE_TYPE:
1101       type = strip_typedefs (TREE_TYPE (t));
1102       result = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
1103       break;
1104     case OFFSET_TYPE:
1105       t0 = strip_typedefs (TYPE_OFFSET_BASETYPE (t));
1106       type = strip_typedefs (TREE_TYPE (t));
1107       result = build_offset_type (t0, type);
1108       break;
1109     case RECORD_TYPE:
1110       if (TYPE_PTRMEMFUNC_P (t))
1111         {
1112           t0 = strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t));
1113           result = build_ptrmemfunc_type (t0);
1114         }
1115       break;
1116     case ARRAY_TYPE:
1117       type = strip_typedefs (TREE_TYPE (t));
1118       t0  = strip_typedefs (TYPE_DOMAIN (t));;
1119       result = build_cplus_array_type (type, t0);
1120       break;
1121     case FUNCTION_TYPE:
1122     case METHOD_TYPE:
1123       {
1124         tree arg_types = NULL, arg_node, arg_type;
1125         for (arg_node = TYPE_ARG_TYPES (t);
1126              arg_node;
1127              arg_node = TREE_CHAIN (arg_node))
1128           {
1129             if (arg_node == void_list_node)
1130               break;
1131             arg_type = strip_typedefs (TREE_VALUE (arg_node));
1132             gcc_assert (arg_type);
1133
1134             arg_types =
1135               tree_cons (TREE_PURPOSE (arg_node), arg_type, arg_types);
1136           }
1137
1138         if (arg_types)
1139           arg_types = nreverse (arg_types);
1140
1141         /* A list of parameters not ending with an ellipsis
1142            must end with void_list_node.  */
1143         if (arg_node)
1144           arg_types = chainon (arg_types, void_list_node);
1145
1146         type = strip_typedefs (TREE_TYPE (t));
1147         if (TREE_CODE (t) == METHOD_TYPE)
1148           {
1149             tree class_type = TREE_TYPE (TREE_VALUE (arg_types));
1150             gcc_assert (class_type);
1151             result =
1152               build_method_type_directly (class_type, type,
1153                                           TREE_CHAIN (arg_types));
1154           }
1155         else
1156           {
1157             result = build_function_type (type,
1158                                           arg_types);
1159             result = apply_memfn_quals (result, type_memfn_quals (t));
1160           }
1161
1162         if (TYPE_RAISES_EXCEPTIONS (t))
1163           result = build_exception_variant (result,
1164                                             TYPE_RAISES_EXCEPTIONS (t));
1165       }
1166       break;
1167     case TYPENAME_TYPE:
1168       result = make_typename_type (strip_typedefs (TYPE_CONTEXT (t)),
1169                                    TYPENAME_TYPE_FULLNAME (t),
1170                                    typename_type, tf_none);
1171       break;
1172     default:
1173       break;
1174     }
1175
1176   if (!result)
1177       result = TYPE_MAIN_VARIANT (t);
1178   if (TYPE_USER_ALIGN (t) != TYPE_USER_ALIGN (result)
1179       || TYPE_ALIGN (t) != TYPE_ALIGN (result))
1180     {
1181       gcc_assert (TYPE_USER_ALIGN (t));
1182       if (TYPE_ALIGN (t) == TYPE_ALIGN (result))
1183         result = build_variant_type_copy (result);
1184       else
1185         result = build_aligned_type (result, TYPE_ALIGN (t));
1186       TYPE_USER_ALIGN (result) = true;
1187     }
1188   if (TYPE_ATTRIBUTES (t))
1189     result = cp_build_type_attribute_variant (result, TYPE_ATTRIBUTES (t));
1190   return cp_build_qualified_type (result, cp_type_quals (t));
1191 }
1192
1193 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1194    graph dominated by T.  If BINFO is NULL, TYPE is a dependent base,
1195    and we do a shallow copy.  If BINFO is non-NULL, we do a deep copy.
1196    VIRT indicates whether TYPE is inherited virtually or not.
1197    IGO_PREV points at the previous binfo of the inheritance graph
1198    order chain.  The newly copied binfo's TREE_CHAIN forms this
1199    ordering.
1200
1201    The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1202    correct order. That is in the order the bases themselves should be
1203    constructed in.
1204
1205    The BINFO_INHERITANCE of a virtual base class points to the binfo
1206    of the most derived type. ??? We could probably change this so that
1207    BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1208    remove a field.  They currently can only differ for primary virtual
1209    virtual bases.  */
1210
1211 tree
1212 copy_binfo (tree binfo, tree type, tree t, tree *igo_prev, int virt)
1213 {
1214   tree new_binfo;
1215
1216   if (virt)
1217     {
1218       /* See if we've already made this virtual base.  */
1219       new_binfo = binfo_for_vbase (type, t);
1220       if (new_binfo)
1221         return new_binfo;
1222     }
1223
1224   new_binfo = make_tree_binfo (binfo ? BINFO_N_BASE_BINFOS (binfo) : 0);
1225   BINFO_TYPE (new_binfo) = type;
1226
1227   /* Chain it into the inheritance graph.  */
1228   TREE_CHAIN (*igo_prev) = new_binfo;
1229   *igo_prev = new_binfo;
1230
1231   if (binfo)
1232     {
1233       int ix;
1234       tree base_binfo;
1235
1236       gcc_assert (!BINFO_DEPENDENT_BASE_P (binfo));
1237       gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type));
1238
1239       BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo);
1240       BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo);
1241
1242       /* We do not need to copy the accesses, as they are read only.  */
1243       BINFO_BASE_ACCESSES (new_binfo) = BINFO_BASE_ACCESSES (binfo);
1244
1245       /* Recursively copy base binfos of BINFO.  */
1246       for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1247         {
1248           tree new_base_binfo;
1249
1250           gcc_assert (!BINFO_DEPENDENT_BASE_P (base_binfo));
1251           new_base_binfo = copy_binfo (base_binfo, BINFO_TYPE (base_binfo),
1252                                        t, igo_prev,
1253                                        BINFO_VIRTUAL_P (base_binfo));
1254
1255           if (!BINFO_INHERITANCE_CHAIN (new_base_binfo))
1256             BINFO_INHERITANCE_CHAIN (new_base_binfo) = new_binfo;
1257           BINFO_BASE_APPEND (new_binfo, new_base_binfo);
1258         }
1259     }
1260   else
1261     BINFO_DEPENDENT_BASE_P (new_binfo) = 1;
1262
1263   if (virt)
1264     {
1265       /* Push it onto the list after any virtual bases it contains
1266          will have been pushed.  */
1267       VEC_quick_push (tree, CLASSTYPE_VBASECLASSES (t), new_binfo);
1268       BINFO_VIRTUAL_P (new_binfo) = 1;
1269       BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t);
1270     }
1271
1272   return new_binfo;
1273 }
1274 \f
1275 /* Hashing of lists so that we don't make duplicates.
1276    The entry point is `list_hash_canon'.  */
1277
1278 /* Now here is the hash table.  When recording a list, it is added
1279    to the slot whose index is the hash code mod the table size.
1280    Note that the hash table is used for several kinds of lists.
1281    While all these live in the same table, they are completely independent,
1282    and the hash code is computed differently for each of these.  */
1283
1284 static GTY ((param_is (union tree_node))) htab_t list_hash_table;
1285
1286 struct list_proxy
1287 {
1288   tree purpose;
1289   tree value;
1290   tree chain;
1291 };
1292
1293 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1294    for a node we are thinking about adding).  */
1295
1296 static int
1297 list_hash_eq (const void* entry, const void* data)
1298 {
1299   const_tree const t = (const_tree) entry;
1300   const struct list_proxy *const proxy = (const struct list_proxy *) data;
1301
1302   return (TREE_VALUE (t) == proxy->value
1303           && TREE_PURPOSE (t) == proxy->purpose
1304           && TREE_CHAIN (t) == proxy->chain);
1305 }
1306
1307 /* Compute a hash code for a list (chain of TREE_LIST nodes
1308    with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1309    TREE_COMMON slots), by adding the hash codes of the individual entries.  */
1310
1311 static hashval_t
1312 list_hash_pieces (tree purpose, tree value, tree chain)
1313 {
1314   hashval_t hashcode = 0;
1315
1316   if (chain)
1317     hashcode += TREE_HASH (chain);
1318
1319   if (value)
1320     hashcode += TREE_HASH (value);
1321   else
1322     hashcode += 1007;
1323   if (purpose)
1324     hashcode += TREE_HASH (purpose);
1325   else
1326     hashcode += 1009;
1327   return hashcode;
1328 }
1329
1330 /* Hash an already existing TREE_LIST.  */
1331
1332 static hashval_t
1333 list_hash (const void* p)
1334 {
1335   const_tree const t = (const_tree) p;
1336   return list_hash_pieces (TREE_PURPOSE (t),
1337                            TREE_VALUE (t),
1338                            TREE_CHAIN (t));
1339 }
1340
1341 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1342    object for an identical list if one already exists.  Otherwise, build a
1343    new one, and record it as the canonical object.  */
1344
1345 tree
1346 hash_tree_cons (tree purpose, tree value, tree chain)
1347 {
1348   int hashcode = 0;
1349   void **slot;
1350   struct list_proxy proxy;
1351
1352   /* Hash the list node.  */
1353   hashcode = list_hash_pieces (purpose, value, chain);
1354   /* Create a proxy for the TREE_LIST we would like to create.  We
1355      don't actually create it so as to avoid creating garbage.  */
1356   proxy.purpose = purpose;
1357   proxy.value = value;
1358   proxy.chain = chain;
1359   /* See if it is already in the table.  */
1360   slot = htab_find_slot_with_hash (list_hash_table, &proxy, hashcode,
1361                                    INSERT);
1362   /* If not, create a new node.  */
1363   if (!*slot)
1364     *slot = tree_cons (purpose, value, chain);
1365   return (tree) *slot;
1366 }
1367
1368 /* Constructor for hashed lists.  */
1369
1370 tree
1371 hash_tree_chain (tree value, tree chain)
1372 {
1373   return hash_tree_cons (NULL_TREE, value, chain);
1374 }
1375 \f
1376 void
1377 debug_binfo (tree elem)
1378 {
1379   HOST_WIDE_INT n;
1380   tree virtuals;
1381
1382   fprintf (stderr, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
1383            "\nvtable type:\n",
1384            TYPE_NAME_STRING (BINFO_TYPE (elem)),
1385            TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
1386   debug_tree (BINFO_TYPE (elem));
1387   if (BINFO_VTABLE (elem))
1388     fprintf (stderr, "vtable decl \"%s\"\n",
1389              IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem))));
1390   else
1391     fprintf (stderr, "no vtable decl yet\n");
1392   fprintf (stderr, "virtuals:\n");
1393   virtuals = BINFO_VIRTUALS (elem);
1394   n = 0;
1395
1396   while (virtuals)
1397     {
1398       tree fndecl = TREE_VALUE (virtuals);
1399       fprintf (stderr, "%s [%ld =? %ld]\n",
1400                IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
1401                (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
1402       ++n;
1403       virtuals = TREE_CHAIN (virtuals);
1404     }
1405 }
1406
1407 /* Build a representation for the qualified name SCOPE::NAME.  TYPE is
1408    the type of the result expression, if known, or NULL_TREE if the
1409    resulting expression is type-dependent.  If TEMPLATE_P is true,
1410    NAME is known to be a template because the user explicitly used the
1411    "template" keyword after the "::".
1412
1413    All SCOPE_REFs should be built by use of this function.  */
1414
1415 tree
1416 build_qualified_name (tree type, tree scope, tree name, bool template_p)
1417 {
1418   tree t;
1419   if (type == error_mark_node
1420       || scope == error_mark_node
1421       || name == error_mark_node)
1422     return error_mark_node;
1423   t = build2 (SCOPE_REF, type, scope, name);
1424   QUALIFIED_NAME_IS_TEMPLATE (t) = template_p;
1425   PTRMEM_OK_P (t) = true;
1426   if (type)
1427     t = convert_from_reference (t);
1428   return t;
1429 }
1430
1431 /* Returns nonzero if X is an expression for a (possibly overloaded)
1432    function.  If "f" is a function or function template, "f", "c->f",
1433    "c.f", "C::f", and "f<int>" will all be considered possibly
1434    overloaded functions.  Returns 2 if the function is actually
1435    overloaded, i.e., if it is impossible to know the type of the
1436    function without performing overload resolution.  */
1437  
1438 int
1439 is_overloaded_fn (tree x)
1440 {
1441   /* A baselink is also considered an overloaded function.  */
1442   if (TREE_CODE (x) == OFFSET_REF
1443       || TREE_CODE (x) == COMPONENT_REF)
1444     x = TREE_OPERAND (x, 1);
1445   if (BASELINK_P (x))
1446     x = BASELINK_FUNCTIONS (x);
1447   if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
1448     x = TREE_OPERAND (x, 0);
1449   if (DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x))
1450       || (TREE_CODE (x) == OVERLOAD && OVL_CHAIN (x)))
1451     return 2;
1452   return  (TREE_CODE (x) == FUNCTION_DECL
1453            || TREE_CODE (x) == OVERLOAD);
1454 }
1455
1456 /* X is the CALL_EXPR_FN of a CALL_EXPR.  If X represents a dependent name
1457    (14.6.2), return the IDENTIFIER_NODE for that name.  Otherwise, return
1458    NULL_TREE.  */
1459
1460 static tree
1461 dependent_name (tree x)
1462 {
1463   if (TREE_CODE (x) == IDENTIFIER_NODE)
1464     return x;
1465   if (TREE_CODE (x) != COMPONENT_REF
1466       && is_overloaded_fn (x))
1467     return DECL_NAME (get_first_fn (x));
1468   return NULL_TREE;
1469 }
1470
1471 /* Returns true iff X is an expression for an overloaded function
1472    whose type cannot be known without performing overload
1473    resolution.  */
1474
1475 bool
1476 really_overloaded_fn (tree x)
1477 {
1478   return is_overloaded_fn (x) == 2;
1479 }
1480
1481 tree
1482 get_fns (tree from)
1483 {
1484   gcc_assert (is_overloaded_fn (from));
1485   /* A baselink is also considered an overloaded function.  */
1486   if (TREE_CODE (from) == OFFSET_REF
1487       || TREE_CODE (from) == COMPONENT_REF)
1488     from = TREE_OPERAND (from, 1);
1489   if (BASELINK_P (from))
1490     from = BASELINK_FUNCTIONS (from);
1491   if (TREE_CODE (from) == TEMPLATE_ID_EXPR)
1492     from = TREE_OPERAND (from, 0);
1493   return from;
1494 }
1495
1496 tree
1497 get_first_fn (tree from)
1498 {
1499   return OVL_CURRENT (get_fns (from));
1500 }
1501
1502 /* Return a new OVL node, concatenating it with the old one.  */
1503
1504 tree
1505 ovl_cons (tree decl, tree chain)
1506 {
1507   tree result = make_node (OVERLOAD);
1508   TREE_TYPE (result) = unknown_type_node;
1509   OVL_FUNCTION (result) = decl;
1510   TREE_CHAIN (result) = chain;
1511
1512   return result;
1513 }
1514
1515 /* Build a new overloaded function. If this is the first one,
1516    just return it; otherwise, ovl_cons the _DECLs */
1517
1518 tree
1519 build_overload (tree decl, tree chain)
1520 {
1521   if (! chain && TREE_CODE (decl) != TEMPLATE_DECL)
1522     return decl;
1523   return ovl_cons (decl, chain);
1524 }
1525
1526 /* Return TRUE if FN is a non-static member function, FALSE otherwise.
1527    This function looks into BASELINK and OVERLOAD nodes.  */
1528
1529 bool
1530 non_static_member_function_p (tree fn)
1531 {
1532   if (fn == NULL_TREE)
1533     return false;
1534
1535   if (is_overloaded_fn (fn))
1536     fn = get_first_fn (fn);
1537
1538   return (DECL_P (fn)
1539           && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn));
1540 }
1541
1542 \f
1543 #define PRINT_RING_SIZE 4
1544
1545 static const char *
1546 cxx_printable_name_internal (tree decl, int v, bool translate)
1547 {
1548   static unsigned int uid_ring[PRINT_RING_SIZE];
1549   static char *print_ring[PRINT_RING_SIZE];
1550   static bool trans_ring[PRINT_RING_SIZE];
1551   static int ring_counter;
1552   int i;
1553
1554   /* Only cache functions.  */
1555   if (v < 2
1556       || TREE_CODE (decl) != FUNCTION_DECL
1557       || DECL_LANG_SPECIFIC (decl) == 0)
1558     return lang_decl_name (decl, v, translate);
1559
1560   /* See if this print name is lying around.  */
1561   for (i = 0; i < PRINT_RING_SIZE; i++)
1562     if (uid_ring[i] == DECL_UID (decl) && translate == trans_ring[i])
1563       /* yes, so return it.  */
1564       return print_ring[i];
1565
1566   if (++ring_counter == PRINT_RING_SIZE)
1567     ring_counter = 0;
1568
1569   if (current_function_decl != NULL_TREE)
1570     {
1571       /* There may be both translated and untranslated versions of the
1572          name cached.  */
1573       for (i = 0; i < 2; i++)
1574         {
1575           if (uid_ring[ring_counter] == DECL_UID (current_function_decl))
1576             ring_counter += 1;
1577           if (ring_counter == PRINT_RING_SIZE)
1578             ring_counter = 0;
1579         }
1580       gcc_assert (uid_ring[ring_counter] != DECL_UID (current_function_decl));
1581     }
1582
1583   free (print_ring[ring_counter]);
1584
1585   print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v, translate));
1586   uid_ring[ring_counter] = DECL_UID (decl);
1587   trans_ring[ring_counter] = translate;
1588   return print_ring[ring_counter];
1589 }
1590
1591 const char *
1592 cxx_printable_name (tree decl, int v)
1593 {
1594   return cxx_printable_name_internal (decl, v, false);
1595 }
1596
1597 const char *
1598 cxx_printable_name_translate (tree decl, int v)
1599 {
1600   return cxx_printable_name_internal (decl, v, true);
1601 }
1602 \f
1603 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1604    listed in RAISES.  */
1605
1606 tree
1607 build_exception_variant (tree type, tree raises)
1608 {
1609   tree v;
1610   int type_quals;
1611
1612   if (comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (type), ce_exact))
1613     return type;
1614
1615   type_quals = TYPE_QUALS (type);
1616   for (v = TYPE_MAIN_VARIANT (type); v; v = TYPE_NEXT_VARIANT (v))
1617     if (check_qualified_type (v, type, type_quals)
1618         && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (v), ce_exact))
1619       return v;
1620
1621   /* Need to build a new variant.  */
1622   v = build_variant_type_copy (type);
1623   TYPE_RAISES_EXCEPTIONS (v) = raises;
1624   return v;
1625 }
1626
1627 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
1628    BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
1629    arguments.  */
1630
1631 tree
1632 bind_template_template_parm (tree t, tree newargs)
1633 {
1634   tree decl = TYPE_NAME (t);
1635   tree t2;
1636
1637   t2 = cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM);
1638   decl = build_decl (input_location,
1639                      TYPE_DECL, DECL_NAME (decl), NULL_TREE);
1640
1641   /* These nodes have to be created to reflect new TYPE_DECL and template
1642      arguments.  */
1643   TEMPLATE_TYPE_PARM_INDEX (t2) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t));
1644   TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2)) = decl;
1645   TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
1646     = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t), newargs);
1647
1648   TREE_TYPE (decl) = t2;
1649   TYPE_NAME (t2) = decl;
1650   TYPE_STUB_DECL (t2) = decl;
1651   TYPE_SIZE (t2) = 0;
1652   SET_TYPE_STRUCTURAL_EQUALITY (t2);
1653
1654   return t2;
1655 }
1656
1657 /* Called from count_trees via walk_tree.  */
1658
1659 static tree
1660 count_trees_r (tree *tp, int *walk_subtrees, void *data)
1661 {
1662   ++*((int *) data);
1663
1664   if (TYPE_P (*tp))
1665     *walk_subtrees = 0;
1666
1667   return NULL_TREE;
1668 }
1669
1670 /* Debugging function for measuring the rough complexity of a tree
1671    representation.  */
1672
1673 int
1674 count_trees (tree t)
1675 {
1676   int n_trees = 0;
1677   cp_walk_tree_without_duplicates (&t, count_trees_r, &n_trees);
1678   return n_trees;
1679 }
1680
1681 /* Called from verify_stmt_tree via walk_tree.  */
1682
1683 static tree
1684 verify_stmt_tree_r (tree* tp,
1685                     int* walk_subtrees ATTRIBUTE_UNUSED ,
1686                     void* data)
1687 {
1688   tree t = *tp;
1689   htab_t *statements = (htab_t *) data;
1690   void **slot;
1691
1692   if (!STATEMENT_CODE_P (TREE_CODE (t)))
1693     return NULL_TREE;
1694
1695   /* If this statement is already present in the hash table, then
1696      there is a circularity in the statement tree.  */
1697   gcc_assert (!htab_find (*statements, t));
1698
1699   slot = htab_find_slot (*statements, t, INSERT);
1700   *slot = t;
1701
1702   return NULL_TREE;
1703 }
1704
1705 /* Debugging function to check that the statement T has not been
1706    corrupted.  For now, this function simply checks that T contains no
1707    circularities.  */
1708
1709 void
1710 verify_stmt_tree (tree t)
1711 {
1712   htab_t statements;
1713   statements = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1714   cp_walk_tree (&t, verify_stmt_tree_r, &statements, NULL);
1715   htab_delete (statements);
1716 }
1717
1718 /* Check if the type T depends on a type with no linkage and if so, return
1719    it.  If RELAXED_P then do not consider a class type declared within
1720    a vague-linkage function to have no linkage.  */
1721
1722 tree
1723 no_linkage_check (tree t, bool relaxed_p)
1724 {
1725   tree r;
1726
1727   /* There's no point in checking linkage on template functions; we
1728      can't know their complete types.  */
1729   if (processing_template_decl)
1730     return NULL_TREE;
1731
1732   switch (TREE_CODE (t))
1733     {
1734     case RECORD_TYPE:
1735       if (TYPE_PTRMEMFUNC_P (t))
1736         goto ptrmem;
1737       /* Lambda types that don't have mangling scope have no linkage.  We
1738          check CLASSTYPE_LAMBDA_EXPR here rather than LAMBDA_TYPE_P because
1739          when we get here from pushtag none of the lambda information is
1740          set up yet, so we want to assume that the lambda has linkage and
1741          fix it up later if not.  */
1742       if (CLASSTYPE_LAMBDA_EXPR (t)
1743           && LAMBDA_TYPE_EXTRA_SCOPE (t) == NULL_TREE)
1744         return t;
1745       /* Fall through.  */
1746     case UNION_TYPE:
1747       if (!CLASS_TYPE_P (t))
1748         return NULL_TREE;
1749       /* Fall through.  */
1750     case ENUMERAL_TYPE:
1751       /* Only treat anonymous types as having no linkage if they're at
1752          namespace scope.  This is core issue 966.  */
1753       if (TYPE_ANONYMOUS_P (t) && TYPE_NAMESPACE_SCOPE_P (t))
1754         return t;
1755
1756       for (r = CP_TYPE_CONTEXT (t); ; )
1757         {
1758           /* If we're a nested type of a !TREE_PUBLIC class, we might not
1759              have linkage, or we might just be in an anonymous namespace.
1760              If we're in a TREE_PUBLIC class, we have linkage.  */
1761           if (TYPE_P (r) && !TREE_PUBLIC (TYPE_NAME (r)))
1762             return no_linkage_check (TYPE_CONTEXT (t), relaxed_p);
1763           else if (TREE_CODE (r) == FUNCTION_DECL)
1764             {
1765               if (!relaxed_p || !vague_linkage_p (r))
1766                 return t;
1767               else
1768                 r = CP_DECL_CONTEXT (r);
1769             }
1770           else
1771             break;
1772         }
1773
1774       return NULL_TREE;
1775
1776     case ARRAY_TYPE:
1777     case POINTER_TYPE:
1778     case REFERENCE_TYPE:
1779       return no_linkage_check (TREE_TYPE (t), relaxed_p);
1780
1781     case OFFSET_TYPE:
1782     ptrmem:
1783       r = no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t),
1784                             relaxed_p);
1785       if (r)
1786         return r;
1787       return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t), relaxed_p);
1788
1789     case METHOD_TYPE:
1790       r = no_linkage_check (TYPE_METHOD_BASETYPE (t), relaxed_p);
1791       if (r)
1792         return r;
1793       /* Fall through.  */
1794     case FUNCTION_TYPE:
1795       {
1796         tree parm;
1797         for (parm = TYPE_ARG_TYPES (t);
1798              parm && parm != void_list_node;
1799              parm = TREE_CHAIN (parm))
1800           {
1801             r = no_linkage_check (TREE_VALUE (parm), relaxed_p);
1802             if (r)
1803               return r;
1804           }
1805         return no_linkage_check (TREE_TYPE (t), relaxed_p);
1806       }
1807
1808     default:
1809       return NULL_TREE;
1810     }
1811 }
1812
1813 #ifdef GATHER_STATISTICS
1814 extern int depth_reached;
1815 #endif
1816
1817 void
1818 cxx_print_statistics (void)
1819 {
1820   print_search_statistics ();
1821   print_class_statistics ();
1822   print_template_statistics ();
1823 #ifdef GATHER_STATISTICS
1824   fprintf (stderr, "maximum template instantiation depth reached: %d\n",
1825            depth_reached);
1826 #endif
1827 }
1828
1829 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1830    (which is an ARRAY_TYPE).  This counts only elements of the top
1831    array.  */
1832
1833 tree
1834 array_type_nelts_top (tree type)
1835 {
1836   return fold_build2_loc (input_location,
1837                       PLUS_EXPR, sizetype,
1838                       array_type_nelts (type),
1839                       size_one_node);
1840 }
1841
1842 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1843    (which is an ARRAY_TYPE).  This one is a recursive count of all
1844    ARRAY_TYPEs that are clumped together.  */
1845
1846 tree
1847 array_type_nelts_total (tree type)
1848 {
1849   tree sz = array_type_nelts_top (type);
1850   type = TREE_TYPE (type);
1851   while (TREE_CODE (type) == ARRAY_TYPE)
1852     {
1853       tree n = array_type_nelts_top (type);
1854       sz = fold_build2_loc (input_location,
1855                         MULT_EXPR, sizetype, sz, n);
1856       type = TREE_TYPE (type);
1857     }
1858   return sz;
1859 }
1860
1861 /* Called from break_out_target_exprs via mapcar.  */
1862
1863 static tree
1864 bot_manip (tree* tp, int* walk_subtrees, void* data)
1865 {
1866   splay_tree target_remap = ((splay_tree) data);
1867   tree t = *tp;
1868
1869   if (!TYPE_P (t) && TREE_CONSTANT (t) && !TREE_SIDE_EFFECTS (t))
1870     {
1871       /* There can't be any TARGET_EXPRs or their slot variables below this
1872          point.  But we must make a copy, in case subsequent processing
1873          alters any part of it.  For example, during gimplification a cast
1874          of the form (T) &X::f (where "f" is a member function) will lead
1875          to replacing the PTRMEM_CST for &X::f with a VAR_DECL.  */
1876       *walk_subtrees = 0;
1877       *tp = unshare_expr (t);
1878       return NULL_TREE;
1879     }
1880   if (TREE_CODE (t) == TARGET_EXPR)
1881     {
1882       tree u;
1883
1884       if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
1885         {
1886           u = build_cplus_new (TREE_TYPE (t), TREE_OPERAND (t, 1),
1887                                tf_warning_or_error);
1888           if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t, 1)))
1889             AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u, 1)) = true;
1890         }
1891       else
1892         u = build_target_expr_with_type (TREE_OPERAND (t, 1), TREE_TYPE (t),
1893                                          tf_warning_or_error);
1894
1895       TARGET_EXPR_IMPLICIT_P (u) = TARGET_EXPR_IMPLICIT_P (t);
1896       TARGET_EXPR_LIST_INIT_P (u) = TARGET_EXPR_LIST_INIT_P (t);
1897       TARGET_EXPR_DIRECT_INIT_P (u) = TARGET_EXPR_DIRECT_INIT_P (t);
1898
1899       /* Map the old variable to the new one.  */
1900       splay_tree_insert (target_remap,
1901                          (splay_tree_key) TREE_OPERAND (t, 0),
1902                          (splay_tree_value) TREE_OPERAND (u, 0));
1903
1904       TREE_OPERAND (u, 1) = break_out_target_exprs (TREE_OPERAND (u, 1));
1905
1906       /* Replace the old expression with the new version.  */
1907       *tp = u;
1908       /* We don't have to go below this point; the recursive call to
1909          break_out_target_exprs will have handled anything below this
1910          point.  */
1911       *walk_subtrees = 0;
1912       return NULL_TREE;
1913     }
1914
1915   /* Make a copy of this node.  */
1916   t = copy_tree_r (tp, walk_subtrees, NULL);
1917   if (TREE_CODE (*tp) == CALL_EXPR)
1918     set_flags_from_callee (*tp);
1919   return t;
1920 }
1921
1922 /* Replace all remapped VAR_DECLs in T with their new equivalents.
1923    DATA is really a splay-tree mapping old variables to new
1924    variables.  */
1925
1926 static tree
1927 bot_replace (tree* t,
1928              int* walk_subtrees ATTRIBUTE_UNUSED ,
1929              void* data)
1930 {
1931   splay_tree target_remap = ((splay_tree) data);
1932
1933   if (TREE_CODE (*t) == VAR_DECL)
1934     {
1935       splay_tree_node n = splay_tree_lookup (target_remap,
1936                                              (splay_tree_key) *t);
1937       if (n)
1938         *t = (tree) n->value;
1939     }
1940   else if (TREE_CODE (*t) == PARM_DECL
1941            && DECL_NAME (*t) == this_identifier)
1942     {
1943       /* In an NSDMI we need to replace the 'this' parameter we used for
1944          parsing with the real one for this function.  */
1945       *t = current_class_ptr;
1946     }
1947
1948   return NULL_TREE;
1949 }
1950
1951 /* When we parse a default argument expression, we may create
1952    temporary variables via TARGET_EXPRs.  When we actually use the
1953    default-argument expression, we make a copy of the expression
1954    and replace the temporaries with appropriate local versions.  */
1955
1956 tree
1957 break_out_target_exprs (tree t)
1958 {
1959   static int target_remap_count;
1960   static splay_tree target_remap;
1961
1962   if (!target_remap_count++)
1963     target_remap = splay_tree_new (splay_tree_compare_pointers,
1964                                    /*splay_tree_delete_key_fn=*/NULL,
1965                                    /*splay_tree_delete_value_fn=*/NULL);
1966   cp_walk_tree (&t, bot_manip, target_remap, NULL);
1967   cp_walk_tree (&t, bot_replace, target_remap, NULL);
1968
1969   if (!--target_remap_count)
1970     {
1971       splay_tree_delete (target_remap);
1972       target_remap = NULL;
1973     }
1974
1975   return t;
1976 }
1977
1978 /* Similar to `build_nt', but for template definitions of dependent
1979    expressions  */
1980
1981 tree
1982 build_min_nt (enum tree_code code, ...)
1983 {
1984   tree t;
1985   int length;
1986   int i;
1987   va_list p;
1988
1989   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1990
1991   va_start (p, code);
1992
1993   t = make_node (code);
1994   length = TREE_CODE_LENGTH (code);
1995
1996   for (i = 0; i < length; i++)
1997     {
1998       tree x = va_arg (p, tree);
1999       TREE_OPERAND (t, i) = x;
2000     }
2001
2002   va_end (p);
2003   return t;
2004 }
2005
2006
2007 /* Similar to `build', but for template definitions.  */
2008
2009 tree
2010 build_min (enum tree_code code, tree tt, ...)
2011 {
2012   tree t;
2013   int length;
2014   int i;
2015   va_list p;
2016
2017   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
2018
2019   va_start (p, tt);
2020
2021   t = make_node (code);
2022   length = TREE_CODE_LENGTH (code);
2023   TREE_TYPE (t) = tt;
2024
2025   for (i = 0; i < length; i++)
2026     {
2027       tree x = va_arg (p, tree);
2028       TREE_OPERAND (t, i) = x;
2029       if (x && !TYPE_P (x) && TREE_SIDE_EFFECTS (x))
2030         TREE_SIDE_EFFECTS (t) = 1;
2031     }
2032
2033   va_end (p);
2034   return t;
2035 }
2036
2037 /* Similar to `build', but for template definitions of non-dependent
2038    expressions. NON_DEP is the non-dependent expression that has been
2039    built.  */
2040
2041 tree
2042 build_min_non_dep (enum tree_code code, tree non_dep, ...)
2043 {
2044   tree t;
2045   int length;
2046   int i;
2047   va_list p;
2048
2049   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
2050
2051   va_start (p, non_dep);
2052
2053   if (REFERENCE_REF_P (non_dep))
2054     non_dep = TREE_OPERAND (non_dep, 0);
2055
2056   t = make_node (code);
2057   length = TREE_CODE_LENGTH (code);
2058   TREE_TYPE (t) = TREE_TYPE (non_dep);
2059   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
2060
2061   for (i = 0; i < length; i++)
2062     {
2063       tree x = va_arg (p, tree);
2064       TREE_OPERAND (t, i) = x;
2065     }
2066
2067   if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR)
2068     /* This should not be considered a COMPOUND_EXPR, because it
2069        resolves to an overload.  */
2070     COMPOUND_EXPR_OVERLOADED (t) = 1;
2071
2072   va_end (p);
2073   return convert_from_reference (t);
2074 }
2075
2076 /* Similar to `build_nt_call_vec', but for template definitions of
2077    non-dependent expressions. NON_DEP is the non-dependent expression
2078    that has been built.  */
2079
2080 tree
2081 build_min_non_dep_call_vec (tree non_dep, tree fn, VEC(tree,gc) *argvec)
2082 {
2083   tree t = build_nt_call_vec (fn, argvec);
2084   if (REFERENCE_REF_P (non_dep))
2085     non_dep = TREE_OPERAND (non_dep, 0);
2086   TREE_TYPE (t) = TREE_TYPE (non_dep);
2087   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
2088   return convert_from_reference (t);
2089 }
2090
2091 tree
2092 get_type_decl (tree t)
2093 {
2094   if (TREE_CODE (t) == TYPE_DECL)
2095     return t;
2096   if (TYPE_P (t))
2097     return TYPE_STUB_DECL (t);
2098   gcc_assert (t == error_mark_node);
2099   return t;
2100 }
2101
2102 /* Returns the namespace that contains DECL, whether directly or
2103    indirectly.  */
2104
2105 tree
2106 decl_namespace_context (tree decl)
2107 {
2108   while (1)
2109     {
2110       if (TREE_CODE (decl) == NAMESPACE_DECL)
2111         return decl;
2112       else if (TYPE_P (decl))
2113         decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
2114       else
2115         decl = CP_DECL_CONTEXT (decl);
2116     }
2117 }
2118
2119 /* Returns true if decl is within an anonymous namespace, however deeply
2120    nested, or false otherwise.  */
2121
2122 bool
2123 decl_anon_ns_mem_p (const_tree decl)
2124 {
2125   while (1)
2126     {
2127       if (decl == NULL_TREE || decl == error_mark_node)
2128         return false;
2129       if (TREE_CODE (decl) == NAMESPACE_DECL
2130           && DECL_NAME (decl) == NULL_TREE)
2131         return true;
2132       /* Classes and namespaces inside anonymous namespaces have
2133          TREE_PUBLIC == 0, so we can shortcut the search.  */
2134       else if (TYPE_P (decl))
2135         return (TREE_PUBLIC (TYPE_NAME (decl)) == 0);
2136       else if (TREE_CODE (decl) == NAMESPACE_DECL)
2137         return (TREE_PUBLIC (decl) == 0);
2138       else
2139         decl = DECL_CONTEXT (decl);
2140     }
2141 }
2142
2143 /* Return truthvalue of whether T1 is the same tree structure as T2.
2144    Return 1 if they are the same. Return 0 if they are different.  */
2145
2146 bool
2147 cp_tree_equal (tree t1, tree t2)
2148 {
2149   enum tree_code code1, code2;
2150
2151   if (t1 == t2)
2152     return true;
2153   if (!t1 || !t2)
2154     return false;
2155
2156   for (code1 = TREE_CODE (t1);
2157        CONVERT_EXPR_CODE_P (code1)
2158          || code1 == NON_LVALUE_EXPR;
2159        code1 = TREE_CODE (t1))
2160     t1 = TREE_OPERAND (t1, 0);
2161   for (code2 = TREE_CODE (t2);
2162        CONVERT_EXPR_CODE_P (code2)
2163          || code1 == NON_LVALUE_EXPR;
2164        code2 = TREE_CODE (t2))
2165     t2 = TREE_OPERAND (t2, 0);
2166
2167   /* They might have become equal now.  */
2168   if (t1 == t2)
2169     return true;
2170
2171   if (code1 != code2)
2172     return false;
2173
2174   switch (code1)
2175     {
2176     case INTEGER_CST:
2177       return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2178         && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
2179
2180     case REAL_CST:
2181       return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2182
2183     case STRING_CST:
2184       return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2185         && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2186                     TREE_STRING_LENGTH (t1));
2187
2188     case FIXED_CST:
2189       return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),
2190                                      TREE_FIXED_CST (t2));
2191
2192     case COMPLEX_CST:
2193       return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
2194         && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
2195
2196     case CONSTRUCTOR:
2197       /* We need to do this when determining whether or not two
2198          non-type pointer to member function template arguments
2199          are the same.  */
2200       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2201           || CONSTRUCTOR_NELTS (t1) != CONSTRUCTOR_NELTS (t2))
2202         return false;
2203       {
2204         tree field, value;
2205         unsigned int i;
2206         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, field, value)
2207           {
2208             constructor_elt *elt2 = CONSTRUCTOR_ELT (t2, i);
2209             if (!cp_tree_equal (field, elt2->index)
2210                 || !cp_tree_equal (value, elt2->value))
2211               return false;
2212           }
2213       }
2214       return true;
2215
2216     case TREE_LIST:
2217       if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
2218         return false;
2219       if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
2220         return false;
2221       return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
2222
2223     case SAVE_EXPR:
2224       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2225
2226     case CALL_EXPR:
2227       {
2228         tree arg1, arg2;
2229         call_expr_arg_iterator iter1, iter2;
2230         /* Core 1321: dependent names are equivalent even if the
2231            overload sets are different.  */
2232         tree name1 = dependent_name (CALL_EXPR_FN (t1));
2233         tree name2 = dependent_name (CALL_EXPR_FN (t2));
2234         if (!(name1 && name2 && name1 == name2)
2235             && !cp_tree_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
2236           return false;
2237         for (arg1 = first_call_expr_arg (t1, &iter1),
2238                arg2 = first_call_expr_arg (t2, &iter2);
2239              arg1 && arg2;
2240              arg1 = next_call_expr_arg (&iter1),
2241                arg2 = next_call_expr_arg (&iter2))
2242           if (!cp_tree_equal (arg1, arg2))
2243             return false;
2244         if (arg1 || arg2)
2245           return false;
2246         return true;
2247       }
2248
2249     case TARGET_EXPR:
2250       {
2251         tree o1 = TREE_OPERAND (t1, 0);
2252         tree o2 = TREE_OPERAND (t2, 0);
2253
2254         /* Special case: if either target is an unallocated VAR_DECL,
2255            it means that it's going to be unified with whatever the
2256            TARGET_EXPR is really supposed to initialize, so treat it
2257            as being equivalent to anything.  */
2258         if (TREE_CODE (o1) == VAR_DECL && DECL_NAME (o1) == NULL_TREE
2259             && !DECL_RTL_SET_P (o1))
2260           /*Nop*/;
2261         else if (TREE_CODE (o2) == VAR_DECL && DECL_NAME (o2) == NULL_TREE
2262                  && !DECL_RTL_SET_P (o2))
2263           /*Nop*/;
2264         else if (!cp_tree_equal (o1, o2))
2265           return false;
2266
2267         return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2268       }
2269
2270     case WITH_CLEANUP_EXPR:
2271       if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2272         return false;
2273       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
2274
2275     case COMPONENT_REF:
2276       if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1))
2277         return false;
2278       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2279
2280     case PARM_DECL:
2281       /* For comparing uses of parameters in late-specified return types
2282          with an out-of-class definition of the function, but can also come
2283          up for expressions that involve 'this' in a member function
2284          template.  */
2285       if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
2286         {
2287           if (DECL_ARTIFICIAL (t1) ^ DECL_ARTIFICIAL (t2))
2288             return false;
2289           if (DECL_ARTIFICIAL (t1)
2290               || (DECL_PARM_LEVEL (t1) == DECL_PARM_LEVEL (t2)
2291                   && DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2)))
2292             return true;
2293         }
2294       return false;
2295
2296     case VAR_DECL:
2297     case CONST_DECL:
2298     case FUNCTION_DECL:
2299     case TEMPLATE_DECL:
2300     case IDENTIFIER_NODE:
2301     case SSA_NAME:
2302       return false;
2303
2304     case BASELINK:
2305       return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
2306               && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
2307               && cp_tree_equal (BASELINK_FUNCTIONS (t1),
2308                                 BASELINK_FUNCTIONS (t2)));
2309
2310     case TEMPLATE_PARM_INDEX:
2311       if (TEMPLATE_PARM_NUM_SIBLINGS (t1)
2312           != TEMPLATE_PARM_NUM_SIBLINGS (t2))
2313         return false;
2314       return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2315               && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
2316               && (TEMPLATE_PARM_PARAMETER_PACK (t1)
2317                   == TEMPLATE_PARM_PARAMETER_PACK (t2))
2318               && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
2319                               TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
2320
2321     case TEMPLATE_ID_EXPR:
2322       {
2323         unsigned ix;
2324         tree vec1, vec2;
2325
2326         if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2327           return false;
2328         vec1 = TREE_OPERAND (t1, 1);
2329         vec2 = TREE_OPERAND (t2, 1);
2330
2331         if (!vec1 || !vec2)
2332           return !vec1 && !vec2;
2333
2334         if (TREE_VEC_LENGTH (vec1) != TREE_VEC_LENGTH (vec2))
2335           return false;
2336
2337         for (ix = TREE_VEC_LENGTH (vec1); ix--;)
2338           if (!cp_tree_equal (TREE_VEC_ELT (vec1, ix),
2339                               TREE_VEC_ELT (vec2, ix)))
2340             return false;
2341
2342         return true;
2343       }
2344
2345     case SIZEOF_EXPR:
2346     case ALIGNOF_EXPR:
2347       {
2348         tree o1 = TREE_OPERAND (t1, 0);
2349         tree o2 = TREE_OPERAND (t2, 0);
2350
2351         if (TREE_CODE (o1) != TREE_CODE (o2))
2352           return false;
2353         if (TYPE_P (o1))
2354           return same_type_p (o1, o2);
2355         else
2356           return cp_tree_equal (o1, o2);
2357       }
2358
2359     case MODOP_EXPR:
2360       {
2361         tree t1_op1, t2_op1;
2362
2363         if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2364           return false;
2365
2366         t1_op1 = TREE_OPERAND (t1, 1);
2367         t2_op1 = TREE_OPERAND (t2, 1);
2368         if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
2369           return false;
2370
2371         return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
2372       }
2373
2374     case PTRMEM_CST:
2375       /* Two pointer-to-members are the same if they point to the same
2376          field or function in the same class.  */
2377       if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
2378         return false;
2379
2380       return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
2381
2382     case OVERLOAD:
2383       if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2))
2384         return false;
2385       return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2));
2386
2387     case TRAIT_EXPR:
2388       if (TRAIT_EXPR_KIND (t1) != TRAIT_EXPR_KIND (t2))
2389         return false;
2390       return same_type_p (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2))
2391         && same_type_p (TRAIT_EXPR_TYPE2 (t1), TRAIT_EXPR_TYPE2 (t2));
2392
2393     case CAST_EXPR:
2394     case STATIC_CAST_EXPR:
2395     case REINTERPRET_CAST_EXPR:
2396     case CONST_CAST_EXPR:
2397     case DYNAMIC_CAST_EXPR:
2398     case IMPLICIT_CONV_EXPR:
2399     case NEW_EXPR:
2400       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
2401         return false;
2402       /* Now compare operands as usual.  */
2403       break;
2404
2405     case DEFERRED_NOEXCEPT:
2406       return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1),
2407                              DEFERRED_NOEXCEPT_PATTERN (t2))
2408               && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1),
2409                                      DEFERRED_NOEXCEPT_ARGS (t2)));
2410       break;
2411
2412     default:
2413       break;
2414     }
2415
2416   switch (TREE_CODE_CLASS (code1))
2417     {
2418     case tcc_unary:
2419     case tcc_binary:
2420     case tcc_comparison:
2421     case tcc_expression:
2422     case tcc_vl_exp:
2423     case tcc_reference:
2424     case tcc_statement:
2425       {
2426         int i, n;
2427
2428         n = cp_tree_operand_length (t1);
2429         if (TREE_CODE_CLASS (code1) == tcc_vl_exp
2430             && n != TREE_OPERAND_LENGTH (t2))
2431           return false;
2432
2433         for (i = 0; i < n; ++i)
2434           if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
2435             return false;
2436
2437         return true;
2438       }
2439
2440     case tcc_type:
2441       return same_type_p (t1, t2);
2442     default:
2443       gcc_unreachable ();
2444     }
2445   /* We can get here with --disable-checking.  */
2446   return false;
2447 }
2448
2449 /* The type of ARG when used as an lvalue.  */
2450
2451 tree
2452 lvalue_type (tree arg)
2453 {
2454   tree type = TREE_TYPE (arg);
2455   return type;
2456 }
2457
2458 /* The type of ARG for printing error messages; denote lvalues with
2459    reference types.  */
2460
2461 tree
2462 error_type (tree arg)
2463 {
2464   tree type = TREE_TYPE (arg);
2465
2466   if (TREE_CODE (type) == ARRAY_TYPE)
2467     ;
2468   else if (TREE_CODE (type) == ERROR_MARK)
2469     ;
2470   else if (real_lvalue_p (arg))
2471     type = build_reference_type (lvalue_type (arg));
2472   else if (MAYBE_CLASS_TYPE_P (type))
2473     type = lvalue_type (arg);
2474
2475   return type;
2476 }
2477
2478 /* Does FUNCTION use a variable-length argument list?  */
2479
2480 int
2481 varargs_function_p (const_tree function)
2482 {
2483   return stdarg_p (TREE_TYPE (function));
2484 }
2485
2486 /* Returns 1 if decl is a member of a class.  */
2487
2488 int
2489 member_p (const_tree decl)
2490 {
2491   const_tree const ctx = DECL_CONTEXT (decl);
2492   return (ctx && TYPE_P (ctx));
2493 }
2494
2495 /* Create a placeholder for member access where we don't actually have an
2496    object that the access is against.  */
2497
2498 tree
2499 build_dummy_object (tree type)
2500 {
2501   tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
2502   return cp_build_indirect_ref (decl, RO_NULL, tf_warning_or_error);
2503 }
2504
2505 /* We've gotten a reference to a member of TYPE.  Return *this if appropriate,
2506    or a dummy object otherwise.  If BINFOP is non-0, it is filled with the
2507    binfo path from current_class_type to TYPE, or 0.  */
2508
2509 tree
2510 maybe_dummy_object (tree type, tree* binfop)
2511 {
2512   tree decl, context;
2513   tree binfo;
2514   tree current = current_nonlambda_class_type ();
2515
2516   if (current
2517       && (binfo = lookup_base (current, type, ba_any, NULL)))
2518     context = current;
2519   else
2520     {
2521       /* Reference from a nested class member function.  */
2522       context = type;
2523       binfo = TYPE_BINFO (type);
2524     }
2525
2526   if (binfop)
2527     *binfop = binfo;
2528
2529   if (current_class_ref
2530       /* current_class_ref might not correspond to current_class_type if
2531          we're in tsubst_default_argument or a lambda-declarator; in either
2532          case, we want to use current_class_ref if it matches CONTEXT.  */
2533       && (same_type_ignoring_top_level_qualifiers_p
2534           (TREE_TYPE (current_class_ref), context)))
2535     decl = current_class_ref;
2536   else if (current != current_class_type
2537            && context == nonlambda_method_basetype ())
2538     /* In a lambda, need to go through 'this' capture.  */
2539     decl = (build_x_indirect_ref
2540             ((lambda_expr_this_capture
2541               (CLASSTYPE_LAMBDA_EXPR (current_class_type))),
2542              RO_NULL, tf_warning_or_error));
2543   else
2544     decl = build_dummy_object (context);
2545
2546   return decl;
2547 }
2548
2549 /* Returns 1 if OB is a placeholder object, or a pointer to one.  */
2550
2551 int
2552 is_dummy_object (const_tree ob)
2553 {
2554   if (TREE_CODE (ob) == INDIRECT_REF)
2555     ob = TREE_OPERAND (ob, 0);
2556   return (TREE_CODE (ob) == NOP_EXPR
2557           && TREE_OPERAND (ob, 0) == void_zero_node);
2558 }
2559
2560 /* Returns 1 iff type T is something we want to treat as a scalar type for
2561    the purpose of deciding whether it is trivial/POD/standard-layout.  */
2562
2563 static bool
2564 scalarish_type_p (const_tree t)
2565 {
2566   if (t == error_mark_node)
2567     return 1;
2568
2569   return (SCALAR_TYPE_P (t)
2570           || TREE_CODE (t) == VECTOR_TYPE);
2571 }
2572
2573 /* Returns true iff T requires non-trivial default initialization.  */
2574
2575 bool
2576 type_has_nontrivial_default_init (const_tree t)
2577 {
2578   t = strip_array_types (CONST_CAST_TREE (t));
2579
2580   if (CLASS_TYPE_P (t))
2581     return TYPE_HAS_COMPLEX_DFLT (t);
2582   else
2583     return 0;
2584 }
2585
2586 /* Returns true iff copying an object of type T (including via move
2587    constructor) is non-trivial.  That is, T has no non-trivial copy
2588    constructors and no non-trivial move constructors.  */
2589
2590 bool
2591 type_has_nontrivial_copy_init (const_tree t)
2592 {
2593   t = strip_array_types (CONST_CAST_TREE (t));
2594
2595   if (CLASS_TYPE_P (t))
2596     {
2597       gcc_assert (COMPLETE_TYPE_P (t));
2598       return ((TYPE_HAS_COPY_CTOR (t)
2599                && TYPE_HAS_COMPLEX_COPY_CTOR (t))
2600               || TYPE_HAS_COMPLEX_MOVE_CTOR (t));
2601     }
2602   else
2603     return 0;
2604 }
2605
2606 /* Returns 1 iff type T is a trivially copyable type, as defined in
2607    [basic.types] and [class].  */
2608
2609 bool
2610 trivially_copyable_p (const_tree t)
2611 {
2612   t = strip_array_types (CONST_CAST_TREE (t));
2613
2614   if (CLASS_TYPE_P (t))
2615     return ((!TYPE_HAS_COPY_CTOR (t)
2616              || !TYPE_HAS_COMPLEX_COPY_CTOR (t))
2617             && !TYPE_HAS_COMPLEX_MOVE_CTOR (t)
2618             && (!TYPE_HAS_COPY_ASSIGN (t)
2619                 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t))
2620             && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t)
2621             && TYPE_HAS_TRIVIAL_DESTRUCTOR (t));
2622   else
2623     return scalarish_type_p (t);
2624 }
2625
2626 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
2627    [class].  */
2628
2629 bool
2630 trivial_type_p (const_tree t)
2631 {
2632   t = strip_array_types (CONST_CAST_TREE (t));
2633
2634   if (CLASS_TYPE_P (t))
2635     return (TYPE_HAS_TRIVIAL_DFLT (t)
2636             && trivially_copyable_p (t));
2637   else
2638     return scalarish_type_p (t);
2639 }
2640
2641 /* Returns 1 iff type T is a POD type, as defined in [basic.types].  */
2642
2643 bool
2644 pod_type_p (const_tree t)
2645 {
2646   /* This CONST_CAST is okay because strip_array_types returns its
2647      argument unmodified and we assign it to a const_tree.  */
2648   t = strip_array_types (CONST_CAST_TREE(t));
2649
2650   if (!CLASS_TYPE_P (t))
2651     return scalarish_type_p (t);
2652   else if (cxx_dialect > cxx98)
2653     /* [class]/10: A POD struct is a class that is both a trivial class and a
2654        standard-layout class, and has no non-static data members of type
2655        non-POD struct, non-POD union (or array of such types).
2656
2657        We don't need to check individual members because if a member is
2658        non-std-layout or non-trivial, the class will be too.  */
2659     return (std_layout_type_p (t) && trivial_type_p (t));
2660   else
2661     /* The C++98 definition of POD is different.  */
2662     return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2663 }
2664
2665 /* Returns true iff T is POD for the purpose of layout, as defined in the
2666    C++ ABI.  */
2667
2668 bool
2669 layout_pod_type_p (const_tree t)
2670 {
2671   t = strip_array_types (CONST_CAST_TREE (t));
2672
2673   if (CLASS_TYPE_P (t))
2674     return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2675   else
2676     return scalarish_type_p (t);
2677 }
2678
2679 /* Returns true iff T is a standard-layout type, as defined in
2680    [basic.types].  */
2681
2682 bool
2683 std_layout_type_p (const_tree t)
2684 {
2685   t = strip_array_types (CONST_CAST_TREE (t));
2686
2687   if (CLASS_TYPE_P (t))
2688     return !CLASSTYPE_NON_STD_LAYOUT (t);
2689   else
2690     return scalarish_type_p (t);
2691 }
2692
2693 /* Nonzero iff type T is a class template implicit specialization.  */
2694
2695 bool
2696 class_tmpl_impl_spec_p (const_tree t)
2697 {
2698   return CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INSTANTIATION (t);
2699 }
2700
2701 /* Returns 1 iff zero initialization of type T means actually storing
2702    zeros in it.  */
2703
2704 int
2705 zero_init_p (const_tree t)
2706 {
2707   /* This CONST_CAST is okay because strip_array_types returns its
2708      argument unmodified and we assign it to a const_tree.  */
2709   t = strip_array_types (CONST_CAST_TREE(t));
2710
2711   if (t == error_mark_node)
2712     return 1;
2713
2714   /* NULL pointers to data members are initialized with -1.  */
2715   if (TYPE_PTRMEM_P (t))
2716     return 0;
2717
2718   /* Classes that contain types that can't be zero-initialized, cannot
2719      be zero-initialized themselves.  */
2720   if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
2721     return 0;
2722
2723   return 1;
2724 }
2725
2726 /* Table of valid C++ attributes.  */
2727 const struct attribute_spec cxx_attribute_table[] =
2728 {
2729   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
2730        affects_type_identity } */
2731   { "java_interface", 0, 0, false, false, false,
2732     handle_java_interface_attribute, false },
2733   { "com_interface",  0, 0, false, false, false,
2734     handle_com_interface_attribute, false },
2735   { "init_priority",  1, 1, true,  false, false,
2736     handle_init_priority_attribute, false },
2737   { NULL,             0, 0, false, false, false, NULL, false }
2738 };
2739
2740 /* Handle a "java_interface" attribute; arguments as in
2741    struct attribute_spec.handler.  */
2742 static tree
2743 handle_java_interface_attribute (tree* node,
2744                                  tree name,
2745                                  tree args ATTRIBUTE_UNUSED ,
2746                                  int flags,
2747                                  bool* no_add_attrs)
2748 {
2749   if (DECL_P (*node)
2750       || !CLASS_TYPE_P (*node)
2751       || !TYPE_FOR_JAVA (*node))
2752     {
2753       error ("%qE attribute can only be applied to Java class definitions",
2754              name);
2755       *no_add_attrs = true;
2756       return NULL_TREE;
2757     }
2758   if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
2759     *node = build_variant_type_copy (*node);
2760   TYPE_JAVA_INTERFACE (*node) = 1;
2761
2762   return NULL_TREE;
2763 }
2764
2765 /* Handle a "com_interface" attribute; arguments as in
2766    struct attribute_spec.handler.  */
2767 static tree
2768 handle_com_interface_attribute (tree* node,
2769                                 tree name,
2770                                 tree args ATTRIBUTE_UNUSED ,
2771                                 int flags ATTRIBUTE_UNUSED ,
2772                                 bool* no_add_attrs)
2773 {
2774   static int warned;
2775
2776   *no_add_attrs = true;
2777
2778   if (DECL_P (*node)
2779       || !CLASS_TYPE_P (*node)
2780       || *node != TYPE_MAIN_VARIANT (*node))
2781     {
2782       warning (OPT_Wattributes, "%qE attribute can only be applied "
2783                "to class definitions", name);
2784       return NULL_TREE;
2785     }
2786
2787   if (!warned++)
2788     warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default",
2789              name);
2790
2791   return NULL_TREE;
2792 }
2793
2794 /* Handle an "init_priority" attribute; arguments as in
2795    struct attribute_spec.handler.  */
2796 static tree
2797 handle_init_priority_attribute (tree* node,
2798                                 tree name,
2799                                 tree args,
2800                                 int flags ATTRIBUTE_UNUSED ,
2801                                 bool* no_add_attrs)
2802 {
2803   tree initp_expr = TREE_VALUE (args);
2804   tree decl = *node;
2805   tree type = TREE_TYPE (decl);
2806   int pri;
2807
2808   STRIP_NOPS (initp_expr);
2809
2810   if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
2811     {
2812       error ("requested init_priority is not an integer constant");
2813       *no_add_attrs = true;
2814       return NULL_TREE;
2815     }
2816
2817   pri = TREE_INT_CST_LOW (initp_expr);
2818
2819   type = strip_array_types (type);
2820
2821   if (decl == NULL_TREE
2822       || TREE_CODE (decl) != VAR_DECL
2823       || !TREE_STATIC (decl)
2824       || DECL_EXTERNAL (decl)
2825       || (TREE_CODE (type) != RECORD_TYPE
2826           && TREE_CODE (type) != UNION_TYPE)
2827       /* Static objects in functions are initialized the
2828          first time control passes through that
2829          function. This is not precise enough to pin down an
2830          init_priority value, so don't allow it.  */
2831       || current_function_decl)
2832     {
2833       error ("can only use %qE attribute on file-scope definitions "
2834              "of objects of class type", name);
2835       *no_add_attrs = true;
2836       return NULL_TREE;
2837     }
2838
2839   if (pri > MAX_INIT_PRIORITY || pri <= 0)
2840     {
2841       error ("requested init_priority is out of range");
2842       *no_add_attrs = true;
2843       return NULL_TREE;
2844     }
2845
2846   /* Check for init_priorities that are reserved for
2847      language and runtime support implementations.*/
2848   if (pri <= MAX_RESERVED_INIT_PRIORITY)
2849     {
2850       warning
2851         (0, "requested init_priority is reserved for internal use");
2852     }
2853
2854   if (SUPPORTS_INIT_PRIORITY)
2855     {
2856       SET_DECL_INIT_PRIORITY (decl, pri);
2857       DECL_HAS_INIT_PRIORITY_P (decl) = 1;
2858       return NULL_TREE;
2859     }
2860   else
2861     {
2862       error ("%qE attribute is not supported on this platform", name);
2863       *no_add_attrs = true;
2864       return NULL_TREE;
2865     }
2866 }
2867
2868 /* Return a new PTRMEM_CST of the indicated TYPE.  The MEMBER is the
2869    thing pointed to by the constant.  */
2870
2871 tree
2872 make_ptrmem_cst (tree type, tree member)
2873 {
2874   tree ptrmem_cst = make_node (PTRMEM_CST);
2875   TREE_TYPE (ptrmem_cst) = type;
2876   PTRMEM_CST_MEMBER (ptrmem_cst) = member;
2877   return ptrmem_cst;
2878 }
2879
2880 /* Build a variant of TYPE that has the indicated ATTRIBUTES.  May
2881    return an existing type if an appropriate type already exists.  */
2882
2883 tree
2884 cp_build_type_attribute_variant (tree type, tree attributes)
2885 {
2886   tree new_type;
2887
2888   new_type = build_type_attribute_variant (type, attributes);
2889   if (TREE_CODE (new_type) == FUNCTION_TYPE
2890       || TREE_CODE (new_type) == METHOD_TYPE)
2891     new_type = build_exception_variant (new_type,
2892                                         TYPE_RAISES_EXCEPTIONS (type));
2893
2894   /* Making a new main variant of a class type is broken.  */
2895   gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
2896     
2897   return new_type;
2898 }
2899
2900 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
2901    Called only after doing all language independent checks.  Only
2902    to check TYPE_RAISES_EXCEPTIONS for FUNCTION_TYPE, the rest is already
2903    compared in type_hash_eq.  */
2904
2905 bool
2906 cxx_type_hash_eq (const_tree typea, const_tree typeb)
2907 {
2908   gcc_assert (TREE_CODE (typea) == FUNCTION_TYPE
2909               || TREE_CODE (typea) == METHOD_TYPE);
2910
2911   return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea),
2912                             TYPE_RAISES_EXCEPTIONS (typeb), ce_exact);
2913 }
2914
2915 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
2916    traversal.  Called from walk_tree.  */
2917
2918 tree
2919 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
2920                   void *data, struct pointer_set_t *pset)
2921 {
2922   enum tree_code code = TREE_CODE (*tp);
2923   tree result;
2924
2925 #define WALK_SUBTREE(NODE)                              \
2926   do                                                    \
2927     {                                                   \
2928       result = cp_walk_tree (&(NODE), func, data, pset);        \
2929       if (result) goto out;                             \
2930     }                                                   \
2931   while (0)
2932
2933   /* Not one of the easy cases.  We must explicitly go through the
2934      children.  */
2935   result = NULL_TREE;
2936   switch (code)
2937     {
2938     case DEFAULT_ARG:
2939     case TEMPLATE_TEMPLATE_PARM:
2940     case BOUND_TEMPLATE_TEMPLATE_PARM:
2941     case UNBOUND_CLASS_TEMPLATE:
2942     case TEMPLATE_PARM_INDEX:
2943     case TEMPLATE_TYPE_PARM:
2944     case TYPENAME_TYPE:
2945     case TYPEOF_TYPE:
2946     case UNDERLYING_TYPE:
2947       /* None of these have subtrees other than those already walked
2948          above.  */
2949       *walk_subtrees_p = 0;
2950       break;
2951
2952     case BASELINK:
2953       WALK_SUBTREE (BASELINK_FUNCTIONS (*tp));
2954       *walk_subtrees_p = 0;
2955       break;
2956
2957     case PTRMEM_CST:
2958       WALK_SUBTREE (TREE_TYPE (*tp));
2959       *walk_subtrees_p = 0;
2960       break;
2961
2962     case TREE_LIST:
2963       WALK_SUBTREE (TREE_PURPOSE (*tp));
2964       break;
2965
2966     case OVERLOAD:
2967       WALK_SUBTREE (OVL_FUNCTION (*tp));
2968       WALK_SUBTREE (OVL_CHAIN (*tp));
2969       *walk_subtrees_p = 0;
2970       break;
2971
2972     case USING_DECL:
2973       WALK_SUBTREE (DECL_NAME (*tp));
2974       WALK_SUBTREE (USING_DECL_SCOPE (*tp));
2975       WALK_SUBTREE (USING_DECL_DECLS (*tp));
2976       *walk_subtrees_p = 0;
2977       break;
2978
2979     case RECORD_TYPE:
2980       if (TYPE_PTRMEMFUNC_P (*tp))
2981         WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
2982       break;
2983
2984     case TYPE_ARGUMENT_PACK:
2985     case NONTYPE_ARGUMENT_PACK:
2986       {
2987         tree args = ARGUMENT_PACK_ARGS (*tp);
2988         int i, len = TREE_VEC_LENGTH (args);
2989         for (i = 0; i < len; i++)
2990           WALK_SUBTREE (TREE_VEC_ELT (args, i));
2991       }
2992       break;
2993
2994     case TYPE_PACK_EXPANSION:
2995       WALK_SUBTREE (TREE_TYPE (*tp));
2996       WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp));
2997       *walk_subtrees_p = 0;
2998       break;
2999       
3000     case EXPR_PACK_EXPANSION:
3001       WALK_SUBTREE (TREE_OPERAND (*tp, 0));
3002       WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp));
3003       *walk_subtrees_p = 0;
3004       break;
3005
3006     case CAST_EXPR:
3007     case REINTERPRET_CAST_EXPR:
3008     case STATIC_CAST_EXPR:
3009     case CONST_CAST_EXPR:
3010     case DYNAMIC_CAST_EXPR:
3011     case IMPLICIT_CONV_EXPR:
3012       if (TREE_TYPE (*tp))
3013         WALK_SUBTREE (TREE_TYPE (*tp));
3014
3015       {
3016         int i;
3017         for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (*tp)); ++i)
3018           WALK_SUBTREE (TREE_OPERAND (*tp, i));
3019       }
3020       *walk_subtrees_p = 0;
3021       break;
3022
3023     case TRAIT_EXPR:
3024       WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp));
3025       WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp));
3026       *walk_subtrees_p = 0;
3027       break;
3028
3029     case DECLTYPE_TYPE:
3030       WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp));
3031       *walk_subtrees_p = 0;
3032       break;
3033  
3034
3035     default:
3036       return NULL_TREE;
3037     }
3038
3039   /* We didn't find what we were looking for.  */
3040  out:
3041   return result;
3042
3043 #undef WALK_SUBTREE
3044 }
3045
3046 /* Like save_expr, but for C++.  */
3047
3048 tree
3049 cp_save_expr (tree expr)
3050 {
3051   /* There is no reason to create a SAVE_EXPR within a template; if
3052      needed, we can create the SAVE_EXPR when instantiating the
3053      template.  Furthermore, the middle-end cannot handle C++-specific
3054      tree codes.  */
3055   if (processing_template_decl)
3056     return expr;
3057   return save_expr (expr);
3058 }
3059
3060 /* Initialize tree.c.  */
3061
3062 void
3063 init_tree (void)
3064 {
3065   list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
3066 }
3067
3068 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
3069    is.  Note that sfk_none is zero, so this function can be used as a
3070    predicate to test whether or not DECL is a special function.  */
3071
3072 special_function_kind
3073 special_function_p (const_tree decl)
3074 {
3075   /* Rather than doing all this stuff with magic names, we should
3076      probably have a field of type `special_function_kind' in
3077      DECL_LANG_SPECIFIC.  */
3078   if (DECL_COPY_CONSTRUCTOR_P (decl))
3079     return sfk_copy_constructor;
3080   if (DECL_MOVE_CONSTRUCTOR_P (decl))
3081     return sfk_move_constructor;
3082   if (DECL_CONSTRUCTOR_P (decl))
3083     return sfk_constructor;
3084   if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
3085     {
3086       if (copy_fn_p (decl))
3087         return sfk_copy_assignment;
3088       if (move_fn_p (decl))
3089         return sfk_move_assignment;
3090     }
3091   if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
3092     return sfk_destructor;
3093   if (DECL_COMPLETE_DESTRUCTOR_P (decl))
3094     return sfk_complete_destructor;
3095   if (DECL_BASE_DESTRUCTOR_P (decl))
3096     return sfk_base_destructor;
3097   if (DECL_DELETING_DESTRUCTOR_P (decl))
3098     return sfk_deleting_destructor;
3099   if (DECL_CONV_FN_P (decl))
3100     return sfk_conversion;
3101
3102   return sfk_none;
3103 }
3104
3105 /* Returns nonzero if TYPE is a character type, including wchar_t.  */
3106
3107 int
3108 char_type_p (tree type)
3109 {
3110   return (same_type_p (type, char_type_node)
3111           || same_type_p (type, unsigned_char_type_node)
3112           || same_type_p (type, signed_char_type_node)
3113           || same_type_p (type, char16_type_node)
3114           || same_type_p (type, char32_type_node)
3115           || same_type_p (type, wchar_type_node));
3116 }
3117
3118 /* Returns the kind of linkage associated with the indicated DECL.  Th
3119    value returned is as specified by the language standard; it is
3120    independent of implementation details regarding template
3121    instantiation, etc.  For example, it is possible that a declaration
3122    to which this function assigns external linkage would not show up
3123    as a global symbol when you run `nm' on the resulting object file.  */
3124
3125 linkage_kind
3126 decl_linkage (tree decl)
3127 {
3128   /* This function doesn't attempt to calculate the linkage from first
3129      principles as given in [basic.link].  Instead, it makes use of
3130      the fact that we have already set TREE_PUBLIC appropriately, and
3131      then handles a few special cases.  Ideally, we would calculate
3132      linkage first, and then transform that into a concrete
3133      implementation.  */
3134
3135   /* Things that don't have names have no linkage.  */
3136   if (!DECL_NAME (decl))
3137     return lk_none;
3138
3139   /* Fields have no linkage.  */
3140   if (TREE_CODE (decl) == FIELD_DECL)
3141     return lk_none;
3142
3143   /* Things that are TREE_PUBLIC have external linkage.  */
3144   if (TREE_PUBLIC (decl))
3145     return lk_external;
3146
3147   if (TREE_CODE (decl) == NAMESPACE_DECL)
3148     return lk_external;
3149
3150   /* Linkage of a CONST_DECL depends on the linkage of the enumeration
3151      type.  */
3152   if (TREE_CODE (decl) == CONST_DECL)
3153     return decl_linkage (TYPE_NAME (TREE_TYPE (decl)));
3154
3155   /* Some things that are not TREE_PUBLIC have external linkage, too.
3156      For example, on targets that don't have weak symbols, we make all
3157      template instantiations have internal linkage (in the object
3158      file), but the symbols should still be treated as having external
3159      linkage from the point of view of the language.  */
3160   if ((TREE_CODE (decl) == FUNCTION_DECL
3161        || TREE_CODE (decl) == VAR_DECL)
3162       && DECL_COMDAT (decl))
3163     return lk_external;
3164
3165   /* Things in local scope do not have linkage, if they don't have
3166      TREE_PUBLIC set.  */
3167   if (decl_function_context (decl))
3168     return lk_none;
3169
3170   /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
3171      are considered to have external linkage for language purposes.  DECLs
3172      really meant to have internal linkage have DECL_THIS_STATIC set.  */
3173   if (TREE_CODE (decl) == TYPE_DECL)
3174     return lk_external;
3175   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
3176     {
3177       if (!DECL_THIS_STATIC (decl))
3178         return lk_external;
3179
3180       /* Static data members and static member functions from classes
3181          in anonymous namespace also don't have TREE_PUBLIC set.  */
3182       if (DECL_CLASS_CONTEXT (decl))
3183         return lk_external;
3184     }
3185
3186   /* Everything else has internal linkage.  */
3187   return lk_internal;
3188 }
3189
3190 /* Returns the storage duration of the object or reference associated with
3191    the indicated DECL, which should be a VAR_DECL or PARM_DECL.  */
3192
3193 duration_kind
3194 decl_storage_duration (tree decl)
3195 {
3196   if (TREE_CODE (decl) == PARM_DECL)
3197     return dk_auto;
3198   if (TREE_CODE (decl) == FUNCTION_DECL)
3199     return dk_static;
3200   gcc_assert (TREE_CODE (decl) == VAR_DECL);
3201   if (!TREE_STATIC (decl)
3202       && !DECL_EXTERNAL (decl))
3203     return dk_auto;
3204   if (DECL_THREAD_LOCAL_P (decl))
3205     return dk_thread;
3206   return dk_static;
3207 }
3208 \f
3209 /* EXP is an expression that we want to pre-evaluate.  Returns (in
3210    *INITP) an expression that will perform the pre-evaluation.  The
3211    value returned by this function is a side-effect free expression
3212    equivalent to the pre-evaluated expression.  Callers must ensure
3213    that *INITP is evaluated before EXP.  */
3214
3215 tree
3216 stabilize_expr (tree exp, tree* initp)
3217 {
3218   tree init_expr;
3219
3220   if (!TREE_SIDE_EFFECTS (exp))
3221     init_expr = NULL_TREE;
3222   /* There are no expressions with REFERENCE_TYPE, but there can be call
3223      arguments with such a type; just treat it as a pointer.  */
3224   else if (TREE_CODE (TREE_TYPE (exp)) == REFERENCE_TYPE
3225            || SCALAR_TYPE_P (TREE_TYPE (exp))
3226            || !lvalue_or_rvalue_with_address_p (exp))
3227     {
3228       init_expr = get_target_expr (exp);
3229       exp = TARGET_EXPR_SLOT (init_expr);
3230     }
3231   else
3232     {
3233       bool xval = !real_lvalue_p (exp);
3234       exp = cp_build_addr_expr (exp, tf_warning_or_error);
3235       init_expr = get_target_expr (exp);
3236       exp = TARGET_EXPR_SLOT (init_expr);
3237       exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error);
3238       if (xval)
3239         exp = move (exp);
3240     }
3241   *initp = init_expr;
3242
3243   gcc_assert (!TREE_SIDE_EFFECTS (exp));
3244   return exp;
3245 }
3246
3247 /* Add NEW_EXPR, an expression whose value we don't care about, after the
3248    similar expression ORIG.  */
3249
3250 tree
3251 add_stmt_to_compound (tree orig, tree new_expr)
3252 {
3253   if (!new_expr || !TREE_SIDE_EFFECTS (new_expr))
3254     return orig;
3255   if (!orig || !TREE_SIDE_EFFECTS (orig))
3256     return new_expr;
3257   return build2 (COMPOUND_EXPR, void_type_node, orig, new_expr);
3258 }
3259
3260 /* Like stabilize_expr, but for a call whose arguments we want to
3261    pre-evaluate.  CALL is modified in place to use the pre-evaluated
3262    arguments, while, upon return, *INITP contains an expression to
3263    compute the arguments.  */
3264
3265 void
3266 stabilize_call (tree call, tree *initp)
3267 {
3268   tree inits = NULL_TREE;
3269   int i;
3270   int nargs = call_expr_nargs (call);
3271
3272   if (call == error_mark_node || processing_template_decl)
3273     {
3274       *initp = NULL_TREE;
3275       return;
3276     }
3277
3278   gcc_assert (TREE_CODE (call) == CALL_EXPR);
3279
3280   for (i = 0; i < nargs; i++)
3281     {
3282       tree init;
3283       CALL_EXPR_ARG (call, i) =
3284         stabilize_expr (CALL_EXPR_ARG (call, i), &init);
3285       inits = add_stmt_to_compound (inits, init);
3286     }
3287
3288   *initp = inits;
3289 }
3290
3291 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
3292    to pre-evaluate.  CALL is modified in place to use the pre-evaluated
3293    arguments, while, upon return, *INITP contains an expression to
3294    compute the arguments.  */
3295
3296 void
3297 stabilize_aggr_init (tree call, tree *initp)
3298 {
3299   tree inits = NULL_TREE;
3300   int i;
3301   int nargs = aggr_init_expr_nargs (call);
3302
3303   if (call == error_mark_node)
3304     return;
3305
3306   gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
3307
3308   for (i = 0; i < nargs; i++)
3309     {
3310       tree init;
3311       AGGR_INIT_EXPR_ARG (call, i) =
3312         stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
3313       inits = add_stmt_to_compound (inits, init);
3314     }
3315
3316   *initp = inits;
3317 }
3318
3319 /* Like stabilize_expr, but for an initialization.  
3320
3321    If the initialization is for an object of class type, this function
3322    takes care not to introduce additional temporaries.
3323
3324    Returns TRUE iff the expression was successfully pre-evaluated,
3325    i.e., if INIT is now side-effect free, except for, possible, a
3326    single call to a constructor.  */
3327
3328 bool
3329 stabilize_init (tree init, tree *initp)
3330 {
3331   tree t = init;
3332
3333   *initp = NULL_TREE;
3334
3335   if (t == error_mark_node || processing_template_decl)
3336     return true;
3337
3338   if (TREE_CODE (t) == INIT_EXPR
3339       && TREE_CODE (TREE_OPERAND (t, 1)) != TARGET_EXPR
3340       && TREE_CODE (TREE_OPERAND (t, 1)) != AGGR_INIT_EXPR)
3341     {
3342       TREE_OPERAND (t, 1) = stabilize_expr (TREE_OPERAND (t, 1), initp);
3343       return true;
3344     }
3345
3346   if (TREE_CODE (t) == INIT_EXPR)
3347     t = TREE_OPERAND (t, 1);
3348   if (TREE_CODE (t) == TARGET_EXPR)
3349     t = TARGET_EXPR_INITIAL (t);
3350   if (TREE_CODE (t) == COMPOUND_EXPR)
3351     t = expr_last (t);
3352   if (TREE_CODE (t) == CONSTRUCTOR)
3353     {
3354       /* Aggregate initialization: stabilize each of the field
3355          initializers.  */
3356       unsigned i;
3357       constructor_elt *ce;
3358       bool good = true;
3359       VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (t);
3360       for (i = 0; VEC_iterate (constructor_elt, v, i, ce); ++i)
3361         {
3362           tree type = TREE_TYPE (ce->value);
3363           tree subinit;
3364           if (TREE_CODE (type) == REFERENCE_TYPE
3365               || SCALAR_TYPE_P (type))
3366             ce->value = stabilize_expr (ce->value, &subinit);
3367           else if (!stabilize_init (ce->value, &subinit))
3368             good = false;
3369           *initp = add_stmt_to_compound (*initp, subinit);
3370         }
3371       return good;
3372     }
3373
3374   /* If the initializer is a COND_EXPR, we can't preevaluate
3375      anything.  */
3376   if (TREE_CODE (t) == COND_EXPR)
3377     return false;
3378
3379   if (TREE_CODE (t) == CALL_EXPR)
3380     {
3381       stabilize_call (t, initp);
3382       return true;
3383     }
3384
3385   if (TREE_CODE (t) == AGGR_INIT_EXPR)
3386     {
3387       stabilize_aggr_init (t, initp);
3388       return true;
3389     }
3390
3391   /* The initialization is being performed via a bitwise copy -- and
3392      the item copied may have side effects.  */
3393   return TREE_SIDE_EFFECTS (init);
3394 }
3395
3396 /* Like "fold", but should be used whenever we might be processing the
3397    body of a template.  */
3398
3399 tree
3400 fold_if_not_in_template (tree expr)
3401 {
3402   /* In the body of a template, there is never any need to call
3403      "fold".  We will call fold later when actually instantiating the
3404      template.  Integral constant expressions in templates will be
3405      evaluated via fold_non_dependent_expr, as necessary.  */
3406   if (processing_template_decl)
3407     return expr;
3408
3409   /* Fold C++ front-end specific tree codes.  */
3410   if (TREE_CODE (expr) == UNARY_PLUS_EXPR)
3411     return fold_convert (TREE_TYPE (expr), TREE_OPERAND (expr, 0));
3412
3413   return fold (expr);
3414 }
3415
3416 /* Returns true if a cast to TYPE may appear in an integral constant
3417    expression.  */
3418
3419 bool
3420 cast_valid_in_integral_constant_expression_p (tree type)
3421 {
3422   return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
3423           || cxx_dialect >= cxx0x
3424           || dependent_type_p (type)
3425           || type == error_mark_node);
3426 }
3427
3428 /* Return true if we need to fix linkage information of DECL.  */
3429
3430 static bool
3431 cp_fix_function_decl_p (tree decl)
3432 {
3433   /* Skip if DECL is not externally visible.  */
3434   if (!TREE_PUBLIC (decl))
3435     return false;
3436
3437   /* We need to fix DECL if it a appears to be exported but with no
3438      function body.  Thunks do not have CFGs and we may need to
3439      handle them specially later.   */
3440   if (!gimple_has_body_p (decl)
3441       && !DECL_THUNK_P (decl)
3442       && !DECL_EXTERNAL (decl))
3443     {
3444       struct cgraph_node *node = cgraph_get_node (decl);
3445
3446       /* Don't fix same_body aliases.  Although they don't have their own
3447          CFG, they share it with what they alias to.  */
3448       if (!node || !node->alias
3449           || !VEC_length (ipa_ref_t, node->ref_list.references))
3450         return true;
3451     }
3452
3453   return false;
3454 }
3455
3456 /* Clean the C++ specific parts of the tree T. */
3457
3458 void
3459 cp_free_lang_data (tree t)
3460 {
3461   if (TREE_CODE (t) == METHOD_TYPE
3462       || TREE_CODE (t) == FUNCTION_TYPE)
3463     {
3464       /* Default args are not interesting anymore.  */
3465       tree argtypes = TYPE_ARG_TYPES (t);
3466       while (argtypes)
3467         {
3468           TREE_PURPOSE (argtypes) = 0;
3469           argtypes = TREE_CHAIN (argtypes);
3470         }
3471     }
3472   else if (TREE_CODE (t) == FUNCTION_DECL
3473            && cp_fix_function_decl_p (t))
3474     {
3475       /* If T is used in this translation unit at all,  the definition
3476          must exist somewhere else since we have decided to not emit it
3477          in this TU.  So make it an external reference.  */
3478       DECL_EXTERNAL (t) = 1;
3479       TREE_STATIC (t) = 0;
3480     }
3481   if (CP_AGGREGATE_TYPE_P (t)
3482       && TYPE_NAME (t))
3483     {
3484       tree name = TYPE_NAME (t);
3485       if (TREE_CODE (name) == TYPE_DECL)
3486         name = DECL_NAME (name);
3487       /* Drop anonymous names.  */
3488       if (name != NULL_TREE
3489           && ANON_AGGRNAME_P (name))
3490         TYPE_NAME (t) = NULL_TREE;
3491     }
3492   if (TREE_CODE (t) == NAMESPACE_DECL)
3493     {
3494       /* The list of users of a namespace isn't useful for the middle-end
3495          or debug generators.  */
3496       DECL_NAMESPACE_USERS (t) = NULL_TREE;
3497       /* Neither do we need the leftover chaining of namespaces
3498          from the binding level.  */
3499       DECL_CHAIN (t) = NULL_TREE;
3500     }
3501 }
3502
3503 /* Stub for c-common.  Please keep in sync with c-decl.c.
3504    FIXME: If address space support is target specific, then this
3505    should be a C target hook.  But currently this is not possible,
3506    because this function is called via REGISTER_TARGET_PRAGMAS.  */
3507 void
3508 c_register_addr_space (const char *word ATTRIBUTE_UNUSED,
3509                        addr_space_t as ATTRIBUTE_UNUSED)
3510 {
3511 }
3512
3513 /* Return the number of operands in T that we care about for things like
3514    mangling.  */
3515
3516 int
3517 cp_tree_operand_length (const_tree t)
3518 {
3519   enum tree_code code = TREE_CODE (t);
3520
3521   switch (code)
3522     {
3523     case PREINCREMENT_EXPR:
3524     case PREDECREMENT_EXPR:
3525     case POSTINCREMENT_EXPR:
3526     case POSTDECREMENT_EXPR:
3527       return 1;
3528
3529     case ARRAY_REF:
3530       return 2;
3531
3532     case EXPR_PACK_EXPANSION:
3533       return 1;
3534
3535     default:
3536       return TREE_OPERAND_LENGTH (t);
3537     }
3538 }
3539 \f
3540 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
3541 /* Complain that some language-specific thing hanging off a tree
3542    node has been accessed improperly.  */
3543
3544 void
3545 lang_check_failed (const char* file, int line, const char* function)
3546 {
3547   internal_error ("lang_* check: failed in %s, at %s:%d",
3548                   function, trim_filename (file), line);
3549 }
3550 #endif /* ENABLE_TREE_CHECKING */
3551
3552 #include "gt-cp-tree.h"