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 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
33 #include "insn-config.h"
34 #include "integrate.h"
35 #include "tree-inline.h"
37 static tree bot_manip
PARAMS ((tree
*, int *, void *));
38 static tree bot_replace
PARAMS ((tree
*, int *, void *));
39 static tree build_cplus_array_type_1
PARAMS ((tree
, tree
));
40 static int list_hash_eq
PARAMS ((const void *, const void *));
41 static hashval_t list_hash_pieces
PARAMS ((tree
, tree
, tree
));
42 static hashval_t list_hash
PARAMS ((const void *));
43 static cp_lvalue_kind lvalue_p_1
PARAMS ((tree
, int));
44 static tree no_linkage_helper
PARAMS ((tree
*, int *, void *));
45 static tree build_srcloc
PARAMS ((const char *, int));
46 static tree mark_local_for_remap_r
PARAMS ((tree
*, int *, void *));
47 static tree cp_unsave_r
PARAMS ((tree
*, int *, void *));
48 static tree build_target_expr
PARAMS ((tree
, tree
));
49 static tree count_trees_r
PARAMS ((tree
*, int *, void *));
50 static tree verify_stmt_tree_r
PARAMS ((tree
*, int *, void *));
51 static tree find_tree_r
PARAMS ((tree
*, int *, void *));
52 extern int cp_statement_code_p
PARAMS ((enum tree_code
));
54 static tree handle_java_interface_attribute
PARAMS ((tree
*, tree
, tree
, int, bool *));
55 static tree handle_com_interface_attribute
PARAMS ((tree
*, tree
, tree
, int, bool *));
56 static tree handle_init_priority_attribute
PARAMS ((tree
*, tree
, tree
, int, bool *));
58 /* If REF is an lvalue, returns the kind of lvalue that REF is.
59 Otherwise, returns clk_none. If TREAT_CLASS_RVALUES_AS_LVALUES is
60 non-zero, rvalues of class type are considered lvalues. */
63 lvalue_p_1 (ref
, treat_class_rvalues_as_lvalues
)
65 int treat_class_rvalues_as_lvalues
;
67 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
68 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
70 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
73 if (ref
== current_class_ptr
)
76 switch (TREE_CODE (ref
))
78 /* preincrements and predecrements are valid lvals, provided
79 what they refer to are valid lvals. */
80 case PREINCREMENT_EXPR
:
81 case PREDECREMENT_EXPR
:
85 case WITH_CLEANUP_EXPR
:
88 /* This shouldn't be here, but there are lots of places in the compiler
89 that are sloppy about tacking on NOP_EXPRs to the same type when
90 no actual conversion is happening. */
92 return lvalue_p_1 (TREE_OPERAND (ref
, 0),
93 treat_class_rvalues_as_lvalues
);
96 op1_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 0),
97 treat_class_rvalues_as_lvalues
);
99 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
101 && TREE_CODE (TREE_OPERAND (ref
, 1)) == FIELD_DECL
102 && DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
104 /* Clear the ordinary bit. If this object was a class
105 rvalue we want to preserve that information. */
106 op1_lvalue_kind
&= ~clk_ordinary
;
107 /* The lvalue is for a btifield. */
108 op1_lvalue_kind
|= clk_bitfield
;
110 return op1_lvalue_kind
;
116 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
117 && DECL_LANG_SPECIFIC (ref
)
118 && DECL_IN_AGGR_P (ref
))
124 if (TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
128 /* A currently unresolved scope ref. */
132 if (TREE_CODE (TREE_OPERAND (ref
, 1)) == FUNCTION_DECL
)
137 op1_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 0),
138 treat_class_rvalues_as_lvalues
);
139 op2_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 1),
140 treat_class_rvalues_as_lvalues
);
144 op1_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 1),
145 treat_class_rvalues_as_lvalues
);
146 op2_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 2),
147 treat_class_rvalues_as_lvalues
);
154 return lvalue_p_1 (TREE_OPERAND (ref
, 1),
155 treat_class_rvalues_as_lvalues
);
158 return treat_class_rvalues_as_lvalues
? clk_class
: clk_none
;
162 return ((treat_class_rvalues_as_lvalues
163 && IS_AGGR_TYPE (TREE_TYPE (ref
)))
164 ? clk_class
: clk_none
);
167 /* All functions (except non-static-member functions) are
169 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
170 ? clk_none
: clk_ordinary
);
176 /* If one operand is not an lvalue at all, then this expression is
178 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
181 /* Otherwise, it's an lvalue, and it has all the odd properties
182 contributed by either operand. */
183 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
184 /* It's not an ordinary lvalue if it involves either a bit-field or
186 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
187 op1_lvalue_kind
&= ~clk_ordinary
;
188 return op1_lvalue_kind
;
191 /* If REF is an lvalue, returns the kind of lvalue that REF is.
192 Otherwise, returns clk_none. Lvalues can be assigned, unless they
193 have TREE_READONLY, or unless they are FUNCTION_DECLs. Lvalues can
194 have their address taken, unless they have DECL_REGISTER. */
200 return lvalue_p_1 (ref
, /*treat_class_rvalues_as_lvalues=*/0);
203 /* This differs from real_lvalue_p in that class rvalues are
204 considered lvalues. */
211 (lvalue_p_1 (ref
, /*treat_class_rvalues_as_lvalues=*/1) != clk_none
);
214 /* Return nonzero if REF is an lvalue valid for this language;
215 otherwise, print an error message and return zero. */
218 lvalue_or_else (ref
, string
)
222 int win
= lvalue_p (ref
);
224 error ("non-lvalue in %s", string
);
228 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
231 build_target_expr (decl
, value
)
237 t
= build (TARGET_EXPR
, TREE_TYPE (decl
), decl
, value
,
238 cxx_maybe_build_cleanup (decl
), NULL_TREE
);
239 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
240 ignore the TARGET_EXPR. If there really turn out to be no
241 side-effects, then the optimizer should be able to get rid of
242 whatever code is generated anyhow. */
243 TREE_SIDE_EFFECTS (t
) = 1;
248 /* INIT is a CALL_EXPR which needs info about its target.
249 TYPE is the type that this initialization should appear to have.
251 Build an encapsulation of the initialization to perform
252 and return it so that it can be processed by language-independent
253 and language-specific expression expanders. */
256 build_cplus_new (type
, init
)
264 /* Make sure that we're not trying to create an instance of an
266 abstract_virtuals_error (NULL_TREE
, type
);
268 if (TREE_CODE (init
) != CALL_EXPR
&& TREE_CODE (init
) != AGGR_INIT_EXPR
)
269 return convert (type
, init
);
271 slot
= build (VAR_DECL
, type
);
272 DECL_ARTIFICIAL (slot
) = 1;
273 DECL_CONTEXT (slot
) = current_function_decl
;
274 layout_decl (slot
, 0);
276 /* We split the CALL_EXPR into its function and its arguments here.
277 Then, in expand_expr, we put them back together. The reason for
278 this is that this expression might be a default argument
279 expression. In that case, we need a new temporary every time the
280 expression is used. That's what break_out_target_exprs does; it
281 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
282 temporary slot. Then, expand_expr builds up a call-expression
283 using the new slot. */
284 fn
= TREE_OPERAND (init
, 0);
285 rval
= build (AGGR_INIT_EXPR
, type
, fn
, TREE_OPERAND (init
, 1), slot
);
286 TREE_SIDE_EFFECTS (rval
) = 1;
287 AGGR_INIT_VIA_CTOR_P (rval
)
288 = (TREE_CODE (fn
) == ADDR_EXPR
289 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
290 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
291 rval
= build_target_expr (slot
, rval
);
296 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
300 build_target_expr_with_type (init
, type
)
307 if (TREE_CODE (init
) == TARGET_EXPR
)
310 slot
= build (VAR_DECL
, type
);
311 DECL_ARTIFICIAL (slot
) = 1;
312 DECL_CONTEXT (slot
) = current_function_decl
;
313 layout_decl (slot
, 0);
314 rval
= build_target_expr (slot
, init
);
319 /* Like build_target_expr_with_type, but use the type of INIT. */
322 get_target_expr (init
)
325 return build_target_expr_with_type (init
, TREE_TYPE (init
));
328 /* Recursively perform a preorder search EXP for CALL_EXPRs, making
329 copies where they are found. Returns a deep copy all nodes transitively
330 containing CALL_EXPRs. */
333 break_out_calls (exp
)
336 register tree t1
, t2
= NULL_TREE
;
337 register enum tree_code code
;
338 register int changed
= 0;
341 if (exp
== NULL_TREE
)
344 code
= TREE_CODE (exp
);
346 if (code
== CALL_EXPR
)
347 return copy_node (exp
);
349 /* Don't try and defeat a save_expr, as it should only be done once. */
350 if (code
== SAVE_EXPR
)
353 switch (TREE_CODE_CLASS (code
))
358 case 'c': /* a constant */
359 case 't': /* a type node */
360 case 'x': /* something random, like an identifier or an ERROR_MARK. */
363 case 'd': /* A decl node */
364 #if 0 /* This is bogus. jason 9/21/94 */
366 t1
= break_out_calls (DECL_INITIAL (exp
));
367 if (t1
!= DECL_INITIAL (exp
))
369 exp
= copy_node (exp
);
370 DECL_INITIAL (exp
) = t1
;
375 case 'b': /* A block node */
377 /* Don't know how to handle these correctly yet. Must do a
378 break_out_calls on all DECL_INITIAL values for local variables,
379 and also break_out_calls on all sub-blocks and sub-statements. */
384 case 'e': /* an expression */
385 case 'r': /* a reference */
386 case 's': /* an expression with side effects */
387 for (i
= TREE_CODE_LENGTH (code
) - 1; i
>= 0; i
--)
389 t1
= break_out_calls (TREE_OPERAND (exp
, i
));
390 if (t1
!= TREE_OPERAND (exp
, i
))
392 exp
= copy_node (exp
);
393 TREE_OPERAND (exp
, i
) = t1
;
398 case '<': /* a comparison expression */
399 case '2': /* a binary arithmetic expression */
400 t2
= break_out_calls (TREE_OPERAND (exp
, 1));
401 if (t2
!= TREE_OPERAND (exp
, 1))
403 case '1': /* a unary arithmetic expression */
404 t1
= break_out_calls (TREE_OPERAND (exp
, 0));
405 if (t1
!= TREE_OPERAND (exp
, 0))
409 if (TREE_CODE_LENGTH (code
) == 1)
410 return build1 (code
, TREE_TYPE (exp
), t1
);
412 return build (code
, TREE_TYPE (exp
), t1
, t2
);
419 /* Construct, lay out and return the type of methods belonging to class
420 BASETYPE and whose arguments are described by ARGTYPES and whose values
421 are described by RETTYPE. If each type exists already, reuse it. */
424 build_cplus_method_type (basetype
, rettype
, argtypes
)
425 tree basetype
, rettype
, argtypes
;
431 /* Make a node of the sort we want. */
432 t
= make_node (METHOD_TYPE
);
434 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
435 TREE_TYPE (t
) = rettype
;
436 ptype
= build_pointer_type (basetype
);
438 /* The actual arglist for this function includes a "hidden" argument
439 which is "this". Put it into the list of argument types. */
440 argtypes
= tree_cons (NULL_TREE
, ptype
, argtypes
);
441 TYPE_ARG_TYPES (t
) = argtypes
;
442 TREE_SIDE_EFFECTS (argtypes
) = 1; /* Mark first argtype as "artificial". */
444 /* If we already have such a type, use the old one and free this one.
445 Note that it also frees up the above cons cell if found. */
446 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (rettype
) +
447 type_hash_list (argtypes
);
449 t
= type_hash_canon (hashcode
, t
);
451 if (!COMPLETE_TYPE_P (t
))
458 build_cplus_array_type_1 (elt_type
, index_type
)
464 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
465 return error_mark_node
;
467 /* Don't do the minimal thing just because processing_template_decl is
468 set; we want to give string constants the right type immediately, so
469 we don't have to fix them up at instantiation time. */
470 if ((processing_template_decl
471 && index_type
&& TYPE_MAX_VALUE (index_type
)
472 && TREE_CODE (TYPE_MAX_VALUE (index_type
)) != INTEGER_CST
)
473 || uses_template_parms (elt_type
)
474 || uses_template_parms (index_type
))
476 t
= make_node (ARRAY_TYPE
);
477 TREE_TYPE (t
) = elt_type
;
478 TYPE_DOMAIN (t
) = index_type
;
481 t
= build_array_type (elt_type
, index_type
);
483 /* Push these needs up so that initialization takes place
485 TYPE_NEEDS_CONSTRUCTING (t
)
486 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
487 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
488 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
493 build_cplus_array_type (elt_type
, index_type
)
498 int type_quals
= cp_type_quals (elt_type
);
499 int cv_quals
= type_quals
& (TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
500 int other_quals
= type_quals
& ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
503 elt_type
= cp_build_qualified_type (elt_type
, other_quals
);
505 t
= build_cplus_array_type_1 (elt_type
, index_type
);
508 t
= cp_build_qualified_type (t
, cv_quals
);
513 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
514 arrays correctly. In particular, if TYPE is an array of T's, and
515 TYPE_QUALS is non-empty, returns an array of qualified T's.
517 FLAGS determines how to deal with illformed qualifications. If
518 tf_ignore_bad_quals is set, then bad qualifications are dropped
519 (this is permitted if TYPE was introduced via a typedef or template
520 type parameter). If bad qualifications are dropped and tf_warning
521 is set, then a warning is issued for non-const qualifications. If
522 tf_ignore_bad_quals is not set and tf_error is not set, we
523 return error_mark_node. Otherwise, we issue an error, and ignore
526 Qualification of a reference type is valid when the reference came
527 via a typedef or template type argument. [dcl.ref] No such
528 dispensation is provided for qualifying a function type. [dcl.fct]
529 DR 295 queries this and the proposed resolution brings it into line
530 with qualifiying a reference. We implement the DR. We also behave
531 in a similar manner for restricting non-pointer types. */
534 cp_build_qualified_type_real (type
, type_quals
, complain
)
537 tsubst_flags_t complain
;
540 int bad_quals
= TYPE_UNQUALIFIED
;
542 if (type
== error_mark_node
)
545 if (type_quals
== cp_type_quals (type
))
548 /* A reference, fucntion or method type shall not be cv qualified.
549 [dcl.ref], [dct.fct] */
550 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
551 && (TREE_CODE (type
) == REFERENCE_TYPE
552 || TREE_CODE (type
) == FUNCTION_TYPE
553 || TREE_CODE (type
) == METHOD_TYPE
))
555 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
556 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
559 /* A restrict-qualified type must be a pointer (or reference)
560 to object or incomplete type. */
561 if ((type_quals
& TYPE_QUAL_RESTRICT
)
562 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
563 && TREE_CODE (type
) != TYPENAME_TYPE
564 && !POINTER_TYPE_P (type
))
566 bad_quals
|= TYPE_QUAL_RESTRICT
;
567 type_quals
&= ~TYPE_QUAL_RESTRICT
;
570 if (bad_quals
== TYPE_UNQUALIFIED
)
572 else if (!(complain
& (tf_error
| tf_ignore_bad_quals
)))
573 return error_mark_node
;
576 if (complain
& tf_ignore_bad_quals
)
577 /* We're not going to warn about constifying things that can't
579 bad_quals
&= ~TYPE_QUAL_CONST
;
582 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
584 if (!(complain
& tf_ignore_bad_quals
))
585 error ("`%V' qualifiers cannot be applied to `%T'",
587 else if (complain
& tf_warning
)
588 warning ("ignoring `%V' qualifiers on `%T'", bad_type
, type
);
592 if (TREE_CODE (type
) == ARRAY_TYPE
)
594 /* In C++, the qualification really applies to the array element
595 type. Obtain the appropriately qualified element type. */
598 = cp_build_qualified_type_real (TREE_TYPE (type
),
602 if (element_type
== error_mark_node
)
603 return error_mark_node
;
605 /* See if we already have an identically qualified type. */
606 t
= get_qualified_type (type
, type_quals
);
608 /* If we didn't already have it, create it now. */
611 /* Make a new array type, just like the old one, but with the
612 appropriately qualified element type. */
613 t
= build_type_copy (type
);
614 TREE_TYPE (t
) = element_type
;
617 /* Even if we already had this variant, we update
618 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
619 they changed since the variant was originally created.
621 This seems hokey; if there is some way to use a previous
622 variant *without* coming through here,
623 TYPE_NEEDS_CONSTRUCTING will never be updated. */
624 TYPE_NEEDS_CONSTRUCTING (t
)
625 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
626 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
627 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
630 else if (TYPE_PTRMEMFUNC_P (type
))
632 /* For a pointer-to-member type, we can't just return a
633 cv-qualified version of the RECORD_TYPE. If we do, we
634 haven't changed the field that contains the actual pointer to
635 a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong. */
638 t
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
639 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
640 return build_ptrmemfunc_type (t
);
643 /* Retrieve (or create) the appropriately qualified variant. */
644 result
= build_qualified_type (type
, type_quals
);
646 /* If this was a pointer-to-method type, and we just made a copy,
647 then we need to clear the cached associated
648 pointer-to-member-function type; it is not valid for the new
651 && TREE_CODE (type
) == POINTER_TYPE
652 && TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
)
653 TYPE_SET_PTRMEMFUNC_TYPE (result
, NULL_TREE
);
658 /* Returns the canonical version of TYPE. In other words, if TYPE is
659 a typedef, returns the underlying type. The cv-qualification of
660 the type returned matches the type input; they will always be
664 canonical_type_variant (t
)
667 return cp_build_qualified_type (TYPE_MAIN_VARIANT (t
), cp_type_quals (t
));
670 /* Makes new binfos for the indirect bases under BINFO, and updates
671 BINFO_OFFSET for them and their bases. */
674 unshare_base_binfos (binfo
)
677 tree binfos
= BINFO_BASETYPES (binfo
);
681 if (binfos
== NULL_TREE
)
684 /* Now unshare the structure beneath BINFO. */
685 for (j
= TREE_VEC_LENGTH (binfos
)-1;
688 tree base_binfo
= TREE_VEC_ELT (binfos
, j
);
689 new_binfo
= TREE_VEC_ELT (binfos
, j
)
690 = make_binfo (BINFO_OFFSET (base_binfo
),
692 BINFO_VTABLE (base_binfo
),
693 BINFO_VIRTUALS (base_binfo
));
694 TREE_VIA_PUBLIC (new_binfo
) = TREE_VIA_PUBLIC (base_binfo
);
695 TREE_VIA_PROTECTED (new_binfo
) = TREE_VIA_PROTECTED (base_binfo
);
696 TREE_VIA_VIRTUAL (new_binfo
) = TREE_VIA_VIRTUAL (base_binfo
);
697 BINFO_INHERITANCE_CHAIN (new_binfo
) = binfo
;
698 BINFO_PRIMARY_BASE_OF (new_binfo
) = NULL_TREE
;
699 unshare_base_binfos (new_binfo
);
704 /* Hashing of lists so that we don't make duplicates.
705 The entry point is `list_hash_canon'. */
707 /* Now here is the hash table. When recording a list, it is added
708 to the slot whose index is the hash code mod the table size.
709 Note that the hash table is used for several kinds of lists.
710 While all these live in the same table, they are completely independent,
711 and the hash code is computed differently for each of these. */
713 static GTY ((param_is (union tree_node
))) htab_t list_hash_table
;
722 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
723 for a node we are thinking about adding). */
726 list_hash_eq (entry
, data
)
730 tree t
= (tree
) entry
;
731 struct list_proxy
*proxy
= (struct list_proxy
*) data
;
733 return (TREE_VALUE (t
) == proxy
->value
734 && TREE_PURPOSE (t
) == proxy
->purpose
735 && TREE_CHAIN (t
) == proxy
->chain
);
738 /* Compute a hash code for a list (chain of TREE_LIST nodes
739 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
740 TREE_COMMON slots), by adding the hash codes of the individual entries. */
743 list_hash_pieces (purpose
, value
, chain
)
748 hashval_t hashcode
= 0;
751 hashcode
+= TYPE_HASH (chain
);
754 hashcode
+= TYPE_HASH (value
);
758 hashcode
+= TYPE_HASH (purpose
);
764 /* Hash an already existing TREE_LIST. */
771 return list_hash_pieces (TREE_PURPOSE (t
),
776 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
777 object for an identical list if one already exists. Otherwise, build a
778 new one, and record it as the canonical object. */
781 hash_tree_cons (purpose
, value
, chain
)
782 tree purpose
, value
, chain
;
786 struct list_proxy proxy
;
788 /* Hash the list node. */
789 hashcode
= list_hash_pieces (purpose
, value
, chain
);
790 /* Create a proxy for the TREE_LIST we would like to create. We
791 don't actually create it so as to avoid creating garbage. */
792 proxy
.purpose
= purpose
;
795 /* See if it is already in the table. */
796 slot
= htab_find_slot_with_hash (list_hash_table
, &proxy
, hashcode
,
798 /* If not, create a new node. */
800 *slot
= (PTR
) tree_cons (purpose
, value
, chain
);
804 /* Constructor for hashed lists. */
807 hash_tree_chain (value
, chain
)
810 return hash_tree_cons (NULL_TREE
, value
, chain
);
813 /* Similar, but used for concatenating two lists. */
816 hash_chainon (list1
, list2
)
823 if (TREE_CHAIN (list1
) == NULL_TREE
)
824 return hash_tree_chain (TREE_VALUE (list1
), list2
);
825 return hash_tree_chain (TREE_VALUE (list1
),
826 hash_chainon (TREE_CHAIN (list1
), list2
));
829 /* Build an association between TYPE and some parameters:
831 OFFSET is the offset added to `this' to convert it to a pointer
834 BINFO is the base binfo to use, if we are deriving from one. This
835 is necessary, as we want specialized parent binfos from base
836 classes, so that the VTABLE_NAMEs of bases are for the most derived
837 type, instead of the simple type.
839 VTABLE is the virtual function table with which to initialize
840 sub-objects of type TYPE.
842 VIRTUALS are the virtual functions sitting in VTABLE. */
845 make_binfo (offset
, binfo
, vtable
, virtuals
)
847 tree vtable
, virtuals
;
849 tree new_binfo
= make_tree_vec (11);
852 if (TREE_CODE (binfo
) == TREE_VEC
)
853 type
= BINFO_TYPE (binfo
);
857 binfo
= CLASS_TYPE_P (type
) ? TYPE_BINFO (binfo
) : NULL_TREE
;
860 TREE_TYPE (new_binfo
) = TYPE_MAIN_VARIANT (type
);
861 BINFO_OFFSET (new_binfo
) = offset
;
862 BINFO_VTABLE (new_binfo
) = vtable
;
863 BINFO_VIRTUALS (new_binfo
) = virtuals
;
865 if (binfo
&& BINFO_BASETYPES (binfo
) != NULL_TREE
)
866 BINFO_BASETYPES (new_binfo
) = copy_node (BINFO_BASETYPES (binfo
));
870 /* Return a TREE_LIST whose TREE_VALUE nodes along the
871 BINFO_INHERITANCE_CHAIN for BINFO, but in the opposite order. In
872 other words, while the BINFO_INHERITANCE_CHAIN goes from base
873 classes to derived classes, the reversed path goes from derived
874 classes to base classes. */
882 reversed_path
= NULL_TREE
;
885 reversed_path
= tree_cons (NULL_TREE
, binfo
, reversed_path
);
886 binfo
= BINFO_INHERITANCE_CHAIN (binfo
);
889 return reversed_path
;
899 fprintf (stderr
, "type \"%s\", offset = ",
900 TYPE_NAME_STRING (BINFO_TYPE (elem
)));
901 fprintf (stderr
, HOST_WIDE_INT_PRINT_DEC
,
902 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
903 fprintf (stderr
, "\nvtable type:\n");
904 debug_tree (BINFO_TYPE (elem
));
905 if (BINFO_VTABLE (elem
))
906 fprintf (stderr
, "vtable decl \"%s\"\n",
907 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
909 fprintf (stderr
, "no vtable decl yet\n");
910 fprintf (stderr
, "virtuals:\n");
911 virtuals
= BINFO_VIRTUALS (elem
);
916 tree fndecl
= TREE_VALUE (virtuals
);
917 fprintf (stderr
, "%s [%ld =? %ld]\n",
918 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
919 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
921 virtuals
= TREE_CHAIN (virtuals
);
930 if (TREE_CODE (t
) == FUNCTION_DECL
)
932 else if (TREE_CODE (t
) == OVERLOAD
)
934 for (i
=0; t
; t
= OVL_CHAIN (t
))
947 /* A baselink is also considered an overloaded function. */
948 if (TREE_CODE (x
) == OFFSET_REF
)
949 x
= TREE_OPERAND (x
, 1);
952 return (TREE_CODE (x
) == FUNCTION_DECL
953 || TREE_CODE (x
) == TEMPLATE_ID_EXPR
954 || DECL_FUNCTION_TEMPLATE_P (x
)
955 || TREE_CODE (x
) == OVERLOAD
);
959 really_overloaded_fn (x
)
962 /* A baselink is also considered an overloaded function. */
963 if (TREE_CODE (x
) == OFFSET_REF
)
964 x
= TREE_OPERAND (x
, 1);
967 return (TREE_CODE (x
) == OVERLOAD
968 && (TREE_CHAIN (x
) != NULL_TREE
969 || DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (x
))));
976 my_friendly_assert (is_overloaded_fn (from
), 9);
977 /* A baselink is also considered an overloaded function. */
978 if (BASELINK_P (from
))
979 from
= TREE_VALUE (from
);
980 return OVL_CURRENT (from
);
983 /* Returns nonzero if T is a ->* or .* expression that refers to a
990 return (TREE_CODE (t
) == OFFSET_REF
991 && TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (t
, 1))));
994 /* Return a new OVL node, concatenating it with the old one. */
997 ovl_cons (decl
, chain
)
1001 tree result
= make_node (OVERLOAD
);
1002 TREE_TYPE (result
) = unknown_type_node
;
1003 OVL_FUNCTION (result
) = decl
;
1004 TREE_CHAIN (result
) = chain
;
1009 /* Build a new overloaded function. If this is the first one,
1010 just return it; otherwise, ovl_cons the _DECLs */
1013 build_overload (decl
, chain
)
1017 if (! chain
&& TREE_CODE (decl
) != TEMPLATE_DECL
)
1019 if (chain
&& TREE_CODE (chain
) != OVERLOAD
)
1020 chain
= ovl_cons (chain
, NULL_TREE
);
1021 return ovl_cons (decl
, chain
);
1025 is_aggr_type_2 (t1
, t2
)
1028 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1030 return IS_AGGR_TYPE (t1
) && IS_AGGR_TYPE (t2
);
1033 /* Returns non-zero if CODE is the code for a statement. */
1036 cp_statement_code_p (code
)
1037 enum tree_code code
;
1041 case CTOR_INITIALIZER
:
1055 #define PRINT_RING_SIZE 4
1058 cxx_printable_name (decl
, v
)
1062 static tree decl_ring
[PRINT_RING_SIZE
];
1063 static char *print_ring
[PRINT_RING_SIZE
];
1064 static int ring_counter
;
1067 /* Only cache functions. */
1069 || TREE_CODE (decl
) != FUNCTION_DECL
1070 || DECL_LANG_SPECIFIC (decl
) == 0)
1071 return lang_decl_name (decl
, v
);
1073 /* See if this print name is lying around. */
1074 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
1075 if (decl_ring
[i
] == decl
)
1076 /* yes, so return it. */
1077 return print_ring
[i
];
1079 if (++ring_counter
== PRINT_RING_SIZE
)
1082 if (current_function_decl
!= NULL_TREE
)
1084 if (decl_ring
[ring_counter
] == current_function_decl
)
1086 if (ring_counter
== PRINT_RING_SIZE
)
1088 if (decl_ring
[ring_counter
] == current_function_decl
)
1092 if (print_ring
[ring_counter
])
1093 free (print_ring
[ring_counter
]);
1095 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
));
1096 decl_ring
[ring_counter
] = decl
;
1097 return print_ring
[ring_counter
];
1100 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1101 listed in RAISES. */
1104 build_exception_variant (type
, raises
)
1108 tree v
= TYPE_MAIN_VARIANT (type
);
1109 int type_quals
= TYPE_QUALS (type
);
1111 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
1112 if (TYPE_QUALS (v
) == type_quals
1113 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (v
), 1))
1116 /* Need to build a new variant. */
1117 v
= build_type_copy (type
);
1118 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
1122 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
1123 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
1127 bind_template_template_parm (t
, newargs
)
1131 tree decl
= TYPE_NAME (t
);
1134 t2
= make_aggr_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
1135 decl
= build_decl (TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
1137 /* These nodes have to be created to reflect new TYPE_DECL and template
1139 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
1140 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
1141 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
1142 = tree_cons (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
),
1143 newargs
, NULL_TREE
);
1145 TREE_TYPE (decl
) = t2
;
1146 TYPE_NAME (t2
) = decl
;
1147 TYPE_STUB_DECL (t2
) = decl
;
1153 /* Called from count_trees via walk_tree. */
1156 count_trees_r (tp
, walk_subtrees
, data
)
1157 tree
*tp ATTRIBUTE_UNUSED
;
1158 int *walk_subtrees ATTRIBUTE_UNUSED
;
1165 /* Debugging function for measuring the rough complexity of a tree
1173 walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
1177 /* Called from verify_stmt_tree via walk_tree. */
1180 verify_stmt_tree_r (tp
, walk_subtrees
, data
)
1182 int *walk_subtrees ATTRIBUTE_UNUSED
;
1186 htab_t
*statements
= (htab_t
*) data
;
1189 if (!statement_code_p (TREE_CODE (t
)))
1192 /* If this statement is already present in the hash table, then
1193 there is a circularity in the statement tree. */
1194 if (htab_find (*statements
, t
))
1197 slot
= htab_find_slot (*statements
, t
, INSERT
);
1203 /* Debugging function to check that the statement T has not been
1204 corrupted. For now, this function simply checks that T contains no
1208 verify_stmt_tree (t
)
1212 statements
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
1213 walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
1214 htab_delete (statements
);
1217 /* Called from find_tree via walk_tree. */
1220 find_tree_r (tp
, walk_subtrees
, data
)
1222 int *walk_subtrees ATTRIBUTE_UNUSED
;
1225 if (*tp
== (tree
) data
)
1231 /* Returns X if X appears in the tree structure rooted at T. */
1238 return walk_tree_without_duplicates (&t
, find_tree_r
, x
);
1241 /* Passed to walk_tree. Checks for the use of types with no linkage. */
1244 no_linkage_helper (tp
, walk_subtrees
, data
)
1246 int *walk_subtrees ATTRIBUTE_UNUSED
;
1247 void *data ATTRIBUTE_UNUSED
;
1252 && (CLASS_TYPE_P (t
) || TREE_CODE (t
) == ENUMERAL_TYPE
)
1253 && (decl_function_context (TYPE_MAIN_DECL (t
))
1254 || TYPE_ANONYMOUS_P (t
)))
1259 /* Check if the type T depends on a type with no linkage and if so, return
1263 no_linkage_check (t
)
1266 /* There's no point in checking linkage on template functions; we
1267 can't know their complete types. */
1268 if (processing_template_decl
)
1271 t
= walk_tree_without_duplicates (&t
, no_linkage_helper
, NULL
);
1272 if (t
!= error_mark_node
)
1277 #ifdef GATHER_STATISTICS
1278 extern int depth_reached
;
1282 cxx_print_statistics ()
1284 print_search_statistics ();
1285 print_class_statistics ();
1286 #ifdef GATHER_STATISTICS
1287 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
1292 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1293 (which is an ARRAY_TYPE). This counts only elements of the top
1297 array_type_nelts_top (type
)
1300 return fold (build (PLUS_EXPR
, sizetype
,
1301 array_type_nelts (type
),
1305 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1306 (which is an ARRAY_TYPE). This one is a recursive count of all
1307 ARRAY_TYPEs that are clumped together. */
1310 array_type_nelts_total (type
)
1313 tree sz
= array_type_nelts_top (type
);
1314 type
= TREE_TYPE (type
);
1315 while (TREE_CODE (type
) == ARRAY_TYPE
)
1317 tree n
= array_type_nelts_top (type
);
1318 sz
= fold (build (MULT_EXPR
, sizetype
, sz
, n
));
1319 type
= TREE_TYPE (type
);
1324 /* Called from break_out_target_exprs via mapcar. */
1327 bot_manip (tp
, walk_subtrees
, data
)
1332 splay_tree target_remap
= ((splay_tree
) data
);
1335 if (TREE_CONSTANT (t
))
1337 /* There can't be any TARGET_EXPRs or their slot variables below
1338 this point. We used to check !TREE_SIDE_EFFECTS, but then we
1339 failed to copy an ADDR_EXPR of the slot VAR_DECL. */
1343 if (TREE_CODE (t
) == TARGET_EXPR
)
1347 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
1349 mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 1), 0), 0));
1351 (TREE_TYPE (t
), break_out_target_exprs (TREE_OPERAND (t
, 1)));
1355 u
= build_target_expr_with_type
1356 (break_out_target_exprs (TREE_OPERAND (t
, 1)), TREE_TYPE (t
));
1359 /* Map the old variable to the new one. */
1360 splay_tree_insert (target_remap
,
1361 (splay_tree_key
) TREE_OPERAND (t
, 0),
1362 (splay_tree_value
) TREE_OPERAND (u
, 0));
1364 /* Replace the old expression with the new version. */
1366 /* We don't have to go below this point; the recursive call to
1367 break_out_target_exprs will have handled anything below this
1372 else if (TREE_CODE (t
) == CALL_EXPR
)
1373 mark_used (TREE_OPERAND (TREE_OPERAND (t
, 0), 0));
1375 /* Make a copy of this node. */
1376 return copy_tree_r (tp
, walk_subtrees
, NULL
);
1379 /* Replace all remapped VAR_DECLs in T with their new equivalents.
1380 DATA is really a splay-tree mapping old variables to new
1384 bot_replace (t
, walk_subtrees
, data
)
1386 int *walk_subtrees ATTRIBUTE_UNUSED
;
1389 splay_tree target_remap
= ((splay_tree
) data
);
1391 if (TREE_CODE (*t
) == VAR_DECL
)
1393 splay_tree_node n
= splay_tree_lookup (target_remap
,
1394 (splay_tree_key
) *t
);
1396 *t
= (tree
) n
->value
;
1402 /* When we parse a default argument expression, we may create
1403 temporary variables via TARGET_EXPRs. When we actually use the
1404 default-argument expression, we make a copy of the expression, but
1405 we must replace the temporaries with appropriate local versions. */
1408 break_out_target_exprs (t
)
1411 static int target_remap_count
;
1412 static splay_tree target_remap
;
1414 if (!target_remap_count
++)
1415 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
1416 /*splay_tree_delete_key_fn=*/NULL
,
1417 /*splay_tree_delete_value_fn=*/NULL
);
1418 walk_tree (&t
, bot_manip
, target_remap
, NULL
);
1419 walk_tree (&t
, bot_replace
, target_remap
, NULL
);
1421 if (!--target_remap_count
)
1423 splay_tree_delete (target_remap
);
1424 target_remap
= NULL
;
1430 /* Obstack used for allocating nodes in template function and variable
1433 /* Similar to `build_nt', except that we set TREE_COMPLEXITY to be the
1434 current line number. */
1437 build_min_nt
VPARAMS ((enum tree_code code
, ...))
1440 register int length
;
1444 VA_FIXEDARG (p
, enum tree_code
, code
);
1446 t
= make_node (code
);
1447 length
= TREE_CODE_LENGTH (code
);
1448 TREE_COMPLEXITY (t
) = lineno
;
1450 for (i
= 0; i
< length
; i
++)
1452 tree x
= va_arg (p
, tree
);
1453 TREE_OPERAND (t
, i
) = x
;
1460 /* Similar to `build', except we set TREE_COMPLEXITY to the current
1464 build_min
VPARAMS ((enum tree_code code
, tree tt
, ...))
1467 register int length
;
1471 VA_FIXEDARG (p
, enum tree_code
, code
);
1472 VA_FIXEDARG (p
, tree
, tt
);
1474 t
= make_node (code
);
1475 length
= TREE_CODE_LENGTH (code
);
1477 TREE_COMPLEXITY (t
) = lineno
;
1479 for (i
= 0; i
< length
; i
++)
1481 tree x
= va_arg (p
, tree
);
1482 TREE_OPERAND (t
, i
) = x
;
1489 /* Returns an INTEGER_CST (of type `int') corresponding to I.
1490 Multiple calls with the same value of I may or may not yield the
1491 same node; therefore, callers should never modify the node
1495 build_shared_int_cst (i
)
1498 static tree cache
[256];
1501 return build_int_2 (i
, 0);
1504 cache
[i
] = build_int_2 (i
, 0);
1513 if (TREE_CODE (t
) == TYPE_DECL
)
1516 return TYPE_STUB_DECL (t
);
1517 if (t
== error_mark_node
)
1522 /* Stop compiler from complaining control reaches end of non-void function. */
1526 /* Return first vector element whose BINFO_TYPE is ELEM.
1527 Return 0 if ELEM is not in VEC. VEC may be NULL_TREE. */
1530 vec_binfo_member (elem
, vec
)
1536 for (i
= 0; i
< TREE_VEC_LENGTH (vec
); ++i
)
1537 if (same_type_p (elem
, BINFO_TYPE (TREE_VEC_ELT (vec
, i
))))
1538 return TREE_VEC_ELT (vec
, i
);
1543 /* Returns the namespace that contains DECL, whether directly or
1547 decl_namespace_context (decl
)
1552 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
1554 else if (TYPE_P (decl
))
1555 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
1557 decl
= CP_DECL_CONTEXT (decl
);
1561 /* Return truthvalue of whether T1 is the same tree structure as T2.
1562 Return 1 if they are the same.
1563 Return 0 if they are understandably different.
1564 Return -1 if either contains tree structure not understood by
1568 cp_tree_equal (t1
, t2
)
1571 register enum tree_code code1
, code2
;
1576 if (t1
== 0 || t2
== 0)
1579 code1
= TREE_CODE (t1
);
1580 code2
= TREE_CODE (t2
);
1582 if (code1
== NOP_EXPR
|| code1
== CONVERT_EXPR
|| code1
== NON_LVALUE_EXPR
)
1584 if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
|| code2
== NON_LVALUE_EXPR
)
1585 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1587 return cp_tree_equal (TREE_OPERAND (t1
, 0), t2
);
1589 else if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
1590 || code2
== NON_LVALUE_EXPR
)
1591 return cp_tree_equal (t1
, TREE_OPERAND (t2
, 0));
1599 return TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
1600 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
);
1603 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
1606 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
1607 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
1608 TREE_STRING_LENGTH (t1
));
1611 /* We need to do this when determining whether or not two
1612 non-type pointer to member function template arguments
1614 if (!(same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
1615 /* The first operand is RTL. */
1616 && TREE_OPERAND (t1
, 0) == TREE_OPERAND (t2
, 0)))
1618 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
1621 cmp
= cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
1624 cmp
= cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
));
1627 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
1630 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1633 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1636 return simple_cst_list_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
1639 /* Special case: if either target is an unallocated VAR_DECL,
1640 it means that it's going to be unified with whatever the
1641 TARGET_EXPR is really supposed to initialize, so treat it
1642 as being equivalent to anything. */
1643 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
1644 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
1645 && !DECL_RTL_SET_P (TREE_OPERAND (t1
, 0)))
1646 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
1647 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
1648 && !DECL_RTL_SET_P (TREE_OPERAND (t2
, 0))))
1651 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1654 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
1656 case WITH_CLEANUP_EXPR
:
1657 cmp
= cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1660 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t1
, 1));
1663 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
1664 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1673 case TEMPLATE_PARM_INDEX
:
1674 return TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
1675 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
);
1679 if (TREE_CODE (TREE_OPERAND (t1
, 0)) != TREE_CODE (TREE_OPERAND (t2
, 0)))
1681 if (TYPE_P (TREE_OPERAND (t1
, 0)))
1682 return same_type_p (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1686 /* Two pointer-to-members are the same if they point to the same
1687 field or function in the same class. */
1688 return (PTRMEM_CST_MEMBER (t1
) == PTRMEM_CST_MEMBER (t2
)
1689 && same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
)));
1695 switch (TREE_CODE_CLASS (code1
))
1707 for (i
= 0; i
< TREE_CODE_LENGTH (code1
); ++i
)
1709 cmp
= cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
1717 return same_type_p (t1
, t2
) ? 1 : 0;
1723 /* Build a wrapper around a 'struct z_candidate' so we can use it as a
1727 build_zc_wrapper (ptr
)
1728 struct z_candidate
*ptr
;
1730 tree t
= make_node (WRAPPER
);
1731 WRAPPER_ZC (t
) = ptr
;
1736 build_srcloc (file
, line
)
1742 t
= make_node (SRCLOC
);
1743 SRCLOC_FILE (t
) = file
;
1744 SRCLOC_LINE (t
) = line
;
1750 build_srcloc_here ()
1752 return build_srcloc (input_filename
, lineno
);
1755 /* The type of ARG when used as an lvalue. */
1761 tree type
= TREE_TYPE (arg
);
1762 if (TREE_CODE (arg
) == OVERLOAD
)
1763 type
= unknown_type_node
;
1767 /* The type of ARG for printing error messages; denote lvalues with
1774 tree type
= TREE_TYPE (arg
);
1775 if (TREE_CODE (type
) == ARRAY_TYPE
)
1777 else if (real_lvalue_p (arg
))
1778 type
= build_reference_type (lvalue_type (arg
));
1779 else if (IS_AGGR_TYPE (type
))
1780 type
= lvalue_type (arg
);
1785 /* Does FUNCTION use a variable-length argument list? */
1788 varargs_function_p (function
)
1791 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (function
));
1792 for (; parm
; parm
= TREE_CHAIN (parm
))
1793 if (TREE_VALUE (parm
) == void_type_node
)
1798 /* Returns 1 if decl is a member of a class. */
1804 const tree ctx
= DECL_CONTEXT (decl
);
1805 return (ctx
&& TYPE_P (ctx
));
1808 /* Create a placeholder for member access where we don't actually have an
1809 object that the access is against. */
1812 build_dummy_object (type
)
1815 tree decl
= build1 (NOP_EXPR
, build_pointer_type (type
), void_zero_node
);
1816 return build_indirect_ref (decl
, NULL
);
1819 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
1820 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
1821 binfo path from current_class_type to TYPE, or 0. */
1824 maybe_dummy_object (type
, binfop
)
1831 if (current_class_type
1832 && (binfo
= lookup_base (current_class_type
, type
,
1833 ba_ignore
| ba_quiet
, NULL
)))
1834 context
= current_class_type
;
1837 /* Reference from a nested class member function. */
1839 binfo
= TYPE_BINFO (type
);
1845 if (current_class_ref
&& context
== current_class_type
1846 // Kludge: Make sure that current_class_type is actually correct.
1847 // It might not be if we're in the middle of tsubst_default_argument.
1848 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref
)),
1849 current_class_type
))
1850 decl
= current_class_ref
;
1852 decl
= build_dummy_object (context
);
1857 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
1860 is_dummy_object (ob
)
1863 if (TREE_CODE (ob
) == INDIRECT_REF
)
1864 ob
= TREE_OPERAND (ob
, 0);
1865 return (TREE_CODE (ob
) == NOP_EXPR
1866 && TREE_OPERAND (ob
, 0) == void_zero_node
);
1869 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
1875 t
= strip_array_types (t
);
1877 if (INTEGRAL_TYPE_P (t
))
1878 return 1; /* integral, character or enumeral type */
1879 if (FLOAT_TYPE_P (t
))
1882 return 1; /* pointer to non-member */
1883 if (TYPE_PTRMEM_P (t
))
1884 return 1; /* pointer to member object */
1885 if (TYPE_PTRMEMFUNC_P (t
))
1886 return 1; /* pointer to member function */
1888 if (! CLASS_TYPE_P (t
))
1889 return 0; /* other non-class type (reference or function) */
1890 if (CLASSTYPE_NON_POD_P (t
))
1895 /* Returns 1 iff zero initialization of type T means actually storing
1902 t
= strip_array_types (t
);
1904 /* NULL pointers to data members are initialized with -1. */
1905 if (TYPE_PTRMEM_P (t
))
1908 /* Classes that contain types that can't be zero-initialized, cannot
1909 be zero-initialized themselves. */
1910 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
1916 /* Table of valid C++ attributes. */
1917 const struct attribute_spec cxx_attribute_table
[] =
1919 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
1920 { "java_interface", 0, 0, false, false, false, handle_java_interface_attribute
},
1921 { "com_interface", 0, 0, false, false, false, handle_com_interface_attribute
},
1922 { "init_priority", 1, 1, true, false, false, handle_init_priority_attribute
},
1923 { NULL
, 0, 0, false, false, false, NULL
}
1926 /* Handle a "java_interface" attribute; arguments as in
1927 struct attribute_spec.handler. */
1929 handle_java_interface_attribute (node
, name
, args
, flags
, no_add_attrs
)
1932 tree args ATTRIBUTE_UNUSED
;
1937 || !CLASS_TYPE_P (*node
)
1938 || !TYPE_FOR_JAVA (*node
))
1940 error ("`%s' attribute can only be applied to Java class definitions",
1941 IDENTIFIER_POINTER (name
));
1942 *no_add_attrs
= true;
1945 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
1946 *node
= build_type_copy (*node
);
1947 TYPE_JAVA_INTERFACE (*node
) = 1;
1952 /* Handle a "com_interface" attribute; arguments as in
1953 struct attribute_spec.handler. */
1955 handle_com_interface_attribute (node
, name
, args
, flags
, no_add_attrs
)
1958 tree args ATTRIBUTE_UNUSED
;
1959 int flags ATTRIBUTE_UNUSED
;
1964 *no_add_attrs
= true;
1967 || !CLASS_TYPE_P (*node
)
1968 || *node
!= TYPE_MAIN_VARIANT (*node
))
1970 warning ("`%s' attribute can only be applied to class definitions",
1971 IDENTIFIER_POINTER (name
));
1976 warning ("`%s' is obsolete; g++ vtables are now COM-compatible by default",
1977 IDENTIFIER_POINTER (name
));
1982 /* Handle an "init_priority" attribute; arguments as in
1983 struct attribute_spec.handler. */
1985 handle_init_priority_attribute (node
, name
, args
, flags
, no_add_attrs
)
1989 int flags ATTRIBUTE_UNUSED
;
1992 tree initp_expr
= TREE_VALUE (args
);
1994 tree type
= TREE_TYPE (decl
);
1997 STRIP_NOPS (initp_expr
);
1999 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
2001 error ("requested init_priority is not an integer constant");
2002 *no_add_attrs
= true;
2006 pri
= TREE_INT_CST_LOW (initp_expr
);
2008 type
= strip_array_types (type
);
2010 if (decl
== NULL_TREE
2011 || TREE_CODE (decl
) != VAR_DECL
2012 || !TREE_STATIC (decl
)
2013 || DECL_EXTERNAL (decl
)
2014 || (TREE_CODE (type
) != RECORD_TYPE
2015 && TREE_CODE (type
) != UNION_TYPE
)
2016 /* Static objects in functions are initialized the
2017 first time control passes through that
2018 function. This is not precise enough to pin down an
2019 init_priority value, so don't allow it. */
2020 || current_function_decl
)
2022 error ("can only use `%s' attribute on file-scope definitions of objects of class type",
2023 IDENTIFIER_POINTER (name
));
2024 *no_add_attrs
= true;
2028 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
2030 error ("requested init_priority is out of range");
2031 *no_add_attrs
= true;
2035 /* Check for init_priorities that are reserved for
2036 language and runtime support implementations.*/
2037 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
2040 ("requested init_priority is reserved for internal use");
2043 if (SUPPORTS_INIT_PRIORITY
)
2045 DECL_INIT_PRIORITY (decl
) = pri
;
2050 error ("`%s' attribute is not supported on this platform",
2051 IDENTIFIER_POINTER (name
));
2052 *no_add_attrs
= true;
2057 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
2058 thing pointed to by the constant. */
2061 make_ptrmem_cst (type
, member
)
2065 tree ptrmem_cst
= make_node (PTRMEM_CST
);
2066 /* If would seem a great convenience if make_node would set
2067 TREE_CONSTANT for things of class `c', but it does not. */
2068 TREE_CONSTANT (ptrmem_cst
) = 1;
2069 TREE_TYPE (ptrmem_cst
) = type
;
2070 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
2074 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
2075 traversal. Called from walk_tree(). */
2078 cp_walk_subtrees (tp
, walk_subtrees_p
, func
, data
, htab
)
2080 int *walk_subtrees_p
;
2085 enum tree_code code
= TREE_CODE (*tp
);
2088 #define WALK_SUBTREE(NODE) \
2091 result = walk_tree (&(NODE), func, data, htab); \
2097 /* Not one of the easy cases. We must explicitly go through the
2102 case TEMPLATE_TEMPLATE_PARM
:
2103 case BOUND_TEMPLATE_TEMPLATE_PARM
:
2104 case UNBOUND_CLASS_TEMPLATE
:
2105 case TEMPLATE_PARM_INDEX
:
2106 case TEMPLATE_TYPE_PARM
:
2109 /* None of thse have subtrees other than those already walked
2111 *walk_subtrees_p
= 0;
2115 WALK_SUBTREE (TREE_TYPE (*tp
));
2116 *walk_subtrees_p
= 0;
2120 /* A BASELINK_P's TREE_PURPOSE is a BINFO, and hence circular. */
2121 if (!BASELINK_P (*tp
))
2122 WALK_SUBTREE (TREE_PURPOSE (*tp
));
2126 WALK_SUBTREE (OVL_FUNCTION (*tp
));
2127 WALK_SUBTREE (OVL_CHAIN (*tp
));
2128 *walk_subtrees_p
= 0;
2132 if (TYPE_PTRMEMFUNC_P (*tp
))
2133 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp
));
2140 /* We didn't find what we were looking for. */
2146 /* Decide whether there are language-specific reasons to not inline a
2147 function as a tree. */
2150 cp_cannot_inline_tree_fn (fnp
)
2155 if (flag_really_no_inline
2156 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)) == NULL
)
2159 /* We can inline a template instantiation only if it's fully
2161 if (DECL_TEMPLATE_INFO (fn
)
2162 && TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn
)))
2164 fn
= *fnp
= instantiate_decl (fn
, /*defer_ok=*/0);
2165 return TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn
));
2168 if (varargs_function_p (fn
))
2170 DECL_UNINLINABLE (fn
) = 1;
2174 if (! function_attribute_inlinable_p (fn
))
2176 DECL_UNINLINABLE (fn
) = 1;
2183 /* Add any pending functions other than the current function (already
2184 handled by the caller), that thus cannot be inlined, to FNS_P, then
2185 return the latest function added to the array, PREV_FN. */
2188 cp_add_pending_fn_decls (fns_p
, prev_fn
)
2192 varray_type
*fnsp
= (varray_type
*)fns_p
;
2193 struct saved_scope
*s
;
2195 for (s
= scope_chain
; s
; s
= s
->prev
)
2196 if (s
->function_decl
&& s
->function_decl
!= prev_fn
)
2198 VARRAY_PUSH_TREE (*fnsp
, s
->function_decl
);
2199 prev_fn
= s
->function_decl
;
2205 /* Determine whether a tree node is an OVERLOAD node. Used to decide
2206 whether to copy a node or to preserve its chain when inlining a
2210 cp_is_overload_p (t
)
2213 return TREE_CODE (t
) == OVERLOAD
;
2216 /* Determine whether VAR is a declaration of an automatic variable in
2220 cp_auto_var_in_fn_p (var
, fn
)
2223 return (DECL_P (var
) && DECL_CONTEXT (var
) == fn
2224 && nonstatic_local_decl_p (var
));
2227 /* Tell whether a declaration is needed for the RESULT of a function
2228 FN being inlined into CALLER or if the top node of target_exprs is
2232 cp_copy_res_decl_for_inlining (result
, fn
, caller
, decl_map_
,
2233 need_decl
, target_exprs
)
2234 tree result
, fn
, caller
;
2239 splay_tree decl_map
= (splay_tree
)decl_map_
;
2240 varray_type
*texps
= (varray_type
*)target_exprs
;
2242 int aggregate_return_p
;
2244 /* Figure out whether or not FN returns an aggregate. */
2245 aggregate_return_p
= IS_AGGR_TYPE (TREE_TYPE (result
));
2246 *need_decl
= ! aggregate_return_p
;
2248 /* If FN returns an aggregate then the caller will always create the
2249 temporary (using a TARGET_EXPR) and the call will be the
2250 initializing expression for the TARGET_EXPR. If we were just to
2251 create a new VAR_DECL here, then the result of this function
2252 would be copied (bitwise) into the variable initialized by the
2253 TARGET_EXPR. That's incorrect, so we must transform any
2254 references to the RESULT into references to the target. */
2255 if (aggregate_return_p
)
2257 if (VARRAY_ACTIVE_SIZE (*texps
) == 0)
2259 var
= TREE_OPERAND (VARRAY_TOP_TREE (*texps
), 0);
2260 if (! same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (var
),
2261 TREE_TYPE (result
)))
2264 /* Otherwise, make an appropriate copy. */
2266 var
= copy_decl_for_inlining (result
, fn
, caller
);
2268 if (DECL_SAVED_FUNCTION_DATA (fn
))
2270 tree nrv
= DECL_SAVED_FUNCTION_DATA (fn
)->x_return_value
;
2273 /* We have a named return value; copy the name and source
2274 position so we can get reasonable debugging information, and
2275 register the return variable as its equivalent. */
2276 DECL_NAME (var
) = DECL_NAME (nrv
);
2277 DECL_SOURCE_FILE (var
) = DECL_SOURCE_FILE (nrv
);
2278 DECL_SOURCE_LINE (var
) = DECL_SOURCE_LINE (nrv
);
2279 DECL_ABSTRACT_ORIGIN (var
) = DECL_ORIGIN (nrv
);
2280 splay_tree_insert (decl_map
,
2281 (splay_tree_key
) nrv
,
2282 (splay_tree_value
) var
);
2289 /* Record that we're about to start inlining FN, and return non-zero if
2290 that's OK. Used for lang_hooks.tree_inlining.start_inlining. */
2293 cp_start_inlining (fn
)
2296 if (DECL_TEMPLATE_INSTANTIATION (fn
))
2297 return push_tinst_level (fn
);
2302 /* Record that we're done inlining FN. Used for
2303 lang_hooks.tree_inlining.end_inlining. */
2306 cp_end_inlining (fn
)
2307 tree fn ATTRIBUTE_UNUSED
;
2309 if (DECL_TEMPLATE_INSTANTIATION (fn
))
2313 /* Initialize tree.c. */
2318 lang_statement_code_p
= cp_statement_code_p
;
2319 list_hash_table
= htab_create_ggc (31, list_hash
, list_hash_eq
, NULL
);
2322 /* Called via walk_tree. If *TP points to a DECL_STMT for a local
2323 declaration, copies the declaration and enters it in the splay_tree
2324 pointed to by DATA (which is really a `splay_tree *'). */
2327 mark_local_for_remap_r (tp
, walk_subtrees
, data
)
2329 int *walk_subtrees ATTRIBUTE_UNUSED
;
2333 splay_tree st
= (splay_tree
) data
;
2337 if (TREE_CODE (t
) == DECL_STMT
2338 && nonstatic_local_decl_p (DECL_STMT_DECL (t
)))
2339 decl
= DECL_STMT_DECL (t
);
2340 else if (TREE_CODE (t
) == LABEL_STMT
)
2341 decl
= LABEL_STMT_LABEL (t
);
2342 else if (TREE_CODE (t
) == TARGET_EXPR
2343 && nonstatic_local_decl_p (TREE_OPERAND (t
, 0)))
2344 decl
= TREE_OPERAND (t
, 0);
2345 else if (TREE_CODE (t
) == CASE_LABEL
)
2346 decl
= CASE_LABEL_DECL (t
);
2355 copy
= copy_decl_for_inlining (decl
,
2356 DECL_CONTEXT (decl
),
2357 DECL_CONTEXT (decl
));
2359 /* Remember the copy. */
2360 splay_tree_insert (st
,
2361 (splay_tree_key
) decl
,
2362 (splay_tree_value
) copy
);
2368 /* Called via walk_tree when an expression is unsaved. Using the
2369 splay_tree pointed to by ST (which is really a `splay_tree'),
2370 remaps all local declarations to appropriate replacements. */
2373 cp_unsave_r (tp
, walk_subtrees
, data
)
2378 splay_tree st
= (splay_tree
) data
;
2381 /* Only a local declaration (variable or label). */
2382 if (nonstatic_local_decl_p (*tp
))
2384 /* Lookup the declaration. */
2385 n
= splay_tree_lookup (st
, (splay_tree_key
) *tp
);
2387 /* If it's there, remap it. */
2389 *tp
= (tree
) n
->value
;
2391 else if (TREE_CODE (*tp
) == SAVE_EXPR
)
2392 remap_save_expr (tp
, st
, current_function_decl
, walk_subtrees
);
2395 copy_tree_r (tp
, walk_subtrees
, NULL
);
2397 /* Do whatever unsaving is required. */
2398 unsave_expr_1 (*tp
);
2401 /* Keep iterating. */
2405 /* Called whenever an expression needs to be unsaved. */
2408 cxx_unsave_expr_now (tp
)
2413 /* Create a splay-tree to map old local variable declarations to new
2415 st
= splay_tree_new (splay_tree_compare_pointers
, NULL
, NULL
);
2417 /* Walk the tree once figuring out what needs to be remapped. */
2418 walk_tree (&tp
, mark_local_for_remap_r
, st
, NULL
);
2420 /* Walk the tree again, copying, remapping, and unsaving. */
2421 walk_tree (&tp
, cp_unsave_r
, st
, NULL
);
2424 splay_tree_delete (st
);
2429 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
2430 is. Note that this sfk_none is zero, so this function can be used
2431 as a predicate to test whether or not DECL is a special function. */
2433 special_function_kind
2434 special_function_p (decl
)
2437 /* Rather than doing all this stuff with magic names, we should
2438 probably have a field of type `special_function_kind' in
2439 DECL_LANG_SPECIFIC. */
2440 if (DECL_COPY_CONSTRUCTOR_P (decl
))
2441 return sfk_copy_constructor
;
2442 if (DECL_CONSTRUCTOR_P (decl
))
2443 return sfk_constructor
;
2444 if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
2445 return sfk_assignment_operator
;
2446 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
2447 return sfk_destructor
;
2448 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
2449 return sfk_complete_destructor
;
2450 if (DECL_BASE_DESTRUCTOR_P (decl
))
2451 return sfk_base_destructor
;
2452 if (DECL_DELETING_DESTRUCTOR_P (decl
))
2453 return sfk_deleting_destructor
;
2454 if (DECL_CONV_FN_P (decl
))
2455 return sfk_conversion
;
2460 /* Returns non-zero if TYPE is a character type, including wchar_t. */
2466 return (same_type_p (type
, char_type_node
)
2467 || same_type_p (type
, unsigned_char_type_node
)
2468 || same_type_p (type
, signed_char_type_node
)
2469 || same_type_p (type
, wchar_type_node
));
2472 /* Returns the kind of linkage associated with the indicated DECL. Th
2473 value returned is as specified by the language standard; it is
2474 independent of implementation details regarding template
2475 instantiation, etc. For example, it is possible that a declaration
2476 to which this function assigns external linkage would not show up
2477 as a global symbol when you run `nm' on the resulting object file. */
2483 /* This function doesn't attempt to calculate the linkage from first
2484 principles as given in [basic.link]. Instead, it makes use of
2485 the fact that we have already set TREE_PUBLIC appropriately, and
2486 then handles a few special cases. Ideally, we would calculate
2487 linkage first, and then transform that into a concrete
2490 /* Things that don't have names have no linkage. */
2491 if (!DECL_NAME (decl
))
2494 /* Things that are TREE_PUBLIC have external linkage. */
2495 if (TREE_PUBLIC (decl
))
2498 /* Some things that are not TREE_PUBLIC have external linkage, too.
2499 For example, on targets that don't have weak symbols, we make all
2500 template instantiations have internal linkage (in the object
2501 file), but the symbols should still be treated as having external
2502 linkage from the point of view of the language. */
2503 if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
2506 /* Things in local scope do not have linkage, if they don't have
2508 if (decl_function_context (decl
))
2511 /* Everything else has internal linkage. */
2515 /* EXP is an expression that we want to pre-evaluate. Returns via INITP an
2516 expression to perform the pre-evaluation, and returns directly an
2517 expression to use the precalculated result. */
2520 stabilize_expr (exp
, initp
)
2526 if (!TREE_SIDE_EFFECTS (exp
))
2528 init_expr
= void_zero_node
;
2530 else if (!real_lvalue_p (exp
)
2531 || !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (exp
)))
2533 init_expr
= get_target_expr (exp
);
2534 exp
= TARGET_EXPR_SLOT (init_expr
);
2538 exp
= build_unary_op (ADDR_EXPR
, exp
, 1);
2539 init_expr
= get_target_expr (exp
);
2540 exp
= TARGET_EXPR_SLOT (init_expr
);
2541 exp
= build_indirect_ref (exp
, 0);
2548 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
2549 /* Complain that some language-specific thing hanging off a tree
2550 node has been accessed improperly. */
2553 lang_check_failed (file
, line
, function
)
2556 const char *function
;
2558 internal_error ("lang_* check: failed in %s, at %s:%d",
2559 function
, trim_filename (file
), line
);
2561 #endif /* ENABLE_TREE_CHECKING */
2563 #include "gt-cp-tree.h"