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