OSDN Git Service

1cedec55f8d7c92b7622221b4a9845c76b41069a
[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 Free Software Foundation, Inc.
4    Hacked by Michael Tiemann (tiemann@cygnus.com)
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING.  If not, write to
20 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA.  */
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 "real.h"
31 #include "rtl.h"
32 #include "toplev.h"
33 #include "insn-config.h"
34 #include "integrate.h"
35 #include "tree-inline.h"
36 #include "debug.h"
37 #include "target.h"
38 #include "convert.h"
39
40 static tree bot_manip (tree *, int *, void *);
41 static tree bot_replace (tree *, int *, void *);
42 static tree build_cplus_array_type_1 (tree, tree);
43 static int list_hash_eq (const void *, const void *);
44 static hashval_t list_hash_pieces (tree, tree, tree);
45 static hashval_t list_hash (const void *);
46 static cp_lvalue_kind lvalue_p_1 (tree, int);
47 static tree build_target_expr (tree, tree);
48 static tree count_trees_r (tree *, int *, void *);
49 static tree verify_stmt_tree_r (tree *, int *, void *);
50 static tree build_local_temp (tree);
51
52 static tree handle_java_interface_attribute (tree *, tree, tree, int, bool *);
53 static tree handle_com_interface_attribute (tree *, tree, tree, int, bool *);
54 static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *);
55
56 /* If REF is an lvalue, returns the kind of lvalue that REF is.
57    Otherwise, returns clk_none.  If TREAT_CLASS_RVALUES_AS_LVALUES is
58    nonzero, rvalues of class type are considered lvalues.  */
59
60 static cp_lvalue_kind
61 lvalue_p_1 (tree ref,
62             int treat_class_rvalues_as_lvalues)
63 {
64   cp_lvalue_kind op1_lvalue_kind = clk_none;
65   cp_lvalue_kind op2_lvalue_kind = clk_none;
66
67   if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
68     return clk_ordinary;
69
70   if (ref == current_class_ptr)
71     return clk_none;
72
73   switch (TREE_CODE (ref))
74     {
75       /* preincrements and predecrements are valid lvals, provided
76          what they refer to are valid lvals.  */
77     case PREINCREMENT_EXPR:
78     case PREDECREMENT_EXPR:
79     case SAVE_EXPR:
80     case TRY_CATCH_EXPR:
81     case WITH_CLEANUP_EXPR:
82     case REALPART_EXPR:
83     case IMAGPART_EXPR:
84       return lvalue_p_1 (TREE_OPERAND (ref, 0),
85                          treat_class_rvalues_as_lvalues);
86
87     case COMPONENT_REF:
88       op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0),
89                                     treat_class_rvalues_as_lvalues);
90       /* Look at the member designator.  */
91       if (!op1_lvalue_kind
92           /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
93              situations.  */
94           || TREE_CODE (TREE_OPERAND (ref, 1)) != FIELD_DECL)
95         ;
96       else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref, 1)))
97         {
98           /* Clear the ordinary bit.  If this object was a class
99              rvalue we want to preserve that information.  */
100           op1_lvalue_kind &= ~clk_ordinary;
101           /* The lvalue is for a bitfield.  */
102           op1_lvalue_kind |= clk_bitfield;
103         }
104       else if (DECL_PACKED (TREE_OPERAND (ref, 1)))
105         op1_lvalue_kind |= clk_packed;
106
107       return op1_lvalue_kind;
108
109     case STRING_CST:
110       return clk_ordinary;
111
112     case CONST_DECL:
113     case VAR_DECL:
114       if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
115           && DECL_LANG_SPECIFIC (ref)
116           && DECL_IN_AGGR_P (ref))
117         return clk_none;
118     case INDIRECT_REF:
119     case ARRAY_REF:
120     case PARM_DECL:
121     case RESULT_DECL:
122       if (TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
123         return clk_ordinary;
124       break;
125
126       /* A currently unresolved scope ref.  */
127     case SCOPE_REF:
128       gcc_unreachable ();
129     case MAX_EXPR:
130     case MIN_EXPR:
131       /* Disallow <? and >? as lvalues if either argument side-effects.  */
132       if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 0))
133           || TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 1)))
134         return clk_none;
135       op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0),
136                                     treat_class_rvalues_as_lvalues);
137       op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1),
138                                     treat_class_rvalues_as_lvalues);
139       break;
140
141     case COND_EXPR:
142       op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1),
143                                     treat_class_rvalues_as_lvalues);
144       op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 2),
145                                     treat_class_rvalues_as_lvalues);
146       break;
147
148     case MODIFY_EXPR:
149       return clk_ordinary;
150
151     case COMPOUND_EXPR:
152       return lvalue_p_1 (TREE_OPERAND (ref, 1),
153                          treat_class_rvalues_as_lvalues);
154
155     case TARGET_EXPR:
156       return treat_class_rvalues_as_lvalues ? clk_class : clk_none;
157
158     case VA_ARG_EXPR:
159       return (treat_class_rvalues_as_lvalues
160               && CLASS_TYPE_P (TREE_TYPE (ref))
161               ? clk_class : clk_none);
162
163     case CALL_EXPR:
164       /* Any class-valued call would be wrapped in a TARGET_EXPR.  */
165       return clk_none;
166
167     case FUNCTION_DECL:
168       /* All functions (except non-static-member functions) are
169          lvalues.  */
170       return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref)
171               ? clk_none : clk_ordinary);
172
173     case NON_DEPENDENT_EXPR:
174       /* We must consider NON_DEPENDENT_EXPRs to be lvalues so that
175          things like "&E" where "E" is an expression with a
176          non-dependent type work. It is safe to be lenient because an
177          error will be issued when the template is instantiated if "E"
178          is not an lvalue.  */
179       return clk_ordinary;
180
181     default:
182       break;
183     }
184
185   /* If one operand is not an lvalue at all, then this expression is
186      not an lvalue.  */
187   if (!op1_lvalue_kind || !op2_lvalue_kind)
188     return clk_none;
189
190   /* Otherwise, it's an lvalue, and it has all the odd properties
191      contributed by either operand.  */
192   op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind;
193   /* It's not an ordinary lvalue if it involves either a bit-field or
194      a class rvalue.  */
195   if ((op1_lvalue_kind & ~clk_ordinary) != clk_none)
196     op1_lvalue_kind &= ~clk_ordinary;
197   return op1_lvalue_kind;
198 }
199
200 /* Returns the kind of lvalue that REF is, in the sense of
201    [basic.lval].  This function should really be named lvalue_p; it
202    computes the C++ definition of lvalue.  */
203
204 cp_lvalue_kind
205 real_lvalue_p (tree ref)
206 {
207   return lvalue_p_1 (ref,
208                      /*treat_class_rvalues_as_lvalues=*/0);
209 }
210
211 /* This differs from real_lvalue_p in that class rvalues are
212    considered lvalues.  */
213
214 int
215 lvalue_p (tree ref)
216 {
217   return
218     (lvalue_p_1 (ref, /*class rvalue ok*/ 1) != clk_none);
219 }
220
221 /* Test whether DECL is a builtin that may appear in a
222    constant-expression. */
223
224 bool
225 builtin_valid_in_constant_expr_p (tree decl)
226 {
227   /* At present BUILT_IN_CONSTANT_P is the only builtin we're allowing
228      in constant-expressions.  We may want to add other builtins later. */
229   return DECL_IS_BUILTIN_CONSTANT_P (decl);
230 }
231
232 /* Build a TARGET_EXPR, initializing the DECL with the VALUE.  */
233
234 static tree
235 build_target_expr (tree decl, tree value)
236 {
237   tree t;
238
239   t = build4 (TARGET_EXPR, TREE_TYPE (decl), decl, value,
240               cxx_maybe_build_cleanup (decl), NULL_TREE);
241   /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
242      ignore the TARGET_EXPR.  If there really turn out to be no
243      side-effects, then the optimizer should be able to get rid of
244      whatever code is generated anyhow.  */
245   TREE_SIDE_EFFECTS (t) = 1;
246
247   return t;
248 }
249
250 /* Return an undeclared local temporary of type TYPE for use in building a
251    TARGET_EXPR.  */
252
253 static tree
254 build_local_temp (tree type)
255 {
256   tree slot = build_decl (VAR_DECL, NULL_TREE, type);
257   DECL_ARTIFICIAL (slot) = 1;
258   DECL_IGNORED_P (slot) = 1;
259   DECL_CONTEXT (slot) = current_function_decl;
260   layout_decl (slot, 0);
261   return slot;
262 }
263
264 /* INIT is a CALL_EXPR which needs info about its target.
265    TYPE is the type that this initialization should appear to have.
266
267    Build an encapsulation of the initialization to perform
268    and return it so that it can be processed by language-independent
269    and language-specific expression expanders.  */
270
271 tree
272 build_cplus_new (tree type, tree init)
273 {
274   tree fn;
275   tree slot;
276   tree rval;
277   int is_ctor;
278
279   /* Make sure that we're not trying to create an instance of an
280      abstract class.  */
281   abstract_virtuals_error (NULL_TREE, type);
282
283   if (TREE_CODE (init) != CALL_EXPR && TREE_CODE (init) != AGGR_INIT_EXPR)
284     return convert (type, init);
285
286   fn = TREE_OPERAND (init, 0);
287   is_ctor = (TREE_CODE (fn) == ADDR_EXPR
288              && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
289              && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0)));
290
291   slot = build_local_temp (type);
292
293   /* We split the CALL_EXPR into its function and its arguments here.
294      Then, in expand_expr, we put them back together.  The reason for
295      this is that this expression might be a default argument
296      expression.  In that case, we need a new temporary every time the
297      expression is used.  That's what break_out_target_exprs does; it
298      replaces every AGGR_INIT_EXPR with a copy that uses a fresh
299      temporary slot.  Then, expand_expr builds up a call-expression
300      using the new slot.  */
301
302   /* If we don't need to use a constructor to create an object of this
303      type, don't mess with AGGR_INIT_EXPR.  */
304   if (is_ctor || TREE_ADDRESSABLE (type))
305     {
306       rval = build3 (AGGR_INIT_EXPR, void_type_node, fn,
307                      TREE_OPERAND (init, 1), slot);
308       TREE_SIDE_EFFECTS (rval) = 1;
309       AGGR_INIT_VIA_CTOR_P (rval) = is_ctor;
310     }
311   else
312     rval = init;
313
314   rval = build_target_expr (slot, rval);
315
316   return rval;
317 }
318
319 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
320    indicated TYPE.  */
321
322 tree
323 build_target_expr_with_type (tree init, tree type)
324 {
325   gcc_assert (!VOID_TYPE_P (type));
326
327   if (TREE_CODE (init) == TARGET_EXPR)
328     return init;
329   else if (CLASS_TYPE_P (type) && !TYPE_HAS_TRIVIAL_INIT_REF (type)
330            && TREE_CODE (init) != COND_EXPR
331            && TREE_CODE (init) != CONSTRUCTOR
332            && TREE_CODE (init) != VA_ARG_EXPR)
333     /* We need to build up a copy constructor call.  COND_EXPR is a special
334        case because we already have copies on the arms and we don't want
335        another one here.  A CONSTRUCTOR is aggregate initialization, which
336        is handled separately.  A VA_ARG_EXPR is magic creation of an
337        aggregate; there's no additional work to be done.  */
338     return force_rvalue (init);
339
340   return force_target_expr (type, init);
341 }
342
343 /* Like the above function, but without the checking.  This function should
344    only be used by code which is deliberately trying to subvert the type
345    system, such as call_builtin_trap.  */
346
347 tree
348 force_target_expr (tree type, tree init)
349 {
350   tree slot;
351
352   gcc_assert (!VOID_TYPE_P (type));
353
354   slot = build_local_temp (type);
355   return build_target_expr (slot, init);
356 }
357
358 /* Like build_target_expr_with_type, but use the type of INIT.  */
359
360 tree
361 get_target_expr (tree init)
362 {
363   return build_target_expr_with_type (init, TREE_TYPE (init));
364 }
365
366 /* If EXPR is a bitfield reference, convert it to the declared type of
367    the bitfield, and return the resulting expression.  Otherwise,
368    return EXPR itself.  */
369
370 tree
371 convert_bitfield_to_declared_type (tree expr)
372 {
373   tree bitfield_type;
374
375   bitfield_type = is_bitfield_expr_with_lowered_type (expr);
376   if (bitfield_type)
377     expr = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type),
378                                expr);
379   return expr;
380 }
381
382 /* EXPR is being used in an rvalue context.  Return a version of EXPR
383    that is marked as an rvalue.  */
384
385 tree
386 rvalue (tree expr)
387 {
388   tree type;
389
390   if (error_operand_p (expr))
391     return expr;
392
393   /* [basic.lval]
394
395      Non-class rvalues always have cv-unqualified types.  */
396   type = TREE_TYPE (expr);
397   if (!CLASS_TYPE_P (type) && cp_type_quals (type))
398     type = TYPE_MAIN_VARIANT (type);
399
400   if (!processing_template_decl && real_lvalue_p (expr))
401     expr = build1 (NON_LVALUE_EXPR, type, expr);
402   else if (type != TREE_TYPE (expr))
403     expr = build_nop (type, expr);
404
405   return expr;
406 }
407
408 \f
409 static tree
410 build_cplus_array_type_1 (tree elt_type, tree index_type)
411 {
412   tree t;
413
414   if (elt_type == error_mark_node || index_type == error_mark_node)
415     return error_mark_node;
416
417   if (dependent_type_p (elt_type)
418       || (index_type
419           && value_dependent_expression_p (TYPE_MAX_VALUE (index_type))))
420     {
421       t = make_node (ARRAY_TYPE);
422       TREE_TYPE (t) = elt_type;
423       TYPE_DOMAIN (t) = index_type;
424     }
425   else
426     t = build_array_type (elt_type, index_type);
427
428   /* Push these needs up so that initialization takes place
429      more easily.  */
430   TYPE_NEEDS_CONSTRUCTING (t)
431     = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
432   TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
433     = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
434   return t;
435 }
436
437 tree
438 build_cplus_array_type (tree elt_type, tree index_type)
439 {
440   tree t;
441   int type_quals = cp_type_quals (elt_type);
442
443   if (type_quals != TYPE_UNQUALIFIED)
444     elt_type = cp_build_qualified_type (elt_type, TYPE_UNQUALIFIED);
445
446   t = build_cplus_array_type_1 (elt_type, index_type);
447
448   if (type_quals != TYPE_UNQUALIFIED)
449     t = cp_build_qualified_type (t, type_quals);
450
451   return t;
452 }
453 \f
454 /* Make a variant of TYPE, qualified with the TYPE_QUALS.  Handles
455    arrays correctly.  In particular, if TYPE is an array of T's, and
456    TYPE_QUALS is non-empty, returns an array of qualified T's.
457
458    FLAGS determines how to deal with illformed qualifications. If
459    tf_ignore_bad_quals is set, then bad qualifications are dropped
460    (this is permitted if TYPE was introduced via a typedef or template
461    type parameter). If bad qualifications are dropped and tf_warning
462    is set, then a warning is issued for non-const qualifications.  If
463    tf_ignore_bad_quals is not set and tf_error is not set, we
464    return error_mark_node. Otherwise, we issue an error, and ignore
465    the qualifications.
466
467    Qualification of a reference type is valid when the reference came
468    via a typedef or template type argument. [dcl.ref] No such
469    dispensation is provided for qualifying a function type.  [dcl.fct]
470    DR 295 queries this and the proposed resolution brings it into line
471    with qualifying a reference.  We implement the DR.  We also behave
472    in a similar manner for restricting non-pointer types.  */
473
474 tree
475 cp_build_qualified_type_real (tree type,
476                               int type_quals,
477                               tsubst_flags_t complain)
478 {
479   tree result;
480   int bad_quals = TYPE_UNQUALIFIED;
481
482   if (type == error_mark_node)
483     return type;
484
485   if (type_quals == cp_type_quals (type))
486     return type;
487
488   if (TREE_CODE (type) == ARRAY_TYPE)
489     {
490       /* In C++, the qualification really applies to the array element
491          type.  Obtain the appropriately qualified element type.  */
492       tree t;
493       tree element_type
494         = cp_build_qualified_type_real (TREE_TYPE (type),
495                                         type_quals,
496                                         complain);
497
498       if (element_type == error_mark_node)
499         return error_mark_node;
500
501       /* See if we already have an identically qualified type.  */
502       for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
503         if (cp_type_quals (t) == type_quals
504             && TYPE_NAME (t) == TYPE_NAME (type)
505             && TYPE_CONTEXT (t) == TYPE_CONTEXT (type))
506           break;
507
508       if (!t)
509         {
510           /* Make a new array type, just like the old one, but with the
511              appropriately qualified element type.  */
512           t = build_variant_type_copy (type);
513           TREE_TYPE (t) = element_type;
514         }
515
516       /* Even if we already had this variant, we update
517          TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
518          they changed since the variant was originally created.
519
520          This seems hokey; if there is some way to use a previous
521          variant *without* coming through here,
522          TYPE_NEEDS_CONSTRUCTING will never be updated.  */
523       TYPE_NEEDS_CONSTRUCTING (t)
524         = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));
525       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
526         = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));
527       return t;
528     }
529   else if (TYPE_PTRMEMFUNC_P (type))
530     {
531       /* For a pointer-to-member type, we can't just return a
532          cv-qualified version of the RECORD_TYPE.  If we do, we
533          haven't changed the field that contains the actual pointer to
534          a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong.  */
535       tree t;
536
537       t = TYPE_PTRMEMFUNC_FN_TYPE (type);
538       t = cp_build_qualified_type_real (t, type_quals, complain);
539       return build_ptrmemfunc_type (t);
540     }
541
542   /* A reference or method type shall not be cv qualified.
543      [dcl.ref], [dct.fct]  */
544   if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)
545       && (TREE_CODE (type) == REFERENCE_TYPE
546           || TREE_CODE (type) == METHOD_TYPE))
547     {
548       bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
549       type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
550     }
551
552   /* A restrict-qualified type must be a pointer (or reference)
553      to object or incomplete type, or a function type. */
554   if ((type_quals & TYPE_QUAL_RESTRICT)
555       && TREE_CODE (type) != TEMPLATE_TYPE_PARM
556       && TREE_CODE (type) != TYPENAME_TYPE
557       && TREE_CODE (type) != FUNCTION_TYPE
558       && !POINTER_TYPE_P (type))
559     {
560       bad_quals |= TYPE_QUAL_RESTRICT;
561       type_quals &= ~TYPE_QUAL_RESTRICT;
562     }
563
564   if (bad_quals == TYPE_UNQUALIFIED)
565     /*OK*/;
566   else if (!(complain & (tf_error | tf_ignore_bad_quals)))
567     return error_mark_node;
568   else
569     {
570       if (complain & tf_ignore_bad_quals)
571         /* We're not going to warn about constifying things that can't
572            be constified.  */
573         bad_quals &= ~TYPE_QUAL_CONST;
574       if (bad_quals)
575         {
576           tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
577
578           if (!(complain & tf_ignore_bad_quals))
579             error ("%qV qualifiers cannot be applied to %qT",
580                    bad_type, type);
581         }
582     }
583
584   /* Retrieve (or create) the appropriately qualified variant.  */
585   result = build_qualified_type (type, type_quals);
586
587   /* If this was a pointer-to-method type, and we just made a copy,
588      then we need to unshare the record that holds the cached
589      pointer-to-member-function type, because these will be distinct
590      between the unqualified and qualified types.  */
591   if (result != type
592       && TREE_CODE (type) == POINTER_TYPE
593       && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)
594     TYPE_LANG_SPECIFIC (result) = NULL;
595
596   return result;
597 }
598
599 /* Returns the canonical version of TYPE.  In other words, if TYPE is
600    a typedef, returns the underlying type.  The cv-qualification of
601    the type returned matches the type input; they will always be
602    compatible types.  */
603
604 tree
605 canonical_type_variant (tree t)
606 {
607   return cp_build_qualified_type (TYPE_MAIN_VARIANT (t), cp_type_quals (t));
608 }
609 \f
610 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
611    graph dominated by T.  If BINFO is NULL, TYPE is a dependent base,
612    and we do a shallow copy.  If BINFO is non-NULL, we do a deep copy.
613    VIRT indicates whether TYPE is inherited virtually or not.
614    IGO_PREV points at the previous binfo of the inheritance graph
615    order chain.  The newly copied binfo's TREE_CHAIN forms this
616    ordering.
617
618    The CLASSTYPE_VBASECLASSES vector of T is constructed in the
619    correct order. That is in the order the bases themselves should be
620    constructed in.
621
622    The BINFO_INHERITANCE of a virtual base class points to the binfo
623    of the most derived type. ??? We could probably change this so that
624    BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
625    remove a field.  They currently can only differ for primary virtual
626    virtual bases.  */
627
628 tree
629 copy_binfo (tree binfo, tree type, tree t, tree *igo_prev, int virt)
630 {
631   tree new_binfo;
632
633   if (virt)
634     {
635       /* See if we've already made this virtual base.  */
636       new_binfo = binfo_for_vbase (type, t);
637       if (new_binfo)
638         return new_binfo;
639     }
640
641   new_binfo = make_tree_binfo (binfo ? BINFO_N_BASE_BINFOS (binfo) : 0);
642   BINFO_TYPE (new_binfo) = type;
643
644   /* Chain it into the inheritance graph.  */
645   TREE_CHAIN (*igo_prev) = new_binfo;
646   *igo_prev = new_binfo;
647
648   if (binfo)
649     {
650       int ix;
651       tree base_binfo;
652
653       gcc_assert (!BINFO_DEPENDENT_BASE_P (binfo));
654       gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type));
655
656       BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo);
657       BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo);
658
659       /* We do not need to copy the accesses, as they are read only.  */
660       BINFO_BASE_ACCESSES (new_binfo) = BINFO_BASE_ACCESSES (binfo);
661
662       /* Recursively copy base binfos of BINFO.  */
663       for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
664         {
665           tree new_base_binfo;
666
667           gcc_assert (!BINFO_DEPENDENT_BASE_P (base_binfo));
668           new_base_binfo = copy_binfo (base_binfo, BINFO_TYPE (base_binfo),
669                                        t, igo_prev,
670                                        BINFO_VIRTUAL_P (base_binfo));
671
672           if (!BINFO_INHERITANCE_CHAIN (new_base_binfo))
673             BINFO_INHERITANCE_CHAIN (new_base_binfo) = new_binfo;
674           BINFO_BASE_APPEND (new_binfo, new_base_binfo);
675         }
676     }
677   else
678     BINFO_DEPENDENT_BASE_P (new_binfo) = 1;
679
680   if (virt)
681     {
682       /* Push it onto the list after any virtual bases it contains
683          will have been pushed.  */
684       VEC_quick_push (tree, CLASSTYPE_VBASECLASSES (t), new_binfo);
685       BINFO_VIRTUAL_P (new_binfo) = 1;
686       BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t);
687     }
688
689   return new_binfo;
690 }
691 \f
692 /* Hashing of lists so that we don't make duplicates.
693    The entry point is `list_hash_canon'.  */
694
695 /* Now here is the hash table.  When recording a list, it is added
696    to the slot whose index is the hash code mod the table size.
697    Note that the hash table is used for several kinds of lists.
698    While all these live in the same table, they are completely independent,
699    and the hash code is computed differently for each of these.  */
700
701 static GTY ((param_is (union tree_node))) htab_t list_hash_table;
702
703 struct list_proxy
704 {
705   tree purpose;
706   tree value;
707   tree chain;
708 };
709
710 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
711    for a node we are thinking about adding).  */
712
713 static int
714 list_hash_eq (const void* entry, const void* data)
715 {
716   tree t = (tree) entry;
717   struct list_proxy *proxy = (struct list_proxy *) data;
718
719   return (TREE_VALUE (t) == proxy->value
720           && TREE_PURPOSE (t) == proxy->purpose
721           && TREE_CHAIN (t) == proxy->chain);
722 }
723
724 /* Compute a hash code for a list (chain of TREE_LIST nodes
725    with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
726    TREE_COMMON slots), by adding the hash codes of the individual entries.  */
727
728 static hashval_t
729 list_hash_pieces (tree purpose, tree value, tree chain)
730 {
731   hashval_t hashcode = 0;
732
733   if (chain)
734     hashcode += TREE_HASH (chain);
735
736   if (value)
737     hashcode += TREE_HASH (value);
738   else
739     hashcode += 1007;
740   if (purpose)
741     hashcode += TREE_HASH (purpose);
742   else
743     hashcode += 1009;
744   return hashcode;
745 }
746
747 /* Hash an already existing TREE_LIST.  */
748
749 static hashval_t
750 list_hash (const void* p)
751 {
752   tree t = (tree) p;
753   return list_hash_pieces (TREE_PURPOSE (t),
754                            TREE_VALUE (t),
755                            TREE_CHAIN (t));
756 }
757
758 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
759    object for an identical list if one already exists.  Otherwise, build a
760    new one, and record it as the canonical object.  */
761
762 tree
763 hash_tree_cons (tree purpose, tree value, tree chain)
764 {
765   int hashcode = 0;
766   void **slot;
767   struct list_proxy proxy;
768
769   /* Hash the list node.  */
770   hashcode = list_hash_pieces (purpose, value, chain);
771   /* Create a proxy for the TREE_LIST we would like to create.  We
772      don't actually create it so as to avoid creating garbage.  */
773   proxy.purpose = purpose;
774   proxy.value = value;
775   proxy.chain = chain;
776   /* See if it is already in the table.  */
777   slot = htab_find_slot_with_hash (list_hash_table, &proxy, hashcode,
778                                    INSERT);
779   /* If not, create a new node.  */
780   if (!*slot)
781     *slot = tree_cons (purpose, value, chain);
782   return (tree) *slot;
783 }
784
785 /* Constructor for hashed lists.  */
786
787 tree
788 hash_tree_chain (tree value, tree chain)
789 {
790   return hash_tree_cons (NULL_TREE, value, chain);
791 }
792 \f
793 void
794 debug_binfo (tree elem)
795 {
796   HOST_WIDE_INT n;
797   tree virtuals;
798
799   fprintf (stderr, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
800            "\nvtable type:\n",
801            TYPE_NAME_STRING (BINFO_TYPE (elem)),
802            TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
803   debug_tree (BINFO_TYPE (elem));
804   if (BINFO_VTABLE (elem))
805     fprintf (stderr, "vtable decl \"%s\"\n",
806              IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem))));
807   else
808     fprintf (stderr, "no vtable decl yet\n");
809   fprintf (stderr, "virtuals:\n");
810   virtuals = BINFO_VIRTUALS (elem);
811   n = 0;
812
813   while (virtuals)
814     {
815       tree fndecl = TREE_VALUE (virtuals);
816       fprintf (stderr, "%s [%ld =? %ld]\n",
817                IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
818                (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
819       ++n;
820       virtuals = TREE_CHAIN (virtuals);
821     }
822 }
823
824 /* Build a representation for the qualified name SCOPE::NAME.  TYPE is
825    the type of the result expression, if known, or NULL_TREE if the
826    resulting expression is type-dependent.  If TEMPLATE_P is true,
827    NAME is known to be a template because the user explicitly used the
828    "template" keyword after the "::".
829
830    All SCOPE_REFs should be built by use of this function.  */
831
832 tree
833 build_qualified_name (tree type, tree scope, tree name, bool template_p)
834 {
835   tree t;
836   if (type == error_mark_node
837       || scope == error_mark_node
838       || name == error_mark_node)
839     return error_mark_node;
840   t = build2 (SCOPE_REF, type, scope, name);
841   QUALIFIED_NAME_IS_TEMPLATE (t) = template_p;
842   return t;
843 }
844
845 int
846 is_overloaded_fn (tree x)
847 {
848   /* A baselink is also considered an overloaded function.  */
849   if (TREE_CODE (x) == OFFSET_REF)
850     x = TREE_OPERAND (x, 1);
851   if (BASELINK_P (x))
852     x = BASELINK_FUNCTIONS (x);
853   return (TREE_CODE (x) == FUNCTION_DECL
854           || TREE_CODE (x) == TEMPLATE_ID_EXPR
855           || DECL_FUNCTION_TEMPLATE_P (x)
856           || TREE_CODE (x) == OVERLOAD);
857 }
858
859 int
860 really_overloaded_fn (tree x)
861 {
862   if (TREE_CODE (x) == OFFSET_REF)
863     x = TREE_OPERAND (x, 1);
864   /* A baselink is also considered an overloaded function.  */
865   if (BASELINK_P (x))
866     x = BASELINK_FUNCTIONS (x);
867
868   return ((TREE_CODE (x) == OVERLOAD && OVL_CHAIN (x))
869           || DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x))
870           || TREE_CODE (x) == TEMPLATE_ID_EXPR);
871 }
872
873 tree
874 get_first_fn (tree from)
875 {
876   gcc_assert (is_overloaded_fn (from));
877   /* A baselink is also considered an overloaded function.  */
878   if (BASELINK_P (from))
879     from = BASELINK_FUNCTIONS (from);
880   return OVL_CURRENT (from);
881 }
882
883 /* Return a new OVL node, concatenating it with the old one.  */
884
885 tree
886 ovl_cons (tree decl, tree chain)
887 {
888   tree result = make_node (OVERLOAD);
889   TREE_TYPE (result) = unknown_type_node;
890   OVL_FUNCTION (result) = decl;
891   TREE_CHAIN (result) = chain;
892
893   return result;
894 }
895
896 /* Build a new overloaded function. If this is the first one,
897    just return it; otherwise, ovl_cons the _DECLs */
898
899 tree
900 build_overload (tree decl, tree chain)
901 {
902   if (! chain && TREE_CODE (decl) != TEMPLATE_DECL)
903     return decl;
904   if (chain && TREE_CODE (chain) != OVERLOAD)
905     chain = ovl_cons (chain, NULL_TREE);
906   return ovl_cons (decl, chain);
907 }
908
909 \f
910 #define PRINT_RING_SIZE 4
911
912 const char *
913 cxx_printable_name (tree decl, int v)
914 {
915   static tree decl_ring[PRINT_RING_SIZE];
916   static char *print_ring[PRINT_RING_SIZE];
917   static int ring_counter;
918   int i;
919
920   /* Only cache functions.  */
921   if (v < 2
922       || TREE_CODE (decl) != FUNCTION_DECL
923       || DECL_LANG_SPECIFIC (decl) == 0)
924     return lang_decl_name (decl, v);
925
926   /* See if this print name is lying around.  */
927   for (i = 0; i < PRINT_RING_SIZE; i++)
928     if (decl_ring[i] == decl)
929       /* yes, so return it.  */
930       return print_ring[i];
931
932   if (++ring_counter == PRINT_RING_SIZE)
933     ring_counter = 0;
934
935   if (current_function_decl != NULL_TREE)
936     {
937       if (decl_ring[ring_counter] == current_function_decl)
938         ring_counter += 1;
939       if (ring_counter == PRINT_RING_SIZE)
940         ring_counter = 0;
941       gcc_assert (decl_ring[ring_counter] != current_function_decl);
942     }
943
944   if (print_ring[ring_counter])
945     free (print_ring[ring_counter]);
946
947   print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v));
948   decl_ring[ring_counter] = decl;
949   return print_ring[ring_counter];
950 }
951 \f
952 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
953    listed in RAISES.  */
954
955 tree
956 build_exception_variant (tree type, tree raises)
957 {
958   tree v = TYPE_MAIN_VARIANT (type);
959   int type_quals = TYPE_QUALS (type);
960
961   for (; v; v = TYPE_NEXT_VARIANT (v))
962     if (check_qualified_type (v, type, type_quals)
963         && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (v), 1))
964       return v;
965
966   /* Need to build a new variant.  */
967   v = build_variant_type_copy (type);
968   TYPE_RAISES_EXCEPTIONS (v) = raises;
969   return v;
970 }
971
972 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
973    BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
974    arguments.  */
975
976 tree
977 bind_template_template_parm (tree t, tree newargs)
978 {
979   tree decl = TYPE_NAME (t);
980   tree t2;
981
982   t2 = make_aggr_type (BOUND_TEMPLATE_TEMPLATE_PARM);
983   decl = build_decl (TYPE_DECL, DECL_NAME (decl), NULL_TREE);
984
985   /* These nodes have to be created to reflect new TYPE_DECL and template
986      arguments.  */
987   TEMPLATE_TYPE_PARM_INDEX (t2) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t));
988   TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2)) = decl;
989   TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
990     = tree_cons (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t),
991                  newargs, NULL_TREE);
992
993   TREE_TYPE (decl) = t2;
994   TYPE_NAME (t2) = decl;
995   TYPE_STUB_DECL (t2) = decl;
996   TYPE_SIZE (t2) = 0;
997
998   return t2;
999 }
1000
1001 /* Called from count_trees via walk_tree.  */
1002
1003 static tree
1004 count_trees_r (tree *tp, int *walk_subtrees, void *data)
1005 {
1006   ++*((int *) data);
1007
1008   if (TYPE_P (*tp))
1009     *walk_subtrees = 0;
1010
1011   return NULL_TREE;
1012 }
1013
1014 /* Debugging function for measuring the rough complexity of a tree
1015    representation.  */
1016
1017 int
1018 count_trees (tree t)
1019 {
1020   int n_trees = 0;
1021   walk_tree_without_duplicates (&t, count_trees_r, &n_trees);
1022   return n_trees;
1023 }
1024
1025 /* Called from verify_stmt_tree via walk_tree.  */
1026
1027 static tree
1028 verify_stmt_tree_r (tree* tp,
1029                     int* walk_subtrees ATTRIBUTE_UNUSED ,
1030                     void* data)
1031 {
1032   tree t = *tp;
1033   htab_t *statements = (htab_t *) data;
1034   void **slot;
1035
1036   if (!STATEMENT_CODE_P (TREE_CODE (t)))
1037     return NULL_TREE;
1038
1039   /* If this statement is already present in the hash table, then
1040      there is a circularity in the statement tree.  */
1041   gcc_assert (!htab_find (*statements, t));
1042
1043   slot = htab_find_slot (*statements, t, INSERT);
1044   *slot = t;
1045
1046   return NULL_TREE;
1047 }
1048
1049 /* Debugging function to check that the statement T has not been
1050    corrupted.  For now, this function simply checks that T contains no
1051    circularities.  */
1052
1053 void
1054 verify_stmt_tree (tree t)
1055 {
1056   htab_t statements;
1057   statements = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1058   walk_tree (&t, verify_stmt_tree_r, &statements, NULL);
1059   htab_delete (statements);
1060 }
1061
1062 /* Check if the type T depends on a type with no linkage and if so, return
1063    it.  If RELAXED_P then do not consider a class type declared within
1064    a TREE_PUBLIC function to have no linkage.  */
1065
1066 tree
1067 no_linkage_check (tree t, bool relaxed_p)
1068 {
1069   tree r;
1070
1071   /* There's no point in checking linkage on template functions; we
1072      can't know their complete types.  */
1073   if (processing_template_decl)
1074     return NULL_TREE;
1075
1076   switch (TREE_CODE (t))
1077     {
1078       tree fn;
1079
1080     case RECORD_TYPE:
1081       if (TYPE_PTRMEMFUNC_P (t))
1082         goto ptrmem;
1083       /* Fall through.  */
1084     case UNION_TYPE:
1085       if (!CLASS_TYPE_P (t))
1086         return NULL_TREE;
1087       /* Fall through.  */
1088     case ENUMERAL_TYPE:
1089       if (TYPE_ANONYMOUS_P (t))
1090         return t;
1091       fn = decl_function_context (TYPE_MAIN_DECL (t));
1092       if (fn && (!relaxed_p || !TREE_PUBLIC (fn)))
1093         return t;
1094       return NULL_TREE;
1095
1096     case ARRAY_TYPE:
1097     case POINTER_TYPE:
1098     case REFERENCE_TYPE:
1099       return no_linkage_check (TREE_TYPE (t), relaxed_p);
1100
1101     case OFFSET_TYPE:
1102     ptrmem:
1103       r = no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t),
1104                             relaxed_p);
1105       if (r)
1106         return r;
1107       return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t), relaxed_p);
1108
1109     case METHOD_TYPE:
1110       r = no_linkage_check (TYPE_METHOD_BASETYPE (t), relaxed_p);
1111       if (r)
1112         return r;
1113       /* Fall through.  */
1114     case FUNCTION_TYPE:
1115       {
1116         tree parm;
1117         for (parm = TYPE_ARG_TYPES (t);
1118              parm && parm != void_list_node;
1119              parm = TREE_CHAIN (parm))
1120           {
1121             r = no_linkage_check (TREE_VALUE (parm), relaxed_p);
1122             if (r)
1123               return r;
1124           }
1125         return no_linkage_check (TREE_TYPE (t), relaxed_p);
1126       }
1127
1128     default:
1129       return NULL_TREE;
1130     }
1131 }
1132
1133 #ifdef GATHER_STATISTICS
1134 extern int depth_reached;
1135 #endif
1136
1137 void
1138 cxx_print_statistics (void)
1139 {
1140   print_search_statistics ();
1141   print_class_statistics ();
1142 #ifdef GATHER_STATISTICS
1143   fprintf (stderr, "maximum template instantiation depth reached: %d\n",
1144            depth_reached);
1145 #endif
1146 }
1147
1148 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1149    (which is an ARRAY_TYPE).  This counts only elements of the top
1150    array.  */
1151
1152 tree
1153 array_type_nelts_top (tree type)
1154 {
1155   return fold_build2 (PLUS_EXPR, sizetype,
1156                       array_type_nelts (type),
1157                       integer_one_node);
1158 }
1159
1160 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1161    (which is an ARRAY_TYPE).  This one is a recursive count of all
1162    ARRAY_TYPEs that are clumped together.  */
1163
1164 tree
1165 array_type_nelts_total (tree type)
1166 {
1167   tree sz = array_type_nelts_top (type);
1168   type = TREE_TYPE (type);
1169   while (TREE_CODE (type) == ARRAY_TYPE)
1170     {
1171       tree n = array_type_nelts_top (type);
1172       sz = fold_build2 (MULT_EXPR, sizetype, sz, n);
1173       type = TREE_TYPE (type);
1174     }
1175   return sz;
1176 }
1177
1178 /* Called from break_out_target_exprs via mapcar.  */
1179
1180 static tree
1181 bot_manip (tree* tp, int* walk_subtrees, void* data)
1182 {
1183   splay_tree target_remap = ((splay_tree) data);
1184   tree t = *tp;
1185
1186   if (!TYPE_P (t) && TREE_CONSTANT (t))
1187     {
1188       /* There can't be any TARGET_EXPRs or their slot variables below
1189          this point.  We used to check !TREE_SIDE_EFFECTS, but then we
1190          failed to copy an ADDR_EXPR of the slot VAR_DECL.  */
1191       *walk_subtrees = 0;
1192       return NULL_TREE;
1193     }
1194   if (TREE_CODE (t) == TARGET_EXPR)
1195     {
1196       tree u;
1197
1198       if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
1199         u = build_cplus_new
1200           (TREE_TYPE (t), break_out_target_exprs (TREE_OPERAND (t, 1)));
1201       else
1202         u = build_target_expr_with_type
1203           (break_out_target_exprs (TREE_OPERAND (t, 1)), TREE_TYPE (t));
1204
1205       /* Map the old variable to the new one.  */
1206       splay_tree_insert (target_remap,
1207                          (splay_tree_key) TREE_OPERAND (t, 0),
1208                          (splay_tree_value) TREE_OPERAND (u, 0));
1209
1210       /* Replace the old expression with the new version.  */
1211       *tp = u;
1212       /* We don't have to go below this point; the recursive call to
1213          break_out_target_exprs will have handled anything below this
1214          point.  */
1215       *walk_subtrees = 0;
1216       return NULL_TREE;
1217     }
1218
1219   /* Make a copy of this node.  */
1220   return copy_tree_r (tp, walk_subtrees, NULL);
1221 }
1222
1223 /* Replace all remapped VAR_DECLs in T with their new equivalents.
1224    DATA is really a splay-tree mapping old variables to new
1225    variables.  */
1226
1227 static tree
1228 bot_replace (tree* t,
1229              int* walk_subtrees ATTRIBUTE_UNUSED ,
1230              void* data)
1231 {
1232   splay_tree target_remap = ((splay_tree) data);
1233
1234   if (TREE_CODE (*t) == VAR_DECL)
1235     {
1236       splay_tree_node n = splay_tree_lookup (target_remap,
1237                                              (splay_tree_key) *t);
1238       if (n)
1239         *t = (tree) n->value;
1240     }
1241
1242   return NULL_TREE;
1243 }
1244
1245 /* When we parse a default argument expression, we may create
1246    temporary variables via TARGET_EXPRs.  When we actually use the
1247    default-argument expression, we make a copy of the expression, but
1248    we must replace the temporaries with appropriate local versions.  */
1249
1250 tree
1251 break_out_target_exprs (tree t)
1252 {
1253   static int target_remap_count;
1254   static splay_tree target_remap;
1255
1256   if (!target_remap_count++)
1257     target_remap = splay_tree_new (splay_tree_compare_pointers,
1258                                    /*splay_tree_delete_key_fn=*/NULL,
1259                                    /*splay_tree_delete_value_fn=*/NULL);
1260   walk_tree (&t, bot_manip, target_remap, NULL);
1261   walk_tree (&t, bot_replace, target_remap, NULL);
1262
1263   if (!--target_remap_count)
1264     {
1265       splay_tree_delete (target_remap);
1266       target_remap = NULL;
1267     }
1268
1269   return t;
1270 }
1271
1272 /* Similar to `build_nt', but for template definitions of dependent
1273    expressions  */
1274
1275 tree
1276 build_min_nt (enum tree_code code, ...)
1277 {
1278   tree t;
1279   int length;
1280   int i;
1281   va_list p;
1282
1283   va_start (p, code);
1284
1285   t = make_node (code);
1286   length = TREE_CODE_LENGTH (code);
1287
1288   for (i = 0; i < length; i++)
1289     {
1290       tree x = va_arg (p, tree);
1291       TREE_OPERAND (t, i) = x;
1292     }
1293
1294   va_end (p);
1295   return t;
1296 }
1297
1298 /* Similar to `build', but for template definitions.  */
1299
1300 tree
1301 build_min (enum tree_code code, tree tt, ...)
1302 {
1303   tree t;
1304   int length;
1305   int i;
1306   va_list p;
1307
1308   va_start (p, tt);
1309
1310   t = make_node (code);
1311   length = TREE_CODE_LENGTH (code);
1312   TREE_TYPE (t) = tt;
1313
1314   for (i = 0; i < length; i++)
1315     {
1316       tree x = va_arg (p, tree);
1317       TREE_OPERAND (t, i) = x;
1318       if (x && !TYPE_P (x) && TREE_SIDE_EFFECTS (x))
1319         TREE_SIDE_EFFECTS (t) = 1;
1320     }
1321
1322   va_end (p);
1323   return t;
1324 }
1325
1326 /* Similar to `build', but for template definitions of non-dependent
1327    expressions. NON_DEP is the non-dependent expression that has been
1328    built.  */
1329
1330 tree
1331 build_min_non_dep (enum tree_code code, tree non_dep, ...)
1332 {
1333   tree t;
1334   int length;
1335   int i;
1336   va_list p;
1337
1338   va_start (p, non_dep);
1339
1340   t = make_node (code);
1341   length = TREE_CODE_LENGTH (code);
1342   TREE_TYPE (t) = TREE_TYPE (non_dep);
1343   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
1344
1345   for (i = 0; i < length; i++)
1346     {
1347       tree x = va_arg (p, tree);
1348       TREE_OPERAND (t, i) = x;
1349     }
1350
1351   if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR)
1352     /* This should not be considered a COMPOUND_EXPR, because it
1353        resolves to an overload.  */
1354     COMPOUND_EXPR_OVERLOADED (t) = 1;
1355
1356   va_end (p);
1357   return t;
1358 }
1359
1360 tree
1361 get_type_decl (tree t)
1362 {
1363   if (TREE_CODE (t) == TYPE_DECL)
1364     return t;
1365   if (TYPE_P (t))
1366     return TYPE_STUB_DECL (t);
1367   gcc_assert (t == error_mark_node);
1368   return t;
1369 }
1370
1371 /* Returns the namespace that contains DECL, whether directly or
1372    indirectly.  */
1373
1374 tree
1375 decl_namespace_context (tree decl)
1376 {
1377   while (1)
1378     {
1379       if (TREE_CODE (decl) == NAMESPACE_DECL)
1380         return decl;
1381       else if (TYPE_P (decl))
1382         decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
1383       else
1384         decl = CP_DECL_CONTEXT (decl);
1385     }
1386 }
1387
1388 /* Returns true if decl is within an anonymous namespace, however deeply
1389    nested, or false otherwise.  */
1390
1391 bool
1392 decl_anon_ns_mem_p (tree decl)
1393 {
1394   while (1)
1395     {
1396       if (decl == NULL_TREE || decl == error_mark_node)
1397         return false;
1398       if (TREE_CODE (decl) == NAMESPACE_DECL
1399           && DECL_NAME (decl) == NULL_TREE)
1400         return true;
1401       /* Classes and namespaces inside anonymous namespaces have
1402          TREE_PUBLIC == 0, so we can shortcut the search.  */
1403       else if (TYPE_P (decl))
1404         return (TREE_PUBLIC (TYPE_NAME (decl)) == 0);
1405       else if (TREE_CODE (decl) == NAMESPACE_DECL)
1406         return (TREE_PUBLIC (decl) == 0);
1407       else
1408         decl = DECL_CONTEXT (decl);
1409     }
1410 }
1411
1412 /* Return truthvalue of whether T1 is the same tree structure as T2.
1413    Return 1 if they are the same. Return 0 if they are different.  */
1414
1415 bool
1416 cp_tree_equal (tree t1, tree t2)
1417 {
1418   enum tree_code code1, code2;
1419
1420   if (t1 == t2)
1421     return true;
1422   if (!t1 || !t2)
1423     return false;
1424
1425   for (code1 = TREE_CODE (t1);
1426        code1 == NOP_EXPR || code1 == CONVERT_EXPR
1427          || code1 == NON_LVALUE_EXPR;
1428        code1 = TREE_CODE (t1))
1429     t1 = TREE_OPERAND (t1, 0);
1430   for (code2 = TREE_CODE (t2);
1431        code2 == NOP_EXPR || code2 == CONVERT_EXPR
1432          || code1 == NON_LVALUE_EXPR;
1433        code2 = TREE_CODE (t2))
1434     t2 = TREE_OPERAND (t2, 0);
1435
1436   /* They might have become equal now.  */
1437   if (t1 == t2)
1438     return true;
1439
1440   if (code1 != code2)
1441     return false;
1442
1443   switch (code1)
1444     {
1445     case INTEGER_CST:
1446       return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
1447         && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
1448
1449     case REAL_CST:
1450       return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
1451
1452     case STRING_CST:
1453       return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
1454         && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
1455                     TREE_STRING_LENGTH (t1));
1456
1457     case CONSTRUCTOR:
1458       /* We need to do this when determining whether or not two
1459          non-type pointer to member function template arguments
1460          are the same.  */
1461       if (!(same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
1462             /* The first operand is RTL.  */
1463             && TREE_OPERAND (t1, 0) == TREE_OPERAND (t2, 0)))
1464         return false;
1465       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
1466
1467     case TREE_LIST:
1468       if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
1469         return false;
1470       if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
1471         return false;
1472       return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
1473
1474     case SAVE_EXPR:
1475       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
1476
1477     case CALL_EXPR:
1478       if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
1479         return false;
1480       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
1481
1482     case TARGET_EXPR:
1483       {
1484         tree o1 = TREE_OPERAND (t1, 0);
1485         tree o2 = TREE_OPERAND (t2, 0);
1486
1487         /* Special case: if either target is an unallocated VAR_DECL,
1488            it means that it's going to be unified with whatever the
1489            TARGET_EXPR is really supposed to initialize, so treat it
1490            as being equivalent to anything.  */
1491         if (TREE_CODE (o1) == VAR_DECL && DECL_NAME (o1) == NULL_TREE
1492             && !DECL_RTL_SET_P (o1))
1493           /*Nop*/;
1494         else if (TREE_CODE (o2) == VAR_DECL && DECL_NAME (o2) == NULL_TREE
1495                  && !DECL_RTL_SET_P (o2))
1496           /*Nop*/;
1497         else if (!cp_tree_equal (o1, o2))
1498           return false;
1499
1500         return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
1501       }
1502
1503     case WITH_CLEANUP_EXPR:
1504       if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
1505         return false;
1506       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
1507
1508     case COMPONENT_REF:
1509       if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1))
1510         return false;
1511       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
1512
1513     case VAR_DECL:
1514     case PARM_DECL:
1515     case CONST_DECL:
1516     case FUNCTION_DECL:
1517     case TEMPLATE_DECL:
1518     case IDENTIFIER_NODE:
1519     case SSA_NAME:
1520       return false;
1521
1522     case BASELINK:
1523       return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
1524               && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
1525               && cp_tree_equal (BASELINK_FUNCTIONS (t1),
1526                                 BASELINK_FUNCTIONS (t2)));
1527
1528     case TEMPLATE_PARM_INDEX:
1529       return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
1530               && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
1531               && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
1532                               TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
1533
1534     case TEMPLATE_ID_EXPR:
1535       {
1536         unsigned ix;
1537         tree vec1, vec2;
1538
1539         if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
1540           return false;
1541         vec1 = TREE_OPERAND (t1, 1);
1542         vec2 = TREE_OPERAND (t2, 1);
1543
1544         if (!vec1 || !vec2)
1545           return !vec1 && !vec2;
1546
1547         if (TREE_VEC_LENGTH (vec1) != TREE_VEC_LENGTH (vec2))
1548           return false;
1549
1550         for (ix = TREE_VEC_LENGTH (vec1); ix--;)
1551           if (!cp_tree_equal (TREE_VEC_ELT (vec1, ix),
1552                               TREE_VEC_ELT (vec2, ix)))
1553             return false;
1554
1555         return true;
1556       }
1557
1558     case SIZEOF_EXPR:
1559     case ALIGNOF_EXPR:
1560       {
1561         tree o1 = TREE_OPERAND (t1, 0);
1562         tree o2 = TREE_OPERAND (t2, 0);
1563
1564         if (TREE_CODE (o1) != TREE_CODE (o2))
1565           return false;
1566         if (TYPE_P (o1))
1567           return same_type_p (o1, o2);
1568         else
1569           return cp_tree_equal (o1, o2);
1570       }
1571
1572     case PTRMEM_CST:
1573       /* Two pointer-to-members are the same if they point to the same
1574          field or function in the same class.  */
1575       if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
1576         return false;
1577
1578       return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
1579
1580     case OVERLOAD:
1581       if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2))
1582         return false;
1583       return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2));
1584
1585     default:
1586       break;
1587     }
1588
1589   switch (TREE_CODE_CLASS (code1))
1590     {
1591     case tcc_unary:
1592     case tcc_binary:
1593     case tcc_comparison:
1594     case tcc_expression:
1595     case tcc_reference:
1596     case tcc_statement:
1597       {
1598         int i;
1599
1600         for (i = 0; i < TREE_CODE_LENGTH (code1); ++i)
1601           if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
1602             return false;
1603
1604         return true;
1605       }
1606
1607     case tcc_type:
1608       return same_type_p (t1, t2);
1609     default:
1610       gcc_unreachable ();
1611     }
1612   /* We can get here with --disable-checking.  */
1613   return false;
1614 }
1615
1616 /* The type of ARG when used as an lvalue.  */
1617
1618 tree
1619 lvalue_type (tree arg)
1620 {
1621   tree type = TREE_TYPE (arg);
1622   return type;
1623 }
1624
1625 /* The type of ARG for printing error messages; denote lvalues with
1626    reference types.  */
1627
1628 tree
1629 error_type (tree arg)
1630 {
1631   tree type = TREE_TYPE (arg);
1632
1633   if (TREE_CODE (type) == ARRAY_TYPE)
1634     ;
1635   else if (TREE_CODE (type) == ERROR_MARK)
1636     ;
1637   else if (real_lvalue_p (arg))
1638     type = build_reference_type (lvalue_type (arg));
1639   else if (IS_AGGR_TYPE (type))
1640     type = lvalue_type (arg);
1641
1642   return type;
1643 }
1644
1645 /* Does FUNCTION use a variable-length argument list?  */
1646
1647 int
1648 varargs_function_p (tree function)
1649 {
1650   tree parm = TYPE_ARG_TYPES (TREE_TYPE (function));
1651   for (; parm; parm = TREE_CHAIN (parm))
1652     if (TREE_VALUE (parm) == void_type_node)
1653       return 0;
1654   return 1;
1655 }
1656
1657 /* Returns 1 if decl is a member of a class.  */
1658
1659 int
1660 member_p (tree decl)
1661 {
1662   const tree ctx = DECL_CONTEXT (decl);
1663   return (ctx && TYPE_P (ctx));
1664 }
1665
1666 /* Create a placeholder for member access where we don't actually have an
1667    object that the access is against.  */
1668
1669 tree
1670 build_dummy_object (tree type)
1671 {
1672   tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
1673   return build_indirect_ref (decl, NULL);
1674 }
1675
1676 /* We've gotten a reference to a member of TYPE.  Return *this if appropriate,
1677    or a dummy object otherwise.  If BINFOP is non-0, it is filled with the
1678    binfo path from current_class_type to TYPE, or 0.  */
1679
1680 tree
1681 maybe_dummy_object (tree type, tree* binfop)
1682 {
1683   tree decl, context;
1684   tree binfo;
1685
1686   if (current_class_type
1687       && (binfo = lookup_base (current_class_type, type,
1688                                ba_unique | ba_quiet, NULL)))
1689     context = current_class_type;
1690   else
1691     {
1692       /* Reference from a nested class member function.  */
1693       context = type;
1694       binfo = TYPE_BINFO (type);
1695     }
1696
1697   if (binfop)
1698     *binfop = binfo;
1699
1700   if (current_class_ref && context == current_class_type
1701       /* Kludge: Make sure that current_class_type is actually
1702          correct.  It might not be if we're in the middle of
1703          tsubst_default_argument.  */
1704       && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref)),
1705                       current_class_type))
1706     decl = current_class_ref;
1707   else
1708     decl = build_dummy_object (context);
1709
1710   return decl;
1711 }
1712
1713 /* Returns 1 if OB is a placeholder object, or a pointer to one.  */
1714
1715 int
1716 is_dummy_object (tree ob)
1717 {
1718   if (TREE_CODE (ob) == INDIRECT_REF)
1719     ob = TREE_OPERAND (ob, 0);
1720   return (TREE_CODE (ob) == NOP_EXPR
1721           && TREE_OPERAND (ob, 0) == void_zero_node);
1722 }
1723
1724 /* Returns 1 iff type T is a POD type, as defined in [basic.types].  */
1725
1726 int
1727 pod_type_p (tree t)
1728 {
1729   t = strip_array_types (t);
1730
1731   if (t == error_mark_node)
1732     return 1;
1733   if (INTEGRAL_TYPE_P (t))
1734     return 1;  /* integral, character or enumeral type */
1735   if (FLOAT_TYPE_P (t))
1736     return 1;
1737   if (TYPE_PTR_P (t))
1738     return 1; /* pointer to non-member */
1739   if (TYPE_PTR_TO_MEMBER_P (t))
1740     return 1; /* pointer to member */
1741
1742   if (TREE_CODE (t) == VECTOR_TYPE)
1743     return 1; /* vectors are (small) arrays of scalars */
1744
1745   if (! CLASS_TYPE_P (t))
1746     return 0; /* other non-class type (reference or function) */
1747   if (CLASSTYPE_NON_POD_P (t))
1748     return 0;
1749   return 1;
1750 }
1751
1752 /* Returns 1 iff zero initialization of type T means actually storing
1753    zeros in it.  */
1754
1755 int
1756 zero_init_p (tree t)
1757 {
1758   t = strip_array_types (t);
1759
1760   if (t == error_mark_node)
1761     return 1;
1762
1763   /* NULL pointers to data members are initialized with -1.  */
1764   if (TYPE_PTRMEM_P (t))
1765     return 0;
1766
1767   /* Classes that contain types that can't be zero-initialized, cannot
1768      be zero-initialized themselves.  */
1769   if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
1770     return 0;
1771
1772   return 1;
1773 }
1774
1775 /* Table of valid C++ attributes.  */
1776 const struct attribute_spec cxx_attribute_table[] =
1777 {
1778   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
1779   { "java_interface", 0, 0, false, false, false, handle_java_interface_attribute },
1780   { "com_interface",  0, 0, false, false, false, handle_com_interface_attribute },
1781   { "init_priority",  1, 1, true,  false, false, handle_init_priority_attribute },
1782   { NULL,             0, 0, false, false, false, NULL }
1783 };
1784
1785 /* Handle a "java_interface" attribute; arguments as in
1786    struct attribute_spec.handler.  */
1787 static tree
1788 handle_java_interface_attribute (tree* node,
1789                                  tree name,
1790                                  tree args ATTRIBUTE_UNUSED ,
1791                                  int flags,
1792                                  bool* no_add_attrs)
1793 {
1794   if (DECL_P (*node)
1795       || !CLASS_TYPE_P (*node)
1796       || !TYPE_FOR_JAVA (*node))
1797     {
1798       error ("%qE attribute can only be applied to Java class definitions",
1799              name);
1800       *no_add_attrs = true;
1801       return NULL_TREE;
1802     }
1803   if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
1804     *node = build_variant_type_copy (*node);
1805   TYPE_JAVA_INTERFACE (*node) = 1;
1806
1807   return NULL_TREE;
1808 }
1809
1810 /* Handle a "com_interface" attribute; arguments as in
1811    struct attribute_spec.handler.  */
1812 static tree
1813 handle_com_interface_attribute (tree* node,
1814                                 tree name,
1815                                 tree args ATTRIBUTE_UNUSED ,
1816                                 int flags ATTRIBUTE_UNUSED ,
1817                                 bool* no_add_attrs)
1818 {
1819   static int warned;
1820
1821   *no_add_attrs = true;
1822
1823   if (DECL_P (*node)
1824       || !CLASS_TYPE_P (*node)
1825       || *node != TYPE_MAIN_VARIANT (*node))
1826     {
1827       warning (OPT_Wattributes, "%qE attribute can only be applied "
1828                "to class definitions", name);
1829       return NULL_TREE;
1830     }
1831
1832   if (!warned++)
1833     warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default",
1834              name);
1835
1836   return NULL_TREE;
1837 }
1838
1839 /* Handle an "init_priority" attribute; arguments as in
1840    struct attribute_spec.handler.  */
1841 static tree
1842 handle_init_priority_attribute (tree* node,
1843                                 tree name,
1844                                 tree args,
1845                                 int flags ATTRIBUTE_UNUSED ,
1846                                 bool* no_add_attrs)
1847 {
1848   tree initp_expr = TREE_VALUE (args);
1849   tree decl = *node;
1850   tree type = TREE_TYPE (decl);
1851   int pri;
1852
1853   STRIP_NOPS (initp_expr);
1854
1855   if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
1856     {
1857       error ("requested init_priority is not an integer constant");
1858       *no_add_attrs = true;
1859       return NULL_TREE;
1860     }
1861
1862   pri = TREE_INT_CST_LOW (initp_expr);
1863
1864   type = strip_array_types (type);
1865
1866   if (decl == NULL_TREE
1867       || TREE_CODE (decl) != VAR_DECL
1868       || !TREE_STATIC (decl)
1869       || DECL_EXTERNAL (decl)
1870       || (TREE_CODE (type) != RECORD_TYPE
1871           && TREE_CODE (type) != UNION_TYPE)
1872       /* Static objects in functions are initialized the
1873          first time control passes through that
1874          function. This is not precise enough to pin down an
1875          init_priority value, so don't allow it.  */
1876       || current_function_decl)
1877     {
1878       error ("can only use %qE attribute on file-scope definitions "
1879              "of objects of class type", name);
1880       *no_add_attrs = true;
1881       return NULL_TREE;
1882     }
1883
1884   if (pri > MAX_INIT_PRIORITY || pri <= 0)
1885     {
1886       error ("requested init_priority is out of range");
1887       *no_add_attrs = true;
1888       return NULL_TREE;
1889     }
1890
1891   /* Check for init_priorities that are reserved for
1892      language and runtime support implementations.*/
1893   if (pri <= MAX_RESERVED_INIT_PRIORITY)
1894     {
1895       warning
1896         (0, "requested init_priority is reserved for internal use");
1897     }
1898
1899   if (SUPPORTS_INIT_PRIORITY)
1900     {
1901       SET_DECL_INIT_PRIORITY (decl, pri);
1902       DECL_HAS_INIT_PRIORITY_P (decl) = 1;
1903       return NULL_TREE;
1904     }
1905   else
1906     {
1907       error ("%qE attribute is not supported on this platform", name);
1908       *no_add_attrs = true;
1909       return NULL_TREE;
1910     }
1911 }
1912
1913 /* Return a new PTRMEM_CST of the indicated TYPE.  The MEMBER is the
1914    thing pointed to by the constant.  */
1915
1916 tree
1917 make_ptrmem_cst (tree type, tree member)
1918 {
1919   tree ptrmem_cst = make_node (PTRMEM_CST);
1920   TREE_TYPE (ptrmem_cst) = type;
1921   PTRMEM_CST_MEMBER (ptrmem_cst) = member;
1922   return ptrmem_cst;
1923 }
1924
1925 /* Build a variant of TYPE that has the indicated ATTRIBUTES.  May
1926    return an existing type of an appropriate type already exists.  */
1927
1928 tree
1929 cp_build_type_attribute_variant (tree type, tree attributes)
1930 {
1931   tree new_type;
1932
1933   new_type = build_type_attribute_variant (type, attributes);
1934   if (TREE_CODE (new_type) == FUNCTION_TYPE
1935       && (TYPE_RAISES_EXCEPTIONS (new_type)
1936           != TYPE_RAISES_EXCEPTIONS (type)))
1937     new_type = build_exception_variant (new_type,
1938                                         TYPE_RAISES_EXCEPTIONS (type));
1939
1940   /* Making a new main variant of a class type is broken.  */
1941   gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
1942     
1943   return new_type;
1944 }
1945
1946 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
1947    traversal.  Called from walk_tree.  */
1948
1949 tree
1950 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
1951                   void *data, struct pointer_set_t *pset)
1952 {
1953   enum tree_code code = TREE_CODE (*tp);
1954   location_t save_locus;
1955   tree result;
1956
1957 #define WALK_SUBTREE(NODE)                              \
1958   do                                                    \
1959     {                                                   \
1960       result = walk_tree (&(NODE), func, data, pset);   \
1961       if (result) goto out;                             \
1962     }                                                   \
1963   while (0)
1964
1965   /* Set input_location here so we get the right instantiation context
1966      if we call instantiate_decl from inlinable_function_p.  */
1967   save_locus = input_location;
1968   if (EXPR_HAS_LOCATION (*tp))
1969     input_location = EXPR_LOCATION (*tp);
1970
1971   /* Not one of the easy cases.  We must explicitly go through the
1972      children.  */
1973   result = NULL_TREE;
1974   switch (code)
1975     {
1976     case DEFAULT_ARG:
1977     case TEMPLATE_TEMPLATE_PARM:
1978     case BOUND_TEMPLATE_TEMPLATE_PARM:
1979     case UNBOUND_CLASS_TEMPLATE:
1980     case TEMPLATE_PARM_INDEX:
1981     case TEMPLATE_TYPE_PARM:
1982     case TYPENAME_TYPE:
1983     case TYPEOF_TYPE:
1984     case BASELINK:
1985       /* None of these have subtrees other than those already walked
1986          above.  */
1987       *walk_subtrees_p = 0;
1988       break;
1989
1990     case TINST_LEVEL:
1991       WALK_SUBTREE (TINST_DECL (*tp));
1992       *walk_subtrees_p = 0;
1993       break;
1994
1995     case PTRMEM_CST:
1996       WALK_SUBTREE (TREE_TYPE (*tp));
1997       *walk_subtrees_p = 0;
1998       break;
1999
2000     case TREE_LIST:
2001       WALK_SUBTREE (TREE_PURPOSE (*tp));
2002       break;
2003
2004     case OVERLOAD:
2005       WALK_SUBTREE (OVL_FUNCTION (*tp));
2006       WALK_SUBTREE (OVL_CHAIN (*tp));
2007       *walk_subtrees_p = 0;
2008       break;
2009
2010     case RECORD_TYPE:
2011       if (TYPE_PTRMEMFUNC_P (*tp))
2012         WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
2013       break;
2014
2015     default:
2016       input_location = save_locus;
2017       return NULL_TREE;
2018     }
2019
2020   /* We didn't find what we were looking for.  */
2021  out:
2022   input_location = save_locus;
2023   return result;
2024
2025 #undef WALK_SUBTREE
2026 }
2027
2028 /* Decide whether there are language-specific reasons to not inline a
2029    function as a tree.  */
2030
2031 int
2032 cp_cannot_inline_tree_fn (tree* fnp)
2033 {
2034   tree fn = *fnp;
2035
2036   /* We can inline a template instantiation only if it's fully
2037      instantiated.  */
2038   if (DECL_TEMPLATE_INFO (fn)
2039       && TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn)))
2040     {
2041       /* Don't instantiate functions that are not going to be
2042          inlined.  */
2043       if (!DECL_INLINE (DECL_TEMPLATE_RESULT
2044                         (template_for_substitution (fn))))
2045         return 1;
2046
2047       fn = *fnp = instantiate_decl (fn, /*defer_ok=*/0, /*undefined_ok=*/0);
2048
2049       if (TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn)))
2050         return 1;
2051     }
2052
2053   if (flag_really_no_inline
2054       && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) == NULL)
2055     return 1;
2056
2057   /* Don't auto-inline anything that might not be bound within
2058      this unit of translation.
2059      Exclude comdat functions from this rule.  While they can be bound
2060      to the other unit, they all must be the same.  This is especially
2061      important so templates can inline.  */
2062   if (!DECL_DECLARED_INLINE_P (fn) && !(*targetm.binds_local_p) (fn)
2063       && !DECL_COMDAT (fn))
2064     {
2065       DECL_UNINLINABLE (fn) = 1;
2066       return 1;
2067     }
2068
2069   if (varargs_function_p (fn))
2070     {
2071       DECL_UNINLINABLE (fn) = 1;
2072       return 1;
2073     }
2074
2075   if (! function_attribute_inlinable_p (fn))
2076     {
2077       DECL_UNINLINABLE (fn) = 1;
2078       return 1;
2079     }
2080
2081   return 0;
2082 }
2083
2084 /* Add any pending functions other than the current function (already
2085    handled by the caller), that thus cannot be inlined, to FNS_P, then
2086    return the latest function added to the array, PREV_FN.  */
2087
2088 tree
2089 cp_add_pending_fn_decls (void* fns_p, tree prev_fn)
2090 {
2091   varray_type *fnsp = (varray_type *)fns_p;
2092   struct saved_scope *s;
2093
2094   for (s = scope_chain; s; s = s->prev)
2095     if (s->function_decl && s->function_decl != prev_fn)
2096       {
2097         VARRAY_PUSH_TREE (*fnsp, s->function_decl);
2098         prev_fn = s->function_decl;
2099       }
2100
2101   return prev_fn;
2102 }
2103
2104 /* Determine whether VAR is a declaration of an automatic variable in
2105    function FN.  */
2106
2107 int
2108 cp_auto_var_in_fn_p (tree var, tree fn)
2109 {
2110   return (DECL_P (var) && DECL_CONTEXT (var) == fn
2111           && nonstatic_local_decl_p (var));
2112 }
2113
2114 /* Like save_expr, but for C++.  */
2115
2116 tree
2117 cp_save_expr (tree expr)
2118 {
2119   /* There is no reason to create a SAVE_EXPR within a template; if
2120      needed, we can create the SAVE_EXPR when instantiating the
2121      template.  Furthermore, the middle-end cannot handle C++-specific
2122      tree codes.  */
2123   if (processing_template_decl)
2124     return expr;
2125   return save_expr (expr);
2126 }
2127
2128 /* Initialize tree.c.  */
2129
2130 void
2131 init_tree (void)
2132 {
2133   list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
2134 }
2135
2136 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
2137    is.  Note that sfk_none is zero, so this function can be used as a
2138    predicate to test whether or not DECL is a special function.  */
2139
2140 special_function_kind
2141 special_function_p (tree decl)
2142 {
2143   /* Rather than doing all this stuff with magic names, we should
2144      probably have a field of type `special_function_kind' in
2145      DECL_LANG_SPECIFIC.  */
2146   if (DECL_COPY_CONSTRUCTOR_P (decl))
2147     return sfk_copy_constructor;
2148   if (DECL_CONSTRUCTOR_P (decl))
2149     return sfk_constructor;
2150   if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
2151     return sfk_assignment_operator;
2152   if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
2153     return sfk_destructor;
2154   if (DECL_COMPLETE_DESTRUCTOR_P (decl))
2155     return sfk_complete_destructor;
2156   if (DECL_BASE_DESTRUCTOR_P (decl))
2157     return sfk_base_destructor;
2158   if (DECL_DELETING_DESTRUCTOR_P (decl))
2159     return sfk_deleting_destructor;
2160   if (DECL_CONV_FN_P (decl))
2161     return sfk_conversion;
2162
2163   return sfk_none;
2164 }
2165
2166 /* Returns nonzero if TYPE is a character type, including wchar_t.  */
2167
2168 int
2169 char_type_p (tree type)
2170 {
2171   return (same_type_p (type, char_type_node)
2172           || same_type_p (type, unsigned_char_type_node)
2173           || same_type_p (type, signed_char_type_node)
2174           || same_type_p (type, wchar_type_node));
2175 }
2176
2177 /* Returns the kind of linkage associated with the indicated DECL.  Th
2178    value returned is as specified by the language standard; it is
2179    independent of implementation details regarding template
2180    instantiation, etc.  For example, it is possible that a declaration
2181    to which this function assigns external linkage would not show up
2182    as a global symbol when you run `nm' on the resulting object file.  */
2183
2184 linkage_kind
2185 decl_linkage (tree decl)
2186 {
2187   /* This function doesn't attempt to calculate the linkage from first
2188      principles as given in [basic.link].  Instead, it makes use of
2189      the fact that we have already set TREE_PUBLIC appropriately, and
2190      then handles a few special cases.  Ideally, we would calculate
2191      linkage first, and then transform that into a concrete
2192      implementation.  */
2193
2194   /* Things that don't have names have no linkage.  */
2195   if (!DECL_NAME (decl))
2196     return lk_none;
2197
2198   /* Things that are TREE_PUBLIC have external linkage.  */
2199   if (TREE_PUBLIC (decl))
2200     return lk_external;
2201
2202   if (TREE_CODE (decl) == NAMESPACE_DECL)
2203     return lk_external;
2204
2205   /* Linkage of a CONST_DECL depends on the linkage of the enumeration
2206      type.  */
2207   if (TREE_CODE (decl) == CONST_DECL)
2208     return decl_linkage (TYPE_NAME (TREE_TYPE (decl)));
2209
2210   /* Some things that are not TREE_PUBLIC have external linkage, too.
2211      For example, on targets that don't have weak symbols, we make all
2212      template instantiations have internal linkage (in the object
2213      file), but the symbols should still be treated as having external
2214      linkage from the point of view of the language.  */
2215   if (TREE_CODE (decl) != TYPE_DECL && DECL_LANG_SPECIFIC (decl)
2216       && DECL_COMDAT (decl))
2217     return lk_external;
2218
2219   /* Things in local scope do not have linkage, if they don't have
2220      TREE_PUBLIC set.  */
2221   if (decl_function_context (decl))
2222     return lk_none;
2223
2224   /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
2225      are considered to have external linkage for language purposes.  DECLs
2226      really meant to have internal linkage have DECL_THIS_STATIC set.  */
2227   if (TREE_CODE (decl) == TYPE_DECL
2228       || ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
2229           && !DECL_THIS_STATIC (decl)))
2230     return lk_external;
2231
2232   /* Everything else has internal linkage.  */
2233   return lk_internal;
2234 }
2235 \f
2236 /* EXP is an expression that we want to pre-evaluate.  Returns (in
2237    *INITP) an expression that will perform the pre-evaluation.  The
2238    value returned by this function is a side-effect free expression
2239    equivalent to the pre-evaluated expression.  Callers must ensure
2240    that *INITP is evaluated before EXP.  */
2241
2242 tree
2243 stabilize_expr (tree exp, tree* initp)
2244 {
2245   tree init_expr;
2246
2247   if (!TREE_SIDE_EFFECTS (exp))
2248     init_expr = NULL_TREE;
2249   else if (!real_lvalue_p (exp)
2250            || !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (exp)))
2251     {
2252       init_expr = get_target_expr (exp);
2253       exp = TARGET_EXPR_SLOT (init_expr);
2254     }
2255   else
2256     {
2257       exp = build_unary_op (ADDR_EXPR, exp, 1);
2258       init_expr = get_target_expr (exp);
2259       exp = TARGET_EXPR_SLOT (init_expr);
2260       exp = build_indirect_ref (exp, 0);
2261     }
2262   *initp = init_expr;
2263
2264   gcc_assert (!TREE_SIDE_EFFECTS (exp));
2265   return exp;
2266 }
2267
2268 /* Add NEW, an expression whose value we don't care about, after the
2269    similar expression ORIG.  */
2270
2271 tree
2272 add_stmt_to_compound (tree orig, tree new)
2273 {
2274   if (!new || !TREE_SIDE_EFFECTS (new))
2275     return orig;
2276   if (!orig || !TREE_SIDE_EFFECTS (orig))
2277     return new;
2278   return build2 (COMPOUND_EXPR, void_type_node, orig, new);
2279 }
2280
2281 /* Like stabilize_expr, but for a call whose arguments we want to
2282    pre-evaluate.  CALL is modified in place to use the pre-evaluated
2283    arguments, while, upon return, *INITP contains an expression to
2284    compute the arguments.  */
2285
2286 void
2287 stabilize_call (tree call, tree *initp)
2288 {
2289   tree inits = NULL_TREE;
2290   tree t;
2291
2292   if (call == error_mark_node)
2293     return;
2294
2295   gcc_assert (TREE_CODE (call) == CALL_EXPR
2296               || TREE_CODE (call) == AGGR_INIT_EXPR);
2297
2298   for (t = TREE_OPERAND (call, 1); t; t = TREE_CHAIN (t))
2299     if (TREE_SIDE_EFFECTS (TREE_VALUE (t)))
2300       {
2301         tree init;
2302         TREE_VALUE (t) = stabilize_expr (TREE_VALUE (t), &init);
2303         inits = add_stmt_to_compound (inits, init);
2304       }
2305
2306   *initp = inits;
2307 }
2308
2309 /* Like stabilize_expr, but for an initialization.  
2310
2311    If the initialization is for an object of class type, this function
2312    takes care not to introduce additional temporaries.
2313
2314    Returns TRUE iff the expression was successfully pre-evaluated,
2315    i.e., if INIT is now side-effect free, except for, possible, a
2316    single call to a constructor.  */
2317
2318 bool
2319 stabilize_init (tree init, tree *initp)
2320 {
2321   tree t = init;
2322
2323   *initp = NULL_TREE;
2324
2325   if (t == error_mark_node)
2326     return true;
2327
2328   if (TREE_CODE (t) == INIT_EXPR
2329       && TREE_CODE (TREE_OPERAND (t, 1)) != TARGET_EXPR)
2330     {
2331       TREE_OPERAND (t, 1) = stabilize_expr (TREE_OPERAND (t, 1), initp);
2332       return true;
2333     }
2334
2335   if (TREE_CODE (t) == INIT_EXPR)
2336     t = TREE_OPERAND (t, 1);
2337   if (TREE_CODE (t) == TARGET_EXPR)
2338     t = TARGET_EXPR_INITIAL (t);
2339   if (TREE_CODE (t) == COMPOUND_EXPR)
2340     t = expr_last (t);
2341   if (TREE_CODE (t) == CONSTRUCTOR
2342       && EMPTY_CONSTRUCTOR_P (t))
2343     /* Default-initialization.  */
2344     return true;
2345
2346   /* If the initializer is a COND_EXPR, we can't preevaluate
2347      anything.  */
2348   if (TREE_CODE (t) == COND_EXPR)
2349     return false;
2350
2351   if (TREE_CODE (t) == CALL_EXPR
2352       || TREE_CODE (t) == AGGR_INIT_EXPR)
2353     {
2354       stabilize_call (t, initp);
2355       return true;
2356     }
2357
2358   /* The initialization is being performed via a bitwise copy -- and
2359      the item copied may have side effects.  */
2360   return TREE_SIDE_EFFECTS (init);
2361 }
2362
2363 /* Like "fold", but should be used whenever we might be processing the
2364    body of a template.  */
2365
2366 tree
2367 fold_if_not_in_template (tree expr)
2368 {
2369   /* In the body of a template, there is never any need to call
2370      "fold".  We will call fold later when actually instantiating the
2371      template.  Integral constant expressions in templates will be
2372      evaluated via fold_non_dependent_expr, as necessary.  */
2373   if (processing_template_decl)
2374     return expr;
2375
2376   /* Fold C++ front-end specific tree codes.  */
2377   if (TREE_CODE (expr) == UNARY_PLUS_EXPR)
2378     return fold_convert (TREE_TYPE (expr), TREE_OPERAND (expr, 0));
2379
2380   return fold (expr);
2381 }
2382
2383 /* Returns true if a cast to TYPE may appear in an integral constant
2384    expression.  */
2385
2386 bool
2387 cast_valid_in_integral_constant_expression_p (tree type)
2388 {
2389   return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
2390           || dependent_type_p (type)
2391           || type == error_mark_node);
2392 }
2393
2394 \f
2395 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
2396 /* Complain that some language-specific thing hanging off a tree
2397    node has been accessed improperly.  */
2398
2399 void
2400 lang_check_failed (const char* file, int line, const char* function)
2401 {
2402   internal_error ("lang_* check: failed in %s, at %s:%d",
2403                   function, trim_filename (file), line);
2404 }
2405 #endif /* ENABLE_TREE_CHECKING */
2406
2407 #include "gt-cp-tree.h"