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