OSDN Git Service

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