1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
25 #include "coretypes.h"
33 #include "insn-config.h"
34 #include "integrate.h"
35 #include "tree-inline.h"
38 static tree
bot_manip (tree
*, int *, void *);
39 static tree
bot_replace (tree
*, int *, void *);
40 static tree
build_cplus_array_type_1 (tree
, tree
);
41 static int list_hash_eq (const void *, const void *);
42 static hashval_t
list_hash_pieces (tree
, tree
, tree
);
43 static hashval_t
list_hash (const void *);
44 static cp_lvalue_kind
lvalue_p_1 (tree
, int);
45 static tree
build_target_expr (tree
, tree
);
46 static tree
count_trees_r (tree
*, int *, void *);
47 static tree
verify_stmt_tree_r (tree
*, int *, void *);
48 static tree
find_tree_r (tree
*, int *, void *);
49 static tree
build_local_temp (tree
);
51 static tree
handle_java_interface_attribute (tree
*, tree
, tree
, int, bool *);
52 static tree
handle_com_interface_attribute (tree
*, tree
, tree
, int, bool *);
53 static tree
handle_init_priority_attribute (tree
*, tree
, tree
, int, bool *);
55 /* If REF is an lvalue, returns the kind of lvalue that REF is.
56 Otherwise, returns clk_none. If TREAT_CLASS_RVALUES_AS_LVALUES is
57 nonzero, rvalues of class type are considered lvalues. */
61 int treat_class_rvalues_as_lvalues
)
63 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
64 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
66 if (TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
69 if (ref
== current_class_ptr
)
72 switch (TREE_CODE (ref
))
74 /* preincrements and predecrements are valid lvals, provided
75 what they refer to are valid lvals. */
76 case PREINCREMENT_EXPR
:
77 case PREDECREMENT_EXPR
:
80 case WITH_CLEANUP_EXPR
:
83 return lvalue_p_1 (TREE_OPERAND (ref
, 0),
84 treat_class_rvalues_as_lvalues
);
87 op1_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 0),
88 treat_class_rvalues_as_lvalues
);
89 /* In an expression of the form "X.Y", the packed-ness of the
90 expression does not depend on "X". */
91 op1_lvalue_kind
&= ~clk_packed
;
92 /* Look at the member designator. */
94 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
96 || TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
98 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
100 /* Clear the ordinary bit. If this object was a class
101 rvalue we want to preserve that information. */
102 op1_lvalue_kind
&= ~clk_ordinary
;
103 /* The lvalue is for a bitfield. */
104 op1_lvalue_kind
|= clk_bitfield
;
106 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
107 op1_lvalue_kind
|= clk_packed
;
109 return op1_lvalue_kind
;
115 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
116 && DECL_LANG_SPECIFIC (ref
)
117 && DECL_IN_AGGR_P (ref
))
123 if (TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
)
127 /* A currently unresolved scope ref. */
132 /* Disallow <? and >? as lvalues if either argument side-effects. */
133 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
134 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
136 op1_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 0),
137 treat_class_rvalues_as_lvalues
);
138 op2_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 1),
139 treat_class_rvalues_as_lvalues
);
143 op1_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 1),
144 treat_class_rvalues_as_lvalues
);
145 op2_lvalue_kind
= lvalue_p_1 (TREE_OPERAND (ref
, 2),
146 treat_class_rvalues_as_lvalues
);
153 return lvalue_p_1 (TREE_OPERAND (ref
, 1),
154 treat_class_rvalues_as_lvalues
);
157 return treat_class_rvalues_as_lvalues
? clk_class
: clk_none
;
161 /* Any class-valued call would be wrapped in a TARGET_EXPR. */
165 /* All functions (except non-static-member functions) are
167 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
168 ? clk_none
: clk_ordinary
);
170 case NON_DEPENDENT_EXPR
:
171 /* We must consider NON_DEPENDENT_EXPRs to be lvalues so that
172 things like "&E" where "E" is an expression with a
173 non-dependent type work. It is safe to be lenient because an
174 error will be issued when the template is instantiated if "E"
182 /* If one operand is not an lvalue at all, then this expression is
184 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
187 /* Otherwise, it's an lvalue, and it has all the odd properties
188 contributed by either operand. */
189 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
190 /* It's not an ordinary lvalue if it involves either a bit-field or
192 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
193 op1_lvalue_kind
&= ~clk_ordinary
;
194 return op1_lvalue_kind
;
197 /* Returns the kind of lvalue that REF is, in the sense of
198 [basic.lval]. This function should really be named lvalue_p; it
199 computes the C++ definition of lvalue. */
202 real_lvalue_p (tree ref
)
204 return lvalue_p_1 (ref
,
205 /*treat_class_rvalues_as_lvalues=*/0);
208 /* This differs from real_lvalue_p in that class rvalues are
209 considered lvalues. */
215 (lvalue_p_1 (ref
, /*class rvalue ok*/ 1) != clk_none
);
218 /* Test whether DECL is a builtin that may appear in a
219 constant-expression. */
222 builtin_valid_in_constant_expr_p (tree decl
)
224 /* At present BUILT_IN_CONSTANT_P is the only builtin we're allowing
225 in constant-expressions. We may want to add other builtins later. */
226 return TREE_CODE (decl
) == FUNCTION_DECL
227 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
228 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_CONSTANT_P
;
231 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
234 build_target_expr (tree decl
, tree value
)
238 t
= build4 (TARGET_EXPR
, TREE_TYPE (decl
), decl
, value
,
239 cxx_maybe_build_cleanup (decl
), NULL_TREE
);
240 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
241 ignore the TARGET_EXPR. If there really turn out to be no
242 side-effects, then the optimizer should be able to get rid of
243 whatever code is generated anyhow. */
244 TREE_SIDE_EFFECTS (t
) = 1;
249 /* Return an undeclared local temporary of type TYPE for use in building a
253 build_local_temp (tree type
)
255 tree slot
= build_decl (VAR_DECL
, NULL_TREE
, type
);
256 DECL_ARTIFICIAL (slot
) = 1;
257 DECL_IGNORED_P (slot
) = 1;
258 DECL_CONTEXT (slot
) = current_function_decl
;
259 layout_decl (slot
, 0);
263 /* INIT is a CALL_EXPR which needs info about its target.
264 TYPE is the type that this initialization should appear to have.
266 Build an encapsulation of the initialization to perform
267 and return it so that it can be processed by language-independent
268 and language-specific expression expanders. */
271 build_cplus_new (tree type
, tree init
)
278 /* Make sure that we're not trying to create an instance of an
280 abstract_virtuals_error (NULL_TREE
, type
);
282 if (TREE_CODE (init
) != CALL_EXPR
&& TREE_CODE (init
) != AGGR_INIT_EXPR
)
283 return convert (type
, init
);
285 fn
= TREE_OPERAND (init
, 0);
286 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
287 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
288 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
290 slot
= build_local_temp (type
);
292 /* We split the CALL_EXPR into its function and its arguments here.
293 Then, in expand_expr, we put them back together. The reason for
294 this is that this expression might be a default argument
295 expression. In that case, we need a new temporary every time the
296 expression is used. That's what break_out_target_exprs does; it
297 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
298 temporary slot. Then, expand_expr builds up a call-expression
299 using the new slot. */
301 /* If we don't need to use a constructor to create an object of this
302 type, don't mess with AGGR_INIT_EXPR. */
303 if (is_ctor
|| TREE_ADDRESSABLE (type
))
305 rval
= build3 (AGGR_INIT_EXPR
, void_type_node
, fn
,
306 TREE_OPERAND (init
, 1), slot
);
307 TREE_SIDE_EFFECTS (rval
) = 1;
308 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
313 rval
= build_target_expr (slot
, rval
);
318 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
322 build_target_expr_with_type (tree init
, tree type
)
326 gcc_assert (!VOID_TYPE_P (type
));
328 if (TREE_CODE (init
) == TARGET_EXPR
)
330 else if (CLASS_TYPE_P (type
) && !TYPE_HAS_TRIVIAL_INIT_REF (type
)
331 && TREE_CODE (init
) != COND_EXPR
332 && TREE_CODE (init
) != CONSTRUCTOR
333 && TREE_CODE (init
) != VA_ARG_EXPR
)
334 /* We need to build up a copy constructor call. COND_EXPR is a special
335 case because we already have copies on the arms and we don't want
336 another one here. A CONSTRUCTOR is aggregate initialization, which
337 is handled separately. A VA_ARG_EXPR is magic creation of an
338 aggregate; there's no additional work to be done. */
339 return force_rvalue (init
);
341 slot
= build_local_temp (type
);
342 return build_target_expr (slot
, init
);
345 /* Like the above function, but without the checking. This function should
346 only be used by code which is deliberately trying to subvert the type
347 system, such as call_builtin_trap. */
350 force_target_expr (tree type
, tree init
)
354 gcc_assert (!VOID_TYPE_P (type
));
356 slot
= build_local_temp (type
);
357 return build_target_expr (slot
, init
);
360 /* Like build_target_expr_with_type, but use the type of INIT. */
363 get_target_expr (tree init
)
365 return build_target_expr_with_type (init
, TREE_TYPE (init
));
370 build_cplus_array_type_1 (tree elt_type
, tree index_type
)
374 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
375 return error_mark_node
;
377 if (dependent_type_p (elt_type
)
379 && value_dependent_expression_p (TYPE_MAX_VALUE (index_type
))))
381 t
= make_node (ARRAY_TYPE
);
382 TREE_TYPE (t
) = elt_type
;
383 TYPE_DOMAIN (t
) = index_type
;
386 t
= build_array_type (elt_type
, index_type
);
388 /* Push these needs up so that initialization takes place
390 TYPE_NEEDS_CONSTRUCTING (t
)
391 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
392 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
393 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
398 build_cplus_array_type (tree elt_type
, tree index_type
)
401 int type_quals
= cp_type_quals (elt_type
);
403 if (type_quals
!= TYPE_UNQUALIFIED
)
404 elt_type
= cp_build_qualified_type (elt_type
, TYPE_UNQUALIFIED
);
406 t
= build_cplus_array_type_1 (elt_type
, index_type
);
408 if (type_quals
!= TYPE_UNQUALIFIED
)
409 t
= cp_build_qualified_type (t
, type_quals
);
414 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
415 arrays correctly. In particular, if TYPE is an array of T's, and
416 TYPE_QUALS is non-empty, returns an array of qualified T's.
418 FLAGS determines how to deal with illformed qualifications. If
419 tf_ignore_bad_quals is set, then bad qualifications are dropped
420 (this is permitted if TYPE was introduced via a typedef or template
421 type parameter). If bad qualifications are dropped and tf_warning
422 is set, then a warning is issued for non-const qualifications. If
423 tf_ignore_bad_quals is not set and tf_error is not set, we
424 return error_mark_node. Otherwise, we issue an error, and ignore
427 Qualification of a reference type is valid when the reference came
428 via a typedef or template type argument. [dcl.ref] No such
429 dispensation is provided for qualifying a function type. [dcl.fct]
430 DR 295 queries this and the proposed resolution brings it into line
431 with qualifying a reference. We implement the DR. We also behave
432 in a similar manner for restricting non-pointer types. */
435 cp_build_qualified_type_real (tree type
,
437 tsubst_flags_t complain
)
440 int bad_quals
= TYPE_UNQUALIFIED
;
442 if (type
== error_mark_node
)
445 if (type_quals
== cp_type_quals (type
))
448 if (TREE_CODE (type
) == ARRAY_TYPE
)
450 /* In C++, the qualification really applies to the array element
451 type. Obtain the appropriately qualified element type. */
454 = cp_build_qualified_type_real (TREE_TYPE (type
),
458 if (element_type
== error_mark_node
)
459 return error_mark_node
;
461 /* See if we already have an identically qualified type. */
462 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
463 if (cp_type_quals (t
) == type_quals
464 && TYPE_NAME (t
) == TYPE_NAME (type
)
465 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
))
470 /* Make a new array type, just like the old one, but with the
471 appropriately qualified element type. */
472 t
= build_variant_type_copy (type
);
473 TREE_TYPE (t
) = element_type
;
476 /* Even if we already had this variant, we update
477 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
478 they changed since the variant was originally created.
480 This seems hokey; if there is some way to use a previous
481 variant *without* coming through here,
482 TYPE_NEEDS_CONSTRUCTING will never be updated. */
483 TYPE_NEEDS_CONSTRUCTING (t
)
484 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
485 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
486 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
489 else if (TYPE_PTRMEMFUNC_P (type
))
491 /* For a pointer-to-member type, we can't just return a
492 cv-qualified version of the RECORD_TYPE. If we do, we
493 haven't changed the field that contains the actual pointer to
494 a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong. */
497 t
= TYPE_PTRMEMFUNC_FN_TYPE (type
);
498 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
499 return build_ptrmemfunc_type (t
);
502 /* A reference or method type shall not be cv qualified.
503 [dcl.ref], [dct.fct] */
504 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
505 && (TREE_CODE (type
) == REFERENCE_TYPE
506 || TREE_CODE (type
) == METHOD_TYPE
))
508 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
509 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
512 /* A restrict-qualified type must be a pointer (or reference)
513 to object or incomplete type, or a function type. */
514 if ((type_quals
& TYPE_QUAL_RESTRICT
)
515 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
516 && TREE_CODE (type
) != TYPENAME_TYPE
517 && TREE_CODE (type
) != FUNCTION_TYPE
518 && !POINTER_TYPE_P (type
))
520 bad_quals
|= TYPE_QUAL_RESTRICT
;
521 type_quals
&= ~TYPE_QUAL_RESTRICT
;
524 if (bad_quals
== TYPE_UNQUALIFIED
)
526 else if (!(complain
& (tf_error
| tf_ignore_bad_quals
)))
527 return error_mark_node
;
530 if (complain
& tf_ignore_bad_quals
)
531 /* We're not going to warn about constifying things that can't
533 bad_quals
&= ~TYPE_QUAL_CONST
;
536 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
538 if (!(complain
& tf_ignore_bad_quals
))
539 error ("%qV qualifiers cannot be applied to %qT",
544 /* Retrieve (or create) the appropriately qualified variant. */
545 result
= build_qualified_type (type
, type_quals
);
547 /* If this was a pointer-to-method type, and we just made a copy,
548 then we need to unshare the record that holds the cached
549 pointer-to-member-function type, because these will be distinct
550 between the unqualified and qualified types. */
552 && TREE_CODE (type
) == POINTER_TYPE
553 && TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
)
554 TYPE_LANG_SPECIFIC (result
) = NULL
;
559 /* Returns the canonical version of TYPE. In other words, if TYPE is
560 a typedef, returns the underlying type. The cv-qualification of
561 the type returned matches the type input; they will always be
565 canonical_type_variant (tree t
)
567 return cp_build_qualified_type (TYPE_MAIN_VARIANT (t
), cp_type_quals (t
));
570 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
571 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
572 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
573 VIRT indicates whether TYPE is inherited virtually or not.
574 IGO_PREV points at the previous binfo of the inheritance graph
575 order chain. The newly copied binfo's TREE_CHAIN forms this
578 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
579 correct order. That is in the order the bases themselves should be
582 The BINFO_INHERITANCE of a virtual base class points to the binfo
583 of the most derived type. ??? We could probably change this so that
584 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
585 remove a field. They currently can only differ for primary virtual
589 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
595 /* See if we've already made this virtual base. */
596 new_binfo
= binfo_for_vbase (type
, t
);
601 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
602 BINFO_TYPE (new_binfo
) = type
;
604 /* Chain it into the inheritance graph. */
605 TREE_CHAIN (*igo_prev
) = new_binfo
;
606 *igo_prev
= new_binfo
;
613 gcc_assert (!BINFO_DEPENDENT_BASE_P (binfo
));
614 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
616 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
617 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
619 /* We do not need to copy the accesses, as they are read only. */
620 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
622 /* Recursively copy base binfos of BINFO. */
623 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
627 gcc_assert (!BINFO_DEPENDENT_BASE_P (base_binfo
));
628 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
630 BINFO_VIRTUAL_P (base_binfo
));
632 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
633 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
634 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
638 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
642 /* Push it onto the list after any virtual bases it contains
643 will have been pushed. */
644 VEC_quick_push (tree
, CLASSTYPE_VBASECLASSES (t
), new_binfo
);
645 BINFO_VIRTUAL_P (new_binfo
) = 1;
646 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
652 /* Hashing of lists so that we don't make duplicates.
653 The entry point is `list_hash_canon'. */
655 /* Now here is the hash table. When recording a list, it is added
656 to the slot whose index is the hash code mod the table size.
657 Note that the hash table is used for several kinds of lists.
658 While all these live in the same table, they are completely independent,
659 and the hash code is computed differently for each of these. */
661 static GTY ((param_is (union tree_node
))) htab_t list_hash_table
;
670 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
671 for a node we are thinking about adding). */
674 list_hash_eq (const void* entry
, const void* data
)
676 tree t
= (tree
) entry
;
677 struct list_proxy
*proxy
= (struct list_proxy
*) data
;
679 return (TREE_VALUE (t
) == proxy
->value
680 && TREE_PURPOSE (t
) == proxy
->purpose
681 && TREE_CHAIN (t
) == proxy
->chain
);
684 /* Compute a hash code for a list (chain of TREE_LIST nodes
685 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
686 TREE_COMMON slots), by adding the hash codes of the individual entries. */
689 list_hash_pieces (tree purpose
, tree value
, tree chain
)
691 hashval_t hashcode
= 0;
694 hashcode
+= TREE_HASH (chain
);
697 hashcode
+= TREE_HASH (value
);
701 hashcode
+= TREE_HASH (purpose
);
707 /* Hash an already existing TREE_LIST. */
710 list_hash (const void* p
)
713 return list_hash_pieces (TREE_PURPOSE (t
),
718 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
719 object for an identical list if one already exists. Otherwise, build a
720 new one, and record it as the canonical object. */
723 hash_tree_cons (tree purpose
, tree value
, tree chain
)
727 struct list_proxy proxy
;
729 /* Hash the list node. */
730 hashcode
= list_hash_pieces (purpose
, value
, chain
);
731 /* Create a proxy for the TREE_LIST we would like to create. We
732 don't actually create it so as to avoid creating garbage. */
733 proxy
.purpose
= purpose
;
736 /* See if it is already in the table. */
737 slot
= htab_find_slot_with_hash (list_hash_table
, &proxy
, hashcode
,
739 /* If not, create a new node. */
741 *slot
= tree_cons (purpose
, value
, chain
);
745 /* Constructor for hashed lists. */
748 hash_tree_chain (tree value
, tree chain
)
750 return hash_tree_cons (NULL_TREE
, value
, chain
);
754 debug_binfo (tree elem
)
759 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
761 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
762 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
763 debug_tree (BINFO_TYPE (elem
));
764 if (BINFO_VTABLE (elem
))
765 fprintf (stderr
, "vtable decl \"%s\"\n",
766 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
768 fprintf (stderr
, "no vtable decl yet\n");
769 fprintf (stderr
, "virtuals:\n");
770 virtuals
= BINFO_VIRTUALS (elem
);
775 tree fndecl
= TREE_VALUE (virtuals
);
776 fprintf (stderr
, "%s [%ld =? %ld]\n",
777 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
778 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
780 virtuals
= TREE_CHAIN (virtuals
);
785 is_overloaded_fn (tree x
)
787 /* A baselink is also considered an overloaded function. */
788 if (TREE_CODE (x
) == OFFSET_REF
)
789 x
= TREE_OPERAND (x
, 1);
791 x
= BASELINK_FUNCTIONS (x
);
792 return (TREE_CODE (x
) == FUNCTION_DECL
793 || TREE_CODE (x
) == TEMPLATE_ID_EXPR
794 || DECL_FUNCTION_TEMPLATE_P (x
)
795 || TREE_CODE (x
) == OVERLOAD
);
799 really_overloaded_fn (tree x
)
801 /* A baselink is also considered an overloaded function. */
802 if (TREE_CODE (x
) == OFFSET_REF
)
803 x
= TREE_OPERAND (x
, 1);
805 x
= BASELINK_FUNCTIONS (x
);
807 return ((TREE_CODE (x
) == OVERLOAD
&& OVL_CHAIN (x
))
808 || DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x
))
809 || TREE_CODE (x
) == TEMPLATE_ID_EXPR
);
813 get_first_fn (tree from
)
815 gcc_assert (is_overloaded_fn (from
));
816 /* A baselink is also considered an overloaded function. */
817 if (BASELINK_P (from
))
818 from
= BASELINK_FUNCTIONS (from
);
819 return OVL_CURRENT (from
);
822 /* Return a new OVL node, concatenating it with the old one. */
825 ovl_cons (tree decl
, tree chain
)
827 tree result
= make_node (OVERLOAD
);
828 TREE_TYPE (result
) = unknown_type_node
;
829 OVL_FUNCTION (result
) = decl
;
830 TREE_CHAIN (result
) = chain
;
835 /* Build a new overloaded function. If this is the first one,
836 just return it; otherwise, ovl_cons the _DECLs */
839 build_overload (tree decl
, tree chain
)
841 if (! chain
&& TREE_CODE (decl
) != TEMPLATE_DECL
)
843 if (chain
&& TREE_CODE (chain
) != OVERLOAD
)
844 chain
= ovl_cons (chain
, NULL_TREE
);
845 return ovl_cons (decl
, chain
);
849 #define PRINT_RING_SIZE 4
852 cxx_printable_name (tree decl
, int v
)
854 static tree decl_ring
[PRINT_RING_SIZE
];
855 static char *print_ring
[PRINT_RING_SIZE
];
856 static int ring_counter
;
859 /* Only cache functions. */
861 || TREE_CODE (decl
) != FUNCTION_DECL
862 || DECL_LANG_SPECIFIC (decl
) == 0)
863 return lang_decl_name (decl
, v
);
865 /* See if this print name is lying around. */
866 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
867 if (decl_ring
[i
] == decl
)
868 /* yes, so return it. */
869 return print_ring
[i
];
871 if (++ring_counter
== PRINT_RING_SIZE
)
874 if (current_function_decl
!= NULL_TREE
)
876 if (decl_ring
[ring_counter
] == current_function_decl
)
878 if (ring_counter
== PRINT_RING_SIZE
)
880 gcc_assert (decl_ring
[ring_counter
] != current_function_decl
);
883 if (print_ring
[ring_counter
])
884 free (print_ring
[ring_counter
]);
886 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
));
887 decl_ring
[ring_counter
] = decl
;
888 return print_ring
[ring_counter
];
891 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
895 build_exception_variant (tree type
, tree raises
)
897 tree v
= TYPE_MAIN_VARIANT (type
);
898 int type_quals
= TYPE_QUALS (type
);
900 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
901 if (check_qualified_type (v
, type
, type_quals
)
902 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (v
), 1))
905 /* Need to build a new variant. */
906 v
= build_variant_type_copy (type
);
907 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
911 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
912 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
916 bind_template_template_parm (tree t
, tree newargs
)
918 tree decl
= TYPE_NAME (t
);
921 t2
= make_aggr_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
922 decl
= build_decl (TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
924 /* These nodes have to be created to reflect new TYPE_DECL and template
926 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
927 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
928 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
929 = tree_cons (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
),
932 TREE_TYPE (decl
) = t2
;
933 TYPE_NAME (t2
) = decl
;
934 TYPE_STUB_DECL (t2
) = decl
;
940 /* Called from count_trees via walk_tree. */
943 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
953 /* Debugging function for measuring the rough complexity of a tree
960 walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
964 /* Called from verify_stmt_tree via walk_tree. */
967 verify_stmt_tree_r (tree
* tp
,
968 int* walk_subtrees ATTRIBUTE_UNUSED
,
972 htab_t
*statements
= (htab_t
*) data
;
975 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
978 /* If this statement is already present in the hash table, then
979 there is a circularity in the statement tree. */
980 gcc_assert (!htab_find (*statements
, t
));
982 slot
= htab_find_slot (*statements
, t
, INSERT
);
988 /* Debugging function to check that the statement T has not been
989 corrupted. For now, this function simply checks that T contains no
993 verify_stmt_tree (tree t
)
996 statements
= htab_create (37, htab_hash_pointer
, htab_eq_pointer
, NULL
);
997 walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
998 htab_delete (statements
);
1001 /* Called from find_tree via walk_tree. */
1004 find_tree_r (tree
* tp
,
1005 int* walk_subtrees ATTRIBUTE_UNUSED
,
1008 if (*tp
== (tree
) data
)
1014 /* Returns X if X appears in the tree structure rooted at T. */
1017 find_tree (tree t
, tree x
)
1019 return walk_tree_without_duplicates (&t
, find_tree_r
, x
);
1022 /* Check if the type T depends on a type with no linkage and if so, return
1023 it. If RELAXED_P then do not consider a class type declared within
1024 a TREE_PUBLIC function to have no linkage. */
1027 no_linkage_check (tree t
, bool relaxed_p
)
1031 /* There's no point in checking linkage on template functions; we
1032 can't know their complete types. */
1033 if (processing_template_decl
)
1036 switch (TREE_CODE (t
))
1041 if (TYPE_PTRMEMFUNC_P (t
))
1045 if (!CLASS_TYPE_P (t
))
1049 if (TYPE_ANONYMOUS_P (t
))
1051 fn
= decl_function_context (TYPE_MAIN_DECL (t
));
1052 if (fn
&& (!relaxed_p
|| !TREE_PUBLIC (fn
)))
1058 case REFERENCE_TYPE
:
1059 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
1063 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
1067 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
1070 r
= no_linkage_check (TYPE_METHOD_BASETYPE (t
), relaxed_p
);
1077 for (parm
= TYPE_ARG_TYPES (t
);
1078 parm
&& parm
!= void_list_node
;
1079 parm
= TREE_CHAIN (parm
))
1081 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
1085 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
1093 #ifdef GATHER_STATISTICS
1094 extern int depth_reached
;
1098 cxx_print_statistics (void)
1100 print_search_statistics ();
1101 print_class_statistics ();
1102 #ifdef GATHER_STATISTICS
1103 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
1108 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1109 (which is an ARRAY_TYPE). This counts only elements of the top
1113 array_type_nelts_top (tree type
)
1115 return fold_build2 (PLUS_EXPR
, sizetype
,
1116 array_type_nelts (type
),
1120 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1121 (which is an ARRAY_TYPE). This one is a recursive count of all
1122 ARRAY_TYPEs that are clumped together. */
1125 array_type_nelts_total (tree type
)
1127 tree sz
= array_type_nelts_top (type
);
1128 type
= TREE_TYPE (type
);
1129 while (TREE_CODE (type
) == ARRAY_TYPE
)
1131 tree n
= array_type_nelts_top (type
);
1132 sz
= fold_build2 (MULT_EXPR
, sizetype
, sz
, n
);
1133 type
= TREE_TYPE (type
);
1138 /* Called from break_out_target_exprs via mapcar. */
1141 bot_manip (tree
* tp
, int* walk_subtrees
, void* data
)
1143 splay_tree target_remap
= ((splay_tree
) data
);
1146 if (!TYPE_P (t
) && TREE_CONSTANT (t
))
1148 /* There can't be any TARGET_EXPRs or their slot variables below
1149 this point. We used to check !TREE_SIDE_EFFECTS, but then we
1150 failed to copy an ADDR_EXPR of the slot VAR_DECL. */
1154 if (TREE_CODE (t
) == TARGET_EXPR
)
1158 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
1160 mark_used (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 1), 0), 0));
1162 (TREE_TYPE (t
), break_out_target_exprs (TREE_OPERAND (t
, 1)));
1166 u
= build_target_expr_with_type
1167 (break_out_target_exprs (TREE_OPERAND (t
, 1)), TREE_TYPE (t
));
1170 /* Map the old variable to the new one. */
1171 splay_tree_insert (target_remap
,
1172 (splay_tree_key
) TREE_OPERAND (t
, 0),
1173 (splay_tree_value
) TREE_OPERAND (u
, 0));
1175 /* Replace the old expression with the new version. */
1177 /* We don't have to go below this point; the recursive call to
1178 break_out_target_exprs will have handled anything below this
1183 else if (TREE_CODE (t
) == CALL_EXPR
)
1184 mark_used (TREE_OPERAND (TREE_OPERAND (t
, 0), 0));
1186 /* Make a copy of this node. */
1187 return copy_tree_r (tp
, walk_subtrees
, NULL
);
1190 /* Replace all remapped VAR_DECLs in T with their new equivalents.
1191 DATA is really a splay-tree mapping old variables to new
1195 bot_replace (tree
* t
,
1196 int* walk_subtrees ATTRIBUTE_UNUSED
,
1199 splay_tree target_remap
= ((splay_tree
) data
);
1201 if (TREE_CODE (*t
) == VAR_DECL
)
1203 splay_tree_node n
= splay_tree_lookup (target_remap
,
1204 (splay_tree_key
) *t
);
1206 *t
= (tree
) n
->value
;
1212 /* When we parse a default argument expression, we may create
1213 temporary variables via TARGET_EXPRs. When we actually use the
1214 default-argument expression, we make a copy of the expression, but
1215 we must replace the temporaries with appropriate local versions. */
1218 break_out_target_exprs (tree t
)
1220 static int target_remap_count
;
1221 static splay_tree target_remap
;
1223 if (!target_remap_count
++)
1224 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
1225 /*splay_tree_delete_key_fn=*/NULL
,
1226 /*splay_tree_delete_value_fn=*/NULL
);
1227 walk_tree (&t
, bot_manip
, target_remap
, NULL
);
1228 walk_tree (&t
, bot_replace
, target_remap
, NULL
);
1230 if (!--target_remap_count
)
1232 splay_tree_delete (target_remap
);
1233 target_remap
= NULL
;
1239 /* Similar to `build_nt', but for template definitions of dependent
1243 build_min_nt (enum tree_code code
, ...)
1252 t
= make_node (code
);
1253 length
= TREE_CODE_LENGTH (code
);
1255 for (i
= 0; i
< length
; i
++)
1257 tree x
= va_arg (p
, tree
);
1258 TREE_OPERAND (t
, i
) = x
;
1265 /* Similar to `build', but for template definitions. */
1268 build_min (enum tree_code code
, tree tt
, ...)
1277 t
= make_node (code
);
1278 length
= TREE_CODE_LENGTH (code
);
1281 for (i
= 0; i
< length
; i
++)
1283 tree x
= va_arg (p
, tree
);
1284 TREE_OPERAND (t
, i
) = x
;
1285 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
1286 TREE_SIDE_EFFECTS (t
) = 1;
1293 /* Similar to `build', but for template definitions of non-dependent
1294 expressions. NON_DEP is the non-dependent expression that has been
1298 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
1305 va_start (p
, non_dep
);
1307 t
= make_node (code
);
1308 length
= TREE_CODE_LENGTH (code
);
1309 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
1310 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
1312 for (i
= 0; i
< length
; i
++)
1314 tree x
= va_arg (p
, tree
);
1315 TREE_OPERAND (t
, i
) = x
;
1318 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
1319 /* This should not be considered a COMPOUND_EXPR, because it
1320 resolves to an overload. */
1321 COMPOUND_EXPR_OVERLOADED (t
) = 1;
1328 get_type_decl (tree t
)
1330 if (TREE_CODE (t
) == TYPE_DECL
)
1333 return TYPE_STUB_DECL (t
);
1334 gcc_assert (t
== error_mark_node
);
1338 /* Returns the namespace that contains DECL, whether directly or
1342 decl_namespace_context (tree decl
)
1346 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
1348 else if (TYPE_P (decl
))
1349 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
1351 decl
= CP_DECL_CONTEXT (decl
);
1355 /* Return truthvalue of whether T1 is the same tree structure as T2.
1356 Return 1 if they are the same. Return 0 if they are different. */
1359 cp_tree_equal (tree t1
, tree t2
)
1361 enum tree_code code1
, code2
;
1368 for (code1
= TREE_CODE (t1
);
1369 code1
== NOP_EXPR
|| code1
== CONVERT_EXPR
1370 || code1
== NON_LVALUE_EXPR
;
1371 code1
= TREE_CODE (t1
))
1372 t1
= TREE_OPERAND (t1
, 0);
1373 for (code2
= TREE_CODE (t2
);
1374 code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
1375 || code1
== NON_LVALUE_EXPR
;
1376 code2
= TREE_CODE (t2
))
1377 t2
= TREE_OPERAND (t2
, 0);
1379 /* They might have become equal now. */
1389 return TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
1390 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
);
1393 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
1396 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
1397 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
1398 TREE_STRING_LENGTH (t1
));
1401 /* We need to do this when determining whether or not two
1402 non-type pointer to member function template arguments
1404 if (!(same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
1405 /* The first operand is RTL. */
1406 && TREE_OPERAND (t1
, 0) == TREE_OPERAND (t2
, 0)))
1408 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
1411 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
1413 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1415 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
1418 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1421 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
1423 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
1427 tree o1
= TREE_OPERAND (t1
, 0);
1428 tree o2
= TREE_OPERAND (t2
, 0);
1430 /* Special case: if either target is an unallocated VAR_DECL,
1431 it means that it's going to be unified with whatever the
1432 TARGET_EXPR is really supposed to initialize, so treat it
1433 as being equivalent to anything. */
1434 if (TREE_CODE (o1
) == VAR_DECL
&& DECL_NAME (o1
) == NULL_TREE
1435 && !DECL_RTL_SET_P (o1
))
1437 else if (TREE_CODE (o2
) == VAR_DECL
&& DECL_NAME (o2
) == NULL_TREE
1438 && !DECL_RTL_SET_P (o2
))
1440 else if (!cp_tree_equal (o1
, o2
))
1443 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
1446 case WITH_CLEANUP_EXPR
:
1447 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
1449 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t1
, 1));
1452 if (TREE_OPERAND (t1
, 1) != TREE_OPERAND (t2
, 1))
1454 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
1461 case IDENTIFIER_NODE
:
1466 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
1467 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
1468 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
1469 BASELINK_FUNCTIONS (t2
)));
1471 case TEMPLATE_PARM_INDEX
:
1472 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
1473 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
1474 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
1475 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
1477 case TEMPLATE_ID_EXPR
:
1482 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
1484 vec1
= TREE_OPERAND (t1
, 1);
1485 vec2
= TREE_OPERAND (t2
, 1);
1488 return !vec1
&& !vec2
;
1490 if (TREE_VEC_LENGTH (vec1
) != TREE_VEC_LENGTH (vec2
))
1493 for (ix
= TREE_VEC_LENGTH (vec1
); ix
--;)
1494 if (!cp_tree_equal (TREE_VEC_ELT (vec1
, ix
),
1495 TREE_VEC_ELT (vec2
, ix
)))
1504 tree o1
= TREE_OPERAND (t1
, 0);
1505 tree o2
= TREE_OPERAND (t2
, 0);
1507 if (TREE_CODE (o1
) != TREE_CODE (o2
))
1510 return same_type_p (o1
, o2
);
1512 return cp_tree_equal (o1
, o2
);
1516 /* Two pointer-to-members are the same if they point to the same
1517 field or function in the same class. */
1518 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
1521 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
1524 if (OVL_FUNCTION (t1
) != OVL_FUNCTION (t2
))
1526 return cp_tree_equal (OVL_CHAIN (t1
), OVL_CHAIN (t2
));
1532 switch (TREE_CODE_CLASS (code1
))
1536 case tcc_comparison
:
1537 case tcc_expression
:
1543 for (i
= 0; i
< TREE_CODE_LENGTH (code1
); ++i
)
1544 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
1551 return same_type_p (t1
, t2
);
1555 /* We can get here with --disable-checking. */
1559 /* The type of ARG when used as an lvalue. */
1562 lvalue_type (tree arg
)
1564 tree type
= TREE_TYPE (arg
);
1568 /* The type of ARG for printing error messages; denote lvalues with
1572 error_type (tree arg
)
1574 tree type
= TREE_TYPE (arg
);
1576 if (TREE_CODE (type
) == ARRAY_TYPE
)
1578 else if (TREE_CODE (type
) == ERROR_MARK
)
1580 else if (real_lvalue_p (arg
))
1581 type
= build_reference_type (lvalue_type (arg
));
1582 else if (IS_AGGR_TYPE (type
))
1583 type
= lvalue_type (arg
);
1588 /* Does FUNCTION use a variable-length argument list? */
1591 varargs_function_p (tree function
)
1593 tree parm
= TYPE_ARG_TYPES (TREE_TYPE (function
));
1594 for (; parm
; parm
= TREE_CHAIN (parm
))
1595 if (TREE_VALUE (parm
) == void_type_node
)
1600 /* Returns 1 if decl is a member of a class. */
1603 member_p (tree decl
)
1605 const tree ctx
= DECL_CONTEXT (decl
);
1606 return (ctx
&& TYPE_P (ctx
));
1609 /* Create a placeholder for member access where we don't actually have an
1610 object that the access is against. */
1613 build_dummy_object (tree type
)
1615 tree decl
= build1 (NOP_EXPR
, build_pointer_type (type
), void_zero_node
);
1616 return build_indirect_ref (decl
, NULL
);
1619 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
1620 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
1621 binfo path from current_class_type to TYPE, or 0. */
1624 maybe_dummy_object (tree type
, tree
* binfop
)
1629 if (current_class_type
1630 && (binfo
= lookup_base (current_class_type
, type
,
1631 ba_unique
| ba_quiet
, NULL
)))
1632 context
= current_class_type
;
1635 /* Reference from a nested class member function. */
1637 binfo
= TYPE_BINFO (type
);
1643 if (current_class_ref
&& context
== current_class_type
1644 /* Kludge: Make sure that current_class_type is actually
1645 correct. It might not be if we're in the middle of
1646 tsubst_default_argument. */
1647 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref
)),
1648 current_class_type
))
1649 decl
= current_class_ref
;
1651 decl
= build_dummy_object (context
);
1656 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
1659 is_dummy_object (tree ob
)
1661 if (TREE_CODE (ob
) == INDIRECT_REF
)
1662 ob
= TREE_OPERAND (ob
, 0);
1663 return (TREE_CODE (ob
) == NOP_EXPR
1664 && TREE_OPERAND (ob
, 0) == void_zero_node
);
1667 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
1672 t
= strip_array_types (t
);
1674 if (t
== error_mark_node
)
1676 if (INTEGRAL_TYPE_P (t
))
1677 return 1; /* integral, character or enumeral type */
1678 if (FLOAT_TYPE_P (t
))
1681 return 1; /* pointer to non-member */
1682 if (TYPE_PTR_TO_MEMBER_P (t
))
1683 return 1; /* pointer to member */
1685 if (TREE_CODE (t
) == VECTOR_TYPE
)
1686 return 1; /* vectors are (small) arrays of scalars */
1688 if (! CLASS_TYPE_P (t
))
1689 return 0; /* other non-class type (reference or function) */
1690 if (CLASSTYPE_NON_POD_P (t
))
1695 /* Returns 1 iff zero initialization of type T means actually storing
1699 zero_init_p (tree t
)
1701 t
= strip_array_types (t
);
1703 if (t
== error_mark_node
)
1706 /* NULL pointers to data members are initialized with -1. */
1707 if (TYPE_PTRMEM_P (t
))
1710 /* Classes that contain types that can't be zero-initialized, cannot
1711 be zero-initialized themselves. */
1712 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
1718 /* Table of valid C++ attributes. */
1719 const struct attribute_spec cxx_attribute_table
[] =
1721 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
1722 { "java_interface", 0, 0, false, false, false, handle_java_interface_attribute
},
1723 { "com_interface", 0, 0, false, false, false, handle_com_interface_attribute
},
1724 { "init_priority", 1, 1, true, false, false, handle_init_priority_attribute
},
1725 { NULL
, 0, 0, false, false, false, NULL
}
1728 /* Handle a "java_interface" attribute; arguments as in
1729 struct attribute_spec.handler. */
1731 handle_java_interface_attribute (tree
* node
,
1733 tree args ATTRIBUTE_UNUSED
,
1738 || !CLASS_TYPE_P (*node
)
1739 || !TYPE_FOR_JAVA (*node
))
1741 error ("%qE attribute can only be applied to Java class definitions",
1743 *no_add_attrs
= true;
1746 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
1747 *node
= build_variant_type_copy (*node
);
1748 TYPE_JAVA_INTERFACE (*node
) = 1;
1753 /* Handle a "com_interface" attribute; arguments as in
1754 struct attribute_spec.handler. */
1756 handle_com_interface_attribute (tree
* node
,
1758 tree args ATTRIBUTE_UNUSED
,
1759 int flags ATTRIBUTE_UNUSED
,
1764 *no_add_attrs
= true;
1767 || !CLASS_TYPE_P (*node
)
1768 || *node
!= TYPE_MAIN_VARIANT (*node
))
1770 warning ("%qE attribute can only be applied to class definitions", name
);
1775 warning ("%qE is obsolete; g++ vtables are now COM-compatible by default",
1781 /* Handle an "init_priority" attribute; arguments as in
1782 struct attribute_spec.handler. */
1784 handle_init_priority_attribute (tree
* node
,
1787 int flags ATTRIBUTE_UNUSED
,
1790 tree initp_expr
= TREE_VALUE (args
);
1792 tree type
= TREE_TYPE (decl
);
1795 STRIP_NOPS (initp_expr
);
1797 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
1799 error ("requested init_priority is not an integer constant");
1800 *no_add_attrs
= true;
1804 pri
= TREE_INT_CST_LOW (initp_expr
);
1806 type
= strip_array_types (type
);
1808 if (decl
== NULL_TREE
1809 || TREE_CODE (decl
) != VAR_DECL
1810 || !TREE_STATIC (decl
)
1811 || DECL_EXTERNAL (decl
)
1812 || (TREE_CODE (type
) != RECORD_TYPE
1813 && TREE_CODE (type
) != UNION_TYPE
)
1814 /* Static objects in functions are initialized the
1815 first time control passes through that
1816 function. This is not precise enough to pin down an
1817 init_priority value, so don't allow it. */
1818 || current_function_decl
)
1820 error ("can only use %qE attribute on file-scope definitions "
1821 "of objects of class type", name
);
1822 *no_add_attrs
= true;
1826 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
1828 error ("requested init_priority is out of range");
1829 *no_add_attrs
= true;
1833 /* Check for init_priorities that are reserved for
1834 language and runtime support implementations.*/
1835 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
1838 ("requested init_priority is reserved for internal use");
1841 if (SUPPORTS_INIT_PRIORITY
)
1843 DECL_INIT_PRIORITY (decl
) = pri
;
1848 error ("%qE attribute is not supported on this platform", name
);
1849 *no_add_attrs
= true;
1854 /* Return a new TINST_LEVEL for DECL at location locus. */
1856 make_tinst_level (tree decl
, location_t locus
)
1858 tree tinst_level
= make_node (TINST_LEVEL
);
1859 TREE_CHAIN (tinst_level
) = NULL_TREE
;
1860 TINST_DECL (tinst_level
) = decl
;
1861 TINST_LOCATION (tinst_level
) = locus
;
1865 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
1866 thing pointed to by the constant. */
1869 make_ptrmem_cst (tree type
, tree member
)
1871 tree ptrmem_cst
= make_node (PTRMEM_CST
);
1872 TREE_TYPE (ptrmem_cst
) = type
;
1873 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
1877 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
1878 return an existing type of an appropriate type already exists. */
1881 cp_build_type_attribute_variant (tree type
, tree attributes
)
1885 new_type
= build_type_attribute_variant (type
, attributes
);
1886 if (TREE_CODE (new_type
) == FUNCTION_TYPE
1887 && (TYPE_RAISES_EXCEPTIONS (new_type
)
1888 != TYPE_RAISES_EXCEPTIONS (type
)))
1889 new_type
= build_exception_variant (new_type
,
1890 TYPE_RAISES_EXCEPTIONS (type
));
1894 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
1895 traversal. Called from walk_tree. */
1898 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
1899 void *data
, struct pointer_set_t
*pset
)
1901 enum tree_code code
= TREE_CODE (*tp
);
1902 location_t save_locus
;
1905 #define WALK_SUBTREE(NODE) \
1908 result = walk_tree (&(NODE), func, data, pset); \
1909 if (result) goto out; \
1913 /* Set input_location here so we get the right instantiation context
1914 if we call instantiate_decl from inlinable_function_p. */
1915 save_locus
= input_location
;
1916 if (EXPR_HAS_LOCATION (*tp
))
1917 input_location
= EXPR_LOCATION (*tp
);
1919 /* Not one of the easy cases. We must explicitly go through the
1925 case TEMPLATE_TEMPLATE_PARM
:
1926 case BOUND_TEMPLATE_TEMPLATE_PARM
:
1927 case UNBOUND_CLASS_TEMPLATE
:
1928 case TEMPLATE_PARM_INDEX
:
1929 case TEMPLATE_TYPE_PARM
:
1933 /* None of these have subtrees other than those already walked
1935 *walk_subtrees_p
= 0;
1939 WALK_SUBTREE (TINST_DECL (*tp
));
1940 *walk_subtrees_p
= 0;
1944 WALK_SUBTREE (TREE_TYPE (*tp
));
1945 *walk_subtrees_p
= 0;
1949 WALK_SUBTREE (TREE_PURPOSE (*tp
));
1953 WALK_SUBTREE (OVL_FUNCTION (*tp
));
1954 WALK_SUBTREE (OVL_CHAIN (*tp
));
1955 *walk_subtrees_p
= 0;
1959 if (TYPE_PTRMEMFUNC_P (*tp
))
1960 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp
));
1964 input_location
= save_locus
;
1968 /* We didn't find what we were looking for. */
1970 input_location
= save_locus
;
1976 /* Decide whether there are language-specific reasons to not inline a
1977 function as a tree. */
1980 cp_cannot_inline_tree_fn (tree
* fnp
)
1984 /* We can inline a template instantiation only if it's fully
1986 if (DECL_TEMPLATE_INFO (fn
)
1987 && TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn
)))
1989 /* Don't instantiate functions that are not going to be
1991 if (!DECL_INLINE (DECL_TEMPLATE_RESULT
1992 (template_for_substitution (fn
))))
1995 fn
= *fnp
= instantiate_decl (fn
, /*defer_ok=*/0, /*undefined_ok=*/0);
1997 if (TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn
)))
2001 if (flag_really_no_inline
2002 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn
)) == NULL
)
2005 /* Don't auto-inline anything that might not be bound within
2006 this unit of translation.
2007 Exclude comdat functions from this rule. While they can be bound
2008 to the other unit, they all must be the same. This is especially
2009 important so templates can inline. */
2010 if (!DECL_DECLARED_INLINE_P (fn
) && !(*targetm
.binds_local_p
) (fn
)
2011 && !DECL_COMDAT (fn
))
2013 DECL_UNINLINABLE (fn
) = 1;
2017 if (varargs_function_p (fn
))
2019 DECL_UNINLINABLE (fn
) = 1;
2023 if (! function_attribute_inlinable_p (fn
))
2025 DECL_UNINLINABLE (fn
) = 1;
2032 /* Add any pending functions other than the current function (already
2033 handled by the caller), that thus cannot be inlined, to FNS_P, then
2034 return the latest function added to the array, PREV_FN. */
2037 cp_add_pending_fn_decls (void* fns_p
, tree prev_fn
)
2039 varray_type
*fnsp
= (varray_type
*)fns_p
;
2040 struct saved_scope
*s
;
2042 for (s
= scope_chain
; s
; s
= s
->prev
)
2043 if (s
->function_decl
&& s
->function_decl
!= prev_fn
)
2045 VARRAY_PUSH_TREE (*fnsp
, s
->function_decl
);
2046 prev_fn
= s
->function_decl
;
2052 /* Determine whether VAR is a declaration of an automatic variable in
2056 cp_auto_var_in_fn_p (tree var
, tree fn
)
2058 return (DECL_P (var
) && DECL_CONTEXT (var
) == fn
2059 && nonstatic_local_decl_p (var
));
2062 /* Initialize tree.c. */
2067 list_hash_table
= htab_create_ggc (31, list_hash
, list_hash_eq
, NULL
);
2070 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
2071 is. Note that sfk_none is zero, so this function can be used as a
2072 predicate to test whether or not DECL is a special function. */
2074 special_function_kind
2075 special_function_p (tree decl
)
2077 /* Rather than doing all this stuff with magic names, we should
2078 probably have a field of type `special_function_kind' in
2079 DECL_LANG_SPECIFIC. */
2080 if (DECL_COPY_CONSTRUCTOR_P (decl
))
2081 return sfk_copy_constructor
;
2082 if (DECL_CONSTRUCTOR_P (decl
))
2083 return sfk_constructor
;
2084 if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
2085 return sfk_assignment_operator
;
2086 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
2087 return sfk_destructor
;
2088 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
2089 return sfk_complete_destructor
;
2090 if (DECL_BASE_DESTRUCTOR_P (decl
))
2091 return sfk_base_destructor
;
2092 if (DECL_DELETING_DESTRUCTOR_P (decl
))
2093 return sfk_deleting_destructor
;
2094 if (DECL_CONV_FN_P (decl
))
2095 return sfk_conversion
;
2100 /* Returns nonzero if TYPE is a character type, including wchar_t. */
2103 char_type_p (tree type
)
2105 return (same_type_p (type
, char_type_node
)
2106 || same_type_p (type
, unsigned_char_type_node
)
2107 || same_type_p (type
, signed_char_type_node
)
2108 || same_type_p (type
, wchar_type_node
));
2111 /* Returns the kind of linkage associated with the indicated DECL. Th
2112 value returned is as specified by the language standard; it is
2113 independent of implementation details regarding template
2114 instantiation, etc. For example, it is possible that a declaration
2115 to which this function assigns external linkage would not show up
2116 as a global symbol when you run `nm' on the resulting object file. */
2119 decl_linkage (tree decl
)
2121 /* This function doesn't attempt to calculate the linkage from first
2122 principles as given in [basic.link]. Instead, it makes use of
2123 the fact that we have already set TREE_PUBLIC appropriately, and
2124 then handles a few special cases. Ideally, we would calculate
2125 linkage first, and then transform that into a concrete
2128 /* Things that don't have names have no linkage. */
2129 if (!DECL_NAME (decl
))
2132 /* Things that are TREE_PUBLIC have external linkage. */
2133 if (TREE_PUBLIC (decl
))
2136 /* Some things that are not TREE_PUBLIC have external linkage, too.
2137 For example, on targets that don't have weak symbols, we make all
2138 template instantiations have internal linkage (in the object
2139 file), but the symbols should still be treated as having external
2140 linkage from the point of view of the language. */
2141 if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
2144 /* Things in local scope do not have linkage, if they don't have
2146 if (decl_function_context (decl
))
2149 /* Everything else has internal linkage. */
2153 /* EXP is an expression that we want to pre-evaluate. Returns via INITP an
2154 expression to perform the pre-evaluation, and returns directly an
2155 expression to use the precalculated result. */
2158 stabilize_expr (tree exp
, tree
* initp
)
2162 if (!TREE_SIDE_EFFECTS (exp
))
2164 init_expr
= NULL_TREE
;
2166 else if (!real_lvalue_p (exp
)
2167 || !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (exp
)))
2169 init_expr
= get_target_expr (exp
);
2170 exp
= TARGET_EXPR_SLOT (init_expr
);
2174 exp
= build_unary_op (ADDR_EXPR
, exp
, 1);
2175 init_expr
= get_target_expr (exp
);
2176 exp
= TARGET_EXPR_SLOT (init_expr
);
2177 exp
= build_indirect_ref (exp
, 0);
2184 /* Add NEW, an expression whose value we don't care about, after the
2185 similar expression ORIG. */
2188 add_stmt_to_compound (tree orig
, tree
new)
2190 if (!new || !TREE_SIDE_EFFECTS (new))
2192 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
2194 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new);
2197 /* Like stabilize_expr, but for a call whose args we want to
2201 stabilize_call (tree call
, tree
*initp
)
2203 tree inits
= NULL_TREE
;
2206 if (call
== error_mark_node
)
2209 gcc_assert (TREE_CODE (call
) == CALL_EXPR
2210 || TREE_CODE (call
) == AGGR_INIT_EXPR
);
2212 for (t
= TREE_OPERAND (call
, 1); t
; t
= TREE_CHAIN (t
))
2213 if (TREE_SIDE_EFFECTS (TREE_VALUE (t
)))
2216 TREE_VALUE (t
) = stabilize_expr (TREE_VALUE (t
), &init
);
2217 inits
= add_stmt_to_compound (inits
, init
);
2223 /* Like stabilize_expr, but for an initialization. If we are initializing
2224 an object of class type, we don't want to introduce an extra temporary,
2225 so we look past the TARGET_EXPR and stabilize the arguments of the call
2229 stabilize_init (tree init
, tree
*initp
)
2233 if (t
== error_mark_node
)
2236 if (TREE_CODE (t
) == INIT_EXPR
2237 && TREE_CODE (TREE_OPERAND (t
, 1)) != TARGET_EXPR
)
2238 TREE_OPERAND (t
, 1) = stabilize_expr (TREE_OPERAND (t
, 1), initp
);
2241 if (TREE_CODE (t
) == INIT_EXPR
)
2242 t
= TREE_OPERAND (t
, 1);
2243 if (TREE_CODE (t
) == TARGET_EXPR
)
2244 t
= TARGET_EXPR_INITIAL (t
);
2245 if (TREE_CODE (t
) == COMPOUND_EXPR
)
2247 if (TREE_CODE (t
) == CONSTRUCTOR
2248 && CONSTRUCTOR_ELTS (t
) == NULL_TREE
)
2250 /* Default-initialization. */
2255 /* If the initializer is a COND_EXPR, we can't preevaluate
2257 if (TREE_CODE (t
) == COND_EXPR
)
2260 stabilize_call (t
, initp
);
2266 /* Like "fold", but should be used whenever we might be processing the
2267 body of a template. */
2270 fold_if_not_in_template (tree expr
)
2272 /* In the body of a template, there is never any need to call
2273 "fold". We will call fold later when actually instantiating the
2274 template. Integral constant expressions in templates will be
2275 evaluated via fold_non_dependent_expr, as necessary. */
2276 return (processing_template_decl
? expr
: fold (expr
));
2280 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
2281 /* Complain that some language-specific thing hanging off a tree
2282 node has been accessed improperly. */
2285 lang_check_failed (const char* file
, int line
, const char* function
)
2287 internal_error ("lang_* check: failed in %s, at %s:%d",
2288 function
, trim_filename (file
), line
);
2290 #endif /* ENABLE_TREE_CHECKING */
2292 #include "gt-cp-tree.h"