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"
33 #include "insn-config.h"
34 #include "integrate.h"
35 #include "tree-inline.h"
39 #include "tree-flow.h"
42 static tree bot_manip (tree *, int *, void *);
43 static tree bot_replace (tree *, int *, void *);
44 static tree build_cplus_array_type_1 (tree, tree);
45 static int list_hash_eq (const void *, const void *);
46 static hashval_t list_hash_pieces (tree, tree, tree);
47 static hashval_t list_hash (const void *);
48 static cp_lvalue_kind lvalue_p_1 (const_tree);
49 static tree build_target_expr (tree, tree);
50 static tree count_trees_r (tree *, int *, void *);
51 static tree verify_stmt_tree_r (tree *, int *, void *);
52 static tree build_local_temp (tree);
54 static tree handle_java_interface_attribute (tree *, tree, tree, int, bool *);
55 static tree handle_com_interface_attribute (tree *, tree, tree, int, bool *);
56 static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *);
58 /* If REF is an lvalue, returns the kind of lvalue that REF is.
59 Otherwise, returns clk_none. */
62 lvalue_p_1 (const_tree ref)
64 cp_lvalue_kind op1_lvalue_kind = clk_none;
65 cp_lvalue_kind op2_lvalue_kind = clk_none;
67 /* Expressions of reference type are sometimes wrapped in
68 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
69 representation, not part of the language, so we have to look
71 if (TREE_CODE (ref) == INDIRECT_REF
72 && TREE_CODE (TREE_TYPE (TREE_OPERAND (ref, 0)))
74 return lvalue_p_1 (TREE_OPERAND (ref, 0));
76 if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
78 /* unnamed rvalue references are rvalues */
79 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref))
80 && TREE_CODE (ref) != PARM_DECL
81 && TREE_CODE (ref) != VAR_DECL
82 && TREE_CODE (ref) != COMPONENT_REF)
85 /* lvalue references and named rvalue references are lvalues. */
89 if (ref == current_class_ptr)
92 switch (TREE_CODE (ref))
96 /* preincrements and predecrements are valid lvals, provided
97 what they refer to are valid lvals. */
98 case PREINCREMENT_EXPR:
99 case PREDECREMENT_EXPR:
101 case WITH_CLEANUP_EXPR:
104 return lvalue_p_1 (TREE_OPERAND (ref, 0));
107 op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0));
108 /* Look at the member designator. */
109 if (!op1_lvalue_kind)
111 else if (is_overloaded_fn (TREE_OPERAND (ref, 1)))
112 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
113 situations. If we're seeing a COMPONENT_REF, it's a non-static
114 member, so it isn't an lvalue. */
115 op1_lvalue_kind = clk_none;
116 else if (TREE_CODE (TREE_OPERAND (ref, 1)) != FIELD_DECL)
117 /* This can be IDENTIFIER_NODE in a template. */;
118 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref, 1)))
120 /* Clear the ordinary bit. If this object was a class
121 rvalue we want to preserve that information. */
122 op1_lvalue_kind &= ~clk_ordinary;
123 /* The lvalue is for a bitfield. */
124 op1_lvalue_kind |= clk_bitfield;
126 else if (DECL_PACKED (TREE_OPERAND (ref, 1)))
127 op1_lvalue_kind |= clk_packed;
129 return op1_lvalue_kind;
132 case COMPOUND_LITERAL_EXPR:
136 /* CONST_DECL without TREE_STATIC are enumeration values and
137 thus not lvalues. With TREE_STATIC they are used by ObjC++
138 in objc_build_string_object and need to be considered as
140 if (! TREE_STATIC (ref))
143 if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
144 && DECL_LANG_SPECIFIC (ref)
145 && DECL_IN_AGGR_P (ref))
151 if (TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
155 /* A currently unresolved scope ref. */
160 /* Disallow <? and >? as lvalues if either argument side-effects. */
161 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 0))
162 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 1)))
164 op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 0));
165 op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1));
169 op1_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 1)
170 ? TREE_OPERAND (ref, 1)
171 : TREE_OPERAND (ref, 0));
172 op2_lvalue_kind = lvalue_p_1 (TREE_OPERAND (ref, 2));
179 return lvalue_p_1 (TREE_OPERAND (ref, 1));
185 return (CLASS_TYPE_P (TREE_TYPE (ref)) ? clk_class : clk_none);
188 /* Any class-valued call would be wrapped in a TARGET_EXPR. */
192 /* All functions (except non-static-member functions) are
194 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref)
195 ? clk_none : clk_ordinary);
198 /* We now represent a reference to a single static member function
200 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
201 its argument unmodified and we assign it to a const_tree. */
202 return lvalue_p_1 (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref)));
204 case NON_DEPENDENT_EXPR:
205 /* We must consider NON_DEPENDENT_EXPRs to be lvalues so that
206 things like "&E" where "E" is an expression with a
207 non-dependent type work. It is safe to be lenient because an
208 error will be issued when the template is instantiated if "E"
216 /* If one operand is not an lvalue at all, then this expression is
218 if (!op1_lvalue_kind || !op2_lvalue_kind)
221 /* Otherwise, it's an lvalue, and it has all the odd properties
222 contributed by either operand. */
223 op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind;
224 /* It's not an ordinary lvalue if it involves any other kind. */
225 if ((op1_lvalue_kind & ~clk_ordinary) != clk_none)
226 op1_lvalue_kind &= ~clk_ordinary;
227 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
228 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
229 if ((op1_lvalue_kind & (clk_rvalueref|clk_class))
230 && (op1_lvalue_kind & (clk_bitfield|clk_packed)))
231 op1_lvalue_kind = clk_none;
232 return op1_lvalue_kind;
235 /* Returns the kind of lvalue that REF is, in the sense of
236 [basic.lval]. This function should really be named lvalue_p; it
237 computes the C++ definition of lvalue. */
240 real_lvalue_p (tree ref)
242 cp_lvalue_kind kind = lvalue_p_1 (ref);
243 if (kind & (clk_rvalueref|clk_class))
249 /* This differs from real_lvalue_p in that class rvalues are considered
253 lvalue_p (const_tree ref)
255 return (lvalue_p_1 (ref) != clk_none);
258 /* This differs from real_lvalue_p in that rvalues formed by dereferencing
259 rvalue references are considered rvalues. */
262 lvalue_or_rvalue_with_address_p (const_tree ref)
264 cp_lvalue_kind kind = lvalue_p_1 (ref);
265 if (kind & clk_class)
268 return (kind != clk_none);
271 /* Test whether DECL is a builtin that may appear in a
272 constant-expression. */
275 builtin_valid_in_constant_expr_p (const_tree decl)
277 /* At present BUILT_IN_CONSTANT_P is the only builtin we're allowing
278 in constant-expressions. We may want to add other builtins later. */
279 return DECL_IS_BUILTIN_CONSTANT_P (decl);
282 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
285 build_target_expr (tree decl, tree value)
289 #ifdef ENABLE_CHECKING
290 gcc_assert (VOID_TYPE_P (TREE_TYPE (value))
291 || TREE_TYPE (decl) == TREE_TYPE (value)
292 || useless_type_conversion_p (TREE_TYPE (decl),
296 t = build4 (TARGET_EXPR, TREE_TYPE (decl), decl, value,
297 cxx_maybe_build_cleanup (decl), NULL_TREE);
298 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
299 ignore the TARGET_EXPR. If there really turn out to be no
300 side-effects, then the optimizer should be able to get rid of
301 whatever code is generated anyhow. */
302 TREE_SIDE_EFFECTS (t) = 1;
307 /* Return an undeclared local temporary of type TYPE for use in building a
311 build_local_temp (tree type)
313 tree slot = build_decl (input_location,
314 VAR_DECL, NULL_TREE, type);
315 DECL_ARTIFICIAL (slot) = 1;
316 DECL_IGNORED_P (slot) = 1;
317 DECL_CONTEXT (slot) = current_function_decl;
318 layout_decl (slot, 0);
322 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
325 process_aggr_init_operands (tree t)
329 side_effects = TREE_SIDE_EFFECTS (t);
333 n = TREE_OPERAND_LENGTH (t);
334 for (i = 1; i < n; i++)
336 tree op = TREE_OPERAND (t, i);
337 if (op && TREE_SIDE_EFFECTS (op))
344 TREE_SIDE_EFFECTS (t) = side_effects;
347 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
348 FN, and SLOT. NARGS is the number of call arguments which are specified
349 as a tree array ARGS. */
352 build_aggr_init_array (tree return_type, tree fn, tree slot, int nargs,
358 t = build_vl_exp (AGGR_INIT_EXPR, nargs + 3);
359 TREE_TYPE (t) = return_type;
360 AGGR_INIT_EXPR_FN (t) = fn;
361 AGGR_INIT_EXPR_SLOT (t) = slot;
362 for (i = 0; i < nargs; i++)
363 AGGR_INIT_EXPR_ARG (t, i) = args[i];
364 process_aggr_init_operands (t);
368 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
369 target. TYPE is the type to be initialized.
371 Build an AGGR_INIT_EXPR to represent the initialization. This function
372 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
373 to initialize another object, whereas a TARGET_EXPR can either
374 initialize another object or create its own temporary object, and as a
375 result building up a TARGET_EXPR requires that the type's destructor be
379 build_aggr_init_expr (tree type, tree init)
386 /* Make sure that we're not trying to create an instance of an
388 abstract_virtuals_error (NULL_TREE, type);
390 if (TREE_CODE (init) == CALL_EXPR)
391 fn = CALL_EXPR_FN (init);
392 else if (TREE_CODE (init) == AGGR_INIT_EXPR)
393 fn = AGGR_INIT_EXPR_FN (init);
395 return convert (type, init);
397 is_ctor = (TREE_CODE (fn) == ADDR_EXPR
398 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
399 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0)));
401 /* We split the CALL_EXPR into its function and its arguments here.
402 Then, in expand_expr, we put them back together. The reason for
403 this is that this expression might be a default argument
404 expression. In that case, we need a new temporary every time the
405 expression is used. That's what break_out_target_exprs does; it
406 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
407 temporary slot. Then, expand_expr builds up a call-expression
408 using the new slot. */
410 /* If we don't need to use a constructor to create an object of this
411 type, don't mess with AGGR_INIT_EXPR. */
412 if (is_ctor || TREE_ADDRESSABLE (type))
414 slot = build_local_temp (type);
416 if (TREE_CODE(init) == CALL_EXPR)
417 rval = build_aggr_init_array (void_type_node, fn, slot,
418 call_expr_nargs (init),
419 CALL_EXPR_ARGP (init));
421 rval = build_aggr_init_array (void_type_node, fn, slot,
422 aggr_init_expr_nargs (init),
423 AGGR_INIT_EXPR_ARGP (init));
424 TREE_SIDE_EFFECTS (rval) = 1;
425 AGGR_INIT_VIA_CTOR_P (rval) = is_ctor;
433 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
434 target. TYPE is the type that this initialization should appear to
437 Build an encapsulation of the initialization to perform
438 and return it so that it can be processed by language-independent
439 and language-specific expression expanders. */
442 build_cplus_new (tree type, tree init)
444 tree rval = build_aggr_init_expr (type, init);
447 if (TREE_CODE (rval) == AGGR_INIT_EXPR)
448 slot = AGGR_INIT_EXPR_SLOT (rval);
449 else if (TREE_CODE (rval) == CALL_EXPR)
450 slot = build_local_temp (type);
454 rval = build_target_expr (slot, rval);
455 TARGET_EXPR_IMPLICIT_P (rval) = 1;
460 /* Return a TARGET_EXPR which expresses the direct-initialization of one
461 array from another. */
464 build_array_copy (tree init)
466 tree type = TREE_TYPE (init);
467 tree slot = build_local_temp (type);
468 init = build2 (VEC_INIT_EXPR, type, slot, init);
469 SET_EXPR_LOCATION (init, input_location);
470 init = build_target_expr (slot, init);
471 TARGET_EXPR_IMPLICIT_P (init) = 1;
476 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
480 build_target_expr_with_type (tree init, tree type)
482 gcc_assert (!VOID_TYPE_P (type));
484 if (TREE_CODE (init) == TARGET_EXPR)
486 else if (CLASS_TYPE_P (type) && !TYPE_HAS_TRIVIAL_INIT_REF (type)
487 && !VOID_TYPE_P (TREE_TYPE (init))
488 && TREE_CODE (init) != COND_EXPR
489 && TREE_CODE (init) != CONSTRUCTOR
490 && TREE_CODE (init) != VA_ARG_EXPR)
491 /* We need to build up a copy constructor call. A void initializer
492 means we're being called from bot_manip. COND_EXPR is a special
493 case because we already have copies on the arms and we don't want
494 another one here. A CONSTRUCTOR is aggregate initialization, which
495 is handled separately. A VA_ARG_EXPR is magic creation of an
496 aggregate; there's no additional work to be done. */
497 return force_rvalue (init);
499 return force_target_expr (type, init);
502 /* Like the above function, but without the checking. This function should
503 only be used by code which is deliberately trying to subvert the type
504 system, such as call_builtin_trap. */
507 force_target_expr (tree type, tree init)
511 gcc_assert (!VOID_TYPE_P (type));
513 slot = build_local_temp (type);
514 return build_target_expr (slot, init);
517 /* Like build_target_expr_with_type, but use the type of INIT. */
520 get_target_expr (tree init)
522 if (TREE_CODE (init) == AGGR_INIT_EXPR)
523 return build_target_expr (AGGR_INIT_EXPR_SLOT (init), init);
525 return build_target_expr_with_type (init, TREE_TYPE (init));
528 /* If EXPR is a bitfield reference, convert it to the declared type of
529 the bitfield, and return the resulting expression. Otherwise,
530 return EXPR itself. */
533 convert_bitfield_to_declared_type (tree expr)
537 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
539 expr = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type),
544 /* EXPR is being used in an rvalue context. Return a version of EXPR
545 that is marked as an rvalue. */
552 if (error_operand_p (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 all of the C++ array types, including
605 dependent array types and array types whose element type is
607 static GTY ((param_is (union tree_node))) htab_t cplus_array_htab;
611 build_cplus_array_type_1 (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 /* Push these needs up so that initialization takes place
670 TYPE_NEEDS_CONSTRUCTING (t)
671 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
672 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
673 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
678 build_cplus_array_type (tree elt_type, tree index_type)
681 int type_quals = cp_type_quals (elt_type);
683 if (type_quals != TYPE_UNQUALIFIED)
684 elt_type = cp_build_qualified_type (elt_type, TYPE_UNQUALIFIED);
686 t = build_cplus_array_type_1 (elt_type, index_type);
688 if (type_quals != TYPE_UNQUALIFIED)
689 t = cp_build_qualified_type (t, type_quals);
694 /* Return an ARRAY_TYPE with element type ELT and length N. */
697 build_array_of_n_type (tree elt, int n)
699 return build_cplus_array_type (elt, build_index_type (size_int (n - 1)));
702 /* Return a reference type node referring to TO_TYPE. If RVAL is
703 true, return an rvalue reference type, otherwise return an lvalue
704 reference type. If a type node exists, reuse it, otherwise create
707 cp_build_reference_type (tree to_type, bool rval)
710 lvalue_ref = build_reference_type (to_type);
714 /* This code to create rvalue reference types is based on and tied
715 to the code creating lvalue reference types in the middle-end
716 functions build_reference_type_for_mode and build_reference_type.
718 It works by putting the rvalue reference type nodes after the
719 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
720 they will effectively be ignored by the middle end. */
722 for (t = lvalue_ref; (t = TYPE_NEXT_REF_TO (t)); )
723 if (TYPE_REF_IS_RVALUE (t))
726 t = build_distinct_type_copy (lvalue_ref);
728 TYPE_REF_IS_RVALUE (t) = true;
729 TYPE_NEXT_REF_TO (t) = TYPE_NEXT_REF_TO (lvalue_ref);
730 TYPE_NEXT_REF_TO (lvalue_ref) = t;
732 if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
733 SET_TYPE_STRUCTURAL_EQUALITY (t);
734 else if (TYPE_CANONICAL (to_type) != to_type)
736 = cp_build_reference_type (TYPE_CANONICAL (to_type), rval);
738 TYPE_CANONICAL (t) = t;
746 /* Returns EXPR cast to rvalue reference type, like std::move. */
751 tree type = TREE_TYPE (expr);
752 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
753 type = cp_build_reference_type (type, /*rval*/true);
754 return build_static_cast (type, expr, tf_warning_or_error);
757 /* Used by the C++ front end to build qualified array types. However,
758 the C version of this function does not properly maintain canonical
759 types (which are not used in C). */
761 c_build_qualified_type (tree type, int type_quals)
763 return cp_build_qualified_type (type, type_quals);
767 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
768 arrays correctly. In particular, if TYPE is an array of T's, and
769 TYPE_QUALS is non-empty, returns an array of qualified T's.
771 FLAGS determines how to deal with ill-formed qualifications. If
772 tf_ignore_bad_quals is set, then bad qualifications are dropped
773 (this is permitted if TYPE was introduced via a typedef or template
774 type parameter). If bad qualifications are dropped and tf_warning
775 is set, then a warning is issued for non-const qualifications. If
776 tf_ignore_bad_quals is not set and tf_error is not set, we
777 return error_mark_node. Otherwise, we issue an error, and ignore
780 Qualification of a reference type is valid when the reference came
781 via a typedef or template type argument. [dcl.ref] No such
782 dispensation is provided for qualifying a function type. [dcl.fct]
783 DR 295 queries this and the proposed resolution brings it into line
784 with qualifying a reference. We implement the DR. We also behave
785 in a similar manner for restricting non-pointer types. */
788 cp_build_qualified_type_real (tree type,
790 tsubst_flags_t complain)
793 int bad_quals = TYPE_UNQUALIFIED;
795 if (type == error_mark_node)
798 if (type_quals == cp_type_quals (type))
801 if (TREE_CODE (type) == ARRAY_TYPE)
803 /* In C++, the qualification really applies to the array element
804 type. Obtain the appropriately qualified element type. */
807 = cp_build_qualified_type_real (TREE_TYPE (type),
811 if (element_type == error_mark_node)
812 return error_mark_node;
814 /* See if we already have an identically qualified type. */
815 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
816 if (cp_type_quals (t) == type_quals
817 && TYPE_NAME (t) == TYPE_NAME (type)
818 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type))
823 t = build_cplus_array_type_1 (element_type, TYPE_DOMAIN (type));
825 if (TYPE_MAIN_VARIANT (t) != TYPE_MAIN_VARIANT (type))
827 /* Set the main variant of the newly-created ARRAY_TYPE
828 (with cv-qualified element type) to the main variant of
829 the unqualified ARRAY_TYPE we started with. */
830 tree last_variant = t;
831 tree m = TYPE_MAIN_VARIANT (type);
833 /* Find the last variant on the new ARRAY_TYPEs list of
834 variants, setting the main variant of each of the other
835 types to the main variant of our unqualified
837 while (TYPE_NEXT_VARIANT (last_variant))
839 TYPE_MAIN_VARIANT (last_variant) = m;
840 last_variant = TYPE_NEXT_VARIANT (last_variant);
843 /* Splice in the newly-created variants. */
844 TYPE_NEXT_VARIANT (last_variant) = TYPE_NEXT_VARIANT (m);
845 TYPE_NEXT_VARIANT (m) = t;
846 TYPE_MAIN_VARIANT (last_variant) = m;
850 /* Even if we already had this variant, we update
851 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
852 they changed since the variant was originally created.
854 This seems hokey; if there is some way to use a previous
855 variant *without* coming through here,
856 TYPE_NEEDS_CONSTRUCTING will never be updated. */
857 TYPE_NEEDS_CONSTRUCTING (t)
858 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));
859 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
860 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));
863 else if (TYPE_PTRMEMFUNC_P (type))
865 /* For a pointer-to-member type, we can't just return a
866 cv-qualified version of the RECORD_TYPE. If we do, we
867 haven't changed the field that contains the actual pointer to
868 a method, and so TYPE_PTRMEMFUNC_FN_TYPE will be wrong. */
871 t = TYPE_PTRMEMFUNC_FN_TYPE (type);
872 t = cp_build_qualified_type_real (t, type_quals, complain);
873 return build_ptrmemfunc_type (t);
875 else if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
877 tree t = PACK_EXPANSION_PATTERN (type);
879 t = cp_build_qualified_type_real (t, type_quals, complain);
880 return make_pack_expansion (t);
883 /* A reference or method type shall not be cv-qualified.
884 [dcl.ref], [dcl.fct] */
885 if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)
886 && (TREE_CODE (type) == REFERENCE_TYPE
887 || TREE_CODE (type) == METHOD_TYPE))
889 bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
890 type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
893 /* A restrict-qualified type must be a pointer (or reference)
894 to object or incomplete type. */
895 if ((type_quals & TYPE_QUAL_RESTRICT)
896 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
897 && TREE_CODE (type) != TYPENAME_TYPE
898 && !POINTER_TYPE_P (type))
900 bad_quals |= TYPE_QUAL_RESTRICT;
901 type_quals &= ~TYPE_QUAL_RESTRICT;
904 if (bad_quals == TYPE_UNQUALIFIED)
906 else if (!(complain & (tf_error | tf_ignore_bad_quals)))
907 return error_mark_node;
910 if (complain & tf_ignore_bad_quals)
911 /* We're not going to warn about constifying things that can't
913 bad_quals &= ~TYPE_QUAL_CONST;
916 tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
918 if (!(complain & tf_ignore_bad_quals))
919 error ("%qV qualifiers cannot be applied to %qT",
924 /* Retrieve (or create) the appropriately qualified variant. */
925 result = build_qualified_type (type, type_quals);
927 /* If this was a pointer-to-method type, and we just made a copy,
928 then we need to unshare the record that holds the cached
929 pointer-to-member-function type, because these will be distinct
930 between the unqualified and qualified types. */
932 && TREE_CODE (type) == POINTER_TYPE
933 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
934 && TYPE_LANG_SPECIFIC (result) == TYPE_LANG_SPECIFIC (type))
935 TYPE_LANG_SPECIFIC (result) = NULL;
937 /* We may also have ended up building a new copy of the canonical
938 type of a pointer-to-method type, which could have the same
939 sharing problem described above. */
940 if (TYPE_CANONICAL (result) != TYPE_CANONICAL (type)
941 && TREE_CODE (type) == POINTER_TYPE
942 && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE
943 && (TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result))
944 == TYPE_LANG_SPECIFIC (TYPE_CANONICAL (type))))
945 TYPE_LANG_SPECIFIC (TYPE_CANONICAL (result)) = NULL;
950 /* Return TYPE with const and volatile removed. */
953 cv_unqualified (tree type)
955 int quals = TYPE_QUALS (type);
956 quals &= ~(TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE);
957 return cp_build_qualified_type (type, quals);
960 /* Builds a qualified variant of T that is not a typedef variant.
961 E.g. consider the following declarations:
962 typedef const int ConstInt;
963 typedef ConstInt* PtrConstInt;
964 If T is PtrConstInt, this function returns a type representing
966 In other words, if T is a typedef, the function returns the underlying type.
967 The cv-qualification and attributes of the type returned match the
969 They will always be compatible types.
970 The returned type is built so that all of its subtypes
971 recursively have their typedefs stripped as well.
973 This is different from just returning TYPE_CANONICAL (T)
974 Because of several reasons:
975 * If T is a type that needs structural equality
976 its TYPE_CANONICAL (T) will be NULL.
977 * TYPE_CANONICAL (T) desn't carry type attributes
978 and looses template parameter names. */
981 strip_typedefs (tree t)
983 tree result = NULL, type = NULL, t0 = NULL;
985 if (!t || t == error_mark_node || t == TYPE_CANONICAL (t))
988 gcc_assert (TYPE_P (t));
990 switch (TREE_CODE (t))
993 type = strip_typedefs (TREE_TYPE (t));
994 result = build_pointer_type (type);
997 type = strip_typedefs (TREE_TYPE (t));
998 result = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
1001 t0 = strip_typedefs (TYPE_OFFSET_BASETYPE (t));
1002 type = strip_typedefs (TREE_TYPE (t));
1003 result = build_offset_type (t0, type);
1006 if (TYPE_PTRMEMFUNC_P (t))
1008 t0 = strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t));
1009 result = build_ptrmemfunc_type (t0);
1013 type = strip_typedefs (TREE_TYPE (t));
1014 t0 = strip_typedefs (TYPE_DOMAIN (t));;
1015 result = build_cplus_array_type (type, t0);
1020 tree arg_types = NULL, arg_node, arg_type;
1021 for (arg_node = TYPE_ARG_TYPES (t);
1023 arg_node = TREE_CHAIN (arg_node))
1025 if (arg_node == void_list_node)
1027 arg_type = strip_typedefs (TREE_VALUE (arg_node));
1028 gcc_assert (arg_type);
1031 tree_cons (TREE_PURPOSE (arg_node), arg_type, arg_types);
1035 arg_types = nreverse (arg_types);
1037 /* A list of parameters not ending with an ellipsis
1038 must end with void_list_node. */
1040 arg_types = chainon (arg_types, void_list_node);
1042 type = strip_typedefs (TREE_TYPE (t));
1043 if (TREE_CODE (t) == METHOD_TYPE)
1045 tree class_type = TREE_TYPE (TREE_VALUE (arg_types));
1046 gcc_assert (class_type);
1048 build_method_type_directly (class_type, type,
1049 TREE_CHAIN (arg_types));
1052 result = build_function_type (type,
1055 if (TYPE_RAISES_EXCEPTIONS (t))
1056 result = build_exception_variant (result,
1057 TYPE_RAISES_EXCEPTIONS (t));
1065 result = TYPE_MAIN_VARIANT (t);
1066 if (TYPE_ATTRIBUTES (t))
1067 result = cp_build_type_attribute_variant (result, TYPE_ATTRIBUTES (t));
1068 return cp_build_qualified_type (result, cp_type_quals (t));
1071 /* Returns true iff TYPE is a type variant created for a typedef. */
1074 typedef_variant_p (tree type)
1076 return is_typedef_decl (TYPE_NAME (type));
1079 /* Setup a TYPE_DECL node as a typedef representation.
1080 See comments of set_underlying_type in c-common.c. */
1083 cp_set_underlying_type (tree t)
1085 set_underlying_type (t);
1086 /* If T is a template type parm, make it require structural equality.
1087 This is useful when comparing two template type parms,
1088 because it forces the comparison of the template parameters of their
1090 if (TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
1091 SET_TYPE_STRUCTURAL_EQUALITY (TREE_TYPE (t));
1095 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1096 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1097 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1098 VIRT indicates whether TYPE is inherited virtually or not.
1099 IGO_PREV points at the previous binfo of the inheritance graph
1100 order chain. The newly copied binfo's TREE_CHAIN forms this
1103 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1104 correct order. That is in the order the bases themselves should be
1107 The BINFO_INHERITANCE of a virtual base class points to the binfo
1108 of the most derived type. ??? We could probably change this so that
1109 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1110 remove a field. They currently can only differ for primary virtual
1114 copy_binfo (tree binfo, tree type, tree t, tree *igo_prev, int virt)
1120 /* See if we've already made this virtual base. */
1121 new_binfo = binfo_for_vbase (type, t);
1126 new_binfo = make_tree_binfo (binfo ? BINFO_N_BASE_BINFOS (binfo) : 0);
1127 BINFO_TYPE (new_binfo) = type;
1129 /* Chain it into the inheritance graph. */
1130 TREE_CHAIN (*igo_prev) = new_binfo;
1131 *igo_prev = new_binfo;
1138 gcc_assert (!BINFO_DEPENDENT_BASE_P (binfo));
1139 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type));
1141 BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo);
1142 BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo);
1144 /* We do not need to copy the accesses, as they are read only. */
1145 BINFO_BASE_ACCESSES (new_binfo) = BINFO_BASE_ACCESSES (binfo);
1147 /* Recursively copy base binfos of BINFO. */
1148 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1150 tree new_base_binfo;
1152 gcc_assert (!BINFO_DEPENDENT_BASE_P (base_binfo));
1153 new_base_binfo = copy_binfo (base_binfo, BINFO_TYPE (base_binfo),
1155 BINFO_VIRTUAL_P (base_binfo));
1157 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo))
1158 BINFO_INHERITANCE_CHAIN (new_base_binfo) = new_binfo;
1159 BINFO_BASE_APPEND (new_binfo, new_base_binfo);
1163 BINFO_DEPENDENT_BASE_P (new_binfo) = 1;
1167 /* Push it onto the list after any virtual bases it contains
1168 will have been pushed. */
1169 VEC_quick_push (tree, CLASSTYPE_VBASECLASSES (t), new_binfo);
1170 BINFO_VIRTUAL_P (new_binfo) = 1;
1171 BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t);
1177 /* Hashing of lists so that we don't make duplicates.
1178 The entry point is `list_hash_canon'. */
1180 /* Now here is the hash table. When recording a list, it is added
1181 to the slot whose index is the hash code mod the table size.
1182 Note that the hash table is used for several kinds of lists.
1183 While all these live in the same table, they are completely independent,
1184 and the hash code is computed differently for each of these. */
1186 static GTY ((param_is (union tree_node))) htab_t list_hash_table;
1195 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1196 for a node we are thinking about adding). */
1199 list_hash_eq (const void* entry, const void* data)
1201 const_tree const t = (const_tree) entry;
1202 const struct list_proxy *const proxy = (const struct list_proxy *) data;
1204 return (TREE_VALUE (t) == proxy->value
1205 && TREE_PURPOSE (t) == proxy->purpose
1206 && TREE_CHAIN (t) == proxy->chain);
1209 /* Compute a hash code for a list (chain of TREE_LIST nodes
1210 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1211 TREE_COMMON slots), by adding the hash codes of the individual entries. */
1214 list_hash_pieces (tree purpose, tree value, tree chain)
1216 hashval_t hashcode = 0;
1219 hashcode += TREE_HASH (chain);
1222 hashcode += TREE_HASH (value);
1226 hashcode += TREE_HASH (purpose);
1232 /* Hash an already existing TREE_LIST. */
1235 list_hash (const void* p)
1237 const_tree const t = (const_tree) p;
1238 return list_hash_pieces (TREE_PURPOSE (t),
1243 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1244 object for an identical list if one already exists. Otherwise, build a
1245 new one, and record it as the canonical object. */
1248 hash_tree_cons (tree purpose, tree value, tree chain)
1252 struct list_proxy proxy;
1254 /* Hash the list node. */
1255 hashcode = list_hash_pieces (purpose, value, chain);
1256 /* Create a proxy for the TREE_LIST we would like to create. We
1257 don't actually create it so as to avoid creating garbage. */
1258 proxy.purpose = purpose;
1259 proxy.value = value;
1260 proxy.chain = chain;
1261 /* See if it is already in the table. */
1262 slot = htab_find_slot_with_hash (list_hash_table, &proxy, hashcode,
1264 /* If not, create a new node. */
1266 *slot = tree_cons (purpose, value, chain);
1267 return (tree) *slot;
1270 /* Constructor for hashed lists. */
1273 hash_tree_chain (tree value, tree chain)
1275 return hash_tree_cons (NULL_TREE, value, chain);
1279 debug_binfo (tree elem)
1284 fprintf (stderr, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
1286 TYPE_NAME_STRING (BINFO_TYPE (elem)),
1287 TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
1288 debug_tree (BINFO_TYPE (elem));
1289 if (BINFO_VTABLE (elem))
1290 fprintf (stderr, "vtable decl \"%s\"\n",
1291 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem))));
1293 fprintf (stderr, "no vtable decl yet\n");
1294 fprintf (stderr, "virtuals:\n");
1295 virtuals = BINFO_VIRTUALS (elem);
1300 tree fndecl = TREE_VALUE (virtuals);
1301 fprintf (stderr, "%s [%ld =? %ld]\n",
1302 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
1303 (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
1305 virtuals = TREE_CHAIN (virtuals);
1309 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
1310 the type of the result expression, if known, or NULL_TREE if the
1311 resulting expression is type-dependent. If TEMPLATE_P is true,
1312 NAME is known to be a template because the user explicitly used the
1313 "template" keyword after the "::".
1315 All SCOPE_REFs should be built by use of this function. */
1318 build_qualified_name (tree type, tree scope, tree name, bool template_p)
1321 if (type == error_mark_node
1322 || scope == error_mark_node
1323 || name == error_mark_node)
1324 return error_mark_node;
1325 t = build2 (SCOPE_REF, type, scope, name);
1326 QUALIFIED_NAME_IS_TEMPLATE (t) = template_p;
1328 t = convert_from_reference (t);
1332 /* Returns nonzero if X is an expression for a (possibly overloaded)
1333 function. If "f" is a function or function template, "f", "c->f",
1334 "c.f", "C::f", and "f<int>" will all be considered possibly
1335 overloaded functions. Returns 2 if the function is actually
1336 overloaded, i.e., if it is impossible to know the type of the
1337 function without performing overload resolution. */
1340 is_overloaded_fn (tree x)
1342 /* A baselink is also considered an overloaded function. */
1343 if (TREE_CODE (x) == OFFSET_REF
1344 || TREE_CODE (x) == COMPONENT_REF)
1345 x = TREE_OPERAND (x, 1);
1347 x = BASELINK_FUNCTIONS (x);
1348 if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
1349 x = TREE_OPERAND (x, 0);
1350 if (DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x))
1351 || (TREE_CODE (x) == OVERLOAD && OVL_CHAIN (x)))
1353 return (TREE_CODE (x) == FUNCTION_DECL
1354 || TREE_CODE (x) == OVERLOAD);
1357 /* Returns true iff X is an expression for an overloaded function
1358 whose type cannot be known without performing overload
1362 really_overloaded_fn (tree x)
1364 return is_overloaded_fn (x) == 2;
1368 get_first_fn (tree from)
1370 gcc_assert (is_overloaded_fn (from));
1371 /* A baselink is also considered an overloaded function. */
1372 if (TREE_CODE (from) == OFFSET_REF
1373 || TREE_CODE (from) == COMPONENT_REF)
1374 from = TREE_OPERAND (from, 1);
1375 if (BASELINK_P (from))
1376 from = BASELINK_FUNCTIONS (from);
1377 if (TREE_CODE (from) == TEMPLATE_ID_EXPR)
1378 from = TREE_OPERAND (from, 0);
1379 return OVL_CURRENT (from);
1382 /* Return a new OVL node, concatenating it with the old one. */
1385 ovl_cons (tree decl, tree chain)
1387 tree result = make_node (OVERLOAD);
1388 TREE_TYPE (result) = unknown_type_node;
1389 OVL_FUNCTION (result) = decl;
1390 TREE_CHAIN (result) = chain;
1395 /* Build a new overloaded function. If this is the first one,
1396 just return it; otherwise, ovl_cons the _DECLs */
1399 build_overload (tree decl, tree chain)
1401 if (! chain && TREE_CODE (decl) != TEMPLATE_DECL)
1403 if (chain && TREE_CODE (chain) != OVERLOAD)
1404 chain = ovl_cons (chain, NULL_TREE);
1405 return ovl_cons (decl, chain);
1409 #define PRINT_RING_SIZE 4
1412 cxx_printable_name_internal (tree decl, int v, bool translate)
1414 static unsigned int uid_ring[PRINT_RING_SIZE];
1415 static char *print_ring[PRINT_RING_SIZE];
1416 static bool trans_ring[PRINT_RING_SIZE];
1417 static int ring_counter;
1420 /* Only cache functions. */
1422 || TREE_CODE (decl) != FUNCTION_DECL
1423 || DECL_LANG_SPECIFIC (decl) == 0)
1424 return lang_decl_name (decl, v, translate);
1426 /* See if this print name is lying around. */
1427 for (i = 0; i < PRINT_RING_SIZE; i++)
1428 if (uid_ring[i] == DECL_UID (decl) && translate == trans_ring[i])
1429 /* yes, so return it. */
1430 return print_ring[i];
1432 if (++ring_counter == PRINT_RING_SIZE)
1435 if (current_function_decl != NULL_TREE)
1437 /* There may be both translated and untranslated versions of the
1439 for (i = 0; i < 2; i++)
1441 if (uid_ring[ring_counter] == DECL_UID (current_function_decl))
1443 if (ring_counter == PRINT_RING_SIZE)
1446 gcc_assert (uid_ring[ring_counter] != DECL_UID (current_function_decl));
1449 if (print_ring[ring_counter])
1450 free (print_ring[ring_counter]);
1452 print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v, translate));
1453 uid_ring[ring_counter] = DECL_UID (decl);
1454 trans_ring[ring_counter] = translate;
1455 return print_ring[ring_counter];
1459 cxx_printable_name (tree decl, int v)
1461 return cxx_printable_name_internal (decl, v, false);
1465 cxx_printable_name_translate (tree decl, int v)
1467 return cxx_printable_name_internal (decl, v, true);
1470 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
1471 listed in RAISES. */
1474 build_exception_variant (tree type, tree raises)
1476 tree v = TYPE_MAIN_VARIANT (type);
1477 int type_quals = TYPE_QUALS (type);
1479 for (; v; v = TYPE_NEXT_VARIANT (v))
1480 if (check_qualified_type (v, type, type_quals)
1481 && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (v), 1))
1484 /* Need to build a new variant. */
1485 v = build_variant_type_copy (type);
1486 TYPE_RAISES_EXCEPTIONS (v) = raises;
1490 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
1491 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
1495 bind_template_template_parm (tree t, tree newargs)
1497 tree decl = TYPE_NAME (t);
1500 t2 = cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM);
1501 decl = build_decl (input_location,
1502 TYPE_DECL, DECL_NAME (decl), NULL_TREE);
1504 /* These nodes have to be created to reflect new TYPE_DECL and template
1506 TEMPLATE_TYPE_PARM_INDEX (t2) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t));
1507 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2)) = decl;
1508 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
1509 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t), newargs);
1511 TREE_TYPE (decl) = t2;
1512 TYPE_NAME (t2) = decl;
1513 TYPE_STUB_DECL (t2) = decl;
1515 SET_TYPE_STRUCTURAL_EQUALITY (t2);
1520 /* Called from count_trees via walk_tree. */
1523 count_trees_r (tree *tp, int *walk_subtrees, void *data)
1533 /* Debugging function for measuring the rough complexity of a tree
1537 count_trees (tree t)
1540 cp_walk_tree_without_duplicates (&t, count_trees_r, &n_trees);
1544 /* Called from verify_stmt_tree via walk_tree. */
1547 verify_stmt_tree_r (tree* tp,
1548 int* walk_subtrees ATTRIBUTE_UNUSED ,
1552 htab_t *statements = (htab_t *) data;
1555 if (!STATEMENT_CODE_P (TREE_CODE (t)))
1558 /* If this statement is already present in the hash table, then
1559 there is a circularity in the statement tree. */
1560 gcc_assert (!htab_find (*statements, t));
1562 slot = htab_find_slot (*statements, t, INSERT);
1568 /* Debugging function to check that the statement T has not been
1569 corrupted. For now, this function simply checks that T contains no
1573 verify_stmt_tree (tree t)
1576 statements = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
1577 cp_walk_tree (&t, verify_stmt_tree_r, &statements, NULL);
1578 htab_delete (statements);
1581 /* Check if the type T depends on a type with no linkage and if so, return
1582 it. If RELAXED_P then do not consider a class type declared within
1583 a vague-linkage function to have no linkage. */
1586 no_linkage_check (tree t, bool relaxed_p)
1590 /* There's no point in checking linkage on template functions; we
1591 can't know their complete types. */
1592 if (processing_template_decl)
1595 switch (TREE_CODE (t))
1598 if (TYPE_PTRMEMFUNC_P (t))
1600 /* Lambda types that don't have mangling scope have no linkage. We
1601 check CLASSTYPE_LAMBDA_EXPR here rather than LAMBDA_TYPE_P because
1602 when we get here from pushtag none of the lambda information is
1603 set up yet, so we want to assume that the lambda has linkage and
1604 fix it up later if not. */
1605 if (CLASSTYPE_LAMBDA_EXPR (t)
1606 && LAMBDA_TYPE_EXTRA_SCOPE (t) == NULL_TREE)
1610 if (!CLASS_TYPE_P (t))
1614 /* Only treat anonymous types as having no linkage if they're at
1615 namespace scope. This is core issue 966. */
1616 if (TYPE_ANONYMOUS_P (t) && TYPE_NAMESPACE_SCOPE_P (t))
1619 for (r = CP_TYPE_CONTEXT (t); ; )
1621 /* If we're a nested type of a !TREE_PUBLIC class, we might not
1622 have linkage, or we might just be in an anonymous namespace.
1623 If we're in a TREE_PUBLIC class, we have linkage. */
1624 if (TYPE_P (r) && !TREE_PUBLIC (TYPE_NAME (r)))
1625 return no_linkage_check (TYPE_CONTEXT (t), relaxed_p);
1626 else if (TREE_CODE (r) == FUNCTION_DECL)
1628 if (!relaxed_p || !vague_linkage_fn_p (r))
1631 r = CP_DECL_CONTEXT (r);
1641 case REFERENCE_TYPE:
1642 return no_linkage_check (TREE_TYPE (t), relaxed_p);
1646 r = no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t),
1650 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t), relaxed_p);
1653 r = no_linkage_check (TYPE_METHOD_BASETYPE (t), relaxed_p);
1660 for (parm = TYPE_ARG_TYPES (t);
1661 parm && parm != void_list_node;
1662 parm = TREE_CHAIN (parm))
1664 r = no_linkage_check (TREE_VALUE (parm), relaxed_p);
1668 return no_linkage_check (TREE_TYPE (t), relaxed_p);
1676 #ifdef GATHER_STATISTICS
1677 extern int depth_reached;
1681 cxx_print_statistics (void)
1683 print_search_statistics ();
1684 print_class_statistics ();
1685 #ifdef GATHER_STATISTICS
1686 fprintf (stderr, "maximum template instantiation depth reached: %d\n",
1691 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1692 (which is an ARRAY_TYPE). This counts only elements of the top
1696 array_type_nelts_top (tree type)
1698 return fold_build2_loc (input_location,
1699 PLUS_EXPR, sizetype,
1700 array_type_nelts (type),
1704 /* Return, as an INTEGER_CST node, the number of elements for TYPE
1705 (which is an ARRAY_TYPE). This one is a recursive count of all
1706 ARRAY_TYPEs that are clumped together. */
1709 array_type_nelts_total (tree type)
1711 tree sz = array_type_nelts_top (type);
1712 type = TREE_TYPE (type);
1713 while (TREE_CODE (type) == ARRAY_TYPE)
1715 tree n = array_type_nelts_top (type);
1716 sz = fold_build2_loc (input_location,
1717 MULT_EXPR, sizetype, sz, n);
1718 type = TREE_TYPE (type);
1723 /* Called from break_out_target_exprs via mapcar. */
1726 bot_manip (tree* tp, int* walk_subtrees, void* data)
1728 splay_tree target_remap = ((splay_tree) data);
1731 if (!TYPE_P (t) && TREE_CONSTANT (t))
1733 /* There can't be any TARGET_EXPRs or their slot variables below
1734 this point. We used to check !TREE_SIDE_EFFECTS, but then we
1735 failed to copy an ADDR_EXPR of the slot VAR_DECL. */
1739 if (TREE_CODE (t) == TARGET_EXPR)
1743 if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
1744 u = build_cplus_new (TREE_TYPE (t), TREE_OPERAND (t, 1));
1746 u = build_target_expr_with_type (TREE_OPERAND (t, 1), TREE_TYPE (t));
1748 /* Map the old variable to the new one. */
1749 splay_tree_insert (target_remap,
1750 (splay_tree_key) TREE_OPERAND (t, 0),
1751 (splay_tree_value) TREE_OPERAND (u, 0));
1753 TREE_OPERAND (u, 1) = break_out_target_exprs (TREE_OPERAND (u, 1));
1755 /* Replace the old expression with the new version. */
1757 /* We don't have to go below this point; the recursive call to
1758 break_out_target_exprs will have handled anything below this
1764 /* Make a copy of this node. */
1765 return copy_tree_r (tp, walk_subtrees, NULL);
1768 /* Replace all remapped VAR_DECLs in T with their new equivalents.
1769 DATA is really a splay-tree mapping old variables to new
1773 bot_replace (tree* t,
1774 int* walk_subtrees ATTRIBUTE_UNUSED ,
1777 splay_tree target_remap = ((splay_tree) data);
1779 if (TREE_CODE (*t) == VAR_DECL)
1781 splay_tree_node n = splay_tree_lookup (target_remap,
1782 (splay_tree_key) *t);
1784 *t = (tree) n->value;
1790 /* When we parse a default argument expression, we may create
1791 temporary variables via TARGET_EXPRs. When we actually use the
1792 default-argument expression, we make a copy of the expression, but
1793 we must replace the temporaries with appropriate local versions. */
1796 break_out_target_exprs (tree t)
1798 static int target_remap_count;
1799 static splay_tree target_remap;
1801 if (!target_remap_count++)
1802 target_remap = splay_tree_new (splay_tree_compare_pointers,
1803 /*splay_tree_delete_key_fn=*/NULL,
1804 /*splay_tree_delete_value_fn=*/NULL);
1805 cp_walk_tree (&t, bot_manip, target_remap, NULL);
1806 cp_walk_tree (&t, bot_replace, target_remap, NULL);
1808 if (!--target_remap_count)
1810 splay_tree_delete (target_remap);
1811 target_remap = NULL;
1817 /* Similar to `build_nt', but for template definitions of dependent
1821 build_min_nt (enum tree_code code, ...)
1828 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1832 t = make_node (code);
1833 length = TREE_CODE_LENGTH (code);
1835 for (i = 0; i < length; i++)
1837 tree x = va_arg (p, tree);
1838 TREE_OPERAND (t, i) = x;
1846 /* Similar to `build', but for template definitions. */
1849 build_min (enum tree_code code, tree tt, ...)
1856 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1860 t = make_node (code);
1861 length = TREE_CODE_LENGTH (code);
1864 for (i = 0; i < length; i++)
1866 tree x = va_arg (p, tree);
1867 TREE_OPERAND (t, i) = x;
1868 if (x && !TYPE_P (x) && TREE_SIDE_EFFECTS (x))
1869 TREE_SIDE_EFFECTS (t) = 1;
1876 /* Similar to `build', but for template definitions of non-dependent
1877 expressions. NON_DEP is the non-dependent expression that has been
1881 build_min_non_dep (enum tree_code code, tree non_dep, ...)
1888 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
1890 va_start (p, non_dep);
1892 t = make_node (code);
1893 length = TREE_CODE_LENGTH (code);
1894 TREE_TYPE (t) = TREE_TYPE (non_dep);
1895 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
1897 for (i = 0; i < length; i++)
1899 tree x = va_arg (p, tree);
1900 TREE_OPERAND (t, i) = x;
1903 if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR)
1904 /* This should not be considered a COMPOUND_EXPR, because it
1905 resolves to an overload. */
1906 COMPOUND_EXPR_OVERLOADED (t) = 1;
1912 /* Similar to `build_call_list', but for template definitions of non-dependent
1913 expressions. NON_DEP is the non-dependent expression that has been
1917 build_min_non_dep_call_vec (tree non_dep, tree fn, VEC(tree,gc) *argvec)
1919 tree t = build_nt_call_vec (fn, argvec);
1920 TREE_TYPE (t) = TREE_TYPE (non_dep);
1921 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
1926 get_type_decl (tree t)
1928 if (TREE_CODE (t) == TYPE_DECL)
1931 return TYPE_STUB_DECL (t);
1932 gcc_assert (t == error_mark_node);
1936 /* Returns the namespace that contains DECL, whether directly or
1940 decl_namespace_context (tree decl)
1944 if (TREE_CODE (decl) == NAMESPACE_DECL)
1946 else if (TYPE_P (decl))
1947 decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
1949 decl = CP_DECL_CONTEXT (decl);
1953 /* Returns true if decl is within an anonymous namespace, however deeply
1954 nested, or false otherwise. */
1957 decl_anon_ns_mem_p (const_tree decl)
1961 if (decl == NULL_TREE || decl == error_mark_node)
1963 if (TREE_CODE (decl) == NAMESPACE_DECL
1964 && DECL_NAME (decl) == NULL_TREE)
1966 /* Classes and namespaces inside anonymous namespaces have
1967 TREE_PUBLIC == 0, so we can shortcut the search. */
1968 else if (TYPE_P (decl))
1969 return (TREE_PUBLIC (TYPE_NAME (decl)) == 0);
1970 else if (TREE_CODE (decl) == NAMESPACE_DECL)
1971 return (TREE_PUBLIC (decl) == 0);
1973 decl = DECL_CONTEXT (decl);
1977 /* Return truthvalue of whether T1 is the same tree structure as T2.
1978 Return 1 if they are the same. Return 0 if they are different. */
1981 cp_tree_equal (tree t1, tree t2)
1983 enum tree_code code1, code2;
1990 for (code1 = TREE_CODE (t1);
1991 CONVERT_EXPR_CODE_P (code1)
1992 || code1 == NON_LVALUE_EXPR;
1993 code1 = TREE_CODE (t1))
1994 t1 = TREE_OPERAND (t1, 0);
1995 for (code2 = TREE_CODE (t2);
1996 CONVERT_EXPR_CODE_P (code2)
1997 || code1 == NON_LVALUE_EXPR;
1998 code2 = TREE_CODE (t2))
1999 t2 = TREE_OPERAND (t2, 0);
2001 /* They might have become equal now. */
2011 return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2012 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
2015 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2018 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2019 && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2020 TREE_STRING_LENGTH (t1));
2023 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),
2024 TREE_FIXED_CST (t2));
2027 return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
2028 && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
2031 /* We need to do this when determining whether or not two
2032 non-type pointer to member function template arguments
2034 if (!(same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2035 /* The first operand is RTL. */
2036 && TREE_OPERAND (t1, 0) == TREE_OPERAND (t2, 0)))
2038 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2041 if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
2043 if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
2045 return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
2048 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2053 call_expr_arg_iterator iter1, iter2;
2054 if (!cp_tree_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
2056 for (arg1 = first_call_expr_arg (t1, &iter1),
2057 arg2 = first_call_expr_arg (t2, &iter2);
2059 arg1 = next_call_expr_arg (&iter1),
2060 arg2 = next_call_expr_arg (&iter2))
2061 if (!cp_tree_equal (arg1, arg2))
2063 return (arg1 || arg2);
2068 tree o1 = TREE_OPERAND (t1, 0);
2069 tree o2 = TREE_OPERAND (t2, 0);
2071 /* Special case: if either target is an unallocated VAR_DECL,
2072 it means that it's going to be unified with whatever the
2073 TARGET_EXPR is really supposed to initialize, so treat it
2074 as being equivalent to anything. */
2075 if (TREE_CODE (o1) == VAR_DECL && DECL_NAME (o1) == NULL_TREE
2076 && !DECL_RTL_SET_P (o1))
2078 else if (TREE_CODE (o2) == VAR_DECL && DECL_NAME (o2) == NULL_TREE
2079 && !DECL_RTL_SET_P (o2))
2081 else if (!cp_tree_equal (o1, o2))
2084 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2087 case WITH_CLEANUP_EXPR:
2088 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2090 return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
2093 if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1))
2095 return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2098 /* For comparing uses of parameters in late-specified return types
2099 with an out-of-class definition of the function. */
2100 if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2101 && DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2))
2110 case IDENTIFIER_NODE:
2115 return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
2116 && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
2117 && cp_tree_equal (BASELINK_FUNCTIONS (t1),
2118 BASELINK_FUNCTIONS (t2)));
2120 case TEMPLATE_PARM_INDEX:
2121 return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
2122 && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
2123 && (TEMPLATE_PARM_PARAMETER_PACK (t1)
2124 == TEMPLATE_PARM_PARAMETER_PACK (t2))
2125 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
2126 TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
2128 case TEMPLATE_ID_EXPR:
2133 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2135 vec1 = TREE_OPERAND (t1, 1);
2136 vec2 = TREE_OPERAND (t2, 1);
2139 return !vec1 && !vec2;
2141 if (TREE_VEC_LENGTH (vec1) != TREE_VEC_LENGTH (vec2))
2144 for (ix = TREE_VEC_LENGTH (vec1); ix--;)
2145 if (!cp_tree_equal (TREE_VEC_ELT (vec1, ix),
2146 TREE_VEC_ELT (vec2, ix)))
2155 tree o1 = TREE_OPERAND (t1, 0);
2156 tree o2 = TREE_OPERAND (t2, 0);
2158 if (TREE_CODE (o1) != TREE_CODE (o2))
2161 return same_type_p (o1, o2);
2163 return cp_tree_equal (o1, o2);
2168 tree t1_op1, t2_op1;
2170 if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
2173 t1_op1 = TREE_OPERAND (t1, 1);
2174 t2_op1 = TREE_OPERAND (t2, 1);
2175 if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
2178 return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
2182 /* Two pointer-to-members are the same if they point to the same
2183 field or function in the same class. */
2184 if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
2187 return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
2190 if (OVL_FUNCTION (t1) != OVL_FUNCTION (t2))
2192 return cp_tree_equal (OVL_CHAIN (t1), OVL_CHAIN (t2));
2195 if (TRAIT_EXPR_KIND (t1) != TRAIT_EXPR_KIND (t2))
2197 return same_type_p (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2))
2198 && same_type_p (TRAIT_EXPR_TYPE2 (t1), TRAIT_EXPR_TYPE2 (t2));
2204 switch (TREE_CODE_CLASS (code1))
2208 case tcc_comparison:
2209 case tcc_expression:
2216 n = TREE_OPERAND_LENGTH (t1);
2217 if (TREE_CODE_CLASS (code1) == tcc_vl_exp
2218 && n != TREE_OPERAND_LENGTH (t2))
2221 for (i = 0; i < n; ++i)
2222 if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
2229 return same_type_p (t1, t2);
2233 /* We can get here with --disable-checking. */
2237 /* The type of ARG when used as an lvalue. */
2240 lvalue_type (tree arg)
2242 tree type = TREE_TYPE (arg);
2246 /* The type of ARG for printing error messages; denote lvalues with
2250 error_type (tree arg)
2252 tree type = TREE_TYPE (arg);
2254 if (TREE_CODE (type) == ARRAY_TYPE)
2256 else if (TREE_CODE (type) == ERROR_MARK)
2258 else if (real_lvalue_p (arg))
2259 type = build_reference_type (lvalue_type (arg));
2260 else if (MAYBE_CLASS_TYPE_P (type))
2261 type = lvalue_type (arg);
2266 /* Does FUNCTION use a variable-length argument list? */
2269 varargs_function_p (const_tree function)
2271 const_tree parm = TYPE_ARG_TYPES (TREE_TYPE (function));
2272 for (; parm; parm = TREE_CHAIN (parm))
2273 if (TREE_VALUE (parm) == void_type_node)
2278 /* Returns 1 if decl is a member of a class. */
2281 member_p (const_tree decl)
2283 const_tree const ctx = DECL_CONTEXT (decl);
2284 return (ctx && TYPE_P (ctx));
2287 /* Create a placeholder for member access where we don't actually have an
2288 object that the access is against. */
2291 build_dummy_object (tree type)
2293 tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node);
2294 return cp_build_indirect_ref (decl, RO_NULL, tf_warning_or_error);
2297 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
2298 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
2299 binfo path from current_class_type to TYPE, or 0. */
2302 maybe_dummy_object (tree type, tree* binfop)
2307 if (current_class_type
2308 && (binfo = lookup_base (current_class_type, type,
2309 ba_unique | ba_quiet, NULL)))
2310 context = current_class_type;
2313 /* Reference from a nested class member function. */
2315 binfo = TYPE_BINFO (type);
2321 if (current_class_ref && context == current_class_type
2322 /* Kludge: Make sure that current_class_type is actually
2323 correct. It might not be if we're in the middle of
2324 tsubst_default_argument. */
2325 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref)),
2326 current_class_type))
2327 decl = current_class_ref;
2329 decl = build_dummy_object (context);
2334 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
2337 is_dummy_object (const_tree ob)
2339 if (TREE_CODE (ob) == INDIRECT_REF)
2340 ob = TREE_OPERAND (ob, 0);
2341 return (TREE_CODE (ob) == NOP_EXPR
2342 && TREE_OPERAND (ob, 0) == void_zero_node);
2345 /* Returns 1 iff type T is something we want to treat as a scalar type for
2346 the purpose of deciding whether it is trivial/POD/standard-layout. */
2349 scalarish_type_p (const_tree t)
2351 if (t == error_mark_node)
2354 return (SCALAR_TYPE_P (t)
2355 || TREE_CODE (t) == VECTOR_TYPE);
2358 /* Returns true iff T requires non-trivial default initialization. */
2361 type_has_nontrivial_default_init (const_tree t)
2363 t = strip_array_types (CONST_CAST_TREE (t));
2365 if (CLASS_TYPE_P (t))
2366 return TYPE_HAS_COMPLEX_DFLT (t);
2371 /* Returns true iff copying an object of type T is non-trivial. */
2374 type_has_nontrivial_copy_init (const_tree t)
2376 t = strip_array_types (CONST_CAST_TREE (t));
2378 if (CLASS_TYPE_P (t))
2379 return TYPE_HAS_COMPLEX_INIT_REF (t);
2384 /* Returns 1 iff type T is a trivial type, as defined in [basic.types]. */
2387 trivial_type_p (const_tree t)
2389 t = strip_array_types (CONST_CAST_TREE (t));
2391 if (CLASS_TYPE_P (t))
2392 return (TYPE_HAS_TRIVIAL_DFLT (t)
2393 && TYPE_HAS_TRIVIAL_INIT_REF (t)
2394 && TYPE_HAS_TRIVIAL_ASSIGN_REF (t)
2395 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t));
2397 return scalarish_type_p (t);
2400 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
2403 pod_type_p (const_tree t)
2405 /* This CONST_CAST is okay because strip_array_types returns its
2406 argument unmodified and we assign it to a const_tree. */
2407 t = strip_array_types (CONST_CAST_TREE(t));
2409 if (CLASS_TYPE_P (t))
2410 /* [class]/10: A POD struct is a class that is both a trivial class and a
2411 standard-layout class, and has no non-static data members of type
2412 non-POD struct, non-POD union (or array of such types).
2414 We don't need to check individual members because if a member is
2415 non-std-layout or non-trivial, the class will be too. */
2416 return (std_layout_type_p (t) && trivial_type_p (t));
2418 return scalarish_type_p (t);
2421 /* Returns true iff T is POD for the purpose of layout, as defined in the
2425 layout_pod_type_p (const_tree t)
2427 t = strip_array_types (CONST_CAST_TREE (t));
2429 if (CLASS_TYPE_P (t))
2430 return !CLASSTYPE_NON_LAYOUT_POD_P (t);
2432 return scalarish_type_p (t);
2435 /* Returns true iff T is a standard-layout type, as defined in
2439 std_layout_type_p (const_tree t)
2441 t = strip_array_types (CONST_CAST_TREE (t));
2443 if (CLASS_TYPE_P (t))
2444 return !CLASSTYPE_NON_STD_LAYOUT (t);
2446 return scalarish_type_p (t);
2449 /* Nonzero iff type T is a class template implicit specialization. */
2452 class_tmpl_impl_spec_p (const_tree t)
2454 return CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INSTANTIATION (t);
2457 /* Returns 1 iff zero initialization of type T means actually storing
2461 zero_init_p (const_tree t)
2463 /* This CONST_CAST is okay because strip_array_types returns its
2464 argument unmodified and we assign it to a const_tree. */
2465 t = strip_array_types (CONST_CAST_TREE(t));
2467 if (t == error_mark_node)
2470 /* NULL pointers to data members are initialized with -1. */
2471 if (TYPE_PTRMEM_P (t))
2474 /* Classes that contain types that can't be zero-initialized, cannot
2475 be zero-initialized themselves. */
2476 if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
2482 /* Table of valid C++ attributes. */
2483 const struct attribute_spec cxx_attribute_table[] =
2485 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2486 { "java_interface", 0, 0, false, false, false, handle_java_interface_attribute },
2487 { "com_interface", 0, 0, false, false, false, handle_com_interface_attribute },
2488 { "init_priority", 1, 1, true, false, false, handle_init_priority_attribute },
2489 { NULL, 0, 0, false, false, false, NULL }
2492 /* Handle a "java_interface" attribute; arguments as in
2493 struct attribute_spec.handler. */
2495 handle_java_interface_attribute (tree* node,
2497 tree args ATTRIBUTE_UNUSED ,
2502 || !CLASS_TYPE_P (*node)
2503 || !TYPE_FOR_JAVA (*node))
2505 error ("%qE attribute can only be applied to Java class definitions",
2507 *no_add_attrs = true;
2510 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
2511 *node = build_variant_type_copy (*node);
2512 TYPE_JAVA_INTERFACE (*node) = 1;
2517 /* Handle a "com_interface" attribute; arguments as in
2518 struct attribute_spec.handler. */
2520 handle_com_interface_attribute (tree* node,
2522 tree args ATTRIBUTE_UNUSED ,
2523 int flags ATTRIBUTE_UNUSED ,
2528 *no_add_attrs = true;
2531 || !CLASS_TYPE_P (*node)
2532 || *node != TYPE_MAIN_VARIANT (*node))
2534 warning (OPT_Wattributes, "%qE attribute can only be applied "
2535 "to class definitions", name);
2540 warning (0, "%qE is obsolete; g++ vtables are now COM-compatible by default",
2546 /* Handle an "init_priority" attribute; arguments as in
2547 struct attribute_spec.handler. */
2549 handle_init_priority_attribute (tree* node,
2552 int flags ATTRIBUTE_UNUSED ,
2555 tree initp_expr = TREE_VALUE (args);
2557 tree type = TREE_TYPE (decl);
2560 STRIP_NOPS (initp_expr);
2562 if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
2564 error ("requested init_priority is not an integer constant");
2565 *no_add_attrs = true;
2569 pri = TREE_INT_CST_LOW (initp_expr);
2571 type = strip_array_types (type);
2573 if (decl == NULL_TREE
2574 || TREE_CODE (decl) != VAR_DECL
2575 || !TREE_STATIC (decl)
2576 || DECL_EXTERNAL (decl)
2577 || (TREE_CODE (type) != RECORD_TYPE
2578 && TREE_CODE (type) != UNION_TYPE)
2579 /* Static objects in functions are initialized the
2580 first time control passes through that
2581 function. This is not precise enough to pin down an
2582 init_priority value, so don't allow it. */
2583 || current_function_decl)
2585 error ("can only use %qE attribute on file-scope definitions "
2586 "of objects of class type", name);
2587 *no_add_attrs = true;
2591 if (pri > MAX_INIT_PRIORITY || pri <= 0)
2593 error ("requested init_priority is out of range");
2594 *no_add_attrs = true;
2598 /* Check for init_priorities that are reserved for
2599 language and runtime support implementations.*/
2600 if (pri <= MAX_RESERVED_INIT_PRIORITY)
2603 (0, "requested init_priority is reserved for internal use");
2606 if (SUPPORTS_INIT_PRIORITY)
2608 SET_DECL_INIT_PRIORITY (decl, pri);
2609 DECL_HAS_INIT_PRIORITY_P (decl) = 1;
2614 error ("%qE attribute is not supported on this platform", name);
2615 *no_add_attrs = true;
2620 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
2621 thing pointed to by the constant. */
2624 make_ptrmem_cst (tree type, tree member)
2626 tree ptrmem_cst = make_node (PTRMEM_CST);
2627 TREE_TYPE (ptrmem_cst) = type;
2628 PTRMEM_CST_MEMBER (ptrmem_cst) = member;
2632 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
2633 return an existing type if an appropriate type already exists. */
2636 cp_build_type_attribute_variant (tree type, tree attributes)
2640 new_type = build_type_attribute_variant (type, attributes);
2641 if ((TREE_CODE (new_type) == FUNCTION_TYPE
2642 || TREE_CODE (new_type) == METHOD_TYPE)
2643 && (TYPE_RAISES_EXCEPTIONS (new_type)
2644 != TYPE_RAISES_EXCEPTIONS (type)))
2645 new_type = build_exception_variant (new_type,
2646 TYPE_RAISES_EXCEPTIONS (type));
2648 /* Making a new main variant of a class type is broken. */
2649 gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
2654 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
2655 Called only after doing all language independent checks. Only
2656 to check TYPE_RAISES_EXCEPTIONS for FUNCTION_TYPE, the rest is already
2657 compared in type_hash_eq. */
2660 cxx_type_hash_eq (const_tree typea, const_tree typeb)
2662 gcc_assert (TREE_CODE (typea) == FUNCTION_TYPE);
2664 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea),
2665 TYPE_RAISES_EXCEPTIONS (typeb), 1);
2668 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
2669 traversal. Called from walk_tree. */
2672 cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
2673 void *data, struct pointer_set_t *pset)
2675 enum tree_code code = TREE_CODE (*tp);
2678 #define WALK_SUBTREE(NODE) \
2681 result = cp_walk_tree (&(NODE), func, data, pset); \
2682 if (result) goto out; \
2686 /* Not one of the easy cases. We must explicitly go through the
2692 case TEMPLATE_TEMPLATE_PARM:
2693 case BOUND_TEMPLATE_TEMPLATE_PARM:
2694 case UNBOUND_CLASS_TEMPLATE:
2695 case TEMPLATE_PARM_INDEX:
2696 case TEMPLATE_TYPE_PARM:
2699 /* None of these have subtrees other than those already walked
2701 *walk_subtrees_p = 0;
2705 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp));
2706 *walk_subtrees_p = 0;
2710 WALK_SUBTREE (TREE_TYPE (*tp));
2711 *walk_subtrees_p = 0;
2715 WALK_SUBTREE (TREE_PURPOSE (*tp));
2719 WALK_SUBTREE (OVL_FUNCTION (*tp));
2720 WALK_SUBTREE (OVL_CHAIN (*tp));
2721 *walk_subtrees_p = 0;
2725 WALK_SUBTREE (DECL_NAME (*tp));
2726 WALK_SUBTREE (USING_DECL_SCOPE (*tp));
2727 WALK_SUBTREE (USING_DECL_DECLS (*tp));
2728 *walk_subtrees_p = 0;
2732 if (TYPE_PTRMEMFUNC_P (*tp))
2733 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE (*tp));
2736 case TYPE_ARGUMENT_PACK:
2737 case NONTYPE_ARGUMENT_PACK:
2739 tree args = ARGUMENT_PACK_ARGS (*tp);
2740 int i, len = TREE_VEC_LENGTH (args);
2741 for (i = 0; i < len; i++)
2742 WALK_SUBTREE (TREE_VEC_ELT (args, i));
2746 case TYPE_PACK_EXPANSION:
2747 WALK_SUBTREE (TREE_TYPE (*tp));
2748 *walk_subtrees_p = 0;
2751 case EXPR_PACK_EXPANSION:
2752 WALK_SUBTREE (TREE_OPERAND (*tp, 0));
2753 *walk_subtrees_p = 0;
2757 case REINTERPRET_CAST_EXPR:
2758 case STATIC_CAST_EXPR:
2759 case CONST_CAST_EXPR:
2760 case DYNAMIC_CAST_EXPR:
2761 if (TREE_TYPE (*tp))
2762 WALK_SUBTREE (TREE_TYPE (*tp));
2766 for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (*tp)); ++i)
2767 WALK_SUBTREE (TREE_OPERAND (*tp, i));
2769 *walk_subtrees_p = 0;
2773 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp));
2774 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp));
2775 *walk_subtrees_p = 0;
2779 WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp));
2780 *walk_subtrees_p = 0;
2788 /* We didn't find what we were looking for. */
2795 /* Like save_expr, but for C++. */
2798 cp_save_expr (tree expr)
2800 /* There is no reason to create a SAVE_EXPR within a template; if
2801 needed, we can create the SAVE_EXPR when instantiating the
2802 template. Furthermore, the middle-end cannot handle C++-specific
2804 if (processing_template_decl)
2806 return save_expr (expr);
2809 /* Initialize tree.c. */
2814 list_hash_table = htab_create_ggc (31, list_hash, list_hash_eq, NULL);
2817 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
2818 is. Note that sfk_none is zero, so this function can be used as a
2819 predicate to test whether or not DECL is a special function. */
2821 special_function_kind
2822 special_function_p (const_tree decl)
2824 /* Rather than doing all this stuff with magic names, we should
2825 probably have a field of type `special_function_kind' in
2826 DECL_LANG_SPECIFIC. */
2827 if (DECL_COPY_CONSTRUCTOR_P (decl))
2828 return sfk_copy_constructor;
2829 if (DECL_MOVE_CONSTRUCTOR_P (decl))
2830 return sfk_move_constructor;
2831 if (DECL_CONSTRUCTOR_P (decl))
2832 return sfk_constructor;
2833 if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
2834 return sfk_assignment_operator;
2835 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
2836 return sfk_destructor;
2837 if (DECL_COMPLETE_DESTRUCTOR_P (decl))
2838 return sfk_complete_destructor;
2839 if (DECL_BASE_DESTRUCTOR_P (decl))
2840 return sfk_base_destructor;
2841 if (DECL_DELETING_DESTRUCTOR_P (decl))
2842 return sfk_deleting_destructor;
2843 if (DECL_CONV_FN_P (decl))
2844 return sfk_conversion;
2849 /* Returns nonzero if TYPE is a character type, including wchar_t. */
2852 char_type_p (tree type)
2854 return (same_type_p (type, char_type_node)
2855 || same_type_p (type, unsigned_char_type_node)
2856 || same_type_p (type, signed_char_type_node)
2857 || same_type_p (type, char16_type_node)
2858 || same_type_p (type, char32_type_node)
2859 || same_type_p (type, wchar_type_node));
2862 /* Returns the kind of linkage associated with the indicated DECL. Th
2863 value returned is as specified by the language standard; it is
2864 independent of implementation details regarding template
2865 instantiation, etc. For example, it is possible that a declaration
2866 to which this function assigns external linkage would not show up
2867 as a global symbol when you run `nm' on the resulting object file. */
2870 decl_linkage (tree decl)
2872 /* This function doesn't attempt to calculate the linkage from first
2873 principles as given in [basic.link]. Instead, it makes use of
2874 the fact that we have already set TREE_PUBLIC appropriately, and
2875 then handles a few special cases. Ideally, we would calculate
2876 linkage first, and then transform that into a concrete
2879 /* Things that don't have names have no linkage. */
2880 if (!DECL_NAME (decl))
2883 /* Fields have no linkage. */
2884 if (TREE_CODE (decl) == FIELD_DECL)
2887 /* Things that are TREE_PUBLIC have external linkage. */
2888 if (TREE_PUBLIC (decl))
2891 if (TREE_CODE (decl) == NAMESPACE_DECL)
2894 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
2896 if (TREE_CODE (decl) == CONST_DECL)
2897 return decl_linkage (TYPE_NAME (TREE_TYPE (decl)));
2899 /* Some things that are not TREE_PUBLIC have external linkage, too.
2900 For example, on targets that don't have weak symbols, we make all
2901 template instantiations have internal linkage (in the object
2902 file), but the symbols should still be treated as having external
2903 linkage from the point of view of the language. */
2904 if ((TREE_CODE (decl) == FUNCTION_DECL
2905 || TREE_CODE (decl) == VAR_DECL)
2906 && DECL_COMDAT (decl))
2909 /* Things in local scope do not have linkage, if they don't have
2911 if (decl_function_context (decl))
2914 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
2915 are considered to have external linkage for language purposes. DECLs
2916 really meant to have internal linkage have DECL_THIS_STATIC set. */
2917 if (TREE_CODE (decl) == TYPE_DECL)
2919 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
2921 if (!DECL_THIS_STATIC (decl))
2924 /* Static data members and static member functions from classes
2925 in anonymous namespace also don't have TREE_PUBLIC set. */
2926 if (DECL_CLASS_CONTEXT (decl))
2930 /* Everything else has internal linkage. */
2934 /* EXP is an expression that we want to pre-evaluate. Returns (in
2935 *INITP) an expression that will perform the pre-evaluation. The
2936 value returned by this function is a side-effect free expression
2937 equivalent to the pre-evaluated expression. Callers must ensure
2938 that *INITP is evaluated before EXP. */
2941 stabilize_expr (tree exp, tree* initp)
2945 if (!TREE_SIDE_EFFECTS (exp))
2946 init_expr = NULL_TREE;
2947 else if (!real_lvalue_p (exp)
2948 || !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (exp)))
2950 init_expr = get_target_expr (exp);
2951 exp = TARGET_EXPR_SLOT (init_expr);
2955 exp = cp_build_unary_op (ADDR_EXPR, exp, 1, tf_warning_or_error);
2956 init_expr = get_target_expr (exp);
2957 exp = TARGET_EXPR_SLOT (init_expr);
2958 exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error);
2962 gcc_assert (!TREE_SIDE_EFFECTS (exp));
2966 /* Add NEW_EXPR, an expression whose value we don't care about, after the
2967 similar expression ORIG. */
2970 add_stmt_to_compound (tree orig, tree new_expr)
2972 if (!new_expr || !TREE_SIDE_EFFECTS (new_expr))
2974 if (!orig || !TREE_SIDE_EFFECTS (orig))
2976 return build2 (COMPOUND_EXPR, void_type_node, orig, new_expr);
2979 /* Like stabilize_expr, but for a call whose arguments we want to
2980 pre-evaluate. CALL is modified in place to use the pre-evaluated
2981 arguments, while, upon return, *INITP contains an expression to
2982 compute the arguments. */
2985 stabilize_call (tree call, tree *initp)
2987 tree inits = NULL_TREE;
2989 int nargs = call_expr_nargs (call);
2991 if (call == error_mark_node || processing_template_decl)
2997 gcc_assert (TREE_CODE (call) == CALL_EXPR);
2999 for (i = 0; i < nargs; i++)
3002 CALL_EXPR_ARG (call, i) =
3003 stabilize_expr (CALL_EXPR_ARG (call, i), &init);
3004 inits = add_stmt_to_compound (inits, init);
3010 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
3011 to pre-evaluate. CALL is modified in place to use the pre-evaluated
3012 arguments, while, upon return, *INITP contains an expression to
3013 compute the arguments. */
3016 stabilize_aggr_init (tree call, tree *initp)
3018 tree inits = NULL_TREE;
3020 int nargs = aggr_init_expr_nargs (call);
3022 if (call == error_mark_node)
3025 gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
3027 for (i = 0; i < nargs; i++)
3030 AGGR_INIT_EXPR_ARG (call, i) =
3031 stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
3032 inits = add_stmt_to_compound (inits, init);
3038 /* Like stabilize_expr, but for an initialization.
3040 If the initialization is for an object of class type, this function
3041 takes care not to introduce additional temporaries.
3043 Returns TRUE iff the expression was successfully pre-evaluated,
3044 i.e., if INIT is now side-effect free, except for, possible, a
3045 single call to a constructor. */
3048 stabilize_init (tree init, tree *initp)
3054 if (t == error_mark_node || processing_template_decl)
3057 if (TREE_CODE (t) == INIT_EXPR
3058 && TREE_CODE (TREE_OPERAND (t, 1)) != TARGET_EXPR
3059 && TREE_CODE (TREE_OPERAND (t, 1)) != AGGR_INIT_EXPR)
3061 TREE_OPERAND (t, 1) = stabilize_expr (TREE_OPERAND (t, 1), initp);
3065 if (TREE_CODE (t) == INIT_EXPR)
3066 t = TREE_OPERAND (t, 1);
3067 if (TREE_CODE (t) == TARGET_EXPR)
3068 t = TARGET_EXPR_INITIAL (t);
3069 if (TREE_CODE (t) == COMPOUND_EXPR)
3071 if (TREE_CODE (t) == CONSTRUCTOR
3072 && EMPTY_CONSTRUCTOR_P (t))
3073 /* Default-initialization. */
3076 /* If the initializer is a COND_EXPR, we can't preevaluate
3078 if (TREE_CODE (t) == COND_EXPR)
3081 if (TREE_CODE (t) == CALL_EXPR)
3083 stabilize_call (t, initp);
3087 if (TREE_CODE (t) == AGGR_INIT_EXPR)
3089 stabilize_aggr_init (t, initp);
3093 /* The initialization is being performed via a bitwise copy -- and
3094 the item copied may have side effects. */
3095 return TREE_SIDE_EFFECTS (init);
3098 /* Like "fold", but should be used whenever we might be processing the
3099 body of a template. */
3102 fold_if_not_in_template (tree expr)
3104 /* In the body of a template, there is never any need to call
3105 "fold". We will call fold later when actually instantiating the
3106 template. Integral constant expressions in templates will be
3107 evaluated via fold_non_dependent_expr, as necessary. */
3108 if (processing_template_decl)
3111 /* Fold C++ front-end specific tree codes. */
3112 if (TREE_CODE (expr) == UNARY_PLUS_EXPR)
3113 return fold_convert (TREE_TYPE (expr), TREE_OPERAND (expr, 0));
3118 /* Returns true if a cast to TYPE may appear in an integral constant
3122 cast_valid_in_integral_constant_expression_p (tree type)
3124 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
3125 || dependent_type_p (type)
3126 || type == error_mark_node);
3129 /* Return true if we need to fix linkage information of DECL. */
3132 cp_fix_function_decl_p (tree decl)
3134 /* Skip if DECL is not externally visible. */
3135 if (!TREE_PUBLIC (decl))
3138 /* We need to fix DECL if it a appears to be exported but with no
3139 function body. Thunks do not have CFGs and we may need to
3140 handle them specially later. */
3141 if (!gimple_has_body_p (decl)
3142 && !DECL_THUNK_P (decl)
3143 && !DECL_EXTERNAL (decl))
3145 struct cgraph_node *node = cgraph_get_node (decl);
3147 /* Don't fix same_body aliases. Although they don't have their own
3148 CFG, they share it with what they alias to. */
3150 || node->decl == decl
3151 || !node->same_body)
3158 /* Clean the C++ specific parts of the tree T. */
3161 cp_free_lang_data (tree t)
3163 if (TREE_CODE (t) == METHOD_TYPE
3164 || TREE_CODE (t) == FUNCTION_TYPE)
3166 /* Default args are not interesting anymore. */
3167 tree argtypes = TYPE_ARG_TYPES (t);
3170 TREE_PURPOSE (argtypes) = 0;
3171 argtypes = TREE_CHAIN (argtypes);
3174 else if (TREE_CODE (t) == FUNCTION_DECL
3175 && cp_fix_function_decl_p (t))
3177 /* If T is used in this translation unit at all, the definition
3178 must exist somewhere else since we have decided to not emit it
3179 in this TU. So make it an external reference. */
3180 DECL_EXTERNAL (t) = 1;
3181 TREE_STATIC (t) = 0;
3183 if (CP_AGGREGATE_TYPE_P (t)
3186 tree name = TYPE_NAME (t);
3187 if (TREE_CODE (name) == TYPE_DECL)
3188 name = DECL_NAME (name);
3189 /* Drop anonymous names. */
3190 if (name != NULL_TREE
3191 && ANON_AGGRNAME_P (name))
3192 TYPE_NAME (t) = NULL_TREE;
3197 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
3198 /* Complain that some language-specific thing hanging off a tree
3199 node has been accessed improperly. */
3202 lang_check_failed (const char* file, int line, const char* function)
3204 internal_error ("lang_* check: failed in %s, at %s:%d",
3205 function, trim_filename (file), line);
3207 #endif /* ENABLE_TREE_CHECKING */
3209 #include "gt-cp-tree.h"