OSDN Git Service

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