1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2016 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
26 #include "gimple-expr.h"
28 #include "stor-layout.h"
29 #include "print-tree.h"
30 #include "tree-iterator.h"
31 #include "tree-inline.h"
37 static tree
bot_manip (tree
*, int *, void *);
38 static tree
bot_replace (tree
*, int *, void *);
39 static hashval_t
list_hash_pieces (tree
, tree
, tree
);
40 static tree
build_target_expr (tree
, tree
, tsubst_flags_t
);
41 static tree
count_trees_r (tree
*, int *, void *);
42 static tree
verify_stmt_tree_r (tree
*, int *, void *);
43 static tree
build_local_temp (tree
);
45 static tree
handle_java_interface_attribute (tree
*, tree
, tree
, int, bool *);
46 static tree
handle_init_priority_attribute (tree
*, tree
, tree
, int, bool *);
47 static tree
handle_abi_tag_attribute (tree
*, tree
, tree
, int, bool *);
49 /* If REF is an lvalue, returns the kind of lvalue that REF is.
50 Otherwise, returns clk_none. */
53 lvalue_kind (const_tree ref
)
55 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
56 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
58 /* Expressions of reference type are sometimes wrapped in
59 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
60 representation, not part of the language, so we have to look
62 if (REFERENCE_REF_P (ref
))
63 return lvalue_kind (TREE_OPERAND (ref
, 0));
66 && TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
68 /* unnamed rvalue references are rvalues */
69 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref
))
70 && TREE_CODE (ref
) != PARM_DECL
72 && TREE_CODE (ref
) != COMPONENT_REF
73 /* Functions are always lvalues. */
74 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref
))) != FUNCTION_TYPE
)
77 /* lvalue references and named rvalue references are lvalues. */
81 if (ref
== current_class_ptr
)
84 switch (TREE_CODE (ref
))
88 /* preincrements and predecrements are valid lvals, provided
89 what they refer to are valid lvals. */
90 case PREINCREMENT_EXPR
:
91 case PREDECREMENT_EXPR
:
93 case WITH_CLEANUP_EXPR
:
96 return lvalue_kind (TREE_OPERAND (ref
, 0));
100 if (TREE_CODE (ref
) == MEMBER_REF
)
101 op1_lvalue_kind
= clk_ordinary
;
103 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
104 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref
, 1))))
105 op1_lvalue_kind
= clk_none
;
106 return op1_lvalue_kind
;
109 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
110 /* Look at the member designator. */
111 if (!op1_lvalue_kind
)
113 else if (is_overloaded_fn (TREE_OPERAND (ref
, 1)))
114 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
115 situations. If we're seeing a COMPONENT_REF, it's a non-static
116 member, so it isn't an lvalue. */
117 op1_lvalue_kind
= clk_none
;
118 else if (TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
119 /* This can be IDENTIFIER_NODE in a template. */;
120 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
122 /* Clear the ordinary bit. If this object was a class
123 rvalue we want to preserve that information. */
124 op1_lvalue_kind
&= ~clk_ordinary
;
125 /* The lvalue is for a bitfield. */
126 op1_lvalue_kind
|= clk_bitfield
;
128 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
129 op1_lvalue_kind
|= clk_packed
;
131 return op1_lvalue_kind
;
134 case COMPOUND_LITERAL_EXPR
:
138 /* CONST_DECL without TREE_STATIC are enumeration values and
139 thus not lvalues. With TREE_STATIC they are used by ObjC++
140 in objc_build_string_object and need to be considered as
142 if (! TREE_STATIC (ref
))
145 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
146 && DECL_LANG_SPECIFIC (ref
)
147 && DECL_IN_AGGR_P (ref
))
152 case ARRAY_NOTATION_REF
:
155 case PLACEHOLDER_EXPR
:
158 /* A scope ref in a template, left as SCOPE_REF to support later
161 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
163 tree op
= TREE_OPERAND (ref
, 1);
164 if (TREE_CODE (op
) == FIELD_DECL
)
165 return (DECL_C_BIT_FIELD (op
) ? clk_bitfield
: clk_ordinary
);
167 return lvalue_kind (op
);
172 /* Disallow <? and >? as lvalues if either argument side-effects. */
173 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
174 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
176 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
177 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1));
181 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1)
182 ? TREE_OPERAND (ref
, 1)
183 : TREE_OPERAND (ref
, 0));
184 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 2));
188 /* We expect to see unlowered MODOP_EXPRs only during
189 template processing. */
190 gcc_assert (processing_template_decl
);
198 return lvalue_kind (TREE_OPERAND (ref
, 1));
204 return (CLASS_TYPE_P (TREE_TYPE (ref
)) ? clk_class
: clk_none
);
207 /* We can see calls outside of TARGET_EXPR in templates. */
208 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
213 /* All functions (except non-static-member functions) are
215 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
216 ? clk_none
: clk_ordinary
);
219 /* We now represent a reference to a single static member function
221 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
222 its argument unmodified and we assign it to a const_tree. */
223 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref
)));
225 case NON_DEPENDENT_EXPR
:
226 return lvalue_kind (TREE_OPERAND (ref
, 0));
229 if (!TREE_TYPE (ref
))
231 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
236 /* If one operand is not an lvalue at all, then this expression is
238 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
241 /* Otherwise, it's an lvalue, and it has all the odd properties
242 contributed by either operand. */
243 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
244 /* It's not an ordinary lvalue if it involves any other kind. */
245 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
246 op1_lvalue_kind
&= ~clk_ordinary
;
247 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
248 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
249 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
250 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
251 op1_lvalue_kind
= clk_none
;
252 return op1_lvalue_kind
;
255 /* Returns the kind of lvalue that REF is, in the sense of
256 [basic.lval]. This function should really be named lvalue_p; it
257 computes the C++ definition of lvalue. */
260 real_lvalue_p (const_tree ref
)
262 cp_lvalue_kind kind
= lvalue_kind (ref
);
263 if (kind
& (clk_rvalueref
|clk_class
))
269 /* This differs from real_lvalue_p in that class rvalues are considered
273 lvalue_p (const_tree ref
)
275 return (lvalue_kind (ref
) != clk_none
);
278 /* This differs from real_lvalue_p in that rvalues formed by dereferencing
279 rvalue references are considered rvalues. */
282 lvalue_or_rvalue_with_address_p (const_tree ref
)
284 cp_lvalue_kind kind
= lvalue_kind (ref
);
285 if (kind
& clk_class
)
288 return (kind
!= clk_none
);
291 /* Returns true if REF is an xvalue, false otherwise. */
294 xvalue_p (const_tree ref
)
296 return (lvalue_kind (ref
) == clk_rvalueref
);
299 /* C++-specific version of stabilize_reference. */
302 cp_stabilize_reference (tree ref
)
304 switch (TREE_CODE (ref
))
306 /* We need to treat specially anything stabilize_reference doesn't
307 handle specifically. */
318 case ARRAY_RANGE_REF
:
322 cp_lvalue_kind kind
= lvalue_kind (ref
);
323 if ((kind
& ~clk_class
) != clk_none
)
325 tree type
= unlowered_expr_type (ref
);
326 bool rval
= !!(kind
& clk_rvalueref
);
327 type
= cp_build_reference_type (type
, rval
);
328 /* This inhibits warnings in, eg, cxx_mark_addressable
330 warning_sentinel
s (extra_warnings
);
331 ref
= build_static_cast (type
, ref
, tf_error
);
335 return stabilize_reference (ref
);
338 /* Test whether DECL is a builtin that may appear in a
339 constant-expression. */
342 builtin_valid_in_constant_expr_p (const_tree decl
)
344 if (!(TREE_CODE (decl
) == FUNCTION_DECL
345 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
))
346 /* Not a built-in. */
348 switch (DECL_FUNCTION_CODE (decl
))
350 /* These always have constant results like the corresponding
353 case BUILT_IN_FUNCTION
:
356 /* The following built-ins are valid in constant expressions
357 when their arguments are. */
358 case BUILT_IN_ADD_OVERFLOW_P
:
359 case BUILT_IN_SUB_OVERFLOW_P
:
360 case BUILT_IN_MUL_OVERFLOW_P
:
362 /* These have constant results even if their operands are
364 case BUILT_IN_CONSTANT_P
:
365 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
372 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
375 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
378 tree type
= TREE_TYPE (decl
);
380 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
381 || TREE_TYPE (decl
) == TREE_TYPE (value
)
382 /* On ARM ctors return 'this'. */
383 || (TYPE_PTR_P (TREE_TYPE (value
))
384 && TREE_CODE (value
) == CALL_EXPR
)
385 || useless_type_conversion_p (TREE_TYPE (decl
),
388 t
= cxx_maybe_build_cleanup (decl
, complain
);
389 if (t
== error_mark_node
)
390 return error_mark_node
;
391 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
392 if (EXPR_HAS_LOCATION (value
))
393 SET_EXPR_LOCATION (t
, EXPR_LOCATION (value
));
394 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
395 ignore the TARGET_EXPR. If there really turn out to be no
396 side-effects, then the optimizer should be able to get rid of
397 whatever code is generated anyhow. */
398 TREE_SIDE_EFFECTS (t
) = 1;
403 /* Return an undeclared local temporary of type TYPE for use in building a
407 build_local_temp (tree type
)
409 tree slot
= build_decl (input_location
,
410 VAR_DECL
, NULL_TREE
, type
);
411 DECL_ARTIFICIAL (slot
) = 1;
412 DECL_IGNORED_P (slot
) = 1;
413 DECL_CONTEXT (slot
) = current_function_decl
;
414 layout_decl (slot
, 0);
418 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
421 process_aggr_init_operands (tree t
)
425 side_effects
= TREE_SIDE_EFFECTS (t
);
429 n
= TREE_OPERAND_LENGTH (t
);
430 for (i
= 1; i
< n
; i
++)
432 tree op
= TREE_OPERAND (t
, i
);
433 if (op
&& TREE_SIDE_EFFECTS (op
))
440 TREE_SIDE_EFFECTS (t
) = side_effects
;
443 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
444 FN, and SLOT. NARGS is the number of call arguments which are specified
445 as a tree array ARGS. */
448 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
454 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
455 TREE_TYPE (t
) = return_type
;
456 AGGR_INIT_EXPR_FN (t
) = fn
;
457 AGGR_INIT_EXPR_SLOT (t
) = slot
;
458 for (i
= 0; i
< nargs
; i
++)
459 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
460 process_aggr_init_operands (t
);
464 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
465 target. TYPE is the type to be initialized.
467 Build an AGGR_INIT_EXPR to represent the initialization. This function
468 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
469 to initialize another object, whereas a TARGET_EXPR can either
470 initialize another object or create its own temporary object, and as a
471 result building up a TARGET_EXPR requires that the type's destructor be
475 build_aggr_init_expr (tree type
, tree init
)
482 /* Don't build AGGR_INIT_EXPR in a template. */
483 if (processing_template_decl
)
486 fn
= cp_get_callee (init
);
488 return convert (type
, init
);
490 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
491 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
492 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
494 /* We split the CALL_EXPR into its function and its arguments here.
495 Then, in expand_expr, we put them back together. The reason for
496 this is that this expression might be a default argument
497 expression. In that case, we need a new temporary every time the
498 expression is used. That's what break_out_target_exprs does; it
499 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
500 temporary slot. Then, expand_expr builds up a call-expression
501 using the new slot. */
503 /* If we don't need to use a constructor to create an object of this
504 type, don't mess with AGGR_INIT_EXPR. */
505 if (is_ctor
|| TREE_ADDRESSABLE (type
))
507 slot
= build_local_temp (type
);
509 if (TREE_CODE (init
) == CALL_EXPR
)
511 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
512 call_expr_nargs (init
),
513 CALL_EXPR_ARGP (init
));
514 AGGR_INIT_FROM_THUNK_P (rval
)
515 = CALL_FROM_THUNK_P (init
);
519 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
520 aggr_init_expr_nargs (init
),
521 AGGR_INIT_EXPR_ARGP (init
));
522 AGGR_INIT_FROM_THUNK_P (rval
)
523 = AGGR_INIT_FROM_THUNK_P (init
);
525 TREE_SIDE_EFFECTS (rval
) = 1;
526 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
527 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
528 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
529 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
530 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
538 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
539 target. TYPE is the type that this initialization should appear to
542 Build an encapsulation of the initialization to perform
543 and return it so that it can be processed by language-independent
544 and language-specific expression expanders. */
547 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
549 tree rval
= build_aggr_init_expr (type
, init
);
552 if (!complete_type_or_maybe_complain (type
, init
, complain
))
553 return error_mark_node
;
555 /* Make sure that we're not trying to create an instance of an
557 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
558 return error_mark_node
;
560 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
561 slot
= AGGR_INIT_EXPR_SLOT (rval
);
562 else if (TREE_CODE (rval
) == CALL_EXPR
563 || TREE_CODE (rval
) == CONSTRUCTOR
)
564 slot
= build_local_temp (type
);
568 rval
= build_target_expr (slot
, rval
, complain
);
570 if (rval
!= error_mark_node
)
571 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
576 /* Subroutine of build_vec_init_expr: Build up a single element
577 intialization as a proxy for the full array initialization to get things
578 marked as used and any appropriate diagnostics.
580 Since we're deferring building the actual constructor calls until
581 gimplification time, we need to build one now and throw it away so
582 that the relevant constructor gets mark_used before cgraph decides
583 what functions are needed. Here we assume that init is either
584 NULL_TREE, void_type_node (indicating value-initialization), or
585 another array to copy. */
588 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
590 tree inner_type
= strip_array_types (type
);
591 vec
<tree
, va_gc
> *argvec
;
593 if (integer_zerop (array_type_nelts_total (type
))
594 || !CLASS_TYPE_P (inner_type
))
595 /* No interesting initialization to do. */
596 return integer_zero_node
;
597 else if (init
== void_type_node
)
598 return build_value_init (inner_type
, complain
);
600 gcc_assert (init
== NULL_TREE
601 || (same_type_ignoring_top_level_qualifiers_p
602 (type
, TREE_TYPE (init
))));
604 argvec
= make_tree_vector ();
607 tree init_type
= strip_array_types (TREE_TYPE (init
));
608 tree dummy
= build_dummy_object (init_type
);
609 if (!real_lvalue_p (init
))
610 dummy
= move (dummy
);
611 argvec
->quick_push (dummy
);
613 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
614 &argvec
, inner_type
, LOOKUP_NORMAL
,
616 release_tree_vector (argvec
);
618 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
619 we don't want one here because we aren't creating a temporary. */
620 if (TREE_CODE (init
) == TARGET_EXPR
)
621 init
= TARGET_EXPR_INITIAL (init
);
626 /* Return a TARGET_EXPR which expresses the initialization of an array to
627 be named later, either default-initialization or copy-initialization
628 from another array of the same type. */
631 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
634 bool value_init
= false;
635 tree elt_init
= build_vec_init_elt (type
, init
, complain
);
637 if (init
== void_type_node
)
643 slot
= build_local_temp (type
);
644 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
645 TREE_SIDE_EFFECTS (init
) = true;
646 SET_EXPR_LOCATION (init
, input_location
);
648 if (cxx_dialect
>= cxx11
649 && potential_constant_expression (elt_init
))
650 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
651 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
656 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
657 that requires a constant expression. */
660 diagnose_non_constexpr_vec_init (tree expr
)
662 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
664 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
665 init
= void_type_node
;
667 init
= VEC_INIT_EXPR_INIT (expr
);
669 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
670 require_potential_constant_expression (elt_init
);
674 build_array_copy (tree init
)
676 return build_vec_init_expr (TREE_TYPE (init
), init
, tf_warning_or_error
);
679 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
683 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
685 gcc_assert (!VOID_TYPE_P (type
));
687 if (TREE_CODE (init
) == TARGET_EXPR
688 || init
== error_mark_node
)
690 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
691 && !VOID_TYPE_P (TREE_TYPE (init
))
692 && TREE_CODE (init
) != COND_EXPR
693 && TREE_CODE (init
) != CONSTRUCTOR
694 && TREE_CODE (init
) != VA_ARG_EXPR
)
695 /* We need to build up a copy constructor call. A void initializer
696 means we're being called from bot_manip. COND_EXPR is a special
697 case because we already have copies on the arms and we don't want
698 another one here. A CONSTRUCTOR is aggregate initialization, which
699 is handled separately. A VA_ARG_EXPR is magic creation of an
700 aggregate; there's no additional work to be done. */
701 return force_rvalue (init
, complain
);
703 return force_target_expr (type
, init
, complain
);
706 /* Like the above function, but without the checking. This function should
707 only be used by code which is deliberately trying to subvert the type
708 system, such as call_builtin_trap. Or build_over_call, to avoid
709 infinite recursion. */
712 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
716 gcc_assert (!VOID_TYPE_P (type
));
718 slot
= build_local_temp (type
);
719 return build_target_expr (slot
, init
, complain
);
722 /* Like build_target_expr_with_type, but use the type of INIT. */
725 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
727 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
728 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
729 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
730 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
732 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
736 get_target_expr (tree init
)
738 return get_target_expr_sfinae (init
, tf_warning_or_error
);
741 /* If EXPR is a bitfield reference, convert it to the declared type of
742 the bitfield, and return the resulting expression. Otherwise,
743 return EXPR itself. */
746 convert_bitfield_to_declared_type (tree expr
)
750 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
752 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
757 /* EXPR is being used in an rvalue context. Return a version of EXPR
758 that is marked as an rvalue. */
765 if (error_operand_p (expr
))
768 expr
= mark_rvalue_use (expr
);
772 Non-class rvalues always have cv-unqualified types. */
773 type
= TREE_TYPE (expr
);
774 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
775 type
= cv_unqualified (type
);
777 /* We need to do this for rvalue refs as well to get the right answer
778 from decltype; see c++/36628. */
779 if (!processing_template_decl
&& lvalue_or_rvalue_with_address_p (expr
))
780 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
781 else if (type
!= TREE_TYPE (expr
))
782 expr
= build_nop (type
, expr
);
788 struct cplus_array_info
794 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
796 typedef cplus_array_info
*compare_type
;
798 static hashval_t
hash (tree t
);
799 static bool equal (tree
, cplus_array_info
*);
802 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
805 cplus_array_hasher::hash (tree t
)
809 hash
= TYPE_UID (TREE_TYPE (t
));
811 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
815 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
816 of type `cplus_array_info*'. */
819 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
821 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
824 /* Hash table containing dependent array types, which are unsuitable for
825 the language-independent type hash table. */
826 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
828 /* Build an ARRAY_TYPE without laying it out. */
831 build_min_array_type (tree elt_type
, tree index_type
)
833 tree t
= cxx_make_type (ARRAY_TYPE
);
834 TREE_TYPE (t
) = elt_type
;
835 TYPE_DOMAIN (t
) = index_type
;
839 /* Set TYPE_CANONICAL like build_array_type_1, but using
840 build_cplus_array_type. */
843 set_array_type_canon (tree t
, tree elt_type
, tree index_type
)
845 /* Set the canonical type for this new node. */
846 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
847 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
848 SET_TYPE_STRUCTURAL_EQUALITY (t
);
849 else if (TYPE_CANONICAL (elt_type
) != elt_type
850 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
852 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
854 ? TYPE_CANONICAL (index_type
) : index_type
);
856 TYPE_CANONICAL (t
) = t
;
859 /* Like build_array_type, but handle special C++ semantics: an array of a
860 variant element type is a variant of the array of the main variant of
864 build_cplus_array_type (tree elt_type
, tree index_type
)
868 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
869 return error_mark_node
;
871 bool dependent
= (uses_template_parms (elt_type
)
872 || (index_type
&& uses_template_parms (index_type
)));
874 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
875 /* Start with an array of the TYPE_MAIN_VARIANT. */
876 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
880 /* Since type_hash_canon calls layout_type, we need to use our own
882 cplus_array_info cai
;
885 if (cplus_array_htab
== NULL
)
886 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
888 hash
= TYPE_UID (elt_type
);
890 hash
^= TYPE_UID (index_type
);
892 cai
.domain
= index_type
;
894 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
896 /* We have found the type: we're done. */
900 /* Build a new array type. */
901 t
= build_min_array_type (elt_type
, index_type
);
903 /* Store it in the hash table. */
906 /* Set the canonical type for this new node. */
907 set_array_type_canon (t
, elt_type
, index_type
);
912 t
= build_array_type (elt_type
, index_type
);
915 /* Now check whether we already have this array variant. */
916 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
919 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
920 if (TREE_TYPE (t
) == elt_type
921 && TYPE_NAME (t
) == NULL_TREE
922 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
926 t
= build_min_array_type (elt_type
, index_type
);
927 set_array_type_canon (t
, elt_type
, index_type
);
931 /* Make sure sizes are shared with the main variant.
932 layout_type can't be called after setting TYPE_NEXT_VARIANT,
933 as it will overwrite alignment etc. of all variants. */
934 TYPE_SIZE (t
) = TYPE_SIZE (m
);
935 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
938 TYPE_MAIN_VARIANT (t
) = m
;
939 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
940 TYPE_NEXT_VARIANT (m
) = t
;
944 /* Avoid spurious warnings with VLAs (c++/54583). */
945 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
946 TREE_NO_WARNING (TYPE_SIZE (t
)) = 1;
948 /* Push these needs up to the ARRAY_TYPE so that initialization takes
949 place more easily. */
950 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
951 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
952 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
953 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
955 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
956 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
958 /* The element type has been completed since the last time we saw
959 this array type; update the layout and 'tor flags for any variants
962 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
964 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
965 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
972 /* Return an ARRAY_TYPE with element type ELT and length N. */
975 build_array_of_n_type (tree elt
, int n
)
977 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
980 /* True iff T is an N3639 array of runtime bound (VLA). These were
981 approved for C++14 but then removed. */
984 array_of_runtime_bound_p (tree t
)
986 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
988 tree dom
= TYPE_DOMAIN (t
);
991 tree max
= TYPE_MAX_VALUE (dom
);
992 return (!potential_rvalue_constant_expression (max
)
993 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
996 /* Return a reference type node referring to TO_TYPE. If RVAL is
997 true, return an rvalue reference type, otherwise return an lvalue
998 reference type. If a type node exists, reuse it, otherwise create
1001 cp_build_reference_type (tree to_type
, bool rval
)
1004 lvalue_ref
= build_reference_type (to_type
);
1008 /* This code to create rvalue reference types is based on and tied
1009 to the code creating lvalue reference types in the middle-end
1010 functions build_reference_type_for_mode and build_reference_type.
1012 It works by putting the rvalue reference type nodes after the
1013 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1014 they will effectively be ignored by the middle end. */
1016 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1017 if (TYPE_REF_IS_RVALUE (t
))
1020 t
= build_distinct_type_copy (lvalue_ref
);
1022 TYPE_REF_IS_RVALUE (t
) = true;
1023 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1024 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1026 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1027 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1028 else if (TYPE_CANONICAL (to_type
) != to_type
)
1030 = cp_build_reference_type (TYPE_CANONICAL (to_type
), rval
);
1032 TYPE_CANONICAL (t
) = t
;
1040 /* Returns EXPR cast to rvalue reference type, like std::move. */
1045 tree type
= TREE_TYPE (expr
);
1046 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
1047 type
= cp_build_reference_type (type
, /*rval*/true);
1048 return build_static_cast (type
, expr
, tf_warning_or_error
);
1051 /* Used by the C++ front end to build qualified array types. However,
1052 the C version of this function does not properly maintain canonical
1053 types (which are not used in C). */
1055 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1056 size_t /* orig_qual_indirect */)
1058 return cp_build_qualified_type (type
, type_quals
);
1062 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1063 arrays correctly. In particular, if TYPE is an array of T's, and
1064 TYPE_QUALS is non-empty, returns an array of qualified T's.
1066 FLAGS determines how to deal with ill-formed qualifications. If
1067 tf_ignore_bad_quals is set, then bad qualifications are dropped
1068 (this is permitted if TYPE was introduced via a typedef or template
1069 type parameter). If bad qualifications are dropped and tf_warning
1070 is set, then a warning is issued for non-const qualifications. If
1071 tf_ignore_bad_quals is not set and tf_error is not set, we
1072 return error_mark_node. Otherwise, we issue an error, and ignore
1075 Qualification of a reference type is valid when the reference came
1076 via a typedef or template type argument. [dcl.ref] No such
1077 dispensation is provided for qualifying a function type. [dcl.fct]
1078 DR 295 queries this and the proposed resolution brings it into line
1079 with qualifying a reference. We implement the DR. We also behave
1080 in a similar manner for restricting non-pointer types. */
1083 cp_build_qualified_type_real (tree type
,
1085 tsubst_flags_t complain
)
1088 int bad_quals
= TYPE_UNQUALIFIED
;
1090 if (type
== error_mark_node
)
1093 if (type_quals
== cp_type_quals (type
))
1096 if (TREE_CODE (type
) == ARRAY_TYPE
)
1098 /* In C++, the qualification really applies to the array element
1099 type. Obtain the appropriately qualified element type. */
1102 = cp_build_qualified_type_real (TREE_TYPE (type
),
1106 if (element_type
== error_mark_node
)
1107 return error_mark_node
;
1109 /* See if we already have an identically qualified type. Tests
1110 should be equivalent to those in check_qualified_type. */
1111 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1112 if (TREE_TYPE (t
) == element_type
1113 && TYPE_NAME (t
) == TYPE_NAME (type
)
1114 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1115 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1116 TYPE_ATTRIBUTES (type
)))
1121 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
));
1123 /* Keep the typedef name. */
1124 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1126 t
= build_variant_type_copy (t
);
1127 TYPE_NAME (t
) = TYPE_NAME (type
);
1128 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1129 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1133 /* Even if we already had this variant, we update
1134 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1135 they changed since the variant was originally created.
1137 This seems hokey; if there is some way to use a previous
1138 variant *without* coming through here,
1139 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1140 TYPE_NEEDS_CONSTRUCTING (t
)
1141 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1142 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1143 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1146 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1148 tree t
= PACK_EXPANSION_PATTERN (type
);
1150 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1151 return make_pack_expansion (t
);
1154 /* A reference or method type shall not be cv-qualified.
1155 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1156 (in CD1) we always ignore extra cv-quals on functions. */
1157 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1158 && (TREE_CODE (type
) == REFERENCE_TYPE
1159 || TREE_CODE (type
) == FUNCTION_TYPE
1160 || TREE_CODE (type
) == METHOD_TYPE
))
1162 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1163 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1164 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1167 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1168 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1169 type_quals
|= type_memfn_quals (type
);
1171 /* A restrict-qualified type must be a pointer (or reference)
1172 to object or incomplete type. */
1173 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1174 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1175 && TREE_CODE (type
) != TYPENAME_TYPE
1176 && !POINTER_TYPE_P (type
))
1178 bad_quals
|= TYPE_QUAL_RESTRICT
;
1179 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1182 if (bad_quals
== TYPE_UNQUALIFIED
1183 || (complain
& tf_ignore_bad_quals
))
1185 else if (!(complain
& tf_error
))
1186 return error_mark_node
;
1189 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1190 error ("%qV qualifiers cannot be applied to %qT",
1194 /* Retrieve (or create) the appropriately qualified variant. */
1195 result
= build_qualified_type (type
, type_quals
);
1197 /* Preserve exception specs and ref-qualifier since build_qualified_type
1198 doesn't know about them. */
1199 if (TREE_CODE (result
) == FUNCTION_TYPE
1200 || TREE_CODE (result
) == METHOD_TYPE
)
1202 result
= build_exception_variant (result
, TYPE_RAISES_EXCEPTIONS (type
));
1203 result
= build_ref_qualified_type (result
, type_memfn_rqual (type
));
1209 /* Return TYPE with const and volatile removed. */
1212 cv_unqualified (tree type
)
1216 if (type
== error_mark_node
)
1219 quals
= cp_type_quals (type
);
1220 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1221 return cp_build_qualified_type (type
, quals
);
1224 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1225 from ATTRIBS that affect type identity, and no others. If any are not
1226 applied, set *remove_attributes to true. */
1229 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1231 tree first_ident
= NULL_TREE
;
1232 tree new_attribs
= NULL_TREE
;
1233 tree
*p
= &new_attribs
;
1235 if (OVERLOAD_TYPE_P (result
))
1237 /* On classes and enums all attributes are ingrained. */
1238 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1242 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1244 const attribute_spec
*as
1245 = lookup_attribute_spec (get_attribute_name (a
));
1246 if (as
&& as
->affects_type_identity
)
1250 else if (first_ident
== error_mark_node
)
1252 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1253 p
= &TREE_CHAIN (*p
);
1256 else if (first_ident
)
1258 for (tree a2
= first_ident
; a2
; a2
= TREE_CHAIN (a2
))
1260 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1261 p
= &TREE_CHAIN (*p
);
1263 first_ident
= error_mark_node
;
1266 if (first_ident
!= error_mark_node
)
1267 new_attribs
= first_ident
;
1269 if (first_ident
== attribs
)
1270 /* All attributes affected type identity. */;
1272 *remove_attributes
= true;
1274 return cp_build_type_attribute_variant (result
, new_attribs
);
1277 /* Builds a qualified variant of T that is not a typedef variant.
1278 E.g. consider the following declarations:
1279 typedef const int ConstInt;
1280 typedef ConstInt* PtrConstInt;
1281 If T is PtrConstInt, this function returns a type representing
1283 In other words, if T is a typedef, the function returns the underlying type.
1284 The cv-qualification and attributes of the type returned match the
1286 They will always be compatible types.
1287 The returned type is built so that all of its subtypes
1288 recursively have their typedefs stripped as well.
1290 This is different from just returning TYPE_CANONICAL (T)
1291 Because of several reasons:
1292 * If T is a type that needs structural equality
1293 its TYPE_CANONICAL (T) will be NULL.
1294 * TYPE_CANONICAL (T) desn't carry type attributes
1295 and loses template parameter names.
1297 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1298 affect type identity, and set the referent to true if any were
1302 strip_typedefs (tree t
, bool *remove_attributes
)
1304 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1306 if (!t
|| t
== error_mark_node
)
1309 if (TREE_CODE (t
) == TREE_LIST
)
1311 bool changed
= false;
1312 vec
<tree
,va_gc
> *vec
= make_tree_vector ();
1314 for (; t
; t
= TREE_CHAIN (t
))
1316 gcc_assert (!TREE_PURPOSE (t
));
1317 tree elt
= strip_typedefs (TREE_VALUE (t
), remove_attributes
);
1318 if (elt
!= TREE_VALUE (t
))
1320 vec_safe_push (vec
, elt
);
1323 r
= build_tree_list_vec (vec
);
1324 release_tree_vector (vec
);
1328 gcc_assert (TYPE_P (t
));
1330 if (t
== TYPE_CANONICAL (t
))
1333 if (dependent_alias_template_spec_p (t
))
1334 /* DR 1558: However, if the template-id is dependent, subsequent
1335 template argument substitution still applies to the template-id. */
1338 switch (TREE_CODE (t
))
1341 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1342 result
= build_pointer_type (type
);
1344 case REFERENCE_TYPE
:
1345 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1346 result
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
1349 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
);
1350 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1351 result
= build_offset_type (t0
, type
);
1354 if (TYPE_PTRMEMFUNC_P (t
))
1356 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
), remove_attributes
);
1357 result
= build_ptrmemfunc_type (t0
);
1361 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1362 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
);
1363 result
= build_cplus_array_type (type
, t0
);
1368 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1371 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1372 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1373 can't expect that re-hashing a function type will find a previous
1374 equivalent type, so try to reuse the input type if nothing has
1375 changed. If the type is itself a variant, that will change. */
1376 bool is_variant
= typedef_variant_p (t
);
1377 if (remove_attributes
1378 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1381 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1382 changed
= type
!= TREE_TYPE (t
) || is_variant
;
1384 for (arg_node
= TYPE_ARG_TYPES (t
);
1386 arg_node
= TREE_CHAIN (arg_node
))
1388 if (arg_node
== void_list_node
)
1390 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1392 gcc_assert (arg_type
);
1393 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1399 for (arg_node2
= TYPE_ARG_TYPES (t
);
1400 arg_node2
!= arg_node
;
1401 arg_node2
= TREE_CHAIN (arg_node2
))
1403 = tree_cons (TREE_PURPOSE (arg_node2
),
1404 TREE_VALUE (arg_node2
), arg_types
);
1408 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1415 arg_types
= nreverse (arg_types
);
1417 /* A list of parameters not ending with an ellipsis
1418 must end with void_list_node. */
1420 arg_types
= chainon (arg_types
, void_list_node
);
1422 if (TREE_CODE (t
) == METHOD_TYPE
)
1424 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1425 gcc_assert (class_type
);
1427 build_method_type_directly (class_type
, type
,
1428 TREE_CHAIN (arg_types
));
1430 = build_ref_qualified_type (result
, type_memfn_rqual (t
));
1434 result
= build_function_type (type
,
1436 result
= apply_memfn_quals (result
,
1437 type_memfn_quals (t
),
1438 type_memfn_rqual (t
));
1441 if (TYPE_RAISES_EXCEPTIONS (t
))
1442 result
= build_exception_variant (result
,
1443 TYPE_RAISES_EXCEPTIONS (t
));
1444 if (TYPE_HAS_LATE_RETURN_TYPE (t
))
1445 TYPE_HAS_LATE_RETURN_TYPE (result
) = 1;
1450 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1451 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1452 && TREE_OPERAND (fullname
, 1))
1454 tree args
= TREE_OPERAND (fullname
, 1);
1455 tree new_args
= copy_node (args
);
1456 bool changed
= false;
1457 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1459 tree arg
= TREE_VEC_ELT (args
, i
);
1462 strip_arg
= strip_typedefs (arg
, remove_attributes
);
1464 strip_arg
= strip_typedefs_expr (arg
, remove_attributes
);
1465 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1466 if (strip_arg
!= arg
)
1471 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1472 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1474 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1478 ggc_free (new_args
);
1480 result
= make_typename_type (strip_typedefs (TYPE_CONTEXT (t
),
1482 fullname
, typename_type
, tf_none
);
1483 /* Handle 'typedef typename A::N N;' */
1484 if (typedef_variant_p (result
))
1485 result
= TYPE_MAIN_VARIANT (DECL_ORIGINAL_TYPE (TYPE_NAME (result
)));
1489 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
),
1491 if (result
== DECLTYPE_TYPE_EXPR (t
))
1494 result
= (finish_decltype_type
1496 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1505 if (typedef_variant_p (t
))
1507 /* Explicitly get the underlying type, as TYPE_MAIN_VARIANT doesn't
1508 strip typedefs with attributes. */
1509 result
= TYPE_MAIN_VARIANT (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)));
1510 result
= strip_typedefs (result
);
1513 result
= TYPE_MAIN_VARIANT (t
);
1515 gcc_assert (!typedef_variant_p (result
));
1516 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1517 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1519 gcc_assert (TYPE_USER_ALIGN (t
));
1520 if (remove_attributes
)
1521 *remove_attributes
= true;
1524 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1525 result
= build_variant_type_copy (result
);
1527 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1528 TYPE_USER_ALIGN (result
) = true;
1531 if (TYPE_ATTRIBUTES (t
))
1533 if (remove_attributes
)
1534 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1537 result
= cp_build_type_attribute_variant (result
, TYPE_ATTRIBUTES (t
));
1539 return cp_build_qualified_type (result
, cp_type_quals (t
));
1542 /* Like strip_typedefs above, but works on expressions, so that in
1544 template<class T> struct A
1550 sizeof(TT) is replaced by sizeof(T). */
1553 strip_typedefs_expr (tree t
, bool *remove_attributes
)
1557 enum tree_code code
;
1559 if (t
== NULL_TREE
|| t
== error_mark_node
)
1562 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1565 /* Some expressions have type operands, so let's handle types here rather
1566 than check TYPE_P in multiple places below. */
1568 return strip_typedefs (t
, remove_attributes
);
1570 code
= TREE_CODE (t
);
1573 case IDENTIFIER_NODE
:
1574 case TEMPLATE_PARM_INDEX
:
1577 case ARGUMENT_PACK_SELECT
:
1582 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
), remove_attributes
);
1583 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
), remove_attributes
);
1584 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1585 && type2
== TRAIT_EXPR_TYPE2 (t
))
1588 TRAIT_EXPR_TYPE1 (r
) = type1
;
1589 TRAIT_EXPR_TYPE2 (r
) = type2
;
1595 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
1596 bool changed
= false;
1598 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1600 tree val
= strip_typedefs_expr (TREE_VALUE (t
), remove_attributes
);
1601 vec_safe_push (vec
, val
);
1602 if (val
!= TREE_VALUE (t
))
1604 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1609 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1610 r
= tree_cons (NULL_TREE
, it
, r
);
1614 release_tree_vector (vec
);
1620 bool changed
= false;
1621 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
1622 n
= TREE_VEC_LENGTH (t
);
1623 vec_safe_reserve (vec
, n
);
1624 for (i
= 0; i
< n
; ++i
)
1626 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
),
1628 vec
->quick_push (op
);
1629 if (op
!= TREE_VEC_ELT (t
, i
))
1635 for (i
= 0; i
< n
; ++i
)
1636 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1637 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1638 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1642 release_tree_vector (vec
);
1648 bool changed
= false;
1649 vec
<constructor_elt
, va_gc
> *vec
1650 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1651 n
= CONSTRUCTOR_NELTS (t
);
1652 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1653 for (i
= 0; i
< n
; ++i
)
1655 constructor_elt
*e
= &(*vec
)[i
];
1656 tree op
= strip_typedefs_expr (e
->value
, remove_attributes
);
1663 (e
->index
== strip_typedefs_expr (e
->index
, remove_attributes
));
1666 if (!changed
&& type
== TREE_TYPE (t
))
1674 TREE_TYPE (r
) = type
;
1675 CONSTRUCTOR_ELTS (r
) = vec
;
1681 error ("lambda-expression in a constant expression");
1682 return error_mark_node
;
1688 gcc_assert (EXPR_P (t
));
1690 n
= TREE_OPERAND_LENGTH (t
);
1691 ops
= XALLOCAVEC (tree
, n
);
1692 type
= TREE_TYPE (t
);
1697 case IMPLICIT_CONV_EXPR
:
1698 case DYNAMIC_CAST_EXPR
:
1699 case STATIC_CAST_EXPR
:
1700 case CONST_CAST_EXPR
:
1701 case REINTERPRET_CAST_EXPR
:
1704 type
= strip_typedefs (type
, remove_attributes
);
1708 for (i
= 0; i
< n
; ++i
)
1709 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
), remove_attributes
);
1713 /* If nothing changed, return t. */
1714 for (i
= 0; i
< n
; ++i
)
1715 if (ops
[i
] != TREE_OPERAND (t
, i
))
1717 if (i
== n
&& type
== TREE_TYPE (t
))
1721 TREE_TYPE (r
) = type
;
1722 for (i
= 0; i
< n
; ++i
)
1723 TREE_OPERAND (r
, i
) = ops
[i
];
1727 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1728 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1729 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1730 VIRT indicates whether TYPE is inherited virtually or not.
1731 IGO_PREV points at the previous binfo of the inheritance graph
1732 order chain. The newly copied binfo's TREE_CHAIN forms this
1735 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1736 correct order. That is in the order the bases themselves should be
1739 The BINFO_INHERITANCE of a virtual base class points to the binfo
1740 of the most derived type. ??? We could probably change this so that
1741 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1742 remove a field. They currently can only differ for primary virtual
1746 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
1752 /* See if we've already made this virtual base. */
1753 new_binfo
= binfo_for_vbase (type
, t
);
1758 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
1759 BINFO_TYPE (new_binfo
) = type
;
1761 /* Chain it into the inheritance graph. */
1762 TREE_CHAIN (*igo_prev
) = new_binfo
;
1763 *igo_prev
= new_binfo
;
1765 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
1770 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
1772 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
1773 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
1775 /* We do not need to copy the accesses, as they are read only. */
1776 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
1778 /* Recursively copy base binfos of BINFO. */
1779 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1781 tree new_base_binfo
;
1782 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
1784 BINFO_VIRTUAL_P (base_binfo
));
1786 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
1787 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
1788 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
1792 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
1796 /* Push it onto the list after any virtual bases it contains
1797 will have been pushed. */
1798 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
1799 BINFO_VIRTUAL_P (new_binfo
) = 1;
1800 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
1806 /* Hashing of lists so that we don't make duplicates.
1807 The entry point is `list_hash_canon'. */
1816 struct list_hasher
: ggc_ptr_hash
<tree_node
>
1818 typedef list_proxy
*compare_type
;
1820 static hashval_t
hash (tree
);
1821 static bool equal (tree
, list_proxy
*);
1824 /* Now here is the hash table. When recording a list, it is added
1825 to the slot whose index is the hash code mod the table size.
1826 Note that the hash table is used for several kinds of lists.
1827 While all these live in the same table, they are completely independent,
1828 and the hash code is computed differently for each of these. */
1830 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
1832 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1833 for a node we are thinking about adding). */
1836 list_hasher::equal (tree t
, list_proxy
*proxy
)
1838 return (TREE_VALUE (t
) == proxy
->value
1839 && TREE_PURPOSE (t
) == proxy
->purpose
1840 && TREE_CHAIN (t
) == proxy
->chain
);
1843 /* Compute a hash code for a list (chain of TREE_LIST nodes
1844 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1845 TREE_COMMON slots), by adding the hash codes of the individual entries. */
1848 list_hash_pieces (tree purpose
, tree value
, tree chain
)
1850 hashval_t hashcode
= 0;
1853 hashcode
+= TREE_HASH (chain
);
1856 hashcode
+= TREE_HASH (value
);
1860 hashcode
+= TREE_HASH (purpose
);
1866 /* Hash an already existing TREE_LIST. */
1869 list_hasher::hash (tree t
)
1871 return list_hash_pieces (TREE_PURPOSE (t
),
1876 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1877 object for an identical list if one already exists. Otherwise, build a
1878 new one, and record it as the canonical object. */
1881 hash_tree_cons (tree purpose
, tree value
, tree chain
)
1885 struct list_proxy proxy
;
1887 /* Hash the list node. */
1888 hashcode
= list_hash_pieces (purpose
, value
, chain
);
1889 /* Create a proxy for the TREE_LIST we would like to create. We
1890 don't actually create it so as to avoid creating garbage. */
1891 proxy
.purpose
= purpose
;
1892 proxy
.value
= value
;
1893 proxy
.chain
= chain
;
1894 /* See if it is already in the table. */
1895 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
1896 /* If not, create a new node. */
1898 *slot
= tree_cons (purpose
, value
, chain
);
1899 return (tree
) *slot
;
1902 /* Constructor for hashed lists. */
1905 hash_tree_chain (tree value
, tree chain
)
1907 return hash_tree_cons (NULL_TREE
, value
, chain
);
1911 debug_binfo (tree elem
)
1916 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
1918 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
1919 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
1920 debug_tree (BINFO_TYPE (elem
));
1921 if (BINFO_VTABLE (elem
))
1922 fprintf (stderr
, "vtable decl \"%s\"\n",
1923 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
1925 fprintf (stderr
, "no vtable decl yet\n");
1926 fprintf (stderr
, "virtuals:\n");
1927 virtuals
= BINFO_VIRTUALS (elem
);
1932 tree fndecl
= TREE_VALUE (virtuals
);
1933 fprintf (stderr
, "%s [%ld =? %ld]\n",
1934 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
1935 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
1937 virtuals
= TREE_CHAIN (virtuals
);
1941 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
1942 the type of the result expression, if known, or NULL_TREE if the
1943 resulting expression is type-dependent. If TEMPLATE_P is true,
1944 NAME is known to be a template because the user explicitly used the
1945 "template" keyword after the "::".
1947 All SCOPE_REFs should be built by use of this function. */
1950 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
1953 if (type
== error_mark_node
1954 || scope
== error_mark_node
1955 || name
== error_mark_node
)
1956 return error_mark_node
;
1957 t
= build2 (SCOPE_REF
, type
, scope
, name
);
1958 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
1959 PTRMEM_OK_P (t
) = true;
1961 t
= convert_from_reference (t
);
1965 /* Like check_qualified_type, but also check ref-qualifier and exception
1969 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
1970 cp_ref_qualifier rqual
, tree raises
)
1972 return (check_qualified_type (cand
, base
, type_quals
)
1973 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
1975 && type_memfn_rqual (cand
) == rqual
);
1978 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
1981 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
1985 if (rqual
== type_memfn_rqual (type
))
1988 int type_quals
= TYPE_QUALS (type
);
1989 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
1990 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1991 if (cp_check_qualified_type (t
, type
, type_quals
, rqual
, raises
))
1994 t
= build_variant_type_copy (type
);
1997 case REF_QUAL_RVALUE
:
1998 FUNCTION_RVALUE_QUALIFIED (t
) = 1;
1999 FUNCTION_REF_QUALIFIED (t
) = 1;
2001 case REF_QUAL_LVALUE
:
2002 FUNCTION_RVALUE_QUALIFIED (t
) = 0;
2003 FUNCTION_REF_QUALIFIED (t
) = 1;
2006 FUNCTION_REF_QUALIFIED (t
) = 0;
2010 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2011 /* Propagate structural equality. */
2012 SET_TYPE_STRUCTURAL_EQUALITY (t
);
2013 else if (TYPE_CANONICAL (type
) != type
)
2014 /* Build the underlying canonical type, since it is different
2016 TYPE_CANONICAL (t
) = build_ref_qualified_type (TYPE_CANONICAL (type
),
2019 /* T is its own canonical type. */
2020 TYPE_CANONICAL (t
) = t
;
2025 /* Returns nonzero if X is an expression for a (possibly overloaded)
2026 function. If "f" is a function or function template, "f", "c->f",
2027 "c.f", "C::f", and "f<int>" will all be considered possibly
2028 overloaded functions. Returns 2 if the function is actually
2029 overloaded, i.e., if it is impossible to know the type of the
2030 function without performing overload resolution. */
2033 is_overloaded_fn (tree x
)
2035 /* A baselink is also considered an overloaded function. */
2036 if (TREE_CODE (x
) == OFFSET_REF
2037 || TREE_CODE (x
) == COMPONENT_REF
)
2038 x
= TREE_OPERAND (x
, 1);
2040 x
= BASELINK_FUNCTIONS (x
);
2041 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2042 x
= TREE_OPERAND (x
, 0);
2043 if (DECL_FUNCTION_TEMPLATE_P (OVL_CURRENT (x
))
2044 || (TREE_CODE (x
) == OVERLOAD
&& OVL_CHAIN (x
)))
2046 return (TREE_CODE (x
) == FUNCTION_DECL
2047 || TREE_CODE (x
) == OVERLOAD
);
2050 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2051 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2055 dependent_name (tree x
)
2057 if (identifier_p (x
))
2059 if (TREE_CODE (x
) != COMPONENT_REF
2060 && TREE_CODE (x
) != OFFSET_REF
2061 && TREE_CODE (x
) != BASELINK
2062 && is_overloaded_fn (x
))
2063 return DECL_NAME (get_first_fn (x
));
2067 /* Returns true iff X is an expression for an overloaded function
2068 whose type cannot be known without performing overload
2072 really_overloaded_fn (tree x
)
2074 return is_overloaded_fn (x
) == 2;
2080 gcc_assert (is_overloaded_fn (from
));
2081 /* A baselink is also considered an overloaded function. */
2082 if (TREE_CODE (from
) == OFFSET_REF
2083 || TREE_CODE (from
) == COMPONENT_REF
)
2084 from
= TREE_OPERAND (from
, 1);
2085 if (BASELINK_P (from
))
2086 from
= BASELINK_FUNCTIONS (from
);
2087 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2088 from
= TREE_OPERAND (from
, 0);
2093 get_first_fn (tree from
)
2095 return OVL_CURRENT (get_fns (from
));
2098 /* Return a new OVL node, concatenating it with the old one. */
2101 ovl_cons (tree decl
, tree chain
)
2103 tree result
= make_node (OVERLOAD
);
2104 TREE_TYPE (result
) = unknown_type_node
;
2105 OVL_FUNCTION (result
) = decl
;
2106 TREE_CHAIN (result
) = chain
;
2111 /* Build a new overloaded function. If this is the first one,
2112 just return it; otherwise, ovl_cons the _DECLs */
2115 build_overload (tree decl
, tree chain
)
2117 if (! chain
&& TREE_CODE (decl
) != TEMPLATE_DECL
)
2119 return ovl_cons (decl
, chain
);
2122 /* Return the scope where the overloaded functions OVL were found. */
2125 ovl_scope (tree ovl
)
2127 if (TREE_CODE (ovl
) == OFFSET_REF
2128 || TREE_CODE (ovl
) == COMPONENT_REF
)
2129 ovl
= TREE_OPERAND (ovl
, 1);
2130 if (TREE_CODE (ovl
) == BASELINK
)
2131 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2132 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2133 ovl
= TREE_OPERAND (ovl
, 0);
2134 /* Skip using-declarations. */
2135 while (TREE_CODE (ovl
) == OVERLOAD
&& OVL_USED (ovl
) && OVL_CHAIN (ovl
))
2136 ovl
= OVL_CHAIN (ovl
);
2137 return CP_DECL_CONTEXT (OVL_CURRENT (ovl
));
2140 #define PRINT_RING_SIZE 4
2143 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2145 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2146 static char *print_ring
[PRINT_RING_SIZE
];
2147 static bool trans_ring
[PRINT_RING_SIZE
];
2148 static int ring_counter
;
2151 /* Only cache functions. */
2153 || TREE_CODE (decl
) != FUNCTION_DECL
2154 || DECL_LANG_SPECIFIC (decl
) == 0)
2155 return lang_decl_name (decl
, v
, translate
);
2157 /* See if this print name is lying around. */
2158 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2159 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2160 /* yes, so return it. */
2161 return print_ring
[i
];
2163 if (++ring_counter
== PRINT_RING_SIZE
)
2166 if (current_function_decl
!= NULL_TREE
)
2168 /* There may be both translated and untranslated versions of the
2170 for (i
= 0; i
< 2; i
++)
2172 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2174 if (ring_counter
== PRINT_RING_SIZE
)
2177 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2180 free (print_ring
[ring_counter
]);
2182 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2183 uid_ring
[ring_counter
] = DECL_UID (decl
);
2184 trans_ring
[ring_counter
] = translate
;
2185 return print_ring
[ring_counter
];
2189 cxx_printable_name (tree decl
, int v
)
2191 return cxx_printable_name_internal (decl
, v
, false);
2195 cxx_printable_name_translate (tree decl
, int v
)
2197 return cxx_printable_name_internal (decl
, v
, true);
2200 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2201 listed in RAISES. */
2204 build_exception_variant (tree type
, tree raises
)
2209 if (comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (type
), ce_exact
))
2212 type_quals
= TYPE_QUALS (type
);
2213 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2214 for (v
= TYPE_MAIN_VARIANT (type
); v
; v
= TYPE_NEXT_VARIANT (v
))
2215 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
))
2218 /* Need to build a new variant. */
2219 v
= build_variant_type_copy (type
);
2220 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2224 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2225 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2229 bind_template_template_parm (tree t
, tree newargs
)
2231 tree decl
= TYPE_NAME (t
);
2234 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2235 decl
= build_decl (input_location
,
2236 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2238 /* These nodes have to be created to reflect new TYPE_DECL and template
2240 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2241 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2242 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2243 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2245 TREE_TYPE (decl
) = t2
;
2246 TYPE_NAME (t2
) = decl
;
2247 TYPE_STUB_DECL (t2
) = decl
;
2249 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2254 /* Called from count_trees via walk_tree. */
2257 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2267 /* Debugging function for measuring the rough complexity of a tree
2271 count_trees (tree t
)
2274 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2278 /* Called from verify_stmt_tree via walk_tree. */
2281 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2284 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2285 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2288 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2291 /* If this statement is already present in the hash table, then
2292 there is a circularity in the statement tree. */
2293 gcc_assert (!statements
->find (t
));
2295 slot
= statements
->find_slot (t
, INSERT
);
2301 /* Debugging function to check that the statement T has not been
2302 corrupted. For now, this function simply checks that T contains no
2306 verify_stmt_tree (tree t
)
2308 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2309 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2312 /* Check if the type T depends on a type with no linkage and if so, return
2313 it. If RELAXED_P then do not consider a class type declared within
2314 a vague-linkage function to have no linkage. */
2317 no_linkage_check (tree t
, bool relaxed_p
)
2321 /* There's no point in checking linkage on template functions; we
2322 can't know their complete types. */
2323 if (processing_template_decl
)
2326 switch (TREE_CODE (t
))
2329 if (TYPE_PTRMEMFUNC_P (t
))
2331 /* Lambda types that don't have mangling scope have no linkage. We
2332 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2333 when we get here from pushtag none of the lambda information is
2334 set up yet, so we want to assume that the lambda has linkage and
2335 fix it up later if not. */
2336 if (CLASSTYPE_LAMBDA_EXPR (t
)
2337 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
2338 && LAMBDA_TYPE_EXTRA_SCOPE (t
) == NULL_TREE
)
2342 if (!CLASS_TYPE_P (t
))
2346 /* Only treat anonymous types as having no linkage if they're at
2347 namespace scope. This is core issue 966. */
2348 if (TYPE_ANONYMOUS_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2351 for (r
= CP_TYPE_CONTEXT (t
); ; )
2353 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2354 have linkage, or we might just be in an anonymous namespace.
2355 If we're in a TREE_PUBLIC class, we have linkage. */
2356 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2357 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2358 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2360 if (!relaxed_p
|| !vague_linkage_p (r
))
2363 r
= CP_DECL_CONTEXT (r
);
2373 case REFERENCE_TYPE
:
2375 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2379 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
2383 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
2388 tree parm
= TYPE_ARG_TYPES (t
);
2389 if (TREE_CODE (t
) == METHOD_TYPE
)
2390 /* The 'this' pointer isn't interesting; a method has the same
2391 linkage (or lack thereof) as its enclosing class. */
2392 parm
= TREE_CHAIN (parm
);
2394 parm
&& parm
!= void_list_node
;
2395 parm
= TREE_CHAIN (parm
))
2397 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
2401 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2409 extern int depth_reached
;
2412 cxx_print_statistics (void)
2414 print_search_statistics ();
2415 print_class_statistics ();
2416 print_template_statistics ();
2417 if (GATHER_STATISTICS
)
2418 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2422 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2423 (which is an ARRAY_TYPE). This counts only elements of the top
2427 array_type_nelts_top (tree type
)
2429 return fold_build2_loc (input_location
,
2430 PLUS_EXPR
, sizetype
,
2431 array_type_nelts (type
),
2435 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2436 (which is an ARRAY_TYPE). This one is a recursive count of all
2437 ARRAY_TYPEs that are clumped together. */
2440 array_type_nelts_total (tree type
)
2442 tree sz
= array_type_nelts_top (type
);
2443 type
= TREE_TYPE (type
);
2444 while (TREE_CODE (type
) == ARRAY_TYPE
)
2446 tree n
= array_type_nelts_top (type
);
2447 sz
= fold_build2_loc (input_location
,
2448 MULT_EXPR
, sizetype
, sz
, n
);
2449 type
= TREE_TYPE (type
);
2454 /* Called from break_out_target_exprs via mapcar. */
2457 bot_manip (tree
* tp
, int* walk_subtrees
, void* data
)
2459 splay_tree target_remap
= ((splay_tree
) data
);
2462 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
2464 /* There can't be any TARGET_EXPRs or their slot variables below this
2465 point. But we must make a copy, in case subsequent processing
2466 alters any part of it. For example, during gimplification a cast
2467 of the form (T) &X::f (where "f" is a member function) will lead
2468 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2470 *tp
= unshare_expr (t
);
2473 if (TREE_CODE (t
) == TARGET_EXPR
)
2477 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
2479 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
2480 tf_warning_or_error
);
2481 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
2482 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
2485 u
= build_target_expr_with_type (TREE_OPERAND (t
, 1), TREE_TYPE (t
),
2486 tf_warning_or_error
);
2488 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
2489 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
2490 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
2492 /* Map the old variable to the new one. */
2493 splay_tree_insert (target_remap
,
2494 (splay_tree_key
) TREE_OPERAND (t
, 0),
2495 (splay_tree_value
) TREE_OPERAND (u
, 0));
2497 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1));
2499 /* Replace the old expression with the new version. */
2501 /* We don't have to go below this point; the recursive call to
2502 break_out_target_exprs will have handled anything below this
2507 if (TREE_CODE (*tp
) == SAVE_EXPR
)
2510 splay_tree_node n
= splay_tree_lookup (target_remap
,
2511 (splay_tree_key
) t
);
2514 *tp
= (tree
)n
->value
;
2519 copy_tree_r (tp
, walk_subtrees
, NULL
);
2520 splay_tree_insert (target_remap
,
2522 (splay_tree_value
)*tp
);
2523 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2524 splay_tree_insert (target_remap
,
2525 (splay_tree_key
)*tp
,
2526 (splay_tree_value
)*tp
);
2531 /* Make a copy of this node. */
2532 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
2533 if (TREE_CODE (*tp
) == CALL_EXPR
)
2535 set_flags_from_callee (*tp
);
2537 /* builtin_LINE and builtin_FILE get the location where the default
2538 argument is expanded, not where the call was written. */
2539 tree callee
= get_callee_fndecl (*tp
);
2540 if (callee
&& DECL_BUILT_IN_CLASS (callee
) == BUILT_IN_NORMAL
)
2541 switch (DECL_FUNCTION_CODE (callee
))
2545 SET_EXPR_LOCATION (*tp
, input_location
);
2553 /* Replace all remapped VAR_DECLs in T with their new equivalents.
2554 DATA is really a splay-tree mapping old variables to new
2558 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data
)
2560 splay_tree target_remap
= ((splay_tree
) data
);
2564 splay_tree_node n
= splay_tree_lookup (target_remap
,
2565 (splay_tree_key
) *t
);
2567 *t
= (tree
) n
->value
;
2569 else if (TREE_CODE (*t
) == PARM_DECL
2570 && DECL_NAME (*t
) == this_identifier
2571 && !DECL_CONTEXT (*t
))
2573 /* In an NSDMI we need to replace the 'this' parameter we used for
2574 parsing with the real one for this function. */
2575 *t
= current_class_ptr
;
2577 else if (TREE_CODE (*t
) == CONVERT_EXPR
2578 && CONVERT_EXPR_VBASE_PATH (*t
))
2580 /* In an NSDMI build_base_path defers building conversions to virtual
2581 bases, and we handle it here. */
2582 tree basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t
)));
2583 vec
<tree
, va_gc
> *vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
2585 FOR_EACH_VEC_SAFE_ELT (vbases
, i
, binfo
)
2586 if (BINFO_TYPE (binfo
) == basetype
)
2588 *t
= build_base_path (PLUS_EXPR
, TREE_OPERAND (*t
, 0), binfo
, true,
2589 tf_warning_or_error
);
2595 /* When we parse a default argument expression, we may create
2596 temporary variables via TARGET_EXPRs. When we actually use the
2597 default-argument expression, we make a copy of the expression
2598 and replace the temporaries with appropriate local versions. */
2601 break_out_target_exprs (tree t
)
2603 static int target_remap_count
;
2604 static splay_tree target_remap
;
2606 if (!target_remap_count
++)
2607 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
2608 /*splay_tree_delete_key_fn=*/NULL
,
2609 /*splay_tree_delete_value_fn=*/NULL
);
2610 cp_walk_tree (&t
, bot_manip
, target_remap
, NULL
);
2611 cp_walk_tree (&t
, bot_replace
, target_remap
, NULL
);
2613 if (!--target_remap_count
)
2615 splay_tree_delete (target_remap
);
2616 target_remap
= NULL
;
2622 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
2623 which we expect to have type TYPE. */
2626 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
2628 if (index
== NULL_TREE
)
2629 /* Can't refer to a particular member of a vector. */
2631 else if (TREE_CODE (index
) == INTEGER_CST
)
2632 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
2634 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
2635 /*reference*/false, tf_none
);
2638 tree objtype
= TREE_TYPE (obj
);
2639 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
2641 /* When the destination object refers to a flexible array member
2642 verify that it matches the type of the source object except
2643 for its domain and qualifiers. */
2644 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
2645 TYPE_MAIN_VARIANT (objtype
),
2646 COMPARE_REDECLARATION
));
2649 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
2655 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
2656 build up subexpressions as we go deeper. */
2659 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
2661 tree obj
= static_cast<tree
>(data_
);
2663 if (TREE_CONSTANT (*t
))
2665 *walk_subtrees
= false;
2669 switch (TREE_CODE (*t
))
2671 case PLACEHOLDER_EXPR
:
2674 for (; !(same_type_ignoring_top_level_qualifiers_p
2675 (TREE_TYPE (*t
), TREE_TYPE (x
)));
2676 x
= TREE_OPERAND (x
, 0))
2677 gcc_assert (TREE_CODE (x
) == COMPONENT_REF
);
2679 *walk_subtrees
= false;
2685 constructor_elt
*ce
;
2686 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
2687 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
2689 tree
*valp
= &ce
->value
;
2690 tree type
= TREE_TYPE (*valp
);
2693 if (TREE_CODE (*valp
) == CONSTRUCTOR
2694 && AGGREGATE_TYPE_P (type
))
2696 /* If we're looking at the initializer for OBJ, then build
2697 a sub-object reference. If we're looking at an
2698 initializer for another object, just pass OBJ down. */
2699 if (same_type_ignoring_top_level_qualifiers_p
2700 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
2701 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
2702 if (TREE_CODE (*valp
) == TARGET_EXPR
)
2703 valp
= &TARGET_EXPR_INITIAL (*valp
);
2706 cp_walk_tree (valp
, replace_placeholders_r
,
2709 *walk_subtrees
= false;
2721 replace_placeholders (tree exp
, tree obj
)
2724 if (TREE_CODE (exp
) == TARGET_EXPR
)
2725 tp
= &TARGET_EXPR_INITIAL (exp
);
2726 cp_walk_tree (tp
, replace_placeholders_r
, obj
, NULL
);
2730 /* Similar to `build_nt', but for template definitions of dependent
2734 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
2741 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
2745 t
= make_node (code
);
2746 SET_EXPR_LOCATION (t
, loc
);
2747 length
= TREE_CODE_LENGTH (code
);
2749 for (i
= 0; i
< length
; i
++)
2751 tree x
= va_arg (p
, tree
);
2752 TREE_OPERAND (t
, i
) = x
;
2760 /* Similar to `build', but for template definitions. */
2763 build_min (enum tree_code code
, tree tt
, ...)
2770 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
2774 t
= make_node (code
);
2775 length
= TREE_CODE_LENGTH (code
);
2778 for (i
= 0; i
< length
; i
++)
2780 tree x
= va_arg (p
, tree
);
2781 TREE_OPERAND (t
, i
) = x
;
2782 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
2783 TREE_SIDE_EFFECTS (t
) = 1;
2790 /* Similar to `build', but for template definitions of non-dependent
2791 expressions. NON_DEP is the non-dependent expression that has been
2795 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
2802 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
2804 va_start (p
, non_dep
);
2806 if (REFERENCE_REF_P (non_dep
))
2807 non_dep
= TREE_OPERAND (non_dep
, 0);
2809 t
= make_node (code
);
2810 length
= TREE_CODE_LENGTH (code
);
2811 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
2812 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
2814 for (i
= 0; i
< length
; i
++)
2816 tree x
= va_arg (p
, tree
);
2817 TREE_OPERAND (t
, i
) = x
;
2820 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
2821 /* This should not be considered a COMPOUND_EXPR, because it
2822 resolves to an overload. */
2823 COMPOUND_EXPR_OVERLOADED (t
) = 1;
2826 return convert_from_reference (t
);
2829 /* Similar to `build_nt_call_vec', but for template definitions of
2830 non-dependent expressions. NON_DEP is the non-dependent expression
2831 that has been built. */
2834 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
2836 tree t
= build_nt_call_vec (fn
, argvec
);
2837 if (REFERENCE_REF_P (non_dep
))
2838 non_dep
= TREE_OPERAND (non_dep
, 0);
2839 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
2840 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
2841 return convert_from_reference (t
);
2844 /* Similar to build_min_non_dep, but for expressions that have been resolved to
2845 a call to an operator overload. OP is the operator that has been
2846 overloaded. NON_DEP is the non-dependent expression that's been built,
2847 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
2848 the overload that NON_DEP is calling. */
2851 build_min_non_dep_op_overload (enum tree_code op
,
2856 int nargs
, expected_nargs
;
2858 vec
<tree
, va_gc
> *args
;
2860 non_dep
= extract_call_expr (non_dep
);
2862 nargs
= call_expr_nargs (non_dep
);
2864 expected_nargs
= cp_tree_code_length (op
);
2865 if (op
== POSTINCREMENT_EXPR
2866 || op
== POSTDECREMENT_EXPR
)
2867 expected_nargs
+= 1;
2868 gcc_assert (nargs
== expected_nargs
);
2870 args
= make_tree_vector ();
2871 va_start (p
, overload
);
2873 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
2876 for (int i
= 0; i
< nargs
; i
++)
2878 tree arg
= va_arg (p
, tree
);
2879 vec_safe_push (args
, arg
);
2882 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
2884 tree object
= va_arg (p
, tree
);
2885 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
2886 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
2887 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
2888 object
, method
, NULL_TREE
);
2889 for (int i
= 1; i
< nargs
; i
++)
2891 tree arg
= va_arg (p
, tree
);
2892 vec_safe_push (args
, arg
);
2899 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
2900 release_tree_vector (args
);
2902 tree call_expr
= extract_call_expr (call
);
2903 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
2904 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
2905 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
2906 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
2912 get_type_decl (tree t
)
2914 if (TREE_CODE (t
) == TYPE_DECL
)
2917 return TYPE_STUB_DECL (t
);
2918 gcc_assert (t
== error_mark_node
);
2922 /* Returns the namespace that contains DECL, whether directly or
2926 decl_namespace_context (tree decl
)
2930 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2932 else if (TYPE_P (decl
))
2933 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
2935 decl
= CP_DECL_CONTEXT (decl
);
2939 /* Returns true if decl is within an anonymous namespace, however deeply
2940 nested, or false otherwise. */
2943 decl_anon_ns_mem_p (const_tree decl
)
2947 if (decl
== NULL_TREE
|| decl
== error_mark_node
)
2949 if (TREE_CODE (decl
) == NAMESPACE_DECL
2950 && DECL_NAME (decl
) == NULL_TREE
)
2952 /* Classes and namespaces inside anonymous namespaces have
2953 TREE_PUBLIC == 0, so we can shortcut the search. */
2954 else if (TYPE_P (decl
))
2955 return (TREE_PUBLIC (TYPE_MAIN_DECL (decl
)) == 0);
2956 else if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2957 return (TREE_PUBLIC (decl
) == 0);
2959 decl
= DECL_CONTEXT (decl
);
2963 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
2964 CALL_EXPRS. Return whether they are equivalent. */
2967 called_fns_equal (tree t1
, tree t2
)
2969 /* Core 1321: dependent names are equivalent even if the overload sets
2970 are different. But do compare explicit template arguments. */
2971 tree name1
= dependent_name (t1
);
2972 tree name2
= dependent_name (t2
);
2975 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
2980 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
2981 targs1
= TREE_OPERAND (t1
, 1);
2982 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
2983 targs2
= TREE_OPERAND (t2
, 1);
2984 return cp_tree_equal (targs1
, targs2
);
2987 return cp_tree_equal (t1
, t2
);
2990 /* Return truthvalue of whether T1 is the same tree structure as T2.
2991 Return 1 if they are the same. Return 0 if they are different. */
2994 cp_tree_equal (tree t1
, tree t2
)
2996 enum tree_code code1
, code2
;
3003 code1
= TREE_CODE (t1
);
3004 code2
= TREE_CODE (t2
);
3012 /* There's only a single VOID_CST node, so we should never reach
3017 return tree_int_cst_equal (t1
, t2
);
3020 return real_equal (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3023 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3024 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3025 TREE_STRING_LENGTH (t1
));
3028 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3029 TREE_FIXED_CST (t2
));
3032 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3033 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3036 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3039 /* We need to do this when determining whether or not two
3040 non-type pointer to member function template arguments
3042 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3043 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3048 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3050 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3051 if (!cp_tree_equal (field
, elt2
->index
)
3052 || !cp_tree_equal (value
, elt2
->value
))
3059 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3061 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3063 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3066 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3071 call_expr_arg_iterator iter1
, iter2
;
3072 if (!called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
3074 for (arg1
= first_call_expr_arg (t1
, &iter1
),
3075 arg2
= first_call_expr_arg (t2
, &iter2
);
3077 arg1
= next_call_expr_arg (&iter1
),
3078 arg2
= next_call_expr_arg (&iter2
))
3079 if (!cp_tree_equal (arg1
, arg2
))
3088 tree o1
= TREE_OPERAND (t1
, 0);
3089 tree o2
= TREE_OPERAND (t2
, 0);
3091 /* Special case: if either target is an unallocated VAR_DECL,
3092 it means that it's going to be unified with whatever the
3093 TARGET_EXPR is really supposed to initialize, so treat it
3094 as being equivalent to anything. */
3095 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
3096 && !DECL_RTL_SET_P (o1
))
3098 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
3099 && !DECL_RTL_SET_P (o2
))
3101 else if (!cp_tree_equal (o1
, o2
))
3104 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
3107 case WITH_CLEANUP_EXPR
:
3108 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3110 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t1
, 1));
3113 if (TREE_OPERAND (t1
, 1) != TREE_OPERAND (t2
, 1))
3115 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3118 /* For comparing uses of parameters in late-specified return types
3119 with an out-of-class definition of the function, but can also come
3120 up for expressions that involve 'this' in a member function
3123 if (comparing_specializations
&& !CONSTRAINT_VAR_P (t1
))
3124 /* When comparing hash table entries, only an exact match is
3125 good enough; we don't want to replace 'this' with the
3126 version from another function. But be more flexible
3127 with local parameters in a requires-expression. */
3130 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3132 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
3134 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
3136 if (DECL_ARTIFICIAL (t1
)
3137 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
3138 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
3148 case IDENTIFIER_NODE
:
3153 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
3154 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
3155 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
3156 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
3157 BASELINK_FUNCTIONS (t2
)));
3159 case TEMPLATE_PARM_INDEX
:
3160 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
3161 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
3162 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
3163 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
3164 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
3165 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
3167 case TEMPLATE_ID_EXPR
:
3168 return (cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
3169 && cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
3171 case CONSTRAINT_INFO
:
3172 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
3173 CI_ASSOCIATED_CONSTRAINTS (t2
));
3178 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3180 for (ix
= TREE_VEC_LENGTH (t1
); ix
--;)
3181 if (!cp_tree_equal (TREE_VEC_ELT (t1
, ix
),
3182 TREE_VEC_ELT (t2
, ix
)))
3190 tree o1
= TREE_OPERAND (t1
, 0);
3191 tree o2
= TREE_OPERAND (t2
, 0);
3193 if (code1
== SIZEOF_EXPR
)
3195 if (SIZEOF_EXPR_TYPE_P (t1
))
3196 o1
= TREE_TYPE (o1
);
3197 if (SIZEOF_EXPR_TYPE_P (t2
))
3198 o2
= TREE_TYPE (o2
);
3200 if (TREE_CODE (o1
) != TREE_CODE (o2
))
3203 return same_type_p (o1
, o2
);
3205 return cp_tree_equal (o1
, o2
);
3210 tree t1_op1
, t2_op1
;
3212 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3215 t1_op1
= TREE_OPERAND (t1
, 1);
3216 t2_op1
= TREE_OPERAND (t2
, 1);
3217 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
3220 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
3224 /* Two pointer-to-members are the same if they point to the same
3225 field or function in the same class. */
3226 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
3229 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
3232 if (OVL_FUNCTION (t1
) != OVL_FUNCTION (t2
))
3234 return cp_tree_equal (OVL_CHAIN (t1
), OVL_CHAIN (t2
));
3237 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
3239 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
3240 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
3243 case STATIC_CAST_EXPR
:
3244 case REINTERPRET_CAST_EXPR
:
3245 case CONST_CAST_EXPR
:
3246 case DYNAMIC_CAST_EXPR
:
3247 case IMPLICIT_CONV_EXPR
:
3250 case NON_LVALUE_EXPR
:
3251 case VIEW_CONVERT_EXPR
:
3252 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3254 /* Now compare operands as usual. */
3257 case DEFERRED_NOEXCEPT
:
3258 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
3259 DEFERRED_NOEXCEPT_PATTERN (t2
))
3260 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
3261 DEFERRED_NOEXCEPT_ARGS (t2
)));
3268 switch (TREE_CODE_CLASS (code1
))
3272 case tcc_comparison
:
3273 case tcc_expression
:
3280 n
= cp_tree_operand_length (t1
);
3281 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
3282 && n
!= TREE_OPERAND_LENGTH (t2
))
3285 for (i
= 0; i
< n
; ++i
)
3286 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
3293 return same_type_p (t1
, t2
);
3297 /* We can get here with --disable-checking. */
3301 /* The type of ARG when used as an lvalue. */
3304 lvalue_type (tree arg
)
3306 tree type
= TREE_TYPE (arg
);
3310 /* The type of ARG for printing error messages; denote lvalues with
3314 error_type (tree arg
)
3316 tree type
= TREE_TYPE (arg
);
3318 if (TREE_CODE (type
) == ARRAY_TYPE
)
3320 else if (TREE_CODE (type
) == ERROR_MARK
)
3322 else if (real_lvalue_p (arg
))
3323 type
= build_reference_type (lvalue_type (arg
));
3324 else if (MAYBE_CLASS_TYPE_P (type
))
3325 type
= lvalue_type (arg
);
3330 /* Does FUNCTION use a variable-length argument list? */
3333 varargs_function_p (const_tree function
)
3335 return stdarg_p (TREE_TYPE (function
));
3338 /* Returns 1 if decl is a member of a class. */
3341 member_p (const_tree decl
)
3343 const_tree
const ctx
= DECL_CONTEXT (decl
);
3344 return (ctx
&& TYPE_P (ctx
));
3347 /* Create a placeholder for member access where we don't actually have an
3348 object that the access is against. */
3351 build_dummy_object (tree type
)
3353 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
3354 return cp_build_indirect_ref (decl
, RO_NULL
, tf_warning_or_error
);
3357 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
3358 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
3359 binfo path from current_class_type to TYPE, or 0. */
3362 maybe_dummy_object (tree type
, tree
* binfop
)
3366 tree current
= current_nonlambda_class_type ();
3369 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
3370 tf_warning_or_error
)))
3374 /* Reference from a nested class member function. */
3376 binfo
= TYPE_BINFO (type
);
3382 if (current_class_ref
3383 /* current_class_ref might not correspond to current_class_type if
3384 we're in tsubst_default_argument or a lambda-declarator; in either
3385 case, we want to use current_class_ref if it matches CONTEXT. */
3386 && (same_type_ignoring_top_level_qualifiers_p
3387 (TREE_TYPE (current_class_ref
), context
)))
3388 decl
= current_class_ref
;
3390 decl
= build_dummy_object (context
);
3395 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
3398 is_dummy_object (const_tree ob
)
3400 if (INDIRECT_REF_P (ob
))
3401 ob
= TREE_OPERAND (ob
, 0);
3402 return (TREE_CODE (ob
) == CONVERT_EXPR
3403 && TREE_OPERAND (ob
, 0) == void_node
);
3406 /* Returns 1 iff type T is something we want to treat as a scalar type for
3407 the purpose of deciding whether it is trivial/POD/standard-layout. */
3410 scalarish_type_p (const_tree t
)
3412 if (t
== error_mark_node
)
3415 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
3418 /* Returns true iff T requires non-trivial default initialization. */
3421 type_has_nontrivial_default_init (const_tree t
)
3423 t
= strip_array_types (CONST_CAST_TREE (t
));
3425 if (CLASS_TYPE_P (t
))
3426 return TYPE_HAS_COMPLEX_DFLT (t
);
3431 /* Returns true iff copying an object of type T (including via move
3432 constructor) is non-trivial. That is, T has no non-trivial copy
3433 constructors and no non-trivial move constructors. */
3436 type_has_nontrivial_copy_init (const_tree t
)
3438 t
= strip_array_types (CONST_CAST_TREE (t
));
3440 if (CLASS_TYPE_P (t
))
3442 gcc_assert (COMPLETE_TYPE_P (t
));
3443 return ((TYPE_HAS_COPY_CTOR (t
)
3444 && TYPE_HAS_COMPLEX_COPY_CTOR (t
))
3445 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
));
3451 /* Returns 1 iff type T is a trivially copyable type, as defined in
3452 [basic.types] and [class]. */
3455 trivially_copyable_p (const_tree t
)
3457 t
= strip_array_types (CONST_CAST_TREE (t
));
3459 if (CLASS_TYPE_P (t
))
3460 return ((!TYPE_HAS_COPY_CTOR (t
)
3461 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
3462 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
3463 && (!TYPE_HAS_COPY_ASSIGN (t
)
3464 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
3465 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
3466 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
3468 return !CP_TYPE_VOLATILE_P (t
) && scalarish_type_p (t
);
3471 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
3475 trivial_type_p (const_tree t
)
3477 t
= strip_array_types (CONST_CAST_TREE (t
));
3479 if (CLASS_TYPE_P (t
))
3480 return (TYPE_HAS_TRIVIAL_DFLT (t
)
3481 && trivially_copyable_p (t
));
3483 return scalarish_type_p (t
);
3486 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
3489 pod_type_p (const_tree t
)
3491 /* This CONST_CAST is okay because strip_array_types returns its
3492 argument unmodified and we assign it to a const_tree. */
3493 t
= strip_array_types (CONST_CAST_TREE(t
));
3495 if (!CLASS_TYPE_P (t
))
3496 return scalarish_type_p (t
);
3497 else if (cxx_dialect
> cxx98
)
3498 /* [class]/10: A POD struct is a class that is both a trivial class and a
3499 standard-layout class, and has no non-static data members of type
3500 non-POD struct, non-POD union (or array of such types).
3502 We don't need to check individual members because if a member is
3503 non-std-layout or non-trivial, the class will be too. */
3504 return (std_layout_type_p (t
) && trivial_type_p (t
));
3506 /* The C++98 definition of POD is different. */
3507 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
3510 /* Returns true iff T is POD for the purpose of layout, as defined in the
3514 layout_pod_type_p (const_tree t
)
3516 t
= strip_array_types (CONST_CAST_TREE (t
));
3518 if (CLASS_TYPE_P (t
))
3519 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
3521 return scalarish_type_p (t
);
3524 /* Returns true iff T is a standard-layout type, as defined in
3528 std_layout_type_p (const_tree t
)
3530 t
= strip_array_types (CONST_CAST_TREE (t
));
3532 if (CLASS_TYPE_P (t
))
3533 return !CLASSTYPE_NON_STD_LAYOUT (t
);
3535 return scalarish_type_p (t
);
3538 /* Nonzero iff type T is a class template implicit specialization. */
3541 class_tmpl_impl_spec_p (const_tree t
)
3543 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
3546 /* Returns 1 iff zero initialization of type T means actually storing
3550 zero_init_p (const_tree t
)
3552 /* This CONST_CAST is okay because strip_array_types returns its
3553 argument unmodified and we assign it to a const_tree. */
3554 t
= strip_array_types (CONST_CAST_TREE(t
));
3556 if (t
== error_mark_node
)
3559 /* NULL pointers to data members are initialized with -1. */
3560 if (TYPE_PTRDATAMEM_P (t
))
3563 /* Classes that contain types that can't be zero-initialized, cannot
3564 be zero-initialized themselves. */
3565 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
3571 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
3572 warn_unused_result attribute. */
3575 handle_nodiscard_attribute (tree
*node
, tree name
, tree
/*args*/,
3576 int /*flags*/, bool *no_add_attrs
)
3578 if (TREE_CODE (*node
) == FUNCTION_DECL
)
3580 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
3581 warning (OPT_Wattributes
, "%qE attribute applied to %qD with void "
3582 "return type", name
, *node
);
3584 else if (OVERLOAD_TYPE_P (*node
))
3588 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
3589 "functions or to class or enumeration types", name
);
3590 *no_add_attrs
= true;
3595 /* Table of valid C++ attributes. */
3596 const struct attribute_spec cxx_attribute_table
[] =
3598 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
3599 affects_type_identity } */
3600 { "java_interface", 0, 0, false, false, false,
3601 handle_java_interface_attribute
, false },
3602 { "init_priority", 1, 1, true, false, false,
3603 handle_init_priority_attribute
, false },
3604 { "abi_tag", 1, -1, false, false, false,
3605 handle_abi_tag_attribute
, true },
3606 { NULL
, 0, 0, false, false, false, NULL
, false }
3609 /* Table of C++ standard attributes. */
3610 const struct attribute_spec std_attribute_table
[] =
3612 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
3613 affects_type_identity } */
3614 { "maybe_unused", 0, 0, false, false, false,
3615 handle_unused_attribute
, false },
3616 { "nodiscard", 0, 0, false, false, false,
3617 handle_nodiscard_attribute
, false },
3618 { NULL
, 0, 0, false, false, false, NULL
, false }
3621 /* Handle a "java_interface" attribute; arguments as in
3622 struct attribute_spec.handler. */
3624 handle_java_interface_attribute (tree
* node
,
3631 || !CLASS_TYPE_P (*node
)
3632 || !TYPE_FOR_JAVA (*node
))
3634 error ("%qE attribute can only be applied to Java class definitions",
3636 *no_add_attrs
= true;
3639 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
3640 *node
= build_variant_type_copy (*node
);
3641 TYPE_JAVA_INTERFACE (*node
) = 1;
3646 /* Handle an "init_priority" attribute; arguments as in
3647 struct attribute_spec.handler. */
3649 handle_init_priority_attribute (tree
* node
,
3655 tree initp_expr
= TREE_VALUE (args
);
3657 tree type
= TREE_TYPE (decl
);
3660 STRIP_NOPS (initp_expr
);
3661 initp_expr
= default_conversion (initp_expr
);
3663 initp_expr
= maybe_constant_value (initp_expr
);
3665 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
3667 error ("requested init_priority is not an integer constant");
3668 cxx_constant_value (initp_expr
);
3669 *no_add_attrs
= true;
3673 pri
= TREE_INT_CST_LOW (initp_expr
);
3675 type
= strip_array_types (type
);
3677 if (decl
== NULL_TREE
3679 || !TREE_STATIC (decl
)
3680 || DECL_EXTERNAL (decl
)
3681 || (TREE_CODE (type
) != RECORD_TYPE
3682 && TREE_CODE (type
) != UNION_TYPE
)
3683 /* Static objects in functions are initialized the
3684 first time control passes through that
3685 function. This is not precise enough to pin down an
3686 init_priority value, so don't allow it. */
3687 || current_function_decl
)
3689 error ("can only use %qE attribute on file-scope definitions "
3690 "of objects of class type", name
);
3691 *no_add_attrs
= true;
3695 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
3697 error ("requested init_priority is out of range");
3698 *no_add_attrs
= true;
3702 /* Check for init_priorities that are reserved for
3703 language and runtime support implementations.*/
3704 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
3707 (0, "requested init_priority is reserved for internal use");
3710 if (SUPPORTS_INIT_PRIORITY
)
3712 SET_DECL_INIT_PRIORITY (decl
, pri
);
3713 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
3718 error ("%qE attribute is not supported on this platform", name
);
3719 *no_add_attrs
= true;
3724 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
3725 and the new one has the tags in NEW_. Give an error if there are tags
3726 in NEW_ that weren't in OLD. */
3729 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
3731 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
3732 old
= TREE_VALUE (old
);
3733 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
3734 new_
= TREE_VALUE (new_
);
3736 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
3738 tree str
= TREE_VALUE (t
);
3739 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
3741 tree ostr
= TREE_VALUE (in
);
3742 if (cp_tree_equal (str
, ostr
))
3745 error ("redeclaration of %qD adds abi tag %E", decl
, str
);
3751 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
3757 /* The abi_tag attribute with the name NAME was given ARGS. If they are
3758 ill-formed, give an error and return false; otherwise, return true. */
3761 check_abi_tag_args (tree args
, tree name
)
3765 error ("the %qE attribute requires arguments", name
);
3768 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
3770 tree elt
= TREE_VALUE (arg
);
3771 if (TREE_CODE (elt
) != STRING_CST
3772 || (!same_type_ignoring_top_level_qualifiers_p
3773 (strip_array_types (TREE_TYPE (elt
)),
3776 error ("arguments to the %qE attribute must be narrow string "
3780 const char *begin
= TREE_STRING_POINTER (elt
);
3781 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
3782 for (const char *p
= begin
; p
!= end
; ++p
)
3787 if (!ISALPHA (c
) && c
!= '_')
3789 error ("arguments to the %qE attribute must contain valid "
3790 "identifiers", name
);
3791 inform (input_location
, "%<%c%> is not a valid first "
3792 "character for an identifier", c
);
3796 else if (p
== end
- 1)
3797 gcc_assert (c
== 0);
3800 if (!ISALNUM (c
) && c
!= '_')
3802 error ("arguments to the %qE attribute must contain valid "
3803 "identifiers", name
);
3804 inform (input_location
, "%<%c%> is not a valid character "
3805 "in an identifier", c
);
3814 /* Handle an "abi_tag" attribute; arguments as in
3815 struct attribute_spec.handler. */
3818 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
3819 int flags
, bool* no_add_attrs
)
3821 if (!check_abi_tag_args (args
, name
))
3826 if (!OVERLOAD_TYPE_P (*node
))
3828 error ("%qE attribute applied to non-class, non-enum type %qT",
3832 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
3834 error ("%qE attribute applied to %qT after its definition",
3838 else if (CLASS_TYPE_P (*node
)
3839 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
3841 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
3842 "template instantiation %qT", name
, *node
);
3845 else if (CLASS_TYPE_P (*node
)
3846 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
3848 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
3849 "template specialization %qT", name
, *node
);
3853 tree attributes
= TYPE_ATTRIBUTES (*node
);
3854 tree decl
= TYPE_NAME (*node
);
3856 /* Make sure all declarations have the same abi tags. */
3857 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
3859 if (!check_abi_tag_redeclaration (decl
,
3860 lookup_attribute ("abi_tag",
3868 if (!VAR_OR_FUNCTION_DECL_P (*node
))
3870 error ("%qE attribute applied to non-function, non-variable %qD",
3874 else if (DECL_LANGUAGE (*node
) == lang_c
)
3876 error ("%qE attribute applied to extern \"C\" declaration %qD",
3885 *no_add_attrs
= true;
3889 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
3890 thing pointed to by the constant. */
3893 make_ptrmem_cst (tree type
, tree member
)
3895 tree ptrmem_cst
= make_node (PTRMEM_CST
);
3896 TREE_TYPE (ptrmem_cst
) = type
;
3897 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
3901 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
3902 return an existing type if an appropriate type already exists. */
3905 cp_build_type_attribute_variant (tree type
, tree attributes
)
3909 new_type
= build_type_attribute_variant (type
, attributes
);
3910 if (TREE_CODE (new_type
) == FUNCTION_TYPE
3911 || TREE_CODE (new_type
) == METHOD_TYPE
)
3913 new_type
= build_exception_variant (new_type
,
3914 TYPE_RAISES_EXCEPTIONS (type
));
3915 new_type
= build_ref_qualified_type (new_type
,
3916 type_memfn_rqual (type
));
3919 /* Making a new main variant of a class type is broken. */
3920 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
3925 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
3926 Called only after doing all language independent checks. Only
3927 to check TYPE_RAISES_EXCEPTIONS for FUNCTION_TYPE, the rest is already
3928 compared in type_hash_eq. */
3931 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
3933 gcc_assert (TREE_CODE (typea
) == FUNCTION_TYPE
3934 || TREE_CODE (typea
) == METHOD_TYPE
);
3936 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
3937 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
3940 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
3941 traversal. Called from walk_tree. */
3944 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
3945 void *data
, hash_set
<tree
> *pset
)
3947 enum tree_code code
= TREE_CODE (*tp
);
3950 #define WALK_SUBTREE(NODE) \
3953 result = cp_walk_tree (&(NODE), func, data, pset); \
3954 if (result) goto out; \
3958 /* Not one of the easy cases. We must explicitly go through the
3964 case TEMPLATE_TEMPLATE_PARM
:
3965 case BOUND_TEMPLATE_TEMPLATE_PARM
:
3966 case UNBOUND_CLASS_TEMPLATE
:
3967 case TEMPLATE_PARM_INDEX
:
3968 case TEMPLATE_TYPE_PARM
:
3971 case UNDERLYING_TYPE
:
3972 /* None of these have subtrees other than those already walked
3974 *walk_subtrees_p
= 0;
3978 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
3979 *walk_subtrees_p
= 0;
3983 WALK_SUBTREE (TREE_TYPE (*tp
));
3984 *walk_subtrees_p
= 0;
3988 WALK_SUBTREE (TREE_PURPOSE (*tp
));
3992 WALK_SUBTREE (OVL_FUNCTION (*tp
));
3993 WALK_SUBTREE (OVL_CHAIN (*tp
));
3994 *walk_subtrees_p
= 0;
3998 WALK_SUBTREE (DECL_NAME (*tp
));
3999 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
4000 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
4001 *walk_subtrees_p
= 0;
4005 if (TYPE_PTRMEMFUNC_P (*tp
))
4006 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
4009 case TYPE_ARGUMENT_PACK
:
4010 case NONTYPE_ARGUMENT_PACK
:
4012 tree args
= ARGUMENT_PACK_ARGS (*tp
);
4013 int i
, len
= TREE_VEC_LENGTH (args
);
4014 for (i
= 0; i
< len
; i
++)
4015 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
4019 case TYPE_PACK_EXPANSION
:
4020 WALK_SUBTREE (TREE_TYPE (*tp
));
4021 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4022 *walk_subtrees_p
= 0;
4025 case EXPR_PACK_EXPANSION
:
4026 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
4027 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4028 *walk_subtrees_p
= 0;
4032 case REINTERPRET_CAST_EXPR
:
4033 case STATIC_CAST_EXPR
:
4034 case CONST_CAST_EXPR
:
4035 case DYNAMIC_CAST_EXPR
:
4036 case IMPLICIT_CONV_EXPR
:
4037 if (TREE_TYPE (*tp
))
4038 WALK_SUBTREE (TREE_TYPE (*tp
));
4042 for (i
= 0; i
< TREE_CODE_LENGTH (TREE_CODE (*tp
)); ++i
)
4043 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
4045 *walk_subtrees_p
= 0;
4049 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
4050 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
4051 *walk_subtrees_p
= 0;
4055 WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp
));
4056 *walk_subtrees_p
= 0;
4060 // Only recurse through the nested expression. Do not
4061 // walk the parameter list. Doing so causes false
4062 // positives in the pack expansion checker since the
4063 // requires parameters are introduced as pack expansions.
4064 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
4065 *walk_subtrees_p
= 0;
4072 /* We didn't find what we were looking for. */
4079 /* Like save_expr, but for C++. */
4082 cp_save_expr (tree expr
)
4084 /* There is no reason to create a SAVE_EXPR within a template; if
4085 needed, we can create the SAVE_EXPR when instantiating the
4086 template. Furthermore, the middle-end cannot handle C++-specific
4088 if (processing_template_decl
)
4090 return save_expr (expr
);
4093 /* Initialize tree.c. */
4098 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
4099 register_scoped_attributes (std_attribute_table
, NULL
);
4102 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
4103 is. Note that sfk_none is zero, so this function can be used as a
4104 predicate to test whether or not DECL is a special function. */
4106 special_function_kind
4107 special_function_p (const_tree decl
)
4109 /* Rather than doing all this stuff with magic names, we should
4110 probably have a field of type `special_function_kind' in
4111 DECL_LANG_SPECIFIC. */
4112 if (DECL_INHERITED_CTOR_BASE (decl
))
4113 return sfk_inheriting_constructor
;
4114 if (DECL_COPY_CONSTRUCTOR_P (decl
))
4115 return sfk_copy_constructor
;
4116 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
4117 return sfk_move_constructor
;
4118 if (DECL_CONSTRUCTOR_P (decl
))
4119 return sfk_constructor
;
4120 if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
4122 if (copy_fn_p (decl
))
4123 return sfk_copy_assignment
;
4124 if (move_fn_p (decl
))
4125 return sfk_move_assignment
;
4127 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
4128 return sfk_destructor
;
4129 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
4130 return sfk_complete_destructor
;
4131 if (DECL_BASE_DESTRUCTOR_P (decl
))
4132 return sfk_base_destructor
;
4133 if (DECL_DELETING_DESTRUCTOR_P (decl
))
4134 return sfk_deleting_destructor
;
4135 if (DECL_CONV_FN_P (decl
))
4136 return sfk_conversion
;
4141 /* Returns nonzero if TYPE is a character type, including wchar_t. */
4144 char_type_p (tree type
)
4146 return (same_type_p (type
, char_type_node
)
4147 || same_type_p (type
, unsigned_char_type_node
)
4148 || same_type_p (type
, signed_char_type_node
)
4149 || same_type_p (type
, char16_type_node
)
4150 || same_type_p (type
, char32_type_node
)
4151 || same_type_p (type
, wchar_type_node
));
4154 /* Returns the kind of linkage associated with the indicated DECL. Th
4155 value returned is as specified by the language standard; it is
4156 independent of implementation details regarding template
4157 instantiation, etc. For example, it is possible that a declaration
4158 to which this function assigns external linkage would not show up
4159 as a global symbol when you run `nm' on the resulting object file. */
4162 decl_linkage (tree decl
)
4164 /* This function doesn't attempt to calculate the linkage from first
4165 principles as given in [basic.link]. Instead, it makes use of
4166 the fact that we have already set TREE_PUBLIC appropriately, and
4167 then handles a few special cases. Ideally, we would calculate
4168 linkage first, and then transform that into a concrete
4171 /* Things that don't have names have no linkage. */
4172 if (!DECL_NAME (decl
))
4175 /* Fields have no linkage. */
4176 if (TREE_CODE (decl
) == FIELD_DECL
)
4179 /* Things that are TREE_PUBLIC have external linkage. */
4180 if (TREE_PUBLIC (decl
))
4183 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
4186 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
4188 if (TREE_CODE (decl
) == CONST_DECL
)
4189 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
4191 /* Things in local scope do not have linkage, if they don't have
4193 if (decl_function_context (decl
))
4196 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
4197 are considered to have external linkage for language purposes, as do
4198 template instantiations on targets without weak symbols. DECLs really
4199 meant to have internal linkage have DECL_THIS_STATIC set. */
4200 if (TREE_CODE (decl
) == TYPE_DECL
)
4202 if (VAR_OR_FUNCTION_DECL_P (decl
))
4204 if (!DECL_THIS_STATIC (decl
))
4207 /* Static data members and static member functions from classes
4208 in anonymous namespace also don't have TREE_PUBLIC set. */
4209 if (DECL_CLASS_CONTEXT (decl
))
4213 /* Everything else has internal linkage. */
4217 /* Returns the storage duration of the object or reference associated with
4218 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
4221 decl_storage_duration (tree decl
)
4223 if (TREE_CODE (decl
) == PARM_DECL
)
4225 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4227 gcc_assert (VAR_P (decl
));
4228 if (!TREE_STATIC (decl
)
4229 && !DECL_EXTERNAL (decl
))
4231 if (CP_DECL_THREAD_LOCAL_P (decl
))
4236 /* EXP is an expression that we want to pre-evaluate. Returns (in
4237 *INITP) an expression that will perform the pre-evaluation. The
4238 value returned by this function is a side-effect free expression
4239 equivalent to the pre-evaluated expression. Callers must ensure
4240 that *INITP is evaluated before EXP. */
4243 stabilize_expr (tree exp
, tree
* initp
)
4247 if (!TREE_SIDE_EFFECTS (exp
))
4248 init_expr
= NULL_TREE
;
4249 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
4254 /* There are no expressions with REFERENCE_TYPE, but there can be call
4255 arguments with such a type; just treat it as a pointer. */
4256 else if (TREE_CODE (TREE_TYPE (exp
)) == REFERENCE_TYPE
4257 || SCALAR_TYPE_P (TREE_TYPE (exp
))
4258 || !lvalue_or_rvalue_with_address_p (exp
))
4260 init_expr
= get_target_expr (exp
);
4261 exp
= TARGET_EXPR_SLOT (init_expr
);
4262 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
4269 bool xval
= !real_lvalue_p (exp
);
4270 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
4271 init_expr
= get_target_expr (exp
);
4272 exp
= TARGET_EXPR_SLOT (init_expr
);
4273 exp
= cp_build_indirect_ref (exp
, RO_NULL
, tf_warning_or_error
);
4279 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
4283 /* Add NEW_EXPR, an expression whose value we don't care about, after the
4284 similar expression ORIG. */
4287 add_stmt_to_compound (tree orig
, tree new_expr
)
4289 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
4291 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
4293 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
4296 /* Like stabilize_expr, but for a call whose arguments we want to
4297 pre-evaluate. CALL is modified in place to use the pre-evaluated
4298 arguments, while, upon return, *INITP contains an expression to
4299 compute the arguments. */
4302 stabilize_call (tree call
, tree
*initp
)
4304 tree inits
= NULL_TREE
;
4306 int nargs
= call_expr_nargs (call
);
4308 if (call
== error_mark_node
|| processing_template_decl
)
4314 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
4316 for (i
= 0; i
< nargs
; i
++)
4319 CALL_EXPR_ARG (call
, i
) =
4320 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
4321 inits
= add_stmt_to_compound (inits
, init
);
4327 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
4328 to pre-evaluate. CALL is modified in place to use the pre-evaluated
4329 arguments, while, upon return, *INITP contains an expression to
4330 compute the arguments. */
4333 stabilize_aggr_init (tree call
, tree
*initp
)
4335 tree inits
= NULL_TREE
;
4337 int nargs
= aggr_init_expr_nargs (call
);
4339 if (call
== error_mark_node
)
4342 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
4344 for (i
= 0; i
< nargs
; i
++)
4347 AGGR_INIT_EXPR_ARG (call
, i
) =
4348 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
4349 inits
= add_stmt_to_compound (inits
, init
);
4355 /* Like stabilize_expr, but for an initialization.
4357 If the initialization is for an object of class type, this function
4358 takes care not to introduce additional temporaries.
4360 Returns TRUE iff the expression was successfully pre-evaluated,
4361 i.e., if INIT is now side-effect free, except for, possibly, a
4362 single call to a constructor. */
4365 stabilize_init (tree init
, tree
*initp
)
4371 if (t
== error_mark_node
|| processing_template_decl
)
4374 if (TREE_CODE (t
) == INIT_EXPR
)
4375 t
= TREE_OPERAND (t
, 1);
4376 if (TREE_CODE (t
) == TARGET_EXPR
)
4377 t
= TARGET_EXPR_INITIAL (t
);
4379 /* If the RHS can be stabilized without breaking copy elision, stabilize
4380 it. We specifically don't stabilize class prvalues here because that
4381 would mean an extra copy, but they might be stabilized below. */
4382 if (TREE_CODE (init
) == INIT_EXPR
4383 && TREE_CODE (t
) != CONSTRUCTOR
4384 && TREE_CODE (t
) != AGGR_INIT_EXPR
4385 && (SCALAR_TYPE_P (TREE_TYPE (t
))
4386 || lvalue_or_rvalue_with_address_p (t
)))
4388 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
4392 if (TREE_CODE (t
) == COMPOUND_EXPR
4393 && TREE_CODE (init
) == INIT_EXPR
)
4395 tree last
= expr_last (t
);
4396 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
4397 if (!TREE_SIDE_EFFECTS (last
))
4400 TREE_OPERAND (init
, 1) = last
;
4405 if (TREE_CODE (t
) == CONSTRUCTOR
)
4407 /* Aggregate initialization: stabilize each of the field
4410 constructor_elt
*ce
;
4412 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
4413 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
4415 tree type
= TREE_TYPE (ce
->value
);
4417 if (TREE_CODE (type
) == REFERENCE_TYPE
4418 || SCALAR_TYPE_P (type
))
4419 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
4420 else if (!stabilize_init (ce
->value
, &subinit
))
4422 *initp
= add_stmt_to_compound (*initp
, subinit
);
4427 if (TREE_CODE (t
) == CALL_EXPR
)
4429 stabilize_call (t
, initp
);
4433 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
4435 stabilize_aggr_init (t
, initp
);
4439 /* The initialization is being performed via a bitwise copy -- and
4440 the item copied may have side effects. */
4441 return !TREE_SIDE_EFFECTS (init
);
4444 /* Returns true if a cast to TYPE may appear in an integral constant
4448 cast_valid_in_integral_constant_expression_p (tree type
)
4450 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
4451 || cxx_dialect
>= cxx11
4452 || dependent_type_p (type
)
4453 || type
== error_mark_node
);
4456 /* Return true if we need to fix linkage information of DECL. */
4459 cp_fix_function_decl_p (tree decl
)
4461 /* Skip if DECL is not externally visible. */
4462 if (!TREE_PUBLIC (decl
))
4465 /* We need to fix DECL if it a appears to be exported but with no
4466 function body. Thunks do not have CFGs and we may need to
4467 handle them specially later. */
4468 if (!gimple_has_body_p (decl
)
4469 && !DECL_THUNK_P (decl
)
4470 && !DECL_EXTERNAL (decl
))
4472 struct cgraph_node
*node
= cgraph_node::get (decl
);
4474 /* Don't fix same_body aliases. Although they don't have their own
4475 CFG, they share it with what they alias to. */
4476 if (!node
|| !node
->alias
4477 || !vec_safe_length (node
->ref_list
.references
))
4484 /* Clean the C++ specific parts of the tree T. */
4487 cp_free_lang_data (tree t
)
4489 if (TREE_CODE (t
) == METHOD_TYPE
4490 || TREE_CODE (t
) == FUNCTION_TYPE
)
4492 /* Default args are not interesting anymore. */
4493 tree argtypes
= TYPE_ARG_TYPES (t
);
4496 TREE_PURPOSE (argtypes
) = 0;
4497 argtypes
= TREE_CHAIN (argtypes
);
4500 else if (TREE_CODE (t
) == FUNCTION_DECL
4501 && cp_fix_function_decl_p (t
))
4503 /* If T is used in this translation unit at all, the definition
4504 must exist somewhere else since we have decided to not emit it
4505 in this TU. So make it an external reference. */
4506 DECL_EXTERNAL (t
) = 1;
4507 TREE_STATIC (t
) = 0;
4509 if (TREE_CODE (t
) == NAMESPACE_DECL
)
4511 /* The list of users of a namespace isn't useful for the middle-end
4512 or debug generators. */
4513 DECL_NAMESPACE_USERS (t
) = NULL_TREE
;
4514 /* Neither do we need the leftover chaining of namespaces
4515 from the binding level. */
4516 DECL_CHAIN (t
) = NULL_TREE
;
4520 /* Stub for c-common. Please keep in sync with c-decl.c.
4521 FIXME: If address space support is target specific, then this
4522 should be a C target hook. But currently this is not possible,
4523 because this function is called via REGISTER_TARGET_PRAGMAS. */
4525 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
4529 /* Return the number of operands in T that we care about for things like
4533 cp_tree_operand_length (const_tree t
)
4535 enum tree_code code
= TREE_CODE (t
);
4537 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
4538 return VL_EXP_OPERAND_LENGTH (t
);
4540 return cp_tree_code_length (code
);
4543 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
4546 cp_tree_code_length (enum tree_code code
)
4548 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
4552 case PREINCREMENT_EXPR
:
4553 case PREDECREMENT_EXPR
:
4554 case POSTINCREMENT_EXPR
:
4555 case POSTDECREMENT_EXPR
:
4561 case EXPR_PACK_EXPANSION
:
4565 return TREE_CODE_LENGTH (code
);
4569 /* Implement -Wzero_as_null_pointer_constant. Return true if the
4570 conditions for the warning hold, false otherwise. */
4572 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
4574 if (c_inhibit_evaluation_warnings
== 0
4575 && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
4577 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
4578 "zero as null pointer constant");
4584 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4585 /* Complain that some language-specific thing hanging off a tree
4586 node has been accessed improperly. */
4589 lang_check_failed (const char* file
, int line
, const char* function
)
4591 internal_error ("lang_* check: failed in %s, at %s:%d",
4592 function
, trim_filename (file
), line
);
4594 #endif /* ENABLE_TREE_CHECKING */
4596 #include "gt-cp-tree.h"