1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Hacked by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
32 #include "insn-config.h"
33 #include "integrate.h"
34 #include "tree-inline.h"
38 #include "tree-flow.h"
41 static tree bot_manip (tree *, int *, void *);
42 static tree bot_replace (tree *, int *, void *);
43 static int list_hash_eq (const void *, const void *);
44 static hashval_t list_hash_pieces (tree, tree, tree);
45 static hashval_t list_hash (const void *);
46 static cp_lvalue_kind lvalue_p_1 (const_tree);
47 static tree build_target_expr (tree, tree);
48 static tree count_trees_r (tree *, int *, void *);
49 static tree verify_stmt_tree_r (tree *, int *, void *);
50 static tree build_local_temp (tree);
52 static tree handle_java_interface_attribute (tree *, tree, tree, int, bool *);
53 static tree handle_com_interface_attribute (tree *, tree, tree, int, bool *);
54 static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *);
56 /* If REF is an lvalue, returns the kind of lvalue that REF is.
57 Otherwise, returns clk_none. */
60 lvalue_p_1 (const_tree ref)
62 cp_lvalue_kind op1_lvalue_kind = clk_none;
63 cp_lvalue_kind op2_lvalue_kind = clk_none;
65 /* Expressions of reference type are sometimes wrapped in
66 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
67 representation, not part of the language, so we have to look
69 if (TREE_CODE (ref) == INDIRECT_REF
70 && TREE_CODE (TREE_TYPE (TREE_OPERAND (ref, 0)))
72 return lvalue_p_1 (TREE_OPERAND (ref, 0));
74 if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
76 /* unnamed rvalue references are rvalues */
77 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref))
78 && TREE_CODE (ref) != PARM_DECL
79 && TREE_CODE (ref) != VAR_DECL
80 && TREE_CODE (ref) != COMPONENT_REF)
83 /* lvalue references and named rvalue references are lvalues. */
87 if (ref == current_class_ptr)
90 switch (TREE_CODE (ref))
94 /* preincrements and predecrements are valid lvals, provided
95 what they refer to are valid lvals. */
96 case PREINCREMENT_EXPR:
97 case PREDECREMENT_EXPR:
99 case WITH_CLEANUP_EXPR:
102 return lvalue_p_1 (TREE_OPERAND (ref, 0));
105 op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0));
106 /* Look at the member designator. */
107 if (!op1_lvalue_kind)
109 else if (is_overloaded_fn (TREE_OPERAND (ref, 1)))
110 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
111 situations. If we're seeing a COMPONENT_REF, it's a non-static
112 member, so it isn't an lvalue. */
113 op1_lvalue_kind = clk_none;
114 else if (TREE_CODE (TREE_OPERAND (ref, 1)) != FIELD_DECL)
115 /* This can be IDENTIFIER_NODE in a template. */;
116 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref, 1)))
118 /* Clear the ordinary bit. If this object was a class
119 rvalue we want to preserve that information. */
120 op1_lvalue_kind &= ~clk_ordinary;
121 /* The lvalue is for a bitfield. */
122 op1_lvalue_kind |= clk_bitfield;
124 else if (DECL_PACKED (TREE_OPERAND (ref, 1)))
125 op1_lvalue_kind |= clk_packed;
127 return op1_lvalue_kind;
130 case COMPOUND_LITERAL_EXPR:
134 /* CONST_DECL without TREE_STATIC are enumeration values and
135 thus not lvalues. With TREE_STATIC they are used by ObjC++
136 in objc_build_string_object and need to be considered as
138 if (! TREE_STATIC (ref))
141 if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
142 && DECL_LANG_SPECIFIC (ref)
143 && DECL_IN_AGGR_P (ref))
149 if (TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
153 /* A currently unresolved scope ref. */
158 /* Disallow <? and >? as lvalues if either argument side-effects. */
159 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 0))
160 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 1)))
162 op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0));
163 op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1));
167 op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1)
168 ? TREE_OPERAND (ref, 1)
169 : TREE_OPERAND (ref, 0));
170 op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 2));
177 return lvalue_p_1 (TREE_OPERAND (ref, 1));
183 return (CLASS_TYPE_P (TREE_TYPE (ref)) ? clk_class : clk_none);
186 /* Any class-valued call would be wrapped in a TARGET_EXPR. */
190 /* All functions (except non-static-member functions) are
192 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref)
193 ? clk_none : clk_ordinary);
196 /* We now represent a reference to a single static member function
198 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
199 its argument unmodified and we assign it to a const_tree. */
200 return lvalue_p_1 (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref)));
202 case NON_DEPENDENT_EXPR:
203 /* We must consider NON_DEPENDENT_EXPRs to be lvalues so that
204 things like "&E" where "E" is an expression with a
205 non-dependent type work. It is safe to be lenient because an
206 error will be issued when the template is instantiated if "E"
214 /* If one operand is not an lvalue at all, then this expression is
216 if (!op1_lvalue_kind || !op2_lvalue_kind)
219 /* Otherwise, it's an lvalue, and it has all the odd properties
220 contributed by either operand. */
221 op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind;
222 /* It's not an ordinary lvalue if it involves any other kind. */
223 if ((op1_lvalue_kind & ~clk_ordinary) != clk_none)
224 op1_lvalue_kind &= ~clk_ordinary;
225 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
226 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
227 if ((op1_lvalue_kind & (clk_rvalueref|clk_class))
228 && (op1_lvalue_kind & (clk_bitfield|clk_packed)))
229 op1_lvalue_kind = clk_none;
230 return op1_lvalue_kind;
233 /* Returns the kind of lvalue that REF is, in the sense of
234 [basic.lval]. This function should really be named lvalue_p; it
235 computes the C++ definition of lvalue. */
238 real_lvalue_p (tree ref)
240 cp_lvalue_kind kind = lvalue_p_1 (ref);
241 if (kind & (clk_rvalueref|clk_class))
247 /* This differs from real_lvalue_p in that class rvalues are considered
251 lvalue_p (const_tree ref)
253 return (lvalue_p_1 (ref) != clk_none);
256 /* This differs from real_lvalue_p in that rvalues formed by dereferencing
257 rvalue references are considered rvalues. */
260 lvalue_or_rvalue_with_address_p (const_tree ref)
262 cp_lvalue_kind kind = lvalue_p_1 (ref);
263 if (kind & clk_class)
266 return (kind != clk_none);
269 /* Test whether DECL is a builtin that may appear in a
270 constant-expression. */
273 builtin_valid_in_constant_expr_p (const_tree decl)
275 /* At present BUILT_IN_CONSTANT_P is the only builtin we're allowing
276 in constant-expressions. We may want to add other builtins later. */
277 return DECL_IS_BUILTIN_CONSTANT_P (decl);
280 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
283 build_target_expr (tree decl, tree value)
287 #ifdef ENABLE_CHECKING
288 gcc_assert (VOID_TYPE_P (TREE_TYPE (value))
289 || TREE_TYPE (decl) == TREE_TYPE (value)
290 || useless_type_conversion_p (TREE_TYPE (decl),
294 t = build4 (TARGET_EXPR, TREE_TYPE (decl), decl, value,
295 cxx_maybe_build_cleanup (decl), NULL_TREE);
296 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
297 ignore the TARGET_EXPR. If there really turn out to be no
298 side-effects, then the optimizer should be able to get rid of
299 whatever code is generated anyhow. */
300 TREE_SIDE_EFFECTS (t) = 1;
305 /* Return an undeclared local temporary of type TYPE for use in building a
309 build_local_temp (tree type)
311 tree slot = build_decl (input_location,
312 VAR_DECL, NULL_TREE, type);
313 DECL_ARTIFICIAL (slot) = 1;
314 DECL_IGNORED_P (slot) = 1;
315 DECL_CONTEXT (slot) = current_function_decl;
316 layout_decl (slot, 0);
320 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
323 process_aggr_init_operands (tree t)
327 side_effects = TREE_SIDE_EFFECTS (t);
331 n = TREE_OPERAND_LENGTH (t);
332 for (i = 1; i < n; i++)
334 tree op = TREE_OPERAND (t, i);
335 if (op && TREE_SIDE_EFFECTS (op))
342 TREE_SIDE_EFFECTS (t) = side_effects;
345 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
346 FN, and SLOT. NARGS is the number of call arguments which are specified
347 as a tree array ARGS. */
350 build_aggr_init_array (tree return_type, tree fn, tree slot, int nargs,
356 t = build_vl_exp (AGGR_INIT_EXPR, nargs + 3);
357 TREE_TYPE (t) = return_type;
358 AGGR_INIT_EXPR_FN (t) = fn;
359 AGGR_INIT_EXPR_SLOT (t) = slot;
360 for (i = 0; i < nargs; i++)
361 AGGR_INIT_EXPR_ARG (t, i) = args[i];
362 process_aggr_init_operands (t);
366 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
367 target. TYPE is the type to be initialized.
369 Build an AGGR_INIT_EXPR to represent the initialization. This function
370 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
371 to initialize another object, whereas a TARGET_EXPR can either
372 initialize another object or create its own temporary object, and as a
373 result building up a TARGET_EXPR requires that the type's destructor be
377 build_aggr_init_expr (tree type, tree init)
384 /* Make sure that we're not trying to create an instance of an
386 abstract_virtuals_error (NULL_TREE, type);
388 if (TREE_CODE (init) == CALL_EXPR)
389 fn = CALL_EXPR_FN (init);
390 else if (TREE_CODE (init) == AGGR_INIT_EXPR)
391 fn = AGGR_INIT_EXPR_FN (init);
393 return convert (type, init);
395 is_ctor = (TREE_CODE (fn) == ADDR_EXPR
396 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
397 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0)));
399 /* We split the CALL_EXPR into its function and its arguments here.
400 Then, in expand_expr, we put them back together. The reason for
401 this is that this expression might be a default argument
402 expression. In that case, we need a new temporary every time the
403 expression is used. That's what break_out_target_exprs does; it
404 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
405 temporary slot. Then, expand_expr builds up a call-expression
406 using the new slot. */
408 /* If we don't need to use a constructor to create an object of this
409 type, don't mess with AGGR_INIT_EXPR. */
410 if (is_ctor || TREE_ADDRESSABLE (type))
412 slot = build_local_temp (type);
414 if (TREE_CODE(init) == CALL_EXPR)
415 rval = build_aggr_init_array (void_type_node, fn, slot,
416 call_expr_nargs (init),
417 CALL_EXPR_ARGP (init));
419 rval = build_aggr_init_array (void_type_node, fn, slot,
420 aggr_init_expr_nargs (init),
421 AGGR_INIT_EXPR_ARGP (init));
422 TREE_SIDE_EFFECTS (rval) = 1;
423 AGGR_INIT_VIA_CTOR_P (rval) = is_ctor;
431 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
432 target. TYPE is the type that this initialization should appear to
435 Build an encapsulation of the initialization to perform
436 and return it so that it can be processed by language-independent
437 and language-specific expression expanders. */
440 build_cplus_new (tree type, tree init)
442 tree rval = build_aggr_init_expr (type, init);
445 if (TREE_CODE (rval) == AGGR_INIT_EXPR)
446 slot = AGGR_INIT_EXPR_SLOT (rval);
447 else if (TREE_CODE (rval) == CALL_EXPR)
448 slot = build_local_temp (type);
452 rval = build_target_expr (slot, rval);
453 TARGET_EXPR_IMPLICIT_P (rval) = 1;
458 /* Return a TARGET_EXPR which expresses the direct-initialization of one
459 array from another. */
462 build_array_copy (tree init)
464 tree type = TREE_TYPE (init);
465 tree slot = build_local_temp (type);
466 init = build2 (VEC_INIT_EXPR, type, slot, init);
467 SET_EXPR_LOCATION (init, input_location);
468 init = build_target_expr (slot, init);
469 TARGET_EXPR_IMPLICIT_P (init) = 1;
474 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
478 build_target_expr_with_type (tree init, tree type)
480 gcc_assert (!VOID_TYPE_P (type));
482 if (TREE_CODE (init) == TARGET_EXPR)
484 else if (CLASS_TYPE_P (type) && !TYPE_HAS_TRIVIAL_INIT_REF (type)
485 && !VOID_TYPE_P (TREE_TYPE (init))
486 && TREE_CODE (init) != COND_EXPR
487 && TREE_CODE (init) != CONSTRUCTOR
488 && TREE_CODE (init) != VA_ARG_EXPR)
489 /* We need to build up a copy constructor call. A void initializer
490 means we're being called from bot_manip. COND_EXPR is a special
491 case because we already have copies on the arms and we don't want
492 another one here. A CONSTRUCTOR is aggregate initialization, which
493 is handled separately. A VA_ARG_EXPR is magic creation of an
494 aggregate; there's no additional work to be done. */
495 return force_rvalue (init);
497 return force_target_expr (type, init);
500 /* Like the above function, but without the checking. This function should
501 only be used by code which is deliberately trying to subvert the type
502 system, such as call_builtin_trap. */
505 force_target_expr (tree type, tree init)
509 gcc_assert (!VOID_TYPE_P (type));
511 slot = build_local_temp (type);
512 return build_target_expr (slot, init);
515 /* Like build_target_expr_with_type, but use the type of INIT. */
518 get_target_expr (tree init)
520 if (TREE_CODE (init) == AGGR_INIT_EXPR)
521 return build_target_expr (AGGR_INIT_EXPR_SLOT (init), init);
523 return build_target_expr_with_type (init, TREE_TYPE (init));
526 /* If EXPR is a bitfield reference, convert it to the declared type of
527 the bitfield, and return the resulting expression. Otherwise,
528 return EXPR itself. */
531 convert_bitfield_to_declared_type (tree expr)
535 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
537 expr = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type),
542 /* EXPR is being used in an rvalue context. Return a version of EXPR
543 that is marked as an rvalue. */
550 if (error_operand_p (expr))
553 expr = mark_rvalue_use (expr);
557 Non-class rvalues always have cv-unqualified types. */
558 type = TREE_TYPE (expr);
559 if (!CLASS_TYPE_P (type) && cv_qualified_p (type))
560 type = cv_unqualified (type);
562 /* We need to do this for rvalue refs as well to get the right answer
563 from decltype; see c++/36628. */
564 if (!processing_template_decl && lvalue_or_rvalue_with_address_p (expr))
565 expr = build1 (NON_LVALUE_EXPR, type, expr);
566 else if (type != TREE_TYPE (expr))
567 expr = build_nop (type, expr);
573 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
576 cplus_array_hash (const void* k)
579 const_tree const t = (const_tree) k;
581 hash = TYPE_UID (TREE_TYPE (t));
583 hash ^= TYPE_UID (TYPE_DOMAIN (t));
587 typedef struct cplus_array_info {
592 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
593 of type `cplus_array_info*'. */
596 cplus_array_compare (const void * k1, const void * k2)
598 const_tree const t1 = (const_tree) k1;
599 const cplus_array_info *const t2 = (const cplus_array_info*) k2;
601 return (TREE_TYPE (t1) == t2->type && TYPE_DOMAIN (t1) == t2->domain);
604 /* Hash table containing dependent array types, which are unsuitable for
605 the language-independent type hash table. */
606 static GTY ((param_is (union tree_node))) htab_t cplus_array_htab;
608 /* Like build_array_type, but handle special C++ semantics. */
611 build_cplus_array_type (tree elt_type, tree index_type)
615 if (elt_type == error_mark_node || index_type == error_mark_node)
616 return error_mark_node;
618 if (processing_template_decl
619 && (dependent_type_p (elt_type)
620 || (index_type && !TREE_CONSTANT (TYPE_MAX_VALUE (index_type)))))
623 cplus_array_info cai;
626 if (cplus_array_htab == NULL)
627 cplus_array_htab = htab_create_ggc (61, &cplus_array_hash,
628 &cplus_array_compare, NULL);
630 hash = TYPE_UID (elt_type);
632 hash ^= TYPE_UID (index_type);
634 cai.domain = index_type;
636 e = htab_find_slot_with_hash (cplus_array_htab, &cai, hash, INSERT);
638 /* We have found the type: we're done. */
642 /* Build a new array type. */
643 t = cxx_make_type (ARRAY_TYPE);
644 TREE_TYPE (t) = elt_type;
645 TYPE_DOMAIN (t) = index_type;
647 /* Store it in the hash table. */
650 /* Set the canonical type for this new node. */
651 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
652 || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
653 SET_TYPE_STRUCTURAL_EQUALITY (t);
654 else if (TYPE_CANONICAL (elt_type) != elt_type
656 && TYPE_CANONICAL (index_type) != index_type))
658 = build_cplus_array_type
659 (TYPE_CANONICAL (elt_type),
660 index_type ? TYPE_CANONICAL (index_type) : index_type);
662 TYPE_CANONICAL (t) = t;
666 t = build_array_type (elt_type, index_type);
668 /* We want TYPE_MAIN_VARIANT of an array to strip cv-quals from the
669 element type as well, so fix it up if needed. */
670 if (elt_type != TYPE_MAIN_VARIANT (elt_type))
672 tree m = build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type),
674 if (TYPE_MAIN_VARIANT (t) != m)
676 TYPE_MAIN_VARIANT (t) = m;
677 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
678 TYPE_NEXT_VARIANT (m) = t;
682 /* Push these needs up so that initialization takes place
684 TYPE_NEEDS_CONSTRUCTING (t)
685 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
686 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
687 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
691 /* Return an ARRAY_TYPE with element type ELT and length N. */
694 build_array_of_n_type (tree elt, int n)
696 return build_cplus_array_type (elt, build_index_type (size_int (n - 1)));
699 /* Return a reference type node referring to TO_TYPE. If RVAL is
700 true, return an rvalue reference type, otherwise return an lvalue
701 reference type. If a type node exists, reuse it, otherwise create
704 cp_build_reference_type (tree to_type, bool rval)
707 lvalue_ref = build_reference_type (to_type);
711 /* This code to create rvalue reference types is based on and tied
712 to the code creating lvalue reference types in the middle-end
713 functions build_reference_type_for_mode and build_reference_type.
715 It works by putting the rvalue reference type nodes after the
716 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
717 they will effectively be ignored by the middle end. */
719 for (t = lvalue_ref; (t = TYPE_NEXT_REF_TO (t)); )
720 if (TYPE_REF_IS_RVALUE (t))
723 t = build_distinct_type_copy (lvalue_ref);
725 TYPE_REF_IS_RVALUE (t) = true;
726 TYPE_NEXT_REF_TO (t) = TYPE_NEXT_REF_TO (lvalue_ref);
727 TYPE_NEXT_REF_TO (lvalue_ref) = t;
729 if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
730 SET_TYPE_STRUCTURAL_EQUALITY (t);
731 else if (TYPE_CANONICAL (to_type) != to_type)
733 = cp_build_reference_type (TYPE_CANONICAL (to_type), rval);
735 TYPE_CANONICAL (t) = t;
743 /* Returns EXPR cast to rvalue reference type, like std::move. */
748 tree type = TREE_TYPE (expr);
749 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
750 type = cp_build_reference_type (type, /*rval*/true);
751 return build_static_cast (type, expr, tf_warning_or_error);
754 /* Used by the C++ front end to build qualified array types. However,
755 the C version of this function does not properly maintain canonical
756 types (which are not used in C). */
758 c_build_qualified_type (tree type, int type_quals)
760 return cp_build_qualified_type (type, type_quals);
764 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
765 arrays correctly. In particular, if TYPE is an array of T's, and
766 TYPE_QUALS is non-empty, returns an array of qualified T's.
768 FLAGS determines how to deal with ill-formed qualifications. If
769 tf_ignore_bad_quals is set, then bad qualifications are dropped
770 (this is permitted if TYPE was introduced via a typedef or template
771 type parameter). If bad qualifications are dropped and tf_warning
772 is set, then a warning is issued for non-const qualifications. If
773 tf_ignore_bad_quals is not set and tf_error is not set, we
774 return error_mark_node. Otherwise, we issue an error, and ignore
777 Qualification of a reference type is valid when the reference came
778 via a typedef or template type argument. [dcl.ref] No such
779 dispensation is provided for qualifying a function type. [dcl.fct]
780 DR 295 queries this and the proposed resolution brings it into line
781 with qualifying a reference. We implement the DR. We also behave
782 in a similar manner for restricting non-pointer types. */
785 cp_build_qualified_type_real (tree type,
787 tsubst_flags_t complain)
790 int bad_quals = TYPE_UNQUALIFIED;
792 if (type == error_mark_node)
795 if (type_quals == cp_type_quals (type))
798 if (TREE_CODE (type) == ARRAY_TYPE)
800 /* In C++, the qualification really applies to the array element
801 type. Obtain the appropriately qualified element type. */
804 = cp_build_qualified_type_real (TREE_TYPE (type),
808 if (element_type == error_mark_node)
809 return error_mark_node;
811 /* See if we already have an identically qualified type. Tests
812 should be equivalent to those in check_qualified_type. */
813 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
814 if (cp_type_quals (t) == type_quals
815 && TYPE_NAME (t) == TYPE_NAME (type)
816 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
817 && attribute_list_equal (TYPE_ATTRIBUTES (t),
818 TYPE_ATTRIBUTES (type)))
823 t = build_cplus_array_type (element_type, TYPE_DOMAIN (type));
825 /* Keep the typedef name. */
826 if (TYPE_NAME (t) != TYPE_NAME (type))
828 t = build_variant_type_copy (t);
829 TYPE_NAME (t) = TYPE_NAME (type);
833 /* Even if we already had this variant, we update
834 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
835 they changed since the variant was originally created.
837 This seems hokey; if there is some way to use a previous
838 variant *without* coming through here,
839 TYPE_NEEDS_CONSTRUCTING will never be updated. */
840 TYPE_NEEDS_CONSTRUCTING (t)
841 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));
842 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
843 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));
846 else if (TYPE_PTRMEMFUNC_P (type))
848 /* For a pointer-to-member type, we can't just return a
849 cv-qualified version of the RECORD_TYPE. If we do, we
850 haven't changed the field that contains the actual pointer to
851 a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong. */
854 t = TYPE_PTRMEMFUNC_FN_TYPE (type);
855 t = cp_build_qualified_type_real (t, type_quals, complain);
856 return build_ptrmemfunc_type (t);
858 else if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
860 tree t = PACK_EXPANSION_PATTERN (type);
862 t = cp_build_qualified_type_real (t, type_quals, complain);
863 return make_pack_expansion (t);
866 /* A reference or method type shall not be cv-qualified.
867 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
868 (in CD1) we always ignore extra cv-quals on functions. */
869 if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)
870 && (TREE_CODE (type) == REFERENCE_TYPE
871 || TREE_CODE (type) == FUNCTION_TYPE
872 || TREE_CODE (type) == METHOD_TYPE))
874 if (TREE_CODE (type) == REFERENCE_TYPE)
875 bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
876 type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
879 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
880 if (TREE_CODE (type) == FUNCTION_TYPE)
881 type_quals |= type_memfn_quals (type);
883 /* A restrict-qualified type must be a pointer (or reference)
884 to object or incomplete type. */
885 if ((type_quals & TYPE_QUAL_RESTRICT)
886 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
887 && TREE_CODE (type) != TYPENAME_TYPE
888 && !POINTER_TYPE_P (type))
890 bad_quals |= TYPE_QUAL_RESTRICT;
891 type_quals &= ~TYPE_QUAL_RESTRICT;
894 if (bad_quals == TYPE_UNQUALIFIED
895 || (complain & tf_ignore_bad_quals))
897 else if (!(complain & tf_error))
898 return error_mark_node;
901 tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
902 error ("%qV qualifiers cannot be applied to %qT",
906 /* Retrieve (or create) the appropriately qualified variant. */
907 result = build_qualified_type (type, type_quals);
909 /* If this was a pointer-to-method type, and we just made a copy,
910 then we need to unshare the record that holds the cached
911 pointer-to-member-function type, because these will be distinct
912 between the unqualified and qualified types. */
914 && TREE_CODE (type) == POINTER_TYPE
915 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
916 && TYPE_LANG_SPECIFIC (result) == TYPE_LANG_SPECIFIC (type))
917 TYPE_LANG_SPECIFIC (result) = NULL;
919 /* We may also have ended up building a new copy of the canonical
920 type of a pointer-to-method type, which could have the same
921 sharing problem described above. */
922 if (TYPE_CANONICAL (result) != TYPE_CANONICAL (type)
923 && TREE_CODE (type) == POINTER_TYPE
924 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
925 && (TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result))
926 == TYPE_LANG_SPECIFIC (TYPE_CANONICAL (type))))
927 TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result)) = NULL;
932 /* Return TYPE with const and volatile removed. */
935 cv_unqualified (tree type)
939 if (type == error_mark_node)
942 quals = cp_type_quals (type);
943 quals &= ~(TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE);
944 return cp_build_qualified_type (type, quals);
947 /* Builds a qualified variant of T that is not a typedef variant.
948 E.g. consider the following declarations:
949 typedef const int ConstInt;
950 typedef ConstInt* PtrConstInt;
951 If T is PtrConstInt, this function returns a type representing
953 In other words, if T is a typedef, the function returns the underlying type.
954 The cv-qualification and attributes of the type returned match the
956 They will always be compatible types.
957 The returned type is built so that all of its subtypes
958 recursively have their typedefs stripped as well.
960 This is different from just returning TYPE_CANONICAL (T)
961 Because of several reasons:
962 * If T is a type that needs structural equality
963 its TYPE_CANONICAL (T) will be NULL.
964 * TYPE_CANONICAL (T) desn't carry type attributes
965 and looses template parameter names. */
968 strip_typedefs (tree t)
970 tree result = NULL, type = NULL, t0 = NULL;
972 if (!t || t == error_mark_node || t == TYPE_CANONICAL (t))
975 gcc_assert (TYPE_P (t));
977 switch (TREE_CODE (t))
980 type = strip_typedefs (TREE_TYPE (t));
981 result = build_pointer_type (type);
984 type = strip_typedefs (TREE_TYPE (t));
985 result = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
988 t0 = strip_typedefs (TYPE_OFFSET_BASETYPE (t));
989 type = strip_typedefs (TREE_TYPE (t));
990 result = build_offset_type (t0, type);
993 if (TYPE_PTRMEMFUNC_P (t))
995 t0 = strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t));
996 result = build_ptrmemfunc_type (t0);
1000 type = strip_typedefs (TREE_TYPE (t));
1001 t0 = strip_typedefs (TYPE_DOMAIN (t));;
1002 result = build_cplus_array_type (type, t0);
1007 tree arg_types = NULL, arg_node, arg_type;
1008 for (arg_node = TYPE_ARG_TYPES (t);
1010 arg_node = TREE_CHAIN (arg_node))
1012 if (arg_node == void_list_node)
1014 arg_type = strip_typedefs (TREE_VALUE (arg_node));
1015 gcc_assert (arg_type);
1018 tree_cons (TREE_PURPOSE (arg_node), arg_type, arg_types);
1022 arg_types = nreverse (arg_types);
1024 /* A list of parameters not ending with an ellipsis
1025 must end with void_list_node. */
1027 arg_types = chainon (arg_types, void_list_node);
1029 type = strip_typedefs (TREE_TYPE (t));
1030 if (TREE_CODE (t) == METHOD_TYPE)
1032 tree class_type = TREE_TYPE (TREE_VALUE (arg_types));
1033 gcc_assert (class_type);
1035 build_method_type_directly (class_type, type,
1036 TREE_CHAIN (arg_types));
1040 result = build_function_type (type,
1042 result = apply_memfn_quals (result, type_memfn_quals (t));
1045 if (TYPE_RAISES_EXCEPTIONS (t))
1046 result = build_exception_variant (result,
1047 TYPE_RAISES_EXCEPTIONS (t));
1055 result = TYPE_MAIN_VARIANT (t);
1056 if (TYPE_ATTRIBUTES (t))
1057 result = cp_build_type_attribute_variant (result, TYPE_ATTRIBUTES (t));
1058 return cp_build_qualified_type (result, cp_type_quals (t));
1061 /* Returns true iff TYPE is a type variant created for a typedef. */
1064 typedef_variant_p (tree type)
1066 return is_typedef_decl (TYPE_NAME (type));
1069 /* Setup a TYPE_DECL node as a typedef representation.
1070 See comments of set_underlying_type in c-common.c. */
1073 cp_set_underlying_type (tree t)
1075 set_underlying_type (t);
1076 /* If T is a template type parm, make it require structural equality.
1077 This is useful when comparing two template type parms,
1078 because it forces the comparison of the template parameters of their
1080 if (TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
1081 SET_TYPE_STRUCTURAL_EQUALITY (TREE_TYPE (t));
1085 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1086 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1087 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1088 VIRT indicates whether TYPE is inherited virtually or not.
1089 IGO_PREV points at the previous binfo of the inheritance graph
1090 order chain. The newly copied binfo's TREE_CHAIN forms this
1093 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1094 correct order. That is in the order the bases themselves should be
1097 The BINFO_INHERITANCE of a virtual base class points to the binfo
1098 of the most derived type. ??? We could probably change this so that
1099 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1100 remove a field. They currently can only differ for primary virtual
1104 copy_binfo (tree binfo, tree type, tree t, tree *igo_prev, int virt)
1110 /* See if we've already made this virtual base. */
1111 new_binfo = binfo_for_vbase (type, t);
1116 new_binfo = make_tree_binfo (binfo ? BINFO_N_BASE_BINFOS (binfo) : 0);
1117 BINFO_TYPE (new_binfo) = type;
1119 /* Chain it into the inheritance graph. */
1120 TREE_CHAIN (*igo_prev) = new_binfo;
1121 *igo_prev = new_binfo;
1128 gcc_assert (!BINFO_DEPENDENT_BASE_P (binfo));
1129 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type));
1131 BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo);
1132 BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo);
1134 /* We do not need to copy the accesses, as they are read only. */
1135 BINFO_BASE_ACCESSES (new_binfo) = BINFO_BASE_ACCESSES (binfo);
1137 /* Recursively copy base binfos of BINFO. */
1138 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1140 tree new_base_binfo;
1142 gcc_assert (!BINFO_DEPENDENT_BASE_P (base_binfo));
1143 new_base_binfo = copy_binfo (base_binfo, BINFO_TYPE (base_binfo),
1145 BINFO_VIRTUAL_P (base_binfo));
1147 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo))
1148 BINFO_INHERITANCE_CHAIN (new_base_binfo) = new_binfo;
1149 BINFO_BASE_APPEND (new_binfo, new_base_binfo);
1153 BINFO_DEPENDENT_BASE_P (new_binfo) = 1;
1157 /* Push it onto the list after any virtual bases it contains
1158 will have been pushed. */
1159 VEC_quick_push (tree, CLASSTYPE_VBASECLASSES (t), new_binfo);
1160 BINFO_VIRTUAL_P (new_binfo) = 1;
1161 BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t);
1167 /* Hashing of lists so that we don't make duplicates.
1168 The entry point is `list_hash_canon'. */
1170 /* Now here is the hash table. When recording a list, it is added
1171 to the slot whose index is the hash code mod the table size.
1172 Note that the hash table is used for several kinds of lists.
1173 While all these live in the same table, they are completely independent,
1174 and the hash code is computed differently for each of these. */
1176 static GTY ((param_is (union tree_node))) htab_t list_hash_table;
1185 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1186 for a node we are thinking about adding). */
1189 list_hash_eq (const void* entry, const void* data)
1191 const_tree const t = (const_tree) entry;
1192 const struct list_proxy *const proxy = (const struct list_proxy *) data;
1194 return (TREE_VALUE (t) == proxy->value
1195 && TREE_PURPOSE (t) == proxy->purpose
1196 && TREE_CHAIN (t) == proxy->chain);
1199 /* Compute a hash code for a list (chain of TREE_LIST nodes
1200 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1201 TREE_COMMON slots), by adding the hash codes of the individual entries. */
1204 list_hash_pieces (tree purpose, tree value, tree chain)
1206 hashval_t hashcode = 0;
1209 hashcode += TREE_HASH (chain);
1212 hashcode += TREE_HASH (value);
1216 hashcode += TREE_HASH (purpose);
1222 /* Hash an already existing TREE_LIST. */
1225 list_hash (const void* p)
1227 const_tree const t = (const_tree) p;
1228 return list_hash_pieces (TREE_PURPOSE (t),
1233 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1234 object for an identical list if one already exists. Otherwise, build a
1235 new one, and record it as the canonical object. */
1238 hash_tree_cons (tree purpose, tree value, tree chain)
1242 struct list_proxy proxy;
1244 /* Hash the list node. */
1245 hashcode = list_hash_pieces (purpose, value, chain);
1246 /* Create a proxy for the TREE_LIST we would like to create. We
1247 don't actually create it so as to avoid creating garbage. */
1248 proxy.purpose = purpose;
1249 proxy.value = value;
1250 proxy.chain = chain;
1251 /* See if it is already in the table. */
1252 slot = htab_find_slot_with_hash (list_hash_table, &proxy, hashcode,
1254 /* If not, create a new node. */
1256 *slot = tree_cons (purpose, value, chain);
1257 return (tree) *slot;
1260 /* Constructor for hashed lists. */
1263 hash_tree_chain (tree value, tree chain)
1265 return hash_tree_cons (NULL_TREE, value, chain);
1269 debug_binfo (tree elem)
1274 fprintf (stderr, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
1276 TYPE_NAME_STRING (BINFO_TYPE (elem)),
1277 TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
1278 debug_tree (BINFO_TYPE (elem));
1279 if (BINFO_VTABLE (elem))
1280 fprintf (stderr, "vtable decl \"%s\"\n",
1281 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem))));
1283 fprintf (stderr, "no vtable decl yet\n");
1284 fprintf (stderr, "virtuals:\n");
1285 virtuals = BINFO_VIRTUALS (elem);
1290 tree fndecl = TREE_VALUE (virtuals);
1291 fprintf (stderr, "%s [%ld =? %ld]\n",
1292 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
1293 (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
1295 virtuals = TREE_CHAIN (virtuals);
1299 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
1300 the type of the result expression, if known, or NULL_TREE if the
1301 resulting expression is type-dependent. If TEMPLATE_P is true,
1302 NAME is known to be a template because the user explicitly used the
1303 "template" keyword after the "::".
1305 All SCOPE_REFs should be built by use of this function. */
1308 build_qualified_name (tree type, tree scope, tree name, bool template_p)
1311 if (type == error_mark_node
1312 || scope == error_mark_node
1313 || name == error_mark_node)
1314 return error_mark_node;
1315 t = build2 (SCOPE_REF, type, scope, name);
1316 QUALIFIED_NAME_IS_TEMPLATE (t) = template_p;
1318 t = convert_from_reference (t);
1322 /* Returns nonzero if X is an expression for a (possibly overloaded)
1323 function. If "f" is a function or function template, "f", "c->f",
1324 "c.f", "C::f", and "f<int>" will all be considered possibly
1325 overloaded functions. Returns 2 if the function is actually
1326 overloaded, i.e., if it is impossible to know the type of the
1327 function without performing overload resolution. */
1330 is_overloaded_fn (tree x)
1332 /* A baselink is also considered an overloaded function. */
1333 if (TREE_CODE (x) == OFFSET_REF
1334 || TREE_CODE (x) == COMPONENT_REF)
1335 x = TREE_OPERAND (x, 1);
1337 x = BASELINK_FUNCTIONS (x);
1338 if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
1339 x = TREE_OPERAND (x, 0);
1340 if (DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x))
1341 || (TREE_CODE (x) == OVERLOAD && OVL_CHAIN (x)))
1343 return (TREE_CODE (x) == FUNCTION_DECL
1344 || TREE_CODE (x) == OVERLOAD);
1347 /* Returns true iff X is an expression for an overloaded function
1348 whose type cannot be known without performing overload
1352 really_overloaded_fn (tree x)
1354 return is_overloaded_fn (x) == 2;
1360 gcc_assert (is_overloaded_fn (from));
1361 /* A baselink is also considered an overloaded function. */
1362 if (TREE_CODE (from) == OFFSET_REF
1363 || TREE_CODE (from) == COMPONENT_REF)
1364 from = TREE_OPERAND (from, 1);
1365 if (BASELINK_P (from))
1366 from = BASELINK_FUNCTIONS (from);
1367 if (TREE_CODE (from) == TEMPLATE_ID_EXPR)
1368 from = TREE_OPERAND (from, 0);
1373 get_first_fn (tree from)
1375 return OVL_CURRENT (get_fns (from));
1378 /* Return a new OVL node, concatenating it with the old one. */
1381 ovl_cons (tree decl, tree chain)
1383 tree result = make_node (OVERLOAD);
1384 TREE_TYPE (result) = unknown_type_node;
1385 OVL_FUNCTION (result) = decl;
1386 TREE_CHAIN (result) = chain;
1391 /* Build a new overloaded function. If this is the first one,
1392 just return it; otherwise, ovl_cons the _DECLs */
1395 build_overload (tree decl, tree chain)
1397 if (! chain && TREE_CODE (decl) != TEMPLATE_DECL)
1399 if (chain && TREE_CODE (chain) != OVERLOAD)
1400 chain = ovl_cons (chain, NULL_TREE);
1401 return ovl_cons (decl, chain);
1405 #define PRINT_RING_SIZE 4
1408 cxx_printable_name_internal (tree decl, int v, bool translate)
1410 static unsigned int uid_ring[PRINT_RING_SIZE];
1411 static char *print_ring[PRINT_RING_SIZE];
1412 static bool trans_ring[PRINT_RING_SIZE];
1413 static int ring_counter;
1416 /* Only cache functions. */
1418 || TREE_CODE (decl) != FUNCTION_DECL
1419 || DECL_LANG_SPECIFIC (decl) == 0)
1420 return lang_decl_name (decl, v, translate);
1422 /* See if this print name is lying around. */
1423 for (i = 0; i < PRINT_RING_SIZE; i++)
1424 if (uid_ring[i] == DECL_UID (decl) && translate == trans_ring[i])
1425 /* yes, so return it. */
1426 return print_ring[i];
1428 if (++ring_counter == PRINT_RING_SIZE)
1431 if (current_function_decl != NULL_TREE)
1433 /* There may be both translated and untranslated versions of the
1435 for (i = 0; i < 2; i++)
1437 if (uid_ring[ring_counter] == DECL_UID (current_function_decl))
1439 if (ring_counter == PRINT_RING_SIZE)
1442 gcc_assert (uid_ring[ring_counter] != DECL_UID (current_function_decl));
1445 if (print_ring[ring_counter])
1446 free (print_ring[ring_counter]);
1448 print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v, translate));
1449 uid_ring[ring_counter] = DECL_UID (decl);
1450 trans_ring[ring_counter] = translate;
1451 return print_ring[ring_counter];
1455 cxx_printable_name (tree decl, int v)
1457 return cxx_printable_name_internal (decl, v, false);
1461 cxx_printable_name_translate (tree decl, int v)
1463 return cxx_printable_name_internal (decl, v, true);
1466 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1467 listed in RAISES. */
1470 build_exception_variant (tree type, tree raises)
1472 tree v = TYPE_MAIN_VARIANT (type);
1473 int type_quals = TYPE_QUALS (type);
1475 for (; v; v = TYPE_NEXT_VARIANT (v))
1476 if (check_qualified_type (v, type, type_quals)
1477 && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (v), 1))
1480 /* Need to build a new variant. */
1481 v = build_variant_type_copy (type);
1482 TYPE_RAISES_EXCEPTIONS (v) = raises;
1486 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
1487 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
1491 bind_template_template_parm (tree t, tree newargs)
1493 tree decl = TYPE_NAME (t);
1496 t2 = cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM);
1497 decl = build_decl (input_location,
1498 TYPE_DECL, DECL_NAME (decl), NULL_TREE);
1500 /* These nodes have to be created to reflect new TYPE_DECL and template
1502 TEMPLATE_TYPE_PARM_INDEX (t2) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t));
1503 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2)) = decl;
1504 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
1505 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t), newargs);
1507 TREE_TYPE (decl) = t2;
1508 TYPE_NAME (t2) = decl;
1509 TYPE_STUB_DECL (t2) = decl;
1511 SET_TYPE_STRUCTURAL_EQUALITY (t2);
1516 /* Called from count_trees via walk_tree. */
1519 count_trees_r (tree *tp, int *walk_subtrees, void *data)
1529 /* Debugging function for measuring the rough complexity of a tree
1533 count_trees (tree t)
1536 cp_walk_tree_without_duplicates (&t, count_trees_r, &n_trees);
1540 /* Called from verify_stmt_tree via walk_tree. */
1543 verify_stmt_tree_r (tree* tp,
1544 int* walk_subtrees ATTRIBUTE_UNUSED ,
1548 htab_t *statements = (htab_t *) data;
1551 if (!STATEMENT_CODE_P (TREE_CODE (t)))
1554 /* If this statement is already present in the hash table, then
1555 there is a circularity in the statement tree. */
1556 gcc_assert (!htab_find (*statements, t));
1558 slot = htab_find_slot (*statements, t, INSERT);
1564 /* Debugging function to check that the statement T has not been
1565 corrupted. For now, this function simply checks that T contains no
1569 verify_stmt_tree (tree t)
1572 statements = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1573 cp_walk_tree (&t, verify_stmt_tree_r, &statements, NULL);
1574 htab_delete (statements);
1577 /* Check if the type T depends on a type with no linkage and if so, return
1578 it. If RELAXED_P then do not consider a class type declared within
1579 a vague-linkage function to have no linkage. */
1582 no_linkage_check (tree t, bool relaxed_p)
1586 /* There's no point in checking linkage on template functions; we
1587 can't know their complete types. */
1588 if (processing_template_decl)
1591 switch (TREE_CODE (t))
1594 if (TYPE_PTRMEMFUNC_P (t))
1596 /* Lambda types that don't have mangling scope have no linkage. We
1597 check CLASSTYPE_LAMBDA_EXPR here rather than LAMBDA_TYPE_P because
1598 when we get here from pushtag none of the lambda information is
1599 set up yet, so we want to assume that the lambda has linkage and
1600 fix it up later if not. */
1601 if (CLASSTYPE_LAMBDA_EXPR (t)
1602 && LAMBDA_TYPE_EXTRA_SCOPE (t) == NULL_TREE)
1606 if (!CLASS_TYPE_P (t))
1610 /* Only treat anonymous types as having no linkage if they're at
1611 namespace scope. This is core issue 966. */
1612 if (TYPE_ANONYMOUS_P (t) && TYPE_NAMESPACE_SCOPE_P (t))
1615 for (r = CP_TYPE_CONTEXT (t); ; )
1617 /* If we're a nested type of a !TREE_PUBLIC class, we might not
1618 have linkage, or we might just be in an anonymous namespace.
1619 If we're in a TREE_PUBLIC class, we have linkage. */
1620 if (TYPE_P (r) && !TREE_PUBLIC (TYPE_NAME (r)))
1621 return no_linkage_check (TYPE_CONTEXT (t), relaxed_p);
1622 else if (TREE_CODE (r) == FUNCTION_DECL)
1624 if (!relaxed_p || !vague_linkage_p (r))
1627 r = CP_DECL_CONTEXT (r);
1637 case REFERENCE_TYPE:
1638 return no_linkage_check (TREE_TYPE (t), relaxed_p);
1642 r = no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t),
1646 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t), relaxed_p);
1649 r = no_linkage_check (TYPE_METHOD_BASETYPE (t), relaxed_p);
1656 for (parm = TYPE_ARG_TYPES (t);
1657 parm && parm != void_list_node;
1658 parm = TREE_CHAIN (parm))
1660 r = no_linkage_check (TREE_VALUE (parm), relaxed_p);
1664 return no_linkage_check (TREE_TYPE (t), relaxed_p);
1672 #ifdef GATHER_STATISTICS
1673 extern int depth_reached;
1677 cxx_print_statistics (void)
1679 print_search_statistics ();
1680 print_class_statistics ();
1681 print_template_statistics ();
1682 #ifdef GATHER_STATISTICS
1683 fprintf (stderr, "maximum template instantiation depth reached: %d\n",
1688 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1689 (which is an ARRAY_TYPE). This counts only elements of the top
1693 array_type_nelts_top (tree type)
1695 return fold_build2_loc (input_location,
1696 PLUS_EXPR, sizetype,
1697 array_type_nelts (type),
1701 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1702 (which is an ARRAY_TYPE). This one is a recursive count of all
1703 ARRAY_TYPEs that are clumped together. */
1706 array_type_nelts_total (tree type)
1708 tree sz = array_type_nelts_top (type);
1709 type = TREE_TYPE (type);
1710 while (TREE_CODE (type) == ARRAY_TYPE)
1712 tree n = array_type_nelts_top (type);
1713 sz = fold_build2_loc (input_location,
1714 MULT_EXPR, sizetype, sz, n);
1715 type = TREE_TYPE (type);
1720 /* Called from break_out_target_exprs via mapcar. */
1723 bot_manip (tree* tp, int* walk_subtrees, void* data)
1725 splay_tree target_remap = ((splay_tree) data);
1728 if (!TYPE_P (t) && TREE_CONSTANT (t))
1730 /* There can't be any TARGET_EXPRs or their slot variables below
1731 this point. We used to check !TREE_SIDE_EFFECTS, but then we
1732 failed to copy an ADDR_EXPR of the slot VAR_DECL. */
1736 if (TREE_CODE (t) == TARGET_EXPR)
1740 if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
1741 u = build_cplus_new (TREE_TYPE (t), TREE_OPERAND (t, 1));
1743 u = build_target_expr_with_type (TREE_OPERAND (t, 1), TREE_TYPE (t));
1745 /* Map the old variable to the new one. */
1746 splay_tree_insert (target_remap,
1747 (splay_tree_key) TREE_OPERAND (t, 0),
1748 (splay_tree_value) TREE_OPERAND (u, 0));
1750 TREE_OPERAND (u, 1) = break_out_target_exprs (TREE_OPERAND (u, 1));
1752 /* Replace the old expression with the new version. */
1754 /* We don't have to go below this point; the recursive call to
1755 break_out_target_exprs will have handled anything below this
1761 /* Make a copy of this node. */
1762 return copy_tree_r (tp, walk_subtrees, NULL);
1765 /* Replace all remapped VAR_DECLs in T with their new equivalents.
1766 DATA is really a splay-tree mapping old variables to new
1770 bot_replace (tree* t,
1771 int* walk_subtrees ATTRIBUTE_UNUSED ,
1774 splay_tree target_remap = ((splay_tree) data);
1776 if (TREE_CODE (*t) == VAR_DECL)
1778 splay_tree_node n = splay_tree_lookup (target_remap,
1779 (splay_tree_key) *t);
1781 *t = (tree) n->value;
1787 /* When we parse a default argument expression, we may create
1788 temporary variables via TARGET_EXPRs. When we actually use the
1789 default-argument expression, we make a copy of the expression, but
1790 we must replace the temporaries with appropriate local versions. */
1793 break_out_target_exprs (tree t)
1795 static int target_remap_count;
1796 static splay_tree target_remap;
1798 if (!target_remap_count++)
1799 target_remap = splay_tree_new (splay_tree_compare_pointers,
1800 /*splay_tree_delete_key_fn=*/NULL,
1801 /*splay_tree_delete_value_fn=*/NULL);
1802 cp_walk_tree (&t, bot_manip, target_remap, NULL);
1803 cp_walk_tree (&t, bot_replace, target_remap, NULL);
1805 if (!--target_remap_count)
1807 splay_tree_delete (target_remap);
1808 target_remap = NULL;
1814 /* Similar to `build_nt', but for template definitions of dependent
1818 build_min_nt (enum tree_code code, ...)
1825 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1829 t = make_node (code);
1830 length = TREE_CODE_LENGTH (code);
1832 for (i = 0; i < length; i++)
1834 tree x = va_arg (p, tree);
1835 TREE_OPERAND (t, i) = x;
1843 /* Similar to `build', but for template definitions. */
1846 build_min (enum tree_code code, tree tt, ...)
1853 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1857 t = make_node (code);
1858 length = TREE_CODE_LENGTH (code);
1861 for (i = 0; i < length; i++)
1863 tree x = va_arg (p, tree);
1864 TREE_OPERAND (t, i) = x;
1865 if (x && !TYPE_P (x) && TREE_SIDE_EFFECTS (x))
1866 TREE_SIDE_EFFECTS (t) = 1;
1873 /* Similar to `build', but for template definitions of non-dependent
1874 expressions. NON_DEP is the non-dependent expression that has been
1878 build_min_non_dep (enum tree_code code, tree non_dep, ...)
1885 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1887 va_start (p, non_dep);
1889 t = make_node (code);
1890 length = TREE_CODE_LENGTH (code);
1891 TREE_TYPE (t) = TREE_TYPE (non_dep);
1892 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
1894 for (i = 0; i < length; i++)
1896 tree x = va_arg (p, tree);
1897 TREE_OPERAND (t, i) = x;
1900 if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR)
1901 /* This should not be considered a COMPOUND_EXPR, because it
1902 resolves to an overload. */
1903 COMPOUND_EXPR_OVERLOADED (t) = 1;
1909 /* Similar to `build_nt_call_vec', but for template definitions of
1910 non-dependent expressions. NON_DEP is the non-dependent expression
1911 that has been built. */
1914 build_min_non_dep_call_vec (tree non_dep, tree fn, VEC(tree,gc) *argvec)
1916 tree t = build_nt_call_vec (fn, argvec);
1917 TREE_TYPE (t) = TREE_TYPE (non_dep);
1918 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
1923 get_type_decl (tree t)
1925 if (TREE_CODE (t) == TYPE_DECL)
1928 return TYPE_STUB_DECL (t);
1929 gcc_assert (t == error_mark_node);
1933 /* Returns the namespace that contains DECL, whether directly or
1937 decl_namespace_context (tree decl)
1941 if (TREE_CODE (decl) == NAMESPACE_DECL)
1943 else if (TYPE_P (decl))
1944 decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
1946 decl = CP_DECL_CONTEXT (decl);
1950 /* Returns true if decl is within an anonymous namespace, however deeply
1951 nested, or false otherwise. */
1954 decl_anon_ns_mem_p (const_tree decl)
1958 if (decl == NULL_TREE || decl == error_mark_node)
1960 if (TREE_CODE (decl) == NAMESPACE_DECL
1961 && DECL_NAME (decl) == NULL_TREE)
1963 /* Classes and namespaces inside anonymous namespaces have
1964 TREE_PUBLIC == 0, so we can shortcut the search. */
1965 else if (TYPE_P (decl))
1966 return (TREE_PUBLIC (TYPE_NAME (decl)) == 0);
1967 else if (TREE_CODE (decl) == NAMESPACE_DECL)
1968 return (TREE_PUBLIC (decl) == 0);
1970 decl = DECL_CONTEXT (decl);
1974 /* Return truthvalue of whether T1 is the same tree structure as T2.
1975 Return 1 if they are the same. Return 0 if they are different. */
1978 cp_tree_equal (tree t1, tree t2)
1980 enum tree_code code1, code2;
1987 for (code1 = TREE_CODE (t1);
1988 CONVERT_EXPR_CODE_P (code1)
1989 || code1 == NON_LVALUE_EXPR;
1990 code1 = TREE_CODE (t1))
1991 t1 = TREE_OPERAND (t1, 0);
1992 for (code2 = TREE_CODE (t2);
1993 CONVERT_EXPR_CODE_P (code2)
1994 || code1 == NON_LVALUE_EXPR;
1995 code2 = TREE_CODE (t2))
1996 t2 = TREE_OPERAND (t2, 0);
1998 /* They might have become equal now. */
2008 return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2009 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
2012 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2015 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2016 && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2017 TREE_STRING_LENGTH (t1));
2020 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),
2021 TREE_FIXED_CST (t2));
2024 return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
2025 && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
2028 /* We need to do this when determining whether or not two
2029 non-type pointer to member function template arguments
2031 if (!(same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2032 /* The first operand is RTL. */
2033 && TREE_OPERAND (t1, 0) == TREE_OPERAND (t2, 0)))
2035 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2038 if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
2040 if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
2042 return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
2045 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2050 call_expr_arg_iterator iter1, iter2;
2051 if (!cp_tree_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
2053 for (arg1 = first_call_expr_arg (t1, &iter1),
2054 arg2 = first_call_expr_arg (t2, &iter2);
2056 arg1 = next_call_expr_arg (&iter1),
2057 arg2 = next_call_expr_arg (&iter2))
2058 if (!cp_tree_equal (arg1, arg2))
2067 tree o1 = TREE_OPERAND (t1, 0);
2068 tree o2 = TREE_OPERAND (t2, 0);
2070 /* Special case: if either target is an unallocated VAR_DECL,
2071 it means that it's going to be unified with whatever the
2072 TARGET_EXPR is really supposed to initialize, so treat it
2073 as being equivalent to anything. */
2074 if (TREE_CODE (o1) == VAR_DECL && DECL_NAME (o1) == NULL_TREE
2075 && !DECL_RTL_SET_P (o1))
2077 else if (TREE_CODE (o2) == VAR_DECL && DECL_NAME (o2) == NULL_TREE
2078 && !DECL_RTL_SET_P (o2))
2080 else if (!cp_tree_equal (o1, o2))
2083 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2086 case WITH_CLEANUP_EXPR:
2087 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2089 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
2092 if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1))
2094 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2097 /* For comparing uses of parameters in late-specified return types
2098 with an out-of-class definition of the function. */
2099 if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2100 && DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2))
2109 case IDENTIFIER_NODE:
2114 return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
2115 && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
2116 && cp_tree_equal (BASELINK_FUNCTIONS (t1),
2117 BASELINK_FUNCTIONS (t2)));
2119 case TEMPLATE_PARM_INDEX:
2120 return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2121 && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
2122 && (TEMPLATE_PARM_PARAMETER_PACK (t1)
2123 == TEMPLATE_PARM_PARAMETER_PACK (t2))
2124 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
2125 TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
2127 case TEMPLATE_ID_EXPR:
2132 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2134 vec1 = TREE_OPERAND (t1, 1);
2135 vec2 = TREE_OPERAND (t2, 1);
2138 return !vec1 && !vec2;
2140 if (TREE_VEC_LENGTH (vec1) != TREE_VEC_LENGTH (vec2))
2143 for (ix = TREE_VEC_LENGTH (vec1); ix--;)
2144 if (!cp_tree_equal (TREE_VEC_ELT (vec1, ix),
2145 TREE_VEC_ELT (vec2, ix)))
2154 tree o1 = TREE_OPERAND (t1, 0);
2155 tree o2 = TREE_OPERAND (t2, 0);
2157 if (TREE_CODE (o1) != TREE_CODE (o2))
2160 return same_type_p (o1, o2);
2162 return cp_tree_equal (o1, o2);
2167 tree t1_op1, t2_op1;
2169 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2172 t1_op1 = TREE_OPERAND (t1, 1);
2173 t2_op1 = TREE_OPERAND (t2, 1);
2174 if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
2177 return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
2181 /* Two pointer-to-members are the same if they point to the same
2182 field or function in the same class. */
2183 if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
2186 return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
2189 if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2))
2191 return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2));
2194 if (TRAIT_EXPR_KIND (t1) != TRAIT_EXPR_KIND (t2))
2196 return same_type_p (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2))
2197 && same_type_p (TRAIT_EXPR_TYPE2 (t1), TRAIT_EXPR_TYPE2 (t2));
2203 switch (TREE_CODE_CLASS (code1))
2207 case tcc_comparison:
2208 case tcc_expression:
2215 n = TREE_OPERAND_LENGTH (t1);
2216 if (TREE_CODE_CLASS (code1) == tcc_vl_exp
2217 && n != TREE_OPERAND_LENGTH (t2))
2220 for (i = 0; i < n; ++i)
2221 if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
2228 return same_type_p (t1, t2);
2232 /* We can get here with --disable-checking. */
2236 /* The type of ARG when used as an lvalue. */
2239 lvalue_type (tree arg)
2241 tree type = TREE_TYPE (arg);
2245 /* The type of ARG for printing error messages; denote lvalues with
2249 error_type (tree arg)
2251 tree type = TREE_TYPE (arg);
2253 if (TREE_CODE (type) == ARRAY_TYPE)
2255 else if (TREE_CODE (type) == ERROR_MARK)
2257 else if (real_lvalue_p (arg))
2258 type = build_reference_type (lvalue_type (arg));
2259 else if (MAYBE_CLASS_TYPE_P (type))
2260 type = lvalue_type (arg);
2265 /* Does FUNCTION use a variable-length argument list? */
2268 varargs_function_p (const_tree function)
2270 const_tree parm = TYPE_ARG_TYPES (TREE_TYPE (function));
2271 for (; parm; parm = TREE_CHAIN (parm))
2272 if (TREE_VALUE (parm) == void_type_node)
2277 /* Returns 1 if decl is a member of a class. */
2280 member_p (const_tree decl)
2282 const_tree const ctx = DECL_CONTEXT (decl);
2283 return (ctx && TYPE_P (ctx));
2286 /* Create a placeholder for member access where we don't actually have an
2287 object that the access is against. */
2290 build_dummy_object (tree type)
2292 tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
2293 return cp_build_indirect_ref (decl, RO_NULL, tf_warning_or_error);
2296 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
2297 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
2298 binfo path from current_class_type to TYPE, or 0. */
2301 maybe_dummy_object (tree type, tree* binfop)
2305 tree current = current_nonlambda_class_type ();
2308 && (binfo = lookup_base (current, type, ba_any, NULL)))
2312 /* Reference from a nested class member function. */
2314 binfo = TYPE_BINFO (type);
2320 if (current_class_ref && context == current_class_type
2321 /* Kludge: Make sure that current_class_type is actually
2322 correct. It might not be if we're in the middle of
2323 tsubst_default_argument. */
2324 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref)),
2325 current_class_type))
2326 decl = current_class_ref;
2327 else if (current != current_class_type
2328 && context == nonlambda_method_basetype ())
2329 /* In a lambda, need to go through 'this' capture. */
2330 decl = (cp_build_indirect_ref
2331 ((lambda_expr_this_capture
2332 (CLASSTYPE_LAMBDA_EXPR (current_class_type))),
2333 RO_NULL, tf_warning_or_error));
2335 decl = build_dummy_object (context);
2340 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
2343 is_dummy_object (const_tree ob)
2345 if (TREE_CODE (ob) == INDIRECT_REF)
2346 ob = TREE_OPERAND (ob, 0);
2347 return (TREE_CODE (ob) == NOP_EXPR
2348 && TREE_OPERAND (ob, 0) == void_zero_node);
2351 /* Returns 1 iff type T is something we want to treat as a scalar type for
2352 the purpose of deciding whether it is trivial/POD/standard-layout. */
2355 scalarish_type_p (const_tree t)
2357 if (t == error_mark_node)
2360 return (SCALAR_TYPE_P (t)
2361 || TREE_CODE (t) == VECTOR_TYPE);
2364 /* Returns true iff T requires non-trivial default initialization. */
2367 type_has_nontrivial_default_init (const_tree t)
2369 t = strip_array_types (CONST_CAST_TREE (t));
2371 if (CLASS_TYPE_P (t))
2372 return TYPE_HAS_COMPLEX_DFLT (t);
2377 /* Returns true iff copying an object of type T is non-trivial. */
2380 type_has_nontrivial_copy_init (const_tree t)
2382 t = strip_array_types (CONST_CAST_TREE (t));
2384 if (CLASS_TYPE_P (t))
2385 return TYPE_HAS_COMPLEX_INIT_REF (t);
2390 /* Returns 1 iff type T is a trivial type, as defined in [basic.types]. */
2393 trivial_type_p (const_tree t)
2395 t = strip_array_types (CONST_CAST_TREE (t));
2397 if (CLASS_TYPE_P (t))
2398 return (TYPE_HAS_TRIVIAL_DFLT (t)
2399 && TYPE_HAS_TRIVIAL_INIT_REF (t)
2400 && TYPE_HAS_TRIVIAL_ASSIGN_REF (t)
2401 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t));
2403 return scalarish_type_p (t);
2406 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
2409 pod_type_p (const_tree t)
2411 /* This CONST_CAST is okay because strip_array_types returns its
2412 argument unmodified and we assign it to a const_tree. */
2413 t = strip_array_types (CONST_CAST_TREE(t));
2415 if (!CLASS_TYPE_P (t))
2416 return scalarish_type_p (t);
2417 else if (cxx_dialect > cxx98)
2418 /* [class]/10: A POD struct is a class that is both a trivial class and a
2419 standard-layout class, and has no non-static data members of type
2420 non-POD struct, non-POD union (or array of such types).
2422 We don't need to check individual members because if a member is
2423 non-std-layout or non-trivial, the class will be too. */
2424 return (std_layout_type_p (t) && trivial_type_p (t));
2426 /* The C++98 definition of POD is different. */
2427 return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2430 /* Returns true iff T is POD for the purpose of layout, as defined in the
2434 layout_pod_type_p (const_tree t)
2436 t = strip_array_types (CONST_CAST_TREE (t));
2438 if (CLASS_TYPE_P (t))
2439 return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2441 return scalarish_type_p (t);
2444 /* Returns true iff T is a standard-layout type, as defined in
2448 std_layout_type_p (const_tree t)
2450 t = strip_array_types (CONST_CAST_TREE (t));
2452 if (CLASS_TYPE_P (t))
2453 return !CLASSTYPE_NON_STD_LAYOUT (t);
2455 return scalarish_type_p (t);
2458 /* Nonzero iff type T is a class template implicit specialization. */
2461 class_tmpl_impl_spec_p (const_tree t)
2463 return CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INSTANTIATION (t);
2466 /* Returns 1 iff zero initialization of type T means actually storing
2470 zero_init_p (const_tree t)
2472 /* This CONST_CAST is okay because strip_array_types returns its
2473 argument unmodified and we assign it to a const_tree. */
2474 t = strip_array_types (CONST_CAST_TREE(t));
2476 if (t == error_mark_node)
2479 /* NULL pointers to data members are initialized with -1. */
2480 if (TYPE_PTRMEM_P (t))
2483 /* Classes that contain types that can't be zero-initialized, cannot
2484 be zero-initialized themselves. */
2485 if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
2491 /* Table of valid C++ attributes. */
2492 const struct attribute_spec cxx_attribute_table[] =
2494 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2495 { "java_interface", 0, 0, false, false, false, handle_java_interface_attribute },
2496 { "com_interface", 0, 0, false, false, false, handle_com_interface_attribute },
2497 { "init_priority", 1, 1, true, false, false, handle_init_priority_attribute },
2498 { NULL, 0, 0, false, false, false, NULL }
2501 /* Handle a "java_interface" attribute; arguments as in
2502 struct attribute_spec.handler. */
2504 handle_java_interface_attribute (tree* node,
2506 tree args ATTRIBUTE_UNUSED ,
2511 || !CLASS_TYPE_P (*node)
2512 || !TYPE_FOR_JAVA (*node))
2514 error ("%qE attribute can only be applied to Java class definitions",
2516 *no_add_attrs = true;
2519 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
2520 *node = build_variant_type_copy (*node);
2521 TYPE_JAVA_INTERFACE (*node) = 1;
2526 /* Handle a "com_interface" attribute; arguments as in
2527 struct attribute_spec.handler. */
2529 handle_com_interface_attribute (tree* node,
2531 tree args ATTRIBUTE_UNUSED ,
2532 int flags ATTRIBUTE_UNUSED ,
2537 *no_add_attrs = true;
2540 || !CLASS_TYPE_P (*node)
2541 || *node != TYPE_MAIN_VARIANT (*node))
2543 warning (OPT_Wattributes, "%qE attribute can only be applied "
2544 "to class definitions", name);
2549 warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default",
2555 /* Handle an "init_priority" attribute; arguments as in
2556 struct attribute_spec.handler. */
2558 handle_init_priority_attribute (tree* node,
2561 int flags ATTRIBUTE_UNUSED ,
2564 tree initp_expr = TREE_VALUE (args);
2566 tree type = TREE_TYPE (decl);
2569 STRIP_NOPS (initp_expr);
2571 if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
2573 error ("requested init_priority is not an integer constant");
2574 *no_add_attrs = true;
2578 pri = TREE_INT_CST_LOW (initp_expr);
2580 type = strip_array_types (type);
2582 if (decl == NULL_TREE
2583 || TREE_CODE (decl) != VAR_DECL
2584 || !TREE_STATIC (decl)
2585 || DECL_EXTERNAL (decl)
2586 || (TREE_CODE (type) != RECORD_TYPE
2587 && TREE_CODE (type) != UNION_TYPE)
2588 /* Static objects in functions are initialized the
2589 first time control passes through that
2590 function. This is not precise enough to pin down an
2591 init_priority value, so don't allow it. */
2592 || current_function_decl)
2594 error ("can only use %qE attribute on file-scope definitions "
2595 "of objects of class type", name);
2596 *no_add_attrs = true;
2600 if (pri > MAX_INIT_PRIORITY || pri <= 0)
2602 error ("requested init_priority is out of range");
2603 *no_add_attrs = true;
2607 /* Check for init_priorities that are reserved for
2608 language and runtime support implementations.*/
2609 if (pri <= MAX_RESERVED_INIT_PRIORITY)
2612 (0, "requested init_priority is reserved for internal use");
2615 if (SUPPORTS_INIT_PRIORITY)
2617 SET_DECL_INIT_PRIORITY (decl, pri);
2618 DECL_HAS_INIT_PRIORITY_P (decl) = 1;
2623 error ("%qE attribute is not supported on this platform", name);
2624 *no_add_attrs = true;
2629 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
2630 thing pointed to by the constant. */
2633 make_ptrmem_cst (tree type, tree member)
2635 tree ptrmem_cst = make_node (PTRMEM_CST);
2636 TREE_TYPE (ptrmem_cst) = type;
2637 PTRMEM_CST_MEMBER (ptrmem_cst) = member;
2641 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
2642 return an existing type if an appropriate type already exists. */
2645 cp_build_type_attribute_variant (tree type, tree attributes)
2649 new_type = build_type_attribute_variant (type, attributes);
2650 if ((TREE_CODE (new_type) == FUNCTION_TYPE
2651 || TREE_CODE (new_type) == METHOD_TYPE)
2652 && (TYPE_RAISES_EXCEPTIONS (new_type)
2653 != TYPE_RAISES_EXCEPTIONS (type)))
2654 new_type = build_exception_variant (new_type,
2655 TYPE_RAISES_EXCEPTIONS (type));
2657 /* Making a new main variant of a class type is broken. */
2658 gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
2663 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
2664 Called only after doing all language independent checks. Only
2665 to check TYPE_RAISES_EXCEPTIONS for FUNCTION_TYPE, the rest is already
2666 compared in type_hash_eq. */
2669 cxx_type_hash_eq (const_tree typea, const_tree typeb)
2671 gcc_assert (TREE_CODE (typea) == FUNCTION_TYPE);
2673 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea),
2674 TYPE_RAISES_EXCEPTIONS (typeb), 1);
2677 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
2678 traversal. Called from walk_tree. */
2681 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
2682 void *data, struct pointer_set_t *pset)
2684 enum tree_code code = TREE_CODE (*tp);
2687 #define WALK_SUBTREE(NODE) \
2690 result = cp_walk_tree (&(NODE), func, data, pset); \
2691 if (result) goto out; \
2695 /* Not one of the easy cases. We must explicitly go through the
2701 case TEMPLATE_TEMPLATE_PARM:
2702 case BOUND_TEMPLATE_TEMPLATE_PARM:
2703 case UNBOUND_CLASS_TEMPLATE:
2704 case TEMPLATE_PARM_INDEX:
2705 case TEMPLATE_TYPE_PARM:
2708 /* None of these have subtrees other than those already walked
2710 *walk_subtrees_p = 0;
2714 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp));
2715 *walk_subtrees_p = 0;
2719 WALK_SUBTREE (TREE_TYPE (*tp));
2720 *walk_subtrees_p = 0;
2724 WALK_SUBTREE (TREE_PURPOSE (*tp));
2728 WALK_SUBTREE (OVL_FUNCTION (*tp));
2729 WALK_SUBTREE (OVL_CHAIN (*tp));
2730 *walk_subtrees_p = 0;
2734 WALK_SUBTREE (DECL_NAME (*tp));
2735 WALK_SUBTREE (USING_DECL_SCOPE (*tp));
2736 WALK_SUBTREE (USING_DECL_DECLS (*tp));
2737 *walk_subtrees_p = 0;
2741 if (TYPE_PTRMEMFUNC_P (*tp))
2742 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
2745 case TYPE_ARGUMENT_PACK:
2746 case NONTYPE_ARGUMENT_PACK:
2748 tree args = ARGUMENT_PACK_ARGS (*tp);
2749 int i, len = TREE_VEC_LENGTH (args);
2750 for (i = 0; i < len; i++)
2751 WALK_SUBTREE (TREE_VEC_ELT (args, i));
2755 case TYPE_PACK_EXPANSION:
2756 WALK_SUBTREE (TREE_TYPE (*tp));
2757 *walk_subtrees_p = 0;
2760 case EXPR_PACK_EXPANSION:
2761 WALK_SUBTREE (TREE_OPERAND (*tp, 0));
2762 *walk_subtrees_p = 0;
2766 case REINTERPRET_CAST_EXPR:
2767 case STATIC_CAST_EXPR:
2768 case CONST_CAST_EXPR:
2769 case DYNAMIC_CAST_EXPR:
2770 if (TREE_TYPE (*tp))
2771 WALK_SUBTREE (TREE_TYPE (*tp));
2775 for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (*tp)); ++i)
2776 WALK_SUBTREE (TREE_OPERAND (*tp, i));
2778 *walk_subtrees_p = 0;
2782 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp));
2783 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp));
2784 *walk_subtrees_p = 0;
2788 WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp));
2789 *walk_subtrees_p = 0;
2797 /* We didn't find what we were looking for. */
2804 /* Like save_expr, but for C++. */
2807 cp_save_expr (tree expr)
2809 /* There is no reason to create a SAVE_EXPR within a template; if
2810 needed, we can create the SAVE_EXPR when instantiating the
2811 template. Furthermore, the middle-end cannot handle C++-specific
2813 if (processing_template_decl)
2815 return save_expr (expr);
2818 /* Initialize tree.c. */
2823 list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
2826 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
2827 is. Note that sfk_none is zero, so this function can be used as a
2828 predicate to test whether or not DECL is a special function. */
2830 special_function_kind
2831 special_function_p (const_tree decl)
2833 /* Rather than doing all this stuff with magic names, we should
2834 probably have a field of type `special_function_kind' in
2835 DECL_LANG_SPECIFIC. */
2836 if (DECL_COPY_CONSTRUCTOR_P (decl))
2837 return sfk_copy_constructor;
2838 if (DECL_MOVE_CONSTRUCTOR_P (decl))
2839 return sfk_move_constructor;
2840 if (DECL_CONSTRUCTOR_P (decl))
2841 return sfk_constructor;
2842 if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
2843 return sfk_assignment_operator;
2844 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
2845 return sfk_destructor;
2846 if (DECL_COMPLETE_DESTRUCTOR_P (decl))
2847 return sfk_complete_destructor;
2848 if (DECL_BASE_DESTRUCTOR_P (decl))
2849 return sfk_base_destructor;
2850 if (DECL_DELETING_DESTRUCTOR_P (decl))
2851 return sfk_deleting_destructor;
2852 if (DECL_CONV_FN_P (decl))
2853 return sfk_conversion;
2858 /* Returns nonzero if TYPE is a character type, including wchar_t. */
2861 char_type_p (tree type)
2863 return (same_type_p (type, char_type_node)
2864 || same_type_p (type, unsigned_char_type_node)
2865 || same_type_p (type, signed_char_type_node)
2866 || same_type_p (type, char16_type_node)
2867 || same_type_p (type, char32_type_node)
2868 || same_type_p (type, wchar_type_node));
2871 /* Returns the kind of linkage associated with the indicated DECL. Th
2872 value returned is as specified by the language standard; it is
2873 independent of implementation details regarding template
2874 instantiation, etc. For example, it is possible that a declaration
2875 to which this function assigns external linkage would not show up
2876 as a global symbol when you run `nm' on the resulting object file. */
2879 decl_linkage (tree decl)
2881 /* This function doesn't attempt to calculate the linkage from first
2882 principles as given in [basic.link]. Instead, it makes use of
2883 the fact that we have already set TREE_PUBLIC appropriately, and
2884 then handles a few special cases. Ideally, we would calculate
2885 linkage first, and then transform that into a concrete
2888 /* Things that don't have names have no linkage. */
2889 if (!DECL_NAME (decl))
2892 /* Fields have no linkage. */
2893 if (TREE_CODE (decl) == FIELD_DECL)
2896 /* Things that are TREE_PUBLIC have external linkage. */
2897 if (TREE_PUBLIC (decl))
2900 if (TREE_CODE (decl) == NAMESPACE_DECL)
2903 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
2905 if (TREE_CODE (decl) == CONST_DECL)
2906 return decl_linkage (TYPE_NAME (TREE_TYPE (decl)));
2908 /* Some things that are not TREE_PUBLIC have external linkage, too.
2909 For example, on targets that don't have weak symbols, we make all
2910 template instantiations have internal linkage (in the object
2911 file), but the symbols should still be treated as having external
2912 linkage from the point of view of the language. */
2913 if ((TREE_CODE (decl) == FUNCTION_DECL
2914 || TREE_CODE (decl) == VAR_DECL)
2915 && DECL_COMDAT (decl))
2918 /* Things in local scope do not have linkage, if they don't have
2920 if (decl_function_context (decl))
2923 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
2924 are considered to have external linkage for language purposes. DECLs
2925 really meant to have internal linkage have DECL_THIS_STATIC set. */
2926 if (TREE_CODE (decl) == TYPE_DECL)
2928 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
2930 if (!DECL_THIS_STATIC (decl))
2933 /* Static data members and static member functions from classes
2934 in anonymous namespace also don't have TREE_PUBLIC set. */
2935 if (DECL_CLASS_CONTEXT (decl))
2939 /* Everything else has internal linkage. */
2943 /* EXP is an expression that we want to pre-evaluate. Returns (in
2944 *INITP) an expression that will perform the pre-evaluation. The
2945 value returned by this function is a side-effect free expression
2946 equivalent to the pre-evaluated expression. Callers must ensure
2947 that *INITP is evaluated before EXP. */
2950 stabilize_expr (tree exp, tree* initp)
2954 if (!TREE_SIDE_EFFECTS (exp))
2955 init_expr = NULL_TREE;
2956 else if (!real_lvalue_p (exp)
2957 || !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (exp)))
2959 init_expr = get_target_expr (exp);
2960 exp = TARGET_EXPR_SLOT (init_expr);
2964 exp = cp_build_unary_op (ADDR_EXPR, exp, 1, tf_warning_or_error);
2965 init_expr = get_target_expr (exp);
2966 exp = TARGET_EXPR_SLOT (init_expr);
2967 exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error);
2971 gcc_assert (!TREE_SIDE_EFFECTS (exp));
2975 /* Add NEW_EXPR, an expression whose value we don't care about, after the
2976 similar expression ORIG. */
2979 add_stmt_to_compound (tree orig, tree new_expr)
2981 if (!new_expr || !TREE_SIDE_EFFECTS (new_expr))
2983 if (!orig || !TREE_SIDE_EFFECTS (orig))
2985 return build2 (COMPOUND_EXPR, void_type_node, orig, new_expr);
2988 /* Like stabilize_expr, but for a call whose arguments we want to
2989 pre-evaluate. CALL is modified in place to use the pre-evaluated
2990 arguments, while, upon return, *INITP contains an expression to
2991 compute the arguments. */
2994 stabilize_call (tree call, tree *initp)
2996 tree inits = NULL_TREE;
2998 int nargs = call_expr_nargs (call);
3000 if (call == error_mark_node || processing_template_decl)
3006 gcc_assert (TREE_CODE (call) == CALL_EXPR);
3008 for (i = 0; i < nargs; i++)
3011 CALL_EXPR_ARG (call, i) =
3012 stabilize_expr (CALL_EXPR_ARG (call, i), &init);
3013 inits = add_stmt_to_compound (inits, init);
3019 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
3020 to pre-evaluate. CALL is modified in place to use the pre-evaluated
3021 arguments, while, upon return, *INITP contains an expression to
3022 compute the arguments. */
3025 stabilize_aggr_init (tree call, tree *initp)
3027 tree inits = NULL_TREE;
3029 int nargs = aggr_init_expr_nargs (call);
3031 if (call == error_mark_node)
3034 gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
3036 for (i = 0; i < nargs; i++)
3039 AGGR_INIT_EXPR_ARG (call, i) =
3040 stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
3041 inits = add_stmt_to_compound (inits, init);
3047 /* Like stabilize_expr, but for an initialization.
3049 If the initialization is for an object of class type, this function
3050 takes care not to introduce additional temporaries.
3052 Returns TRUE iff the expression was successfully pre-evaluated,
3053 i.e., if INIT is now side-effect free, except for, possible, a
3054 single call to a constructor. */
3057 stabilize_init (tree init, tree *initp)
3063 if (t == error_mark_node || processing_template_decl)
3066 if (TREE_CODE (t) == INIT_EXPR
3067 && TREE_CODE (TREE_OPERAND (t, 1)) != TARGET_EXPR
3068 && TREE_CODE (TREE_OPERAND (t, 1)) != AGGR_INIT_EXPR)
3070 TREE_OPERAND (t, 1) = stabilize_expr (TREE_OPERAND (t, 1), initp);
3074 if (TREE_CODE (t) == INIT_EXPR)
3075 t = TREE_OPERAND (t, 1);
3076 if (TREE_CODE (t) == TARGET_EXPR)
3077 t = TARGET_EXPR_INITIAL (t);
3078 if (TREE_CODE (t) == COMPOUND_EXPR)
3080 if (TREE_CODE (t) == CONSTRUCTOR
3081 && EMPTY_CONSTRUCTOR_P (t))
3082 /* Default-initialization. */
3085 /* If the initializer is a COND_EXPR, we can't preevaluate
3087 if (TREE_CODE (t) == COND_EXPR)
3090 if (TREE_CODE (t) == CALL_EXPR)
3092 stabilize_call (t, initp);
3096 if (TREE_CODE (t) == AGGR_INIT_EXPR)
3098 stabilize_aggr_init (t, initp);
3102 /* The initialization is being performed via a bitwise copy -- and
3103 the item copied may have side effects. */
3104 return TREE_SIDE_EFFECTS (init);
3107 /* Like "fold", but should be used whenever we might be processing the
3108 body of a template. */
3111 fold_if_not_in_template (tree expr)
3113 /* In the body of a template, there is never any need to call
3114 "fold". We will call fold later when actually instantiating the
3115 template. Integral constant expressions in templates will be
3116 evaluated via fold_non_dependent_expr, as necessary. */
3117 if (processing_template_decl)
3120 /* Fold C++ front-end specific tree codes. */
3121 if (TREE_CODE (expr) == UNARY_PLUS_EXPR)
3122 return fold_convert (TREE_TYPE (expr), TREE_OPERAND (expr, 0));
3127 /* Returns true if a cast to TYPE may appear in an integral constant
3131 cast_valid_in_integral_constant_expression_p (tree type)
3133 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
3134 || dependent_type_p (type)
3135 || type == error_mark_node);
3138 /* Return true if we need to fix linkage information of DECL. */
3141 cp_fix_function_decl_p (tree decl)
3143 /* Skip if DECL is not externally visible. */
3144 if (!TREE_PUBLIC (decl))
3147 /* We need to fix DECL if it a appears to be exported but with no
3148 function body. Thunks do not have CFGs and we may need to
3149 handle them specially later. */
3150 if (!gimple_has_body_p (decl)
3151 && !DECL_THUNK_P (decl)
3152 && !DECL_EXTERNAL (decl))
3154 struct cgraph_node *node = cgraph_get_node (decl);
3156 /* Don't fix same_body aliases. Although they don't have their own
3157 CFG, they share it with what they alias to. */
3159 || node->decl == decl
3160 || !node->same_body)
3167 /* Clean the C++ specific parts of the tree T. */
3170 cp_free_lang_data (tree t)
3172 if (TREE_CODE (t) == METHOD_TYPE
3173 || TREE_CODE (t) == FUNCTION_TYPE)
3175 /* Default args are not interesting anymore. */
3176 tree argtypes = TYPE_ARG_TYPES (t);
3179 TREE_PURPOSE (argtypes) = 0;
3180 argtypes = TREE_CHAIN (argtypes);
3183 else if (TREE_CODE (t) == FUNCTION_DECL
3184 && cp_fix_function_decl_p (t))
3186 /* If T is used in this translation unit at all, the definition
3187 must exist somewhere else since we have decided to not emit it
3188 in this TU. So make it an external reference. */
3189 DECL_EXTERNAL (t) = 1;
3190 TREE_STATIC (t) = 0;
3192 if (CP_AGGREGATE_TYPE_P (t)
3195 tree name = TYPE_NAME (t);
3196 if (TREE_CODE (name) == TYPE_DECL)
3197 name = DECL_NAME (name);
3198 /* Drop anonymous names. */
3199 if (name != NULL_TREE
3200 && ANON_AGGRNAME_P (name))
3201 TYPE_NAME (t) = NULL_TREE;
3206 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
3207 /* Complain that some language-specific thing hanging off a tree
3208 node has been accessed improperly. */
3211 lang_check_failed (const char* file, int line, const char* function)
3213 internal_error ("lang_* check: failed in %s, at %s:%d",
3214 function, trim_filename (file), line);
3216 #endif /* ENABLE_TREE_CHECKING */
3218 #include "gt-cp-tree.h"