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