1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2017 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"
35 #include "stringpool.h"
39 static tree
bot_manip (tree
*, int *, void *);
40 static tree
bot_replace (tree
*, int *, void *);
41 static hashval_t
list_hash_pieces (tree
, tree
, tree
);
42 static tree
build_target_expr (tree
, tree
, tsubst_flags_t
);
43 static tree
count_trees_r (tree
*, int *, void *);
44 static tree
verify_stmt_tree_r (tree
*, int *, void *);
45 static tree
build_local_temp (tree
);
47 static tree
handle_init_priority_attribute (tree
*, tree
, tree
, int, bool *);
48 static tree
handle_abi_tag_attribute (tree
*, tree
, tree
, int, bool *);
50 /* If REF is an lvalue, returns the kind of lvalue that REF is.
51 Otherwise, returns clk_none. */
54 lvalue_kind (const_tree ref
)
56 cp_lvalue_kind op1_lvalue_kind
= clk_none
;
57 cp_lvalue_kind op2_lvalue_kind
= clk_none
;
59 /* Expressions of reference type are sometimes wrapped in
60 INDIRECT_REFs. INDIRECT_REFs are just internal compiler
61 representation, not part of the language, so we have to look
63 if (REFERENCE_REF_P (ref
))
64 return lvalue_kind (TREE_OPERAND (ref
, 0));
67 && TREE_CODE (TREE_TYPE (ref
)) == REFERENCE_TYPE
)
69 /* unnamed rvalue references are rvalues */
70 if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref
))
71 && TREE_CODE (ref
) != PARM_DECL
73 && TREE_CODE (ref
) != COMPONENT_REF
74 /* Functions are always lvalues. */
75 && TREE_CODE (TREE_TYPE (TREE_TYPE (ref
))) != FUNCTION_TYPE
)
78 /* lvalue references and named rvalue references are lvalues. */
82 if (ref
== current_class_ptr
)
85 switch (TREE_CODE (ref
))
89 /* preincrements and predecrements are valid lvals, provided
90 what they refer to are valid lvals. */
91 case PREINCREMENT_EXPR
:
92 case PREDECREMENT_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 if (BASELINK_P (TREE_OPERAND (ref
, 1)))
111 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (ref
, 1));
113 /* For static member function recurse on the BASELINK, we can get
114 here e.g. from reference_binding. If BASELINK_FUNCTIONS is
115 OVERLOAD, the overload is resolved first if possible through
116 resolve_address_of_overloaded_function. */
117 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_STATIC_FUNCTION_P (fn
))
118 return lvalue_kind (TREE_OPERAND (ref
, 1));
120 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
121 /* Look at the member designator. */
122 if (!op1_lvalue_kind
)
124 else if (is_overloaded_fn (TREE_OPERAND (ref
, 1)))
125 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
126 situations. If we're seeing a COMPONENT_REF, it's a non-static
127 member, so it isn't an lvalue. */
128 op1_lvalue_kind
= clk_none
;
129 else if (TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
130 /* This can be IDENTIFIER_NODE in a template. */;
131 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
133 /* Clear the ordinary bit. If this object was a class
134 rvalue we want to preserve that information. */
135 op1_lvalue_kind
&= ~clk_ordinary
;
136 /* The lvalue is for a bitfield. */
137 op1_lvalue_kind
|= clk_bitfield
;
139 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
140 op1_lvalue_kind
|= clk_packed
;
142 return op1_lvalue_kind
;
145 case COMPOUND_LITERAL_EXPR
:
149 /* CONST_DECL without TREE_STATIC are enumeration values and
150 thus not lvalues. With TREE_STATIC they are used by ObjC++
151 in objc_build_string_object and need to be considered as
153 if (! TREE_STATIC (ref
))
157 if (VAR_P (ref
) && DECL_HAS_VALUE_EXPR_P (ref
))
158 return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref
)));
160 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
161 && DECL_LANG_SPECIFIC (ref
)
162 && DECL_IN_AGGR_P (ref
))
168 case ARRAY_NOTATION_REF
:
171 case PLACEHOLDER_EXPR
:
174 /* A scope ref in a template, left as SCOPE_REF to support later
177 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
179 tree op
= TREE_OPERAND (ref
, 1);
180 if (TREE_CODE (op
) == FIELD_DECL
)
181 return (DECL_C_BIT_FIELD (op
) ? clk_bitfield
: clk_ordinary
);
183 return lvalue_kind (op
);
188 /* Disallow <? and >? as lvalues if either argument side-effects. */
189 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
190 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
192 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
193 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1));
197 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1)
198 ? TREE_OPERAND (ref
, 1)
199 : TREE_OPERAND (ref
, 0));
200 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 2));
204 /* We expect to see unlowered MODOP_EXPRs only during
205 template processing. */
206 gcc_assert (processing_template_decl
);
214 return lvalue_kind (TREE_OPERAND (ref
, 1));
220 return (CLASS_TYPE_P (TREE_TYPE (ref
)) ? clk_class
: clk_none
);
223 /* We can see calls outside of TARGET_EXPR in templates. */
224 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
229 /* All functions (except non-static-member functions) are
231 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
232 ? clk_none
: clk_ordinary
);
235 /* We now represent a reference to a single static member function
237 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
238 its argument unmodified and we assign it to a const_tree. */
239 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref
)));
241 case NON_DEPENDENT_EXPR
:
242 return lvalue_kind (TREE_OPERAND (ref
, 0));
245 if (!TREE_TYPE (ref
))
247 if (CLASS_TYPE_P (TREE_TYPE (ref
))
248 || TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
)
253 /* If one operand is not an lvalue at all, then this expression is
255 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
258 /* Otherwise, it's an lvalue, and it has all the odd properties
259 contributed by either operand. */
260 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
261 /* It's not an ordinary lvalue if it involves any other kind. */
262 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
263 op1_lvalue_kind
&= ~clk_ordinary
;
264 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
265 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
266 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
267 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
268 op1_lvalue_kind
= clk_none
;
269 return op1_lvalue_kind
;
272 /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
275 real_lvalue_p (const_tree ref
)
277 cp_lvalue_kind kind
= lvalue_kind (ref
);
278 if (kind
& (clk_rvalueref
|clk_class
))
284 /* c-common wants us to return bool. */
287 lvalue_p (const_tree t
)
289 return real_lvalue_p (t
);
292 /* This differs from lvalue_p in that xvalues are included. */
295 glvalue_p (const_tree ref
)
297 cp_lvalue_kind kind
= lvalue_kind (ref
);
298 if (kind
& clk_class
)
301 return (kind
!= clk_none
);
304 /* This differs from glvalue_p in that class prvalues are included. */
307 obvalue_p (const_tree ref
)
309 return (lvalue_kind (ref
) != clk_none
);
312 /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
313 reference), false otherwise. */
316 xvalue_p (const_tree ref
)
318 return (lvalue_kind (ref
) == clk_rvalueref
);
321 /* True if REF is a bit-field. */
324 bitfield_p (const_tree ref
)
326 return (lvalue_kind (ref
) & clk_bitfield
);
329 /* C++-specific version of stabilize_reference. */
332 cp_stabilize_reference (tree ref
)
334 switch (TREE_CODE (ref
))
336 /* We need to treat specially anything stabilize_reference doesn't
337 handle specifically. */
348 case ARRAY_RANGE_REF
:
352 cp_lvalue_kind kind
= lvalue_kind (ref
);
353 if ((kind
& ~clk_class
) != clk_none
)
355 tree type
= unlowered_expr_type (ref
);
356 bool rval
= !!(kind
& clk_rvalueref
);
357 type
= cp_build_reference_type (type
, rval
);
358 /* This inhibits warnings in, eg, cxx_mark_addressable
360 warning_sentinel
s (extra_warnings
);
361 ref
= build_static_cast (type
, ref
, tf_error
);
365 return stabilize_reference (ref
);
368 /* Test whether DECL is a builtin that may appear in a
369 constant-expression. */
372 builtin_valid_in_constant_expr_p (const_tree decl
)
374 if (!(TREE_CODE (decl
) == FUNCTION_DECL
375 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
))
376 /* Not a built-in. */
378 switch (DECL_FUNCTION_CODE (decl
))
380 /* These always have constant results like the corresponding
383 case BUILT_IN_FUNCTION
:
386 /* The following built-ins are valid in constant expressions
387 when their arguments are. */
388 case BUILT_IN_ADD_OVERFLOW_P
:
389 case BUILT_IN_SUB_OVERFLOW_P
:
390 case BUILT_IN_MUL_OVERFLOW_P
:
392 /* These have constant results even if their operands are
394 case BUILT_IN_CONSTANT_P
:
395 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
402 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
405 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
408 tree type
= TREE_TYPE (decl
);
410 value
= mark_rvalue_use (value
);
412 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
413 || TREE_TYPE (decl
) == TREE_TYPE (value
)
414 /* On ARM ctors return 'this'. */
415 || (TYPE_PTR_P (TREE_TYPE (value
))
416 && TREE_CODE (value
) == CALL_EXPR
)
417 || useless_type_conversion_p (TREE_TYPE (decl
),
420 if (complain
& tf_no_cleanup
)
421 /* The caller is building a new-expr and does not need a cleanup. */
425 t
= cxx_maybe_build_cleanup (decl
, complain
);
426 if (t
== error_mark_node
)
427 return error_mark_node
;
429 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
430 if (EXPR_HAS_LOCATION (value
))
431 SET_EXPR_LOCATION (t
, EXPR_LOCATION (value
));
432 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
433 ignore the TARGET_EXPR. If there really turn out to be no
434 side-effects, then the optimizer should be able to get rid of
435 whatever code is generated anyhow. */
436 TREE_SIDE_EFFECTS (t
) = 1;
441 /* Return an undeclared local temporary of type TYPE for use in building a
445 build_local_temp (tree type
)
447 tree slot
= build_decl (input_location
,
448 VAR_DECL
, NULL_TREE
, type
);
449 DECL_ARTIFICIAL (slot
) = 1;
450 DECL_IGNORED_P (slot
) = 1;
451 DECL_CONTEXT (slot
) = current_function_decl
;
452 layout_decl (slot
, 0);
456 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
459 process_aggr_init_operands (tree t
)
463 side_effects
= TREE_SIDE_EFFECTS (t
);
467 n
= TREE_OPERAND_LENGTH (t
);
468 for (i
= 1; i
< n
; i
++)
470 tree op
= TREE_OPERAND (t
, i
);
471 if (op
&& TREE_SIDE_EFFECTS (op
))
478 TREE_SIDE_EFFECTS (t
) = side_effects
;
481 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
482 FN, and SLOT. NARGS is the number of call arguments which are specified
483 as a tree array ARGS. */
486 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
492 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
493 TREE_TYPE (t
) = return_type
;
494 AGGR_INIT_EXPR_FN (t
) = fn
;
495 AGGR_INIT_EXPR_SLOT (t
) = slot
;
496 for (i
= 0; i
< nargs
; i
++)
497 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
498 process_aggr_init_operands (t
);
502 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
503 target. TYPE is the type to be initialized.
505 Build an AGGR_INIT_EXPR to represent the initialization. This function
506 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
507 to initialize another object, whereas a TARGET_EXPR can either
508 initialize another object or create its own temporary object, and as a
509 result building up a TARGET_EXPR requires that the type's destructor be
513 build_aggr_init_expr (tree type
, tree init
)
520 /* Don't build AGGR_INIT_EXPR in a template. */
521 if (processing_template_decl
)
524 fn
= cp_get_callee (init
);
526 return convert (type
, init
);
528 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
529 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
530 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
532 /* We split the CALL_EXPR into its function and its arguments here.
533 Then, in expand_expr, we put them back together. The reason for
534 this is that this expression might be a default argument
535 expression. In that case, we need a new temporary every time the
536 expression is used. That's what break_out_target_exprs does; it
537 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
538 temporary slot. Then, expand_expr builds up a call-expression
539 using the new slot. */
541 /* If we don't need to use a constructor to create an object of this
542 type, don't mess with AGGR_INIT_EXPR. */
543 if (is_ctor
|| TREE_ADDRESSABLE (type
))
545 slot
= build_local_temp (type
);
547 if (TREE_CODE (init
) == CALL_EXPR
)
549 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
550 call_expr_nargs (init
),
551 CALL_EXPR_ARGP (init
));
552 AGGR_INIT_FROM_THUNK_P (rval
)
553 = CALL_FROM_THUNK_P (init
);
557 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
558 aggr_init_expr_nargs (init
),
559 AGGR_INIT_EXPR_ARGP (init
));
560 AGGR_INIT_FROM_THUNK_P (rval
)
561 = AGGR_INIT_FROM_THUNK_P (init
);
563 TREE_SIDE_EFFECTS (rval
) = 1;
564 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
565 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
566 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
567 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
568 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
576 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
577 target. TYPE is the type that this initialization should appear to
580 Build an encapsulation of the initialization to perform
581 and return it so that it can be processed by language-independent
582 and language-specific expression expanders. */
585 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
587 tree rval
= build_aggr_init_expr (type
, init
);
590 if (!complete_type_or_maybe_complain (type
, init
, complain
))
591 return error_mark_node
;
593 /* Make sure that we're not trying to create an instance of an
595 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
596 return error_mark_node
;
598 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
599 slot
= AGGR_INIT_EXPR_SLOT (rval
);
600 else if (TREE_CODE (rval
) == CALL_EXPR
601 || TREE_CODE (rval
) == CONSTRUCTOR
)
602 slot
= build_local_temp (type
);
606 rval
= build_target_expr (slot
, rval
, complain
);
608 if (rval
!= error_mark_node
)
609 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
614 /* Subroutine of build_vec_init_expr: Build up a single element
615 intialization as a proxy for the full array initialization to get things
616 marked as used and any appropriate diagnostics.
618 Since we're deferring building the actual constructor calls until
619 gimplification time, we need to build one now and throw it away so
620 that the relevant constructor gets mark_used before cgraph decides
621 what functions are needed. Here we assume that init is either
622 NULL_TREE, void_type_node (indicating value-initialization), or
623 another array to copy. */
626 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
628 tree inner_type
= strip_array_types (type
);
629 vec
<tree
, va_gc
> *argvec
;
631 if (integer_zerop (array_type_nelts_total (type
))
632 || !CLASS_TYPE_P (inner_type
))
633 /* No interesting initialization to do. */
634 return integer_zero_node
;
635 else if (init
== void_type_node
)
636 return build_value_init (inner_type
, complain
);
638 gcc_assert (init
== NULL_TREE
639 || (same_type_ignoring_top_level_qualifiers_p
640 (type
, TREE_TYPE (init
))));
642 argvec
= make_tree_vector ();
645 tree init_type
= strip_array_types (TREE_TYPE (init
));
646 tree dummy
= build_dummy_object (init_type
);
647 if (!lvalue_p (init
))
648 dummy
= move (dummy
);
649 argvec
->quick_push (dummy
);
651 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
652 &argvec
, inner_type
, LOOKUP_NORMAL
,
654 release_tree_vector (argvec
);
656 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
657 we don't want one here because we aren't creating a temporary. */
658 if (TREE_CODE (init
) == TARGET_EXPR
)
659 init
= TARGET_EXPR_INITIAL (init
);
664 /* Return a TARGET_EXPR which expresses the initialization of an array to
665 be named later, either default-initialization or copy-initialization
666 from another array of the same type. */
669 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
672 bool value_init
= false;
673 tree elt_init
= build_vec_init_elt (type
, init
, complain
);
675 if (init
== void_type_node
)
681 slot
= build_local_temp (type
);
682 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
683 TREE_SIDE_EFFECTS (init
) = true;
684 SET_EXPR_LOCATION (init
, input_location
);
686 if (cxx_dialect
>= cxx11
687 && potential_constant_expression (elt_init
))
688 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
689 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
694 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
695 that requires a constant expression. */
698 diagnose_non_constexpr_vec_init (tree expr
)
700 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
702 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
703 init
= void_type_node
;
705 init
= VEC_INIT_EXPR_INIT (expr
);
707 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
708 require_potential_constant_expression (elt_init
);
712 build_array_copy (tree init
)
714 return build_vec_init_expr (TREE_TYPE (init
), init
, tf_warning_or_error
);
717 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
721 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
723 gcc_assert (!VOID_TYPE_P (type
));
725 if (TREE_CODE (init
) == TARGET_EXPR
726 || init
== error_mark_node
)
728 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
729 && !VOID_TYPE_P (TREE_TYPE (init
))
730 && TREE_CODE (init
) != COND_EXPR
731 && TREE_CODE (init
) != CONSTRUCTOR
732 && TREE_CODE (init
) != VA_ARG_EXPR
)
733 /* We need to build up a copy constructor call. A void initializer
734 means we're being called from bot_manip. COND_EXPR is a special
735 case because we already have copies on the arms and we don't want
736 another one here. A CONSTRUCTOR is aggregate initialization, which
737 is handled separately. A VA_ARG_EXPR is magic creation of an
738 aggregate; there's no additional work to be done. */
739 return force_rvalue (init
, complain
);
741 return force_target_expr (type
, init
, complain
);
744 /* Like the above function, but without the checking. This function should
745 only be used by code which is deliberately trying to subvert the type
746 system, such as call_builtin_trap. Or build_over_call, to avoid
747 infinite recursion. */
750 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
754 gcc_assert (!VOID_TYPE_P (type
));
756 slot
= build_local_temp (type
);
757 return build_target_expr (slot
, init
, complain
);
760 /* Like build_target_expr_with_type, but use the type of INIT. */
763 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
765 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
766 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
767 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
768 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
771 init
= convert_bitfield_to_declared_type (init
);
772 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
777 get_target_expr (tree init
)
779 return get_target_expr_sfinae (init
, tf_warning_or_error
);
782 /* If EXPR is a bitfield reference, convert it to the declared type of
783 the bitfield, and return the resulting expression. Otherwise,
784 return EXPR itself. */
787 convert_bitfield_to_declared_type (tree expr
)
791 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
793 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
798 /* EXPR is being used in an rvalue context. Return a version of EXPR
799 that is marked as an rvalue. */
806 if (error_operand_p (expr
))
809 expr
= mark_rvalue_use (expr
);
813 Non-class rvalues always have cv-unqualified types. */
814 type
= TREE_TYPE (expr
);
815 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
816 type
= cv_unqualified (type
);
818 /* We need to do this for rvalue refs as well to get the right answer
819 from decltype; see c++/36628. */
820 if (!processing_template_decl
&& glvalue_p (expr
))
821 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
822 else if (type
!= TREE_TYPE (expr
))
823 expr
= build_nop (type
, expr
);
829 struct cplus_array_info
835 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
837 typedef cplus_array_info
*compare_type
;
839 static hashval_t
hash (tree t
);
840 static bool equal (tree
, cplus_array_info
*);
843 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
846 cplus_array_hasher::hash (tree t
)
850 hash
= TYPE_UID (TREE_TYPE (t
));
852 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
856 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
857 of type `cplus_array_info*'. */
860 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
862 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
865 /* Hash table containing dependent array types, which are unsuitable for
866 the language-independent type hash table. */
867 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
869 /* Build an ARRAY_TYPE without laying it out. */
872 build_min_array_type (tree elt_type
, tree index_type
)
874 tree t
= cxx_make_type (ARRAY_TYPE
);
875 TREE_TYPE (t
) = elt_type
;
876 TYPE_DOMAIN (t
) = index_type
;
880 /* Set TYPE_CANONICAL like build_array_type_1, but using
881 build_cplus_array_type. */
884 set_array_type_canon (tree t
, tree elt_type
, tree index_type
)
886 /* Set the canonical type for this new node. */
887 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
888 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
889 SET_TYPE_STRUCTURAL_EQUALITY (t
);
890 else if (TYPE_CANONICAL (elt_type
) != elt_type
891 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
893 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
895 ? TYPE_CANONICAL (index_type
) : index_type
);
897 TYPE_CANONICAL (t
) = t
;
900 /* Like build_array_type, but handle special C++ semantics: an array of a
901 variant element type is a variant of the array of the main variant of
905 build_cplus_array_type (tree elt_type
, tree index_type
)
909 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
910 return error_mark_node
;
912 bool dependent
= (uses_template_parms (elt_type
)
913 || (index_type
&& uses_template_parms (index_type
)));
915 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
916 /* Start with an array of the TYPE_MAIN_VARIANT. */
917 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
921 /* Since type_hash_canon calls layout_type, we need to use our own
923 cplus_array_info cai
;
926 if (cplus_array_htab
== NULL
)
927 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
929 hash
= TYPE_UID (elt_type
);
931 hash
^= TYPE_UID (index_type
);
933 cai
.domain
= index_type
;
935 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
937 /* We have found the type: we're done. */
941 /* Build a new array type. */
942 t
= build_min_array_type (elt_type
, index_type
);
944 /* Store it in the hash table. */
947 /* Set the canonical type for this new node. */
948 set_array_type_canon (t
, elt_type
, index_type
);
953 bool typeless_storage
954 = (elt_type
== unsigned_char_type_node
955 || elt_type
== signed_char_type_node
956 || elt_type
== char_type_node
957 || (TREE_CODE (elt_type
) == ENUMERAL_TYPE
958 && TYPE_CONTEXT (elt_type
) == std_node
959 && !strcmp ("byte", TYPE_NAME_STRING (elt_type
))));
960 t
= build_array_type (elt_type
, index_type
, typeless_storage
);
963 /* Now check whether we already have this array variant. */
964 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
967 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
968 if (TREE_TYPE (t
) == elt_type
969 && TYPE_NAME (t
) == NULL_TREE
970 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
974 t
= build_min_array_type (elt_type
, index_type
);
975 set_array_type_canon (t
, elt_type
, index_type
);
979 /* Make sure sizes are shared with the main variant.
980 layout_type can't be called after setting TYPE_NEXT_VARIANT,
981 as it will overwrite alignment etc. of all variants. */
982 TYPE_SIZE (t
) = TYPE_SIZE (m
);
983 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
984 TYPE_TYPELESS_STORAGE (t
) = TYPE_TYPELESS_STORAGE (m
);
987 TYPE_MAIN_VARIANT (t
) = m
;
988 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
989 TYPE_NEXT_VARIANT (m
) = t
;
993 /* Avoid spurious warnings with VLAs (c++/54583). */
994 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
995 TREE_NO_WARNING (TYPE_SIZE (t
)) = 1;
997 /* Push these needs up to the ARRAY_TYPE so that initialization takes
998 place more easily. */
999 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
1000 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
1001 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1002 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
1004 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
1005 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
1007 /* The element type has been completed since the last time we saw
1008 this array type; update the layout and 'tor flags for any variants
1011 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1013 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
1014 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
1021 /* Return an ARRAY_TYPE with element type ELT and length N. */
1024 build_array_of_n_type (tree elt
, int n
)
1026 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
1029 /* True iff T is an N3639 array of runtime bound (VLA). These were
1030 approved for C++14 but then removed. */
1033 array_of_runtime_bound_p (tree t
)
1035 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
1037 tree dom
= TYPE_DOMAIN (t
);
1040 tree max
= TYPE_MAX_VALUE (dom
);
1041 return (!potential_rvalue_constant_expression (max
)
1042 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
1045 /* Return a reference type node referring to TO_TYPE. If RVAL is
1046 true, return an rvalue reference type, otherwise return an lvalue
1047 reference type. If a type node exists, reuse it, otherwise create
1050 cp_build_reference_type (tree to_type
, bool rval
)
1054 if (TREE_CODE (to_type
) == REFERENCE_TYPE
)
1056 rval
= rval
&& TYPE_REF_IS_RVALUE (to_type
);
1057 to_type
= TREE_TYPE (to_type
);
1060 lvalue_ref
= build_reference_type (to_type
);
1064 /* This code to create rvalue reference types is based on and tied
1065 to the code creating lvalue reference types in the middle-end
1066 functions build_reference_type_for_mode and build_reference_type.
1068 It works by putting the rvalue reference type nodes after the
1069 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1070 they will effectively be ignored by the middle end. */
1072 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1073 if (TYPE_REF_IS_RVALUE (t
))
1076 t
= build_distinct_type_copy (lvalue_ref
);
1078 TYPE_REF_IS_RVALUE (t
) = true;
1079 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1080 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1082 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1083 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1084 else if (TYPE_CANONICAL (to_type
) != to_type
)
1086 = cp_build_reference_type (TYPE_CANONICAL (to_type
), rval
);
1088 TYPE_CANONICAL (t
) = t
;
1096 /* Returns EXPR cast to rvalue reference type, like std::move. */
1101 tree type
= TREE_TYPE (expr
);
1102 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
1103 type
= cp_build_reference_type (type
, /*rval*/true);
1104 return build_static_cast (type
, expr
, tf_warning_or_error
);
1107 /* Used by the C++ front end to build qualified array types. However,
1108 the C version of this function does not properly maintain canonical
1109 types (which are not used in C). */
1111 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1112 size_t /* orig_qual_indirect */)
1114 return cp_build_qualified_type (type
, type_quals
);
1118 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1119 arrays correctly. In particular, if TYPE is an array of T's, and
1120 TYPE_QUALS is non-empty, returns an array of qualified T's.
1122 FLAGS determines how to deal with ill-formed qualifications. If
1123 tf_ignore_bad_quals is set, then bad qualifications are dropped
1124 (this is permitted if TYPE was introduced via a typedef or template
1125 type parameter). If bad qualifications are dropped and tf_warning
1126 is set, then a warning is issued for non-const qualifications. If
1127 tf_ignore_bad_quals is not set and tf_error is not set, we
1128 return error_mark_node. Otherwise, we issue an error, and ignore
1131 Qualification of a reference type is valid when the reference came
1132 via a typedef or template type argument. [dcl.ref] No such
1133 dispensation is provided for qualifying a function type. [dcl.fct]
1134 DR 295 queries this and the proposed resolution brings it into line
1135 with qualifying a reference. We implement the DR. We also behave
1136 in a similar manner for restricting non-pointer types. */
1139 cp_build_qualified_type_real (tree type
,
1141 tsubst_flags_t complain
)
1144 int bad_quals
= TYPE_UNQUALIFIED
;
1146 if (type
== error_mark_node
)
1149 if (type_quals
== cp_type_quals (type
))
1152 if (TREE_CODE (type
) == ARRAY_TYPE
)
1154 /* In C++, the qualification really applies to the array element
1155 type. Obtain the appropriately qualified element type. */
1158 = cp_build_qualified_type_real (TREE_TYPE (type
),
1162 if (element_type
== error_mark_node
)
1163 return error_mark_node
;
1165 /* See if we already have an identically qualified type. Tests
1166 should be equivalent to those in check_qualified_type. */
1167 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1168 if (TREE_TYPE (t
) == element_type
1169 && TYPE_NAME (t
) == TYPE_NAME (type
)
1170 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1171 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1172 TYPE_ATTRIBUTES (type
)))
1177 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
));
1179 /* Keep the typedef name. */
1180 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1182 t
= build_variant_type_copy (t
);
1183 TYPE_NAME (t
) = TYPE_NAME (type
);
1184 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1185 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1189 /* Even if we already had this variant, we update
1190 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1191 they changed since the variant was originally created.
1193 This seems hokey; if there is some way to use a previous
1194 variant *without* coming through here,
1195 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1196 TYPE_NEEDS_CONSTRUCTING (t
)
1197 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1198 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1199 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1202 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1204 tree t
= PACK_EXPANSION_PATTERN (type
);
1206 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1207 return make_pack_expansion (t
);
1210 /* A reference or method type shall not be cv-qualified.
1211 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1212 (in CD1) we always ignore extra cv-quals on functions. */
1213 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1214 && (TREE_CODE (type
) == REFERENCE_TYPE
1215 || TREE_CODE (type
) == FUNCTION_TYPE
1216 || TREE_CODE (type
) == METHOD_TYPE
))
1218 if (TREE_CODE (type
) == REFERENCE_TYPE
)
1219 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1220 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1223 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1224 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1225 type_quals
|= type_memfn_quals (type
);
1227 /* A restrict-qualified type must be a pointer (or reference)
1228 to object or incomplete type. */
1229 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1230 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1231 && TREE_CODE (type
) != TYPENAME_TYPE
1232 && !POINTER_TYPE_P (type
))
1234 bad_quals
|= TYPE_QUAL_RESTRICT
;
1235 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1238 if (bad_quals
== TYPE_UNQUALIFIED
1239 || (complain
& tf_ignore_bad_quals
))
1241 else if (!(complain
& tf_error
))
1242 return error_mark_node
;
1245 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1246 error ("%qV qualifiers cannot be applied to %qT",
1250 /* Retrieve (or create) the appropriately qualified variant. */
1251 result
= build_qualified_type (type
, type_quals
);
1253 /* Preserve exception specs and ref-qualifier since build_qualified_type
1254 doesn't know about them. */
1255 if (TREE_CODE (result
) == FUNCTION_TYPE
1256 || TREE_CODE (result
) == METHOD_TYPE
)
1258 result
= build_exception_variant (result
, TYPE_RAISES_EXCEPTIONS (type
));
1259 result
= build_ref_qualified_type (result
, type_memfn_rqual (type
));
1265 /* Return TYPE with const and volatile removed. */
1268 cv_unqualified (tree type
)
1272 if (type
== error_mark_node
)
1275 quals
= cp_type_quals (type
);
1276 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1277 return cp_build_qualified_type (type
, quals
);
1280 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1281 from ATTRIBS that affect type identity, and no others. If any are not
1282 applied, set *remove_attributes to true. */
1285 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1287 tree first_ident
= NULL_TREE
;
1288 tree new_attribs
= NULL_TREE
;
1289 tree
*p
= &new_attribs
;
1291 if (OVERLOAD_TYPE_P (result
))
1293 /* On classes and enums all attributes are ingrained. */
1294 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1298 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1300 const attribute_spec
*as
1301 = lookup_attribute_spec (get_attribute_name (a
));
1302 if (as
&& as
->affects_type_identity
)
1306 else if (first_ident
== error_mark_node
)
1308 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1309 p
= &TREE_CHAIN (*p
);
1312 else if (first_ident
)
1314 for (tree a2
= first_ident
; a2
; a2
= TREE_CHAIN (a2
))
1316 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1317 p
= &TREE_CHAIN (*p
);
1319 first_ident
= error_mark_node
;
1322 if (first_ident
!= error_mark_node
)
1323 new_attribs
= first_ident
;
1325 if (first_ident
== attribs
)
1326 /* All attributes affected type identity. */;
1328 *remove_attributes
= true;
1330 return cp_build_type_attribute_variant (result
, new_attribs
);
1333 /* Builds a qualified variant of T that is not a typedef variant.
1334 E.g. consider the following declarations:
1335 typedef const int ConstInt;
1336 typedef ConstInt* PtrConstInt;
1337 If T is PtrConstInt, this function returns a type representing
1339 In other words, if T is a typedef, the function returns the underlying type.
1340 The cv-qualification and attributes of the type returned match the
1342 They will always be compatible types.
1343 The returned type is built so that all of its subtypes
1344 recursively have their typedefs stripped as well.
1346 This is different from just returning TYPE_CANONICAL (T)
1347 Because of several reasons:
1348 * If T is a type that needs structural equality
1349 its TYPE_CANONICAL (T) will be NULL.
1350 * TYPE_CANONICAL (T) desn't carry type attributes
1351 and loses template parameter names.
1353 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1354 affect type identity, and set the referent to true if any were
1358 strip_typedefs (tree t
, bool *remove_attributes
)
1360 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1362 if (!t
|| t
== error_mark_node
)
1365 if (TREE_CODE (t
) == TREE_LIST
)
1367 bool changed
= false;
1368 vec
<tree
,va_gc
> *vec
= make_tree_vector ();
1370 for (; t
; t
= TREE_CHAIN (t
))
1372 gcc_assert (!TREE_PURPOSE (t
));
1373 tree elt
= strip_typedefs (TREE_VALUE (t
), remove_attributes
);
1374 if (elt
!= TREE_VALUE (t
))
1376 vec_safe_push (vec
, elt
);
1379 r
= build_tree_list_vec (vec
);
1380 release_tree_vector (vec
);
1384 gcc_assert (TYPE_P (t
));
1386 if (t
== TYPE_CANONICAL (t
))
1389 if (dependent_alias_template_spec_p (t
))
1390 /* DR 1558: However, if the template-id is dependent, subsequent
1391 template argument substitution still applies to the template-id. */
1394 switch (TREE_CODE (t
))
1397 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1398 result
= build_pointer_type (type
);
1400 case REFERENCE_TYPE
:
1401 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1402 result
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
1405 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
);
1406 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1407 result
= build_offset_type (t0
, type
);
1410 if (TYPE_PTRMEMFUNC_P (t
))
1412 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
), remove_attributes
);
1413 result
= build_ptrmemfunc_type (t0
);
1417 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1418 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
);
1419 result
= build_cplus_array_type (type
, t0
);
1424 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1427 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1428 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1429 can't expect that re-hashing a function type will find a previous
1430 equivalent type, so try to reuse the input type if nothing has
1431 changed. If the type is itself a variant, that will change. */
1432 bool is_variant
= typedef_variant_p (t
);
1433 if (remove_attributes
1434 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1437 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1438 changed
= type
!= TREE_TYPE (t
) || is_variant
;
1440 for (arg_node
= TYPE_ARG_TYPES (t
);
1442 arg_node
= TREE_CHAIN (arg_node
))
1444 if (arg_node
== void_list_node
)
1446 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1448 gcc_assert (arg_type
);
1449 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1455 for (arg_node2
= TYPE_ARG_TYPES (t
);
1456 arg_node2
!= arg_node
;
1457 arg_node2
= TREE_CHAIN (arg_node2
))
1459 = tree_cons (TREE_PURPOSE (arg_node2
),
1460 TREE_VALUE (arg_node2
), arg_types
);
1464 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1471 arg_types
= nreverse (arg_types
);
1473 /* A list of parameters not ending with an ellipsis
1474 must end with void_list_node. */
1476 arg_types
= chainon (arg_types
, void_list_node
);
1478 if (TREE_CODE (t
) == METHOD_TYPE
)
1480 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1481 gcc_assert (class_type
);
1483 build_method_type_directly (class_type
, type
,
1484 TREE_CHAIN (arg_types
));
1486 = build_ref_qualified_type (result
, type_memfn_rqual (t
));
1490 result
= build_function_type (type
,
1492 result
= apply_memfn_quals (result
,
1493 type_memfn_quals (t
),
1494 type_memfn_rqual (t
));
1497 if (TYPE_RAISES_EXCEPTIONS (t
))
1498 result
= build_exception_variant (result
,
1499 TYPE_RAISES_EXCEPTIONS (t
));
1500 if (TYPE_HAS_LATE_RETURN_TYPE (t
))
1501 TYPE_HAS_LATE_RETURN_TYPE (result
) = 1;
1506 bool changed
= false;
1507 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1508 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1509 && TREE_OPERAND (fullname
, 1))
1511 tree args
= TREE_OPERAND (fullname
, 1);
1512 tree new_args
= copy_node (args
);
1513 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1515 tree arg
= TREE_VEC_ELT (args
, i
);
1518 strip_arg
= strip_typedefs (arg
, remove_attributes
);
1520 strip_arg
= strip_typedefs_expr (arg
, remove_attributes
);
1521 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1522 if (strip_arg
!= arg
)
1527 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1528 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1530 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1534 ggc_free (new_args
);
1536 tree ctx
= strip_typedefs (TYPE_CONTEXT (t
), remove_attributes
);
1537 if (!changed
&& ctx
== TYPE_CONTEXT (t
) && !typedef_variant_p (t
))
1539 tree name
= fullname
;
1540 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
1541 name
= TREE_OPERAND (fullname
, 0);
1542 /* Use build_typename_type rather than make_typename_type because we
1543 don't want to resolve it here, just strip typedefs. */
1544 result
= build_typename_type (ctx
, name
, fullname
, typename_type
);
1548 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
),
1550 if (result
== DECLTYPE_TYPE_EXPR (t
))
1553 result
= (finish_decltype_type
1555 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1558 case UNDERLYING_TYPE
:
1559 type
= strip_typedefs (UNDERLYING_TYPE_TYPE (t
), remove_attributes
);
1560 result
= finish_underlying_type (type
);
1568 if (typedef_variant_p (t
))
1570 /* Explicitly get the underlying type, as TYPE_MAIN_VARIANT doesn't
1571 strip typedefs with attributes. */
1572 result
= TYPE_MAIN_VARIANT (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)));
1573 result
= strip_typedefs (result
);
1576 result
= TYPE_MAIN_VARIANT (t
);
1578 gcc_assert (!typedef_variant_p (result
));
1580 if (COMPLETE_TYPE_P (result
) && !COMPLETE_TYPE_P (t
))
1581 /* If RESULT is complete and T isn't, it's likely the case that T
1582 is a variant of RESULT which hasn't been updated yet. Skip the
1583 attribute handling. */;
1586 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1587 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1589 gcc_assert (TYPE_USER_ALIGN (t
));
1590 if (remove_attributes
)
1591 *remove_attributes
= true;
1594 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1595 result
= build_variant_type_copy (result
);
1597 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1598 TYPE_USER_ALIGN (result
) = true;
1602 if (TYPE_ATTRIBUTES (t
))
1604 if (remove_attributes
)
1605 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1608 result
= cp_build_type_attribute_variant (result
,
1609 TYPE_ATTRIBUTES (t
));
1613 return cp_build_qualified_type (result
, cp_type_quals (t
));
1616 /* Like strip_typedefs above, but works on expressions, so that in
1618 template<class T> struct A
1624 sizeof(TT) is replaced by sizeof(T). */
1627 strip_typedefs_expr (tree t
, bool *remove_attributes
)
1631 enum tree_code code
;
1633 if (t
== NULL_TREE
|| t
== error_mark_node
)
1636 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1639 /* Some expressions have type operands, so let's handle types here rather
1640 than check TYPE_P in multiple places below. */
1642 return strip_typedefs (t
, remove_attributes
);
1644 code
= TREE_CODE (t
);
1647 case IDENTIFIER_NODE
:
1648 case TEMPLATE_PARM_INDEX
:
1651 case ARGUMENT_PACK_SELECT
:
1656 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
), remove_attributes
);
1657 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
), remove_attributes
);
1658 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1659 && type2
== TRAIT_EXPR_TYPE2 (t
))
1662 TRAIT_EXPR_TYPE1 (r
) = type1
;
1663 TRAIT_EXPR_TYPE2 (r
) = type2
;
1669 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
1670 bool changed
= false;
1672 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1674 tree val
= strip_typedefs_expr (TREE_VALUE (t
), remove_attributes
);
1675 vec_safe_push (vec
, val
);
1676 if (val
!= TREE_VALUE (t
))
1678 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1683 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1684 r
= tree_cons (NULL_TREE
, it
, r
);
1688 release_tree_vector (vec
);
1694 bool changed
= false;
1695 vec
<tree
, va_gc
> *vec
= make_tree_vector ();
1696 n
= TREE_VEC_LENGTH (t
);
1697 vec_safe_reserve (vec
, n
);
1698 for (i
= 0; i
< n
; ++i
)
1700 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
),
1702 vec
->quick_push (op
);
1703 if (op
!= TREE_VEC_ELT (t
, i
))
1709 for (i
= 0; i
< n
; ++i
)
1710 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1711 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1712 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1716 release_tree_vector (vec
);
1722 bool changed
= false;
1723 vec
<constructor_elt
, va_gc
> *vec
1724 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1725 n
= CONSTRUCTOR_NELTS (t
);
1726 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
);
1727 for (i
= 0; i
< n
; ++i
)
1729 constructor_elt
*e
= &(*vec
)[i
];
1730 tree op
= strip_typedefs_expr (e
->value
, remove_attributes
);
1737 (e
->index
== strip_typedefs_expr (e
->index
, remove_attributes
));
1740 if (!changed
&& type
== TREE_TYPE (t
))
1748 TREE_TYPE (r
) = type
;
1749 CONSTRUCTOR_ELTS (r
) = vec
;
1755 error ("lambda-expression in a constant expression");
1756 return error_mark_node
;
1762 gcc_assert (EXPR_P (t
));
1764 n
= TREE_OPERAND_LENGTH (t
);
1765 ops
= XALLOCAVEC (tree
, n
);
1766 type
= TREE_TYPE (t
);
1771 case IMPLICIT_CONV_EXPR
:
1772 case DYNAMIC_CAST_EXPR
:
1773 case STATIC_CAST_EXPR
:
1774 case CONST_CAST_EXPR
:
1775 case REINTERPRET_CAST_EXPR
:
1778 type
= strip_typedefs (type
, remove_attributes
);
1782 for (i
= 0; i
< n
; ++i
)
1783 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
), remove_attributes
);
1787 /* If nothing changed, return t. */
1788 for (i
= 0; i
< n
; ++i
)
1789 if (ops
[i
] != TREE_OPERAND (t
, i
))
1791 if (i
== n
&& type
== TREE_TYPE (t
))
1795 TREE_TYPE (r
) = type
;
1796 for (i
= 0; i
< n
; ++i
)
1797 TREE_OPERAND (r
, i
) = ops
[i
];
1801 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1802 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1803 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1804 VIRT indicates whether TYPE is inherited virtually or not.
1805 IGO_PREV points at the previous binfo of the inheritance graph
1806 order chain. The newly copied binfo's TREE_CHAIN forms this
1809 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1810 correct order. That is in the order the bases themselves should be
1813 The BINFO_INHERITANCE of a virtual base class points to the binfo
1814 of the most derived type. ??? We could probably change this so that
1815 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1816 remove a field. They currently can only differ for primary virtual
1820 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
1826 /* See if we've already made this virtual base. */
1827 new_binfo
= binfo_for_vbase (type
, t
);
1832 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
1833 BINFO_TYPE (new_binfo
) = type
;
1835 /* Chain it into the inheritance graph. */
1836 TREE_CHAIN (*igo_prev
) = new_binfo
;
1837 *igo_prev
= new_binfo
;
1839 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
1844 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
1846 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
1847 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
1849 /* We do not need to copy the accesses, as they are read only. */
1850 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
1852 /* Recursively copy base binfos of BINFO. */
1853 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
1855 tree new_base_binfo
;
1856 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
1858 BINFO_VIRTUAL_P (base_binfo
));
1860 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
1861 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
1862 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
1866 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
1870 /* Push it onto the list after any virtual bases it contains
1871 will have been pushed. */
1872 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
1873 BINFO_VIRTUAL_P (new_binfo
) = 1;
1874 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
1880 /* Hashing of lists so that we don't make duplicates.
1881 The entry point is `list_hash_canon'. */
1890 struct list_hasher
: ggc_ptr_hash
<tree_node
>
1892 typedef list_proxy
*compare_type
;
1894 static hashval_t
hash (tree
);
1895 static bool equal (tree
, list_proxy
*);
1898 /* Now here is the hash table. When recording a list, it is added
1899 to the slot whose index is the hash code mod the table size.
1900 Note that the hash table is used for several kinds of lists.
1901 While all these live in the same table, they are completely independent,
1902 and the hash code is computed differently for each of these. */
1904 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
1906 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
1907 for a node we are thinking about adding). */
1910 list_hasher::equal (tree t
, list_proxy
*proxy
)
1912 return (TREE_VALUE (t
) == proxy
->value
1913 && TREE_PURPOSE (t
) == proxy
->purpose
1914 && TREE_CHAIN (t
) == proxy
->chain
);
1917 /* Compute a hash code for a list (chain of TREE_LIST nodes
1918 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
1919 TREE_COMMON slots), by adding the hash codes of the individual entries. */
1922 list_hash_pieces (tree purpose
, tree value
, tree chain
)
1924 hashval_t hashcode
= 0;
1927 hashcode
+= TREE_HASH (chain
);
1930 hashcode
+= TREE_HASH (value
);
1934 hashcode
+= TREE_HASH (purpose
);
1940 /* Hash an already existing TREE_LIST. */
1943 list_hasher::hash (tree t
)
1945 return list_hash_pieces (TREE_PURPOSE (t
),
1950 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
1951 object for an identical list if one already exists. Otherwise, build a
1952 new one, and record it as the canonical object. */
1955 hash_tree_cons (tree purpose
, tree value
, tree chain
)
1959 struct list_proxy proxy
;
1961 /* Hash the list node. */
1962 hashcode
= list_hash_pieces (purpose
, value
, chain
);
1963 /* Create a proxy for the TREE_LIST we would like to create. We
1964 don't actually create it so as to avoid creating garbage. */
1965 proxy
.purpose
= purpose
;
1966 proxy
.value
= value
;
1967 proxy
.chain
= chain
;
1968 /* See if it is already in the table. */
1969 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
1970 /* If not, create a new node. */
1972 *slot
= tree_cons (purpose
, value
, chain
);
1973 return (tree
) *slot
;
1976 /* Constructor for hashed lists. */
1979 hash_tree_chain (tree value
, tree chain
)
1981 return hash_tree_cons (NULL_TREE
, value
, chain
);
1985 debug_binfo (tree elem
)
1990 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
1992 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
1993 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
1994 debug_tree (BINFO_TYPE (elem
));
1995 if (BINFO_VTABLE (elem
))
1996 fprintf (stderr
, "vtable decl \"%s\"\n",
1997 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
1999 fprintf (stderr
, "no vtable decl yet\n");
2000 fprintf (stderr
, "virtuals:\n");
2001 virtuals
= BINFO_VIRTUALS (elem
);
2006 tree fndecl
= TREE_VALUE (virtuals
);
2007 fprintf (stderr
, "%s [%ld =? %ld]\n",
2008 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
2009 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
2011 virtuals
= TREE_CHAIN (virtuals
);
2015 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2016 the type of the result expression, if known, or NULL_TREE if the
2017 resulting expression is type-dependent. If TEMPLATE_P is true,
2018 NAME is known to be a template because the user explicitly used the
2019 "template" keyword after the "::".
2021 All SCOPE_REFs should be built by use of this function. */
2024 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
2027 if (type
== error_mark_node
2028 || scope
== error_mark_node
2029 || name
== error_mark_node
)
2030 return error_mark_node
;
2031 gcc_assert (TREE_CODE (name
) != SCOPE_REF
);
2032 t
= build2 (SCOPE_REF
, type
, scope
, name
);
2033 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
2034 PTRMEM_OK_P (t
) = true;
2036 t
= convert_from_reference (t
);
2040 /* Like check_qualified_type, but also check ref-qualifier and exception
2044 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
2045 cp_ref_qualifier rqual
, tree raises
)
2047 return (TYPE_QUALS (cand
) == type_quals
2048 && check_base_type (cand
, base
)
2049 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
2051 && type_memfn_rqual (cand
) == rqual
);
2054 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2057 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
2061 if (rqual
== type_memfn_rqual (type
))
2064 int type_quals
= TYPE_QUALS (type
);
2065 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2066 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
2067 if (cp_check_qualified_type (t
, type
, type_quals
, rqual
, raises
))
2070 t
= build_variant_type_copy (type
);
2073 case REF_QUAL_RVALUE
:
2074 FUNCTION_RVALUE_QUALIFIED (t
) = 1;
2075 FUNCTION_REF_QUALIFIED (t
) = 1;
2077 case REF_QUAL_LVALUE
:
2078 FUNCTION_RVALUE_QUALIFIED (t
) = 0;
2079 FUNCTION_REF_QUALIFIED (t
) = 1;
2082 FUNCTION_REF_QUALIFIED (t
) = 0;
2086 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2087 /* Propagate structural equality. */
2088 SET_TYPE_STRUCTURAL_EQUALITY (t
);
2089 else if (TYPE_CANONICAL (type
) != type
)
2090 /* Build the underlying canonical type, since it is different
2092 TYPE_CANONICAL (t
) = build_ref_qualified_type (TYPE_CANONICAL (type
),
2095 /* T is its own canonical type. */
2096 TYPE_CANONICAL (t
) = t
;
2101 /* Cache of free ovl nodes. Uses OVL_FUNCTION for chaining. */
2102 static GTY((deletable
)) tree ovl_cache
;
2104 /* Make a raw overload node containing FN. */
2107 ovl_make (tree fn
, tree next
)
2109 tree result
= ovl_cache
;
2113 ovl_cache
= OVL_FUNCTION (result
);
2114 /* Zap the flags. */
2115 memset (result
, 0, sizeof (tree_base
));
2116 TREE_SET_CODE (result
, OVERLOAD
);
2119 result
= make_node (OVERLOAD
);
2121 if (TREE_CODE (fn
) == OVERLOAD
)
2122 OVL_NESTED_P (result
) = true;
2124 TREE_TYPE (result
) = (next
|| TREE_CODE (fn
) == TEMPLATE_DECL
2125 ? unknown_type_node
: TREE_TYPE (fn
));
2126 OVL_FUNCTION (result
) = fn
;
2127 OVL_CHAIN (result
) = next
;
2134 tree result
= ovl_cache
;
2138 ovl_cache
= OVL_FUNCTION (result
);
2139 /* Zap the flags. */
2140 memset (result
, 0, sizeof (tree_base
));
2141 TREE_SET_CODE (result
, OVERLOAD
);
2144 result
= make_node (OVERLOAD
);
2146 gcc_checking_assert (!OVL_NESTED_P (ovl
) && OVL_USED_P (ovl
));
2147 TREE_TYPE (result
) = TREE_TYPE (ovl
);
2148 OVL_FUNCTION (result
) = OVL_FUNCTION (ovl
);
2149 OVL_CHAIN (result
) = OVL_CHAIN (ovl
);
2150 OVL_HIDDEN_P (result
) = OVL_HIDDEN_P (ovl
);
2151 OVL_USING_P (result
) = OVL_USING_P (ovl
);
2152 OVL_LOOKUP_P (result
) = OVL_LOOKUP_P (ovl
);
2157 /* Add FN to the (potentially NULL) overload set OVL. USING_P is
2158 true, if FN is via a using declaration. We also pay attention to
2159 DECL_HIDDEN. Overloads are ordered as hidden, using, regular. */
2162 ovl_insert (tree fn
, tree maybe_ovl
, bool using_p
)
2164 bool copying
= false; /* Checking use only. */
2165 bool hidden_p
= DECL_HIDDEN_P (fn
);
2166 int weight
= (hidden_p
<< 1) | (using_p
<< 0);
2168 tree result
= NULL_TREE
;
2169 tree insert_after
= NULL_TREE
;
2171 /* Find insertion point. */
2172 while (maybe_ovl
&& TREE_CODE (maybe_ovl
) == OVERLOAD
2173 && (weight
< ((OVL_HIDDEN_P (maybe_ovl
) << 1)
2174 | (OVL_USING_P (maybe_ovl
) << 0))))
2176 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl
)
2177 && (!copying
|| OVL_USED_P (maybe_ovl
)));
2178 if (OVL_USED_P (maybe_ovl
))
2181 maybe_ovl
= ovl_copy (maybe_ovl
);
2183 OVL_CHAIN (insert_after
) = maybe_ovl
;
2187 insert_after
= maybe_ovl
;
2188 maybe_ovl
= OVL_CHAIN (maybe_ovl
);
2192 if (maybe_ovl
|| using_p
|| hidden_p
|| TREE_CODE (fn
) == TEMPLATE_DECL
)
2194 trail
= ovl_make (fn
, maybe_ovl
);
2196 OVL_HIDDEN_P (trail
) = true;
2198 OVL_USING_P (trail
) = true;
2203 OVL_CHAIN (insert_after
) = trail
;
2204 TREE_TYPE (insert_after
) = unknown_type_node
;
2212 /* Skip any hidden names at the beginning of OVL. */
2215 ovl_skip_hidden (tree ovl
)
2218 ovl
&& TREE_CODE (ovl
) == OVERLOAD
&& OVL_HIDDEN_P (ovl
);
2219 ovl
= OVL_CHAIN (ovl
))
2220 gcc_checking_assert (DECL_HIDDEN_P (OVL_FUNCTION (ovl
)));
2222 if (ovl
&& TREE_CODE (ovl
) != OVERLOAD
&& DECL_HIDDEN_P (ovl
))
2224 /* Any hidden functions should have been wrapped in an
2225 overload, but injected friend classes will not. */
2226 gcc_checking_assert (!DECL_DECLARES_FUNCTION_P (ovl
));
2233 /* NODE is an OVL_HIDDEN_P node which is now revealed. */
2236 ovl_iterator::reveal_node (tree overload
, tree node
)
2238 /* We cannot have returned NODE as part of a lookup overload, so it
2240 gcc_checking_assert (!OVL_USED_P (node
));
2242 OVL_HIDDEN_P (node
) = false;
2243 if (tree chain
= OVL_CHAIN (node
))
2244 if (TREE_CODE (chain
) == OVERLOAD
2245 && (OVL_USING_P (chain
) || OVL_HIDDEN_P (chain
)))
2247 /* The node needs moving, and the simplest way is to remove it
2249 overload
= remove_node (overload
, node
);
2250 overload
= ovl_insert (OVL_FUNCTION (node
), overload
);
2255 /* NODE is on the overloads of OVL. Remove it. If a predecessor is
2256 OVL_USED_P we must copy OVL nodes, because those are immutable.
2257 The removed node is unaltered and may continue to be iterated
2258 from (i.e. it is safe to remove a node from an overload one is
2259 currently iterating over). */
2262 ovl_iterator::remove_node (tree overload
, tree node
)
2264 bool copying
= false; /* Checking use only. */
2266 tree
*slot
= &overload
;
2267 while (*slot
!= node
)
2270 gcc_checking_assert (!OVL_LOOKUP_P (probe
)
2271 && (!copying
|| OVL_USED_P (probe
)));
2272 if (OVL_USED_P (probe
))
2275 probe
= ovl_copy (probe
);
2279 slot
= &OVL_CHAIN (probe
);
2282 /* Stitch out NODE. We don't have to worry about now making a
2283 singleton overload (and consequently maybe setting its type),
2284 because all uses of this function will be followed by inserting a
2285 new node that must follow the place we've cut this out from. */
2286 if (TREE_CODE (node
) != OVERLOAD
)
2287 /* Cloned inherited ctors don't mark themselves as via_using. */
2290 *slot
= OVL_CHAIN (node
);
2295 /* Mark or unmark a lookup set. */
2298 lookup_mark (tree ovl
, bool val
)
2300 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
2302 gcc_checking_assert (LOOKUP_SEEN_P (*iter
) != val
);
2303 LOOKUP_SEEN_P (*iter
) = val
;
2307 /* Add a set of new FNS into a lookup. */
2310 lookup_add (tree fns
, tree lookup
)
2312 if (lookup
|| TREE_CODE (fns
) == TEMPLATE_DECL
)
2314 lookup
= ovl_make (fns
, lookup
);
2315 OVL_LOOKUP_P (lookup
) = true;
2323 /* FNS is a new overload set, add them to LOOKUP, if they are not
2324 already present there. */
2327 lookup_maybe_add (tree fns
, tree lookup
, bool deduping
)
2330 for (tree next
, probe
= fns
; probe
; probe
= next
)
2335 if (TREE_CODE (probe
) == OVERLOAD
)
2337 fn
= OVL_FUNCTION (probe
);
2338 next
= OVL_CHAIN (probe
);
2341 if (!LOOKUP_SEEN_P (fn
))
2342 LOOKUP_SEEN_P (fn
) = true;
2345 /* This function was already seen. Insert all the
2346 predecessors onto the lookup. */
2347 for (; fns
!= probe
; fns
= OVL_CHAIN (fns
))
2349 lookup
= lookup_add (OVL_FUNCTION (fns
), lookup
);
2350 /* Propagate OVL_USING, but OVL_HIDDEN doesn't matter. */
2351 if (OVL_USING_P (fns
))
2352 OVL_USING_P (lookup
) = true;
2355 /* And now skip this function. */
2361 /* We ended in a set of new functions. Add them all in one go. */
2362 lookup
= lookup_add (fns
, lookup
);
2367 /* Regular overload OVL is part of a kept lookup. Mark the nodes on
2374 ovl
&& TREE_CODE (ovl
) == OVERLOAD
2375 && !OVL_USED_P (ovl
);
2376 ovl
= OVL_CHAIN (ovl
))
2378 gcc_checking_assert (!OVL_LOOKUP_P (ovl
));
2379 OVL_USED_P (ovl
) = true;
2383 /* If KEEP is true, preserve the contents of a lookup so that it is
2384 available for a later instantiation. Otherwise release the LOOKUP
2388 lookup_keep (tree lookup
, bool keep
)
2391 lookup
&& TREE_CODE (lookup
) == OVERLOAD
2392 && OVL_LOOKUP_P (lookup
) && !OVL_USED_P (lookup
);
2393 lookup
= OVL_CHAIN (lookup
))
2396 OVL_USED_P (lookup
) = true;
2397 ovl_used (OVL_FUNCTION (lookup
));
2401 OVL_FUNCTION (lookup
) = ovl_cache
;
2409 /* Returns nonzero if X is an expression for a (possibly overloaded)
2410 function. If "f" is a function or function template, "f", "c->f",
2411 "c.f", "C::f", and "f<int>" will all be considered possibly
2412 overloaded functions. Returns 2 if the function is actually
2413 overloaded, i.e., if it is impossible to know the type of the
2414 function without performing overload resolution. */
2417 is_overloaded_fn (tree x
)
2419 /* A baselink is also considered an overloaded function. */
2420 if (TREE_CODE (x
) == OFFSET_REF
2421 || TREE_CODE (x
) == COMPONENT_REF
)
2422 x
= TREE_OPERAND (x
, 1);
2423 x
= MAYBE_BASELINK_FUNCTIONS (x
);
2424 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2425 x
= TREE_OPERAND (x
, 0);
2427 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x
))
2428 || (TREE_CODE (x
) == OVERLOAD
&& !OVL_SINGLE_P (x
)))
2431 return (TREE_CODE (x
) == FUNCTION_DECL
2432 || TREE_CODE (x
) == OVERLOAD
);
2435 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2436 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2440 dependent_name (tree x
)
2442 if (identifier_p (x
))
2444 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2445 x
= TREE_OPERAND (x
, 0);
2446 if (TREE_CODE (x
) == OVERLOAD
|| TREE_CODE (x
) == FUNCTION_DECL
)
2447 return OVL_NAME (x
);
2451 /* Returns true iff X is an expression for an overloaded function
2452 whose type cannot be known without performing overload
2456 really_overloaded_fn (tree x
)
2458 return is_overloaded_fn (x
) == 2;
2461 /* Get the overload set FROM refers to. */
2466 /* A baselink is also considered an overloaded function. */
2467 if (TREE_CODE (from
) == OFFSET_REF
2468 || TREE_CODE (from
) == COMPONENT_REF
)
2469 from
= TREE_OPERAND (from
, 1);
2470 if (BASELINK_P (from
))
2471 from
= BASELINK_FUNCTIONS (from
);
2472 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2473 from
= TREE_OPERAND (from
, 0);
2474 gcc_assert (TREE_CODE (from
) == OVERLOAD
2475 || TREE_CODE (from
) == FUNCTION_DECL
);
2479 /* Return the first function of the overload set FROM refers to. */
2482 get_first_fn (tree from
)
2484 return OVL_FIRST (get_fns (from
));
2487 /* Return the scope where the overloaded functions OVL were found. */
2490 ovl_scope (tree ovl
)
2492 if (TREE_CODE (ovl
) == OFFSET_REF
2493 || TREE_CODE (ovl
) == COMPONENT_REF
)
2494 ovl
= TREE_OPERAND (ovl
, 1);
2495 if (TREE_CODE (ovl
) == BASELINK
)
2496 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2497 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2498 ovl
= TREE_OPERAND (ovl
, 0);
2499 /* Skip using-declarations. */
2500 lkp_iterator
iter (ovl
);
2503 while (iter
.using_p () && ++iter
);
2505 return CP_DECL_CONTEXT (ovl
);
2508 #define PRINT_RING_SIZE 4
2511 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2513 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2514 static char *print_ring
[PRINT_RING_SIZE
];
2515 static bool trans_ring
[PRINT_RING_SIZE
];
2516 static int ring_counter
;
2519 /* Only cache functions. */
2521 || TREE_CODE (decl
) != FUNCTION_DECL
2522 || DECL_LANG_SPECIFIC (decl
) == 0)
2523 return lang_decl_name (decl
, v
, translate
);
2525 /* See if this print name is lying around. */
2526 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2527 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2528 /* yes, so return it. */
2529 return print_ring
[i
];
2531 if (++ring_counter
== PRINT_RING_SIZE
)
2534 if (current_function_decl
!= NULL_TREE
)
2536 /* There may be both translated and untranslated versions of the
2538 for (i
= 0; i
< 2; i
++)
2540 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2542 if (ring_counter
== PRINT_RING_SIZE
)
2545 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2548 free (print_ring
[ring_counter
]);
2550 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2551 uid_ring
[ring_counter
] = DECL_UID (decl
);
2552 trans_ring
[ring_counter
] = translate
;
2553 return print_ring
[ring_counter
];
2557 cxx_printable_name (tree decl
, int v
)
2559 return cxx_printable_name_internal (decl
, v
, false);
2563 cxx_printable_name_translate (tree decl
, int v
)
2565 return cxx_printable_name_internal (decl
, v
, true);
2568 /* Return the canonical version of exception-specification RAISES for a C++17
2569 function type, for use in type comparison and building TYPE_CANONICAL. */
2572 canonical_eh_spec (tree raises
)
2574 if (raises
== NULL_TREE
)
2576 else if (DEFERRED_NOEXCEPT_SPEC_P (raises
)
2577 || uses_template_parms (raises
)
2578 || uses_template_parms (TREE_PURPOSE (raises
)))
2579 /* Keep a dependent or deferred exception specification. */
2581 else if (nothrow_spec_p (raises
))
2582 /* throw() -> noexcept. */
2583 return noexcept_true_spec
;
2585 /* For C++17 type matching, anything else -> nothing. */
2589 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2590 listed in RAISES. */
2593 build_exception_variant (tree type
, tree raises
)
2598 if (comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (type
), ce_exact
))
2601 type_quals
= TYPE_QUALS (type
);
2602 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2603 for (v
= TYPE_MAIN_VARIANT (type
); v
; v
= TYPE_NEXT_VARIANT (v
))
2604 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
))
2607 /* Need to build a new variant. */
2608 v
= build_variant_type_copy (type
);
2609 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2611 if (!flag_noexcept_type
)
2612 /* The exception-specification is not part of the canonical type. */
2615 /* Canonicalize the exception specification. */
2616 tree cr
= canonical_eh_spec (raises
);
2618 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2619 /* Propagate structural equality. */
2620 SET_TYPE_STRUCTURAL_EQUALITY (v
);
2621 else if (TYPE_CANONICAL (type
) != type
|| cr
!= raises
)
2622 /* Build the underlying canonical type, since it is different
2624 TYPE_CANONICAL (v
) = build_exception_variant (TYPE_CANONICAL (type
), cr
);
2626 /* T is its own canonical type. */
2627 TYPE_CANONICAL (v
) = v
;
2632 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2633 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2637 bind_template_template_parm (tree t
, tree newargs
)
2639 tree decl
= TYPE_NAME (t
);
2642 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2643 decl
= build_decl (input_location
,
2644 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2646 /* These nodes have to be created to reflect new TYPE_DECL and template
2648 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2649 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2650 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2651 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2653 TREE_TYPE (decl
) = t2
;
2654 TYPE_NAME (t2
) = decl
;
2655 TYPE_STUB_DECL (t2
) = decl
;
2657 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2662 /* Called from count_trees via walk_tree. */
2665 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2675 /* Debugging function for measuring the rough complexity of a tree
2679 count_trees (tree t
)
2682 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2686 /* Called from verify_stmt_tree via walk_tree. */
2689 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2692 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2693 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2696 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2699 /* If this statement is already present in the hash table, then
2700 there is a circularity in the statement tree. */
2701 gcc_assert (!statements
->find (t
));
2703 slot
= statements
->find_slot (t
, INSERT
);
2709 /* Debugging function to check that the statement T has not been
2710 corrupted. For now, this function simply checks that T contains no
2714 verify_stmt_tree (tree t
)
2716 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2717 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2720 /* Check if the type T depends on a type with no linkage and if so, return
2721 it. If RELAXED_P then do not consider a class type declared within
2722 a vague-linkage function to have no linkage. */
2725 no_linkage_check (tree t
, bool relaxed_p
)
2729 /* There's no point in checking linkage on template functions; we
2730 can't know their complete types. */
2731 if (processing_template_decl
)
2734 switch (TREE_CODE (t
))
2737 if (TYPE_PTRMEMFUNC_P (t
))
2739 /* Lambda types that don't have mangling scope have no linkage. We
2740 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2741 when we get here from pushtag none of the lambda information is
2742 set up yet, so we want to assume that the lambda has linkage and
2743 fix it up later if not. */
2744 if (CLASSTYPE_LAMBDA_EXPR (t
)
2745 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
2746 && LAMBDA_TYPE_EXTRA_SCOPE (t
) == NULL_TREE
)
2750 if (!CLASS_TYPE_P (t
))
2754 /* Only treat unnamed types as having no linkage if they're at
2755 namespace scope. This is core issue 966. */
2756 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2759 for (r
= CP_TYPE_CONTEXT (t
); ; )
2761 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2762 have linkage, or we might just be in an anonymous namespace.
2763 If we're in a TREE_PUBLIC class, we have linkage. */
2764 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2765 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2766 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2768 if (!relaxed_p
|| !vague_linkage_p (r
))
2771 r
= CP_DECL_CONTEXT (r
);
2781 case REFERENCE_TYPE
:
2783 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2787 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
2791 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
2796 tree parm
= TYPE_ARG_TYPES (t
);
2797 if (TREE_CODE (t
) == METHOD_TYPE
)
2798 /* The 'this' pointer isn't interesting; a method has the same
2799 linkage (or lack thereof) as its enclosing class. */
2800 parm
= TREE_CHAIN (parm
);
2802 parm
&& parm
!= void_list_node
;
2803 parm
= TREE_CHAIN (parm
))
2805 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
2809 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2817 extern int depth_reached
;
2820 cxx_print_statistics (void)
2822 print_class_statistics ();
2823 print_template_statistics ();
2824 if (GATHER_STATISTICS
)
2825 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2829 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2830 (which is an ARRAY_TYPE). This counts only elements of the top
2834 array_type_nelts_top (tree type
)
2836 return fold_build2_loc (input_location
,
2837 PLUS_EXPR
, sizetype
,
2838 array_type_nelts (type
),
2842 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2843 (which is an ARRAY_TYPE). This one is a recursive count of all
2844 ARRAY_TYPEs that are clumped together. */
2847 array_type_nelts_total (tree type
)
2849 tree sz
= array_type_nelts_top (type
);
2850 type
= TREE_TYPE (type
);
2851 while (TREE_CODE (type
) == ARRAY_TYPE
)
2853 tree n
= array_type_nelts_top (type
);
2854 sz
= fold_build2_loc (input_location
,
2855 MULT_EXPR
, sizetype
, sz
, n
);
2856 type
= TREE_TYPE (type
);
2861 /* Called from break_out_target_exprs via mapcar. */
2864 bot_manip (tree
* tp
, int* walk_subtrees
, void* data
)
2866 splay_tree target_remap
= ((splay_tree
) data
);
2869 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
2871 /* There can't be any TARGET_EXPRs or their slot variables below this
2872 point. But we must make a copy, in case subsequent processing
2873 alters any part of it. For example, during gimplification a cast
2874 of the form (T) &X::f (where "f" is a member function) will lead
2875 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2877 *tp
= unshare_expr (t
);
2880 if (TREE_CODE (t
) == TARGET_EXPR
)
2884 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
2886 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
2887 tf_warning_or_error
);
2888 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
2889 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
2892 u
= build_target_expr_with_type (TREE_OPERAND (t
, 1), TREE_TYPE (t
),
2893 tf_warning_or_error
);
2895 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
2896 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
2897 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
2899 /* Map the old variable to the new one. */
2900 splay_tree_insert (target_remap
,
2901 (splay_tree_key
) TREE_OPERAND (t
, 0),
2902 (splay_tree_value
) TREE_OPERAND (u
, 0));
2904 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1));
2906 /* Replace the old expression with the new version. */
2908 /* We don't have to go below this point; the recursive call to
2909 break_out_target_exprs will have handled anything below this
2914 if (TREE_CODE (*tp
) == SAVE_EXPR
)
2917 splay_tree_node n
= splay_tree_lookup (target_remap
,
2918 (splay_tree_key
) t
);
2921 *tp
= (tree
)n
->value
;
2926 copy_tree_r (tp
, walk_subtrees
, NULL
);
2927 splay_tree_insert (target_remap
,
2929 (splay_tree_value
)*tp
);
2930 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
2931 splay_tree_insert (target_remap
,
2932 (splay_tree_key
)*tp
,
2933 (splay_tree_value
)*tp
);
2938 /* Make a copy of this node. */
2939 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
2940 if (TREE_CODE (*tp
) == CALL_EXPR
)
2942 set_flags_from_callee (*tp
);
2944 /* builtin_LINE and builtin_FILE get the location where the default
2945 argument is expanded, not where the call was written. */
2946 tree callee
= get_callee_fndecl (*tp
);
2947 if (callee
&& DECL_BUILT_IN_CLASS (callee
) == BUILT_IN_NORMAL
)
2948 switch (DECL_FUNCTION_CODE (callee
))
2952 SET_EXPR_LOCATION (*tp
, input_location
);
2960 /* Replace all remapped VAR_DECLs in T with their new equivalents.
2961 DATA is really a splay-tree mapping old variables to new
2965 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data
)
2967 splay_tree target_remap
= ((splay_tree
) data
);
2971 splay_tree_node n
= splay_tree_lookup (target_remap
,
2972 (splay_tree_key
) *t
);
2974 *t
= (tree
) n
->value
;
2976 else if (TREE_CODE (*t
) == PARM_DECL
2977 && DECL_NAME (*t
) == this_identifier
2978 && !DECL_CONTEXT (*t
))
2980 /* In an NSDMI we need to replace the 'this' parameter we used for
2981 parsing with the real one for this function. */
2982 *t
= current_class_ptr
;
2984 else if (TREE_CODE (*t
) == CONVERT_EXPR
2985 && CONVERT_EXPR_VBASE_PATH (*t
))
2987 /* In an NSDMI build_base_path defers building conversions to virtual
2988 bases, and we handle it here. */
2989 tree basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t
)));
2990 vec
<tree
, va_gc
> *vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
2992 FOR_EACH_VEC_SAFE_ELT (vbases
, i
, binfo
)
2993 if (BINFO_TYPE (binfo
) == basetype
)
2995 *t
= build_base_path (PLUS_EXPR
, TREE_OPERAND (*t
, 0), binfo
, true,
2996 tf_warning_or_error
);
3002 /* When we parse a default argument expression, we may create
3003 temporary variables via TARGET_EXPRs. When we actually use the
3004 default-argument expression, we make a copy of the expression
3005 and replace the temporaries with appropriate local versions. */
3008 break_out_target_exprs (tree t
)
3010 static int target_remap_count
;
3011 static splay_tree target_remap
;
3013 if (!target_remap_count
++)
3014 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
3015 /*splay_tree_delete_key_fn=*/NULL
,
3016 /*splay_tree_delete_value_fn=*/NULL
);
3017 cp_walk_tree (&t
, bot_manip
, target_remap
, NULL
);
3018 cp_walk_tree (&t
, bot_replace
, target_remap
, NULL
);
3020 if (!--target_remap_count
)
3022 splay_tree_delete (target_remap
);
3023 target_remap
= NULL
;
3029 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3030 which we expect to have type TYPE. */
3033 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
3035 if (index
== NULL_TREE
)
3036 /* Can't refer to a particular member of a vector. */
3038 else if (TREE_CODE (index
) == INTEGER_CST
)
3039 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
3041 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
3042 /*reference*/false, tf_none
);
3045 tree objtype
= TREE_TYPE (obj
);
3046 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
3048 /* When the destination object refers to a flexible array member
3049 verify that it matches the type of the source object except
3050 for its domain and qualifiers. */
3051 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
3052 TYPE_MAIN_VARIANT (objtype
),
3053 COMPARE_REDECLARATION
));
3056 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
3062 struct replace_placeholders_t
3064 tree obj
; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3065 bool seen
; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3066 hash_set
<tree
> *pset
; /* To avoid walking same trees multiple times. */
3069 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3070 build up subexpressions as we go deeper. */
3073 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
3075 replace_placeholders_t
*d
= static_cast<replace_placeholders_t
*>(data_
);
3078 if (TREE_CONSTANT (*t
))
3080 *walk_subtrees
= false;
3084 switch (TREE_CODE (*t
))
3086 case PLACEHOLDER_EXPR
:
3089 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t
),
3091 x
= TREE_OPERAND (x
, 0))
3092 gcc_assert (TREE_CODE (x
) == COMPONENT_REF
);
3094 *walk_subtrees
= false;
3101 constructor_elt
*ce
;
3102 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
3103 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
3105 tree
*valp
= &ce
->value
;
3106 tree type
= TREE_TYPE (*valp
);
3109 if (TREE_CODE (*valp
) == CONSTRUCTOR
3110 && AGGREGATE_TYPE_P (type
))
3112 /* If we're looking at the initializer for OBJ, then build
3113 a sub-object reference. If we're looking at an
3114 initializer for another object, just pass OBJ down. */
3115 if (same_type_ignoring_top_level_qualifiers_p
3116 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
3117 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
3118 if (TREE_CODE (*valp
) == TARGET_EXPR
)
3119 valp
= &TARGET_EXPR_INITIAL (*valp
);
3122 cp_walk_tree (valp
, replace_placeholders_r
, data_
, d
->pset
);
3125 *walk_subtrees
= false;
3136 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3137 a PLACEHOLDER_EXPR has been encountered. */
3140 replace_placeholders (tree exp
, tree obj
, bool *seen_p
)
3142 /* This is only relevant for C++14. */
3143 if (cxx_dialect
< cxx14
)
3146 /* If the object isn't a (member of a) class, do nothing. */
3148 while (TREE_CODE (op0
) == COMPONENT_REF
)
3149 op0
= TREE_OPERAND (op0
, 0);
3150 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0
))))
3154 hash_set
<tree
> pset
;
3155 replace_placeholders_t data
= { obj
, false, &pset
};
3156 if (TREE_CODE (exp
) == TARGET_EXPR
)
3157 tp
= &TARGET_EXPR_INITIAL (exp
);
3158 cp_walk_tree (tp
, replace_placeholders_r
, &data
, &pset
);
3160 *seen_p
= data
.seen
;
3164 /* Similar to `build_nt', but for template definitions of dependent
3168 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
3175 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3179 t
= make_node (code
);
3180 SET_EXPR_LOCATION (t
, loc
);
3181 length
= TREE_CODE_LENGTH (code
);
3183 for (i
= 0; i
< length
; i
++)
3185 tree x
= va_arg (p
, tree
);
3186 TREE_OPERAND (t
, i
) = x
;
3187 if (x
&& TREE_CODE (x
) == OVERLOAD
)
3188 lookup_keep (x
, true);
3195 /* Similar to `build', but for template definitions. */
3198 build_min (enum tree_code code
, tree tt
, ...)
3205 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3209 t
= make_node (code
);
3210 length
= TREE_CODE_LENGTH (code
);
3213 for (i
= 0; i
< length
; i
++)
3215 tree x
= va_arg (p
, tree
);
3216 TREE_OPERAND (t
, i
) = x
;
3219 if (!TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
3220 TREE_SIDE_EFFECTS (t
) = 1;
3221 if (TREE_CODE (x
) == OVERLOAD
)
3222 lookup_keep (x
, true);
3230 /* Similar to `build', but for template definitions of non-dependent
3231 expressions. NON_DEP is the non-dependent expression that has been
3235 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
3242 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3244 va_start (p
, non_dep
);
3246 if (REFERENCE_REF_P (non_dep
))
3247 non_dep
= TREE_OPERAND (non_dep
, 0);
3249 t
= make_node (code
);
3250 length
= TREE_CODE_LENGTH (code
);
3251 TREE_TYPE (t
) = unlowered_expr_type (non_dep
);
3252 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3254 for (i
= 0; i
< length
; i
++)
3256 tree x
= va_arg (p
, tree
);
3257 TREE_OPERAND (t
, i
) = x
;
3258 if (x
&& TREE_CODE (x
) == OVERLOAD
)
3259 lookup_keep (x
, true);
3262 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
3263 /* This should not be considered a COMPOUND_EXPR, because it
3264 resolves to an overload. */
3265 COMPOUND_EXPR_OVERLOADED (t
) = 1;
3268 return convert_from_reference (t
);
3271 /* Similar to build_min_nt, but call expressions */
3274 build_min_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
3279 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
3280 CALL_EXPR_FN (ret
) = fn
;
3281 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
3282 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
3284 CALL_EXPR_ARG (ret
, ix
) = t
;
3285 if (TREE_CODE (t
) == OVERLOAD
)
3286 lookup_keep (t
, true);
3291 /* Similar to `build_min_nt_call_vec', but for template definitions of
3292 non-dependent expressions. NON_DEP is the non-dependent expression
3293 that has been built. */
3296 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
3298 tree t
= build_min_nt_call_vec (fn
, argvec
);
3299 if (REFERENCE_REF_P (non_dep
))
3300 non_dep
= TREE_OPERAND (non_dep
, 0);
3301 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
3302 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3303 return convert_from_reference (t
);
3306 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3307 a call to an operator overload. OP is the operator that has been
3308 overloaded. NON_DEP is the non-dependent expression that's been built,
3309 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3310 the overload that NON_DEP is calling. */
3313 build_min_non_dep_op_overload (enum tree_code op
,
3318 int nargs
, expected_nargs
;
3320 vec
<tree
, va_gc
> *args
;
3322 non_dep
= extract_call_expr (non_dep
);
3324 nargs
= call_expr_nargs (non_dep
);
3326 expected_nargs
= cp_tree_code_length (op
);
3327 if ((op
== POSTINCREMENT_EXPR
3328 || op
== POSTDECREMENT_EXPR
)
3329 /* With -fpermissive non_dep could be operator++(). */
3330 && (!flag_permissive
|| nargs
!= expected_nargs
))
3331 expected_nargs
+= 1;
3332 gcc_assert (nargs
== expected_nargs
);
3334 args
= make_tree_vector ();
3335 va_start (p
, overload
);
3337 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
3340 for (int i
= 0; i
< nargs
; i
++)
3342 tree arg
= va_arg (p
, tree
);
3343 vec_safe_push (args
, arg
);
3346 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3348 tree object
= va_arg (p
, tree
);
3349 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3350 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3351 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3352 object
, method
, NULL_TREE
);
3353 for (int i
= 1; i
< nargs
; i
++)
3355 tree arg
= va_arg (p
, tree
);
3356 vec_safe_push (args
, arg
);
3363 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3364 release_tree_vector (args
);
3366 tree call_expr
= extract_call_expr (call
);
3367 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3368 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3369 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3370 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3375 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3378 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
3380 unsigned len
= vec_safe_length (old_vec
);
3381 gcc_assert (idx
<= len
);
3383 vec
<tree
, va_gc
> *new_vec
= NULL
;
3384 vec_alloc (new_vec
, len
+ 1);
3387 for (i
= 0; i
< len
; ++i
)
3390 new_vec
->quick_push (elt
);
3391 new_vec
->quick_push ((*old_vec
)[i
]);
3394 new_vec
->quick_push (elt
);
3400 get_type_decl (tree t
)
3402 if (TREE_CODE (t
) == TYPE_DECL
)
3405 return TYPE_STUB_DECL (t
);
3406 gcc_assert (t
== error_mark_node
);
3410 /* Returns the namespace that contains DECL, whether directly or
3414 decl_namespace_context (tree decl
)
3418 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3420 else if (TYPE_P (decl
))
3421 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
3423 decl
= CP_DECL_CONTEXT (decl
);
3427 /* Returns true if decl is within an anonymous namespace, however deeply
3428 nested, or false otherwise. */
3431 decl_anon_ns_mem_p (const_tree decl
)
3433 while (TREE_CODE (decl
) != NAMESPACE_DECL
)
3435 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3437 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl
));
3439 decl
= CP_DECL_CONTEXT (decl
);
3441 return !TREE_PUBLIC (decl
);
3444 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3445 CALL_EXPRS. Return whether they are equivalent. */
3448 called_fns_equal (tree t1
, tree t2
)
3450 /* Core 1321: dependent names are equivalent even if the overload sets
3451 are different. But do compare explicit template arguments. */
3452 tree name1
= dependent_name (t1
);
3453 tree name2
= dependent_name (t2
);
3456 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3461 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3462 targs1
= TREE_OPERAND (t1
, 1);
3463 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3464 targs2
= TREE_OPERAND (t2
, 1);
3465 return cp_tree_equal (targs1
, targs2
);
3468 return cp_tree_equal (t1
, t2
);
3471 /* Return truthvalue of whether T1 is the same tree structure as T2.
3472 Return 1 if they are the same. Return 0 if they are different. */
3475 cp_tree_equal (tree t1
, tree t2
)
3477 enum tree_code code1
, code2
;
3484 code1
= TREE_CODE (t1
);
3485 code2
= TREE_CODE (t2
);
3493 /* There's only a single VOID_CST node, so we should never reach
3498 return tree_int_cst_equal (t1
, t2
);
3501 return real_equal (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3504 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3505 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3506 TREE_STRING_LENGTH (t1
));
3509 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3510 TREE_FIXED_CST (t2
));
3513 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3514 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3517 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3520 /* We need to do this when determining whether or not two
3521 non-type pointer to member function template arguments
3523 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3524 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3529 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3531 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3532 if (!cp_tree_equal (field
, elt2
->index
)
3533 || !cp_tree_equal (value
, elt2
->value
))
3540 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3542 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3544 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3547 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3552 call_expr_arg_iterator iter1
, iter2
;
3553 if (!called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
3555 for (arg1
= first_call_expr_arg (t1
, &iter1
),
3556 arg2
= first_call_expr_arg (t2
, &iter2
);
3558 arg1
= next_call_expr_arg (&iter1
),
3559 arg2
= next_call_expr_arg (&iter2
))
3560 if (!cp_tree_equal (arg1
, arg2
))
3569 tree o1
= TREE_OPERAND (t1
, 0);
3570 tree o2
= TREE_OPERAND (t2
, 0);
3572 /* Special case: if either target is an unallocated VAR_DECL,
3573 it means that it's going to be unified with whatever the
3574 TARGET_EXPR is really supposed to initialize, so treat it
3575 as being equivalent to anything. */
3576 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
3577 && !DECL_RTL_SET_P (o1
))
3579 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
3580 && !DECL_RTL_SET_P (o2
))
3582 else if (!cp_tree_equal (o1
, o2
))
3585 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
3589 /* For comparing uses of parameters in late-specified return types
3590 with an out-of-class definition of the function, but can also come
3591 up for expressions that involve 'this' in a member function
3594 if (comparing_specializations
&& !CONSTRAINT_VAR_P (t1
))
3595 /* When comparing hash table entries, only an exact match is
3596 good enough; we don't want to replace 'this' with the
3597 version from another function. But be more flexible
3598 with local parameters in a requires-expression. */
3601 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3603 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
3605 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
3607 if (DECL_ARTIFICIAL (t1
)
3608 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
3609 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
3619 case IDENTIFIER_NODE
:
3624 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
3625 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
3626 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
3627 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
3628 BASELINK_FUNCTIONS (t2
)));
3630 case TEMPLATE_PARM_INDEX
:
3631 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
3632 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
3633 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
3634 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
3635 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
3636 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
3638 case TEMPLATE_ID_EXPR
:
3639 return (cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
3640 && cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
3642 case CONSTRAINT_INFO
:
3643 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
3644 CI_ASSOCIATED_CONSTRAINTS (t2
));
3647 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
3648 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
3649 CHECK_CONSTR_ARGS (t2
)));
3654 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
3656 for (ix
= TREE_VEC_LENGTH (t1
); ix
--;)
3657 if (!cp_tree_equal (TREE_VEC_ELT (t1
, ix
),
3658 TREE_VEC_ELT (t2
, ix
)))
3666 tree o1
= TREE_OPERAND (t1
, 0);
3667 tree o2
= TREE_OPERAND (t2
, 0);
3669 if (code1
== SIZEOF_EXPR
)
3671 if (SIZEOF_EXPR_TYPE_P (t1
))
3672 o1
= TREE_TYPE (o1
);
3673 if (SIZEOF_EXPR_TYPE_P (t2
))
3674 o2
= TREE_TYPE (o2
);
3676 if (TREE_CODE (o1
) != TREE_CODE (o2
))
3679 return same_type_p (o1
, o2
);
3681 return cp_tree_equal (o1
, o2
);
3686 tree t1_op1
, t2_op1
;
3688 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3691 t1_op1
= TREE_OPERAND (t1
, 1);
3692 t2_op1
= TREE_OPERAND (t2
, 1);
3693 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
3696 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
3700 /* Two pointer-to-members are the same if they point to the same
3701 field or function in the same class. */
3702 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
3705 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
3709 /* Two overloads. Must be exactly the same set of decls. */
3710 lkp_iterator
first (t1
);
3711 lkp_iterator
second (t2
);
3713 for (; first
&& second
; ++first
, ++second
)
3714 if (*first
!= *second
)
3716 return !(first
|| second
);
3720 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
3722 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
3723 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
3726 case STATIC_CAST_EXPR
:
3727 case REINTERPRET_CAST_EXPR
:
3728 case CONST_CAST_EXPR
:
3729 case DYNAMIC_CAST_EXPR
:
3730 case IMPLICIT_CONV_EXPR
:
3733 case NON_LVALUE_EXPR
:
3734 case VIEW_CONVERT_EXPR
:
3735 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3737 /* Now compare operands as usual. */
3740 case DEFERRED_NOEXCEPT
:
3741 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
3742 DEFERRED_NOEXCEPT_PATTERN (t2
))
3743 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
3744 DEFERRED_NOEXCEPT_ARGS (t2
)));
3751 switch (TREE_CODE_CLASS (code1
))
3755 case tcc_comparison
:
3756 case tcc_expression
:
3763 n
= cp_tree_operand_length (t1
);
3764 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
3765 && n
!= TREE_OPERAND_LENGTH (t2
))
3768 for (i
= 0; i
< n
; ++i
)
3769 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
3776 return same_type_p (t1
, t2
);
3780 /* We can get here with --disable-checking. */
3784 /* The type of ARG when used as an lvalue. */
3787 lvalue_type (tree arg
)
3789 tree type
= TREE_TYPE (arg
);
3793 /* The type of ARG for printing error messages; denote lvalues with
3797 error_type (tree arg
)
3799 tree type
= TREE_TYPE (arg
);
3801 if (TREE_CODE (type
) == ARRAY_TYPE
)
3803 else if (TREE_CODE (type
) == ERROR_MARK
)
3805 else if (lvalue_p (arg
))
3806 type
= build_reference_type (lvalue_type (arg
));
3807 else if (MAYBE_CLASS_TYPE_P (type
))
3808 type
= lvalue_type (arg
);
3813 /* Does FUNCTION use a variable-length argument list? */
3816 varargs_function_p (const_tree function
)
3818 return stdarg_p (TREE_TYPE (function
));
3821 /* Returns 1 if decl is a member of a class. */
3824 member_p (const_tree decl
)
3826 const_tree
const ctx
= DECL_CONTEXT (decl
);
3827 return (ctx
&& TYPE_P (ctx
));
3830 /* Create a placeholder for member access where we don't actually have an
3831 object that the access is against. */
3834 build_dummy_object (tree type
)
3836 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
3837 return cp_build_indirect_ref (decl
, RO_NULL
, tf_warning_or_error
);
3840 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
3841 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
3842 binfo path from current_class_type to TYPE, or 0. */
3845 maybe_dummy_object (tree type
, tree
* binfop
)
3849 tree current
= current_nonlambda_class_type ();
3852 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
3853 tf_warning_or_error
)))
3857 /* Reference from a nested class member function. */
3859 binfo
= TYPE_BINFO (type
);
3865 if (current_class_ref
3866 /* current_class_ref might not correspond to current_class_type if
3867 we're in tsubst_default_argument or a lambda-declarator; in either
3868 case, we want to use current_class_ref if it matches CONTEXT. */
3869 && (same_type_ignoring_top_level_qualifiers_p
3870 (TREE_TYPE (current_class_ref
), context
)))
3871 decl
= current_class_ref
;
3873 decl
= build_dummy_object (context
);
3878 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
3881 is_dummy_object (const_tree ob
)
3883 if (INDIRECT_REF_P (ob
))
3884 ob
= TREE_OPERAND (ob
, 0);
3885 return (TREE_CODE (ob
) == CONVERT_EXPR
3886 && TREE_OPERAND (ob
, 0) == void_node
);
3889 /* Returns 1 iff type T is something we want to treat as a scalar type for
3890 the purpose of deciding whether it is trivial/POD/standard-layout. */
3893 scalarish_type_p (const_tree t
)
3895 if (t
== error_mark_node
)
3898 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
3901 /* Returns true iff T requires non-trivial default initialization. */
3904 type_has_nontrivial_default_init (const_tree t
)
3906 t
= strip_array_types (CONST_CAST_TREE (t
));
3908 if (CLASS_TYPE_P (t
))
3909 return TYPE_HAS_COMPLEX_DFLT (t
);
3914 /* Track classes with only deleted copy/move constructors so that we can warn
3915 if they are used in call/return by value. */
3917 static GTY(()) hash_set
<tree
>* deleted_copy_types
;
3919 remember_deleted_copy (const_tree t
)
3921 if (!deleted_copy_types
)
3922 deleted_copy_types
= hash_set
<tree
>::create_ggc(37);
3923 deleted_copy_types
->add (CONST_CAST_TREE (t
));
3926 maybe_warn_parm_abi (tree t
, location_t loc
)
3928 if (!deleted_copy_types
3929 || !deleted_copy_types
->contains (t
))
3932 warning_at (loc
, OPT_Wabi
, "the calling convention for %qT changes in "
3933 "-fabi-version=12 (GCC 8)", t
);
3934 static bool explained
= false;
3937 inform (loc
, " because all of its copy and move constructors "
3943 /* Returns true iff copying an object of type T (including via move
3944 constructor) is non-trivial. That is, T has no non-trivial copy
3945 constructors and no non-trivial move constructors, and not all copy/move
3946 constructors are deleted. This function implements the ABI notion of
3947 non-trivial copy, which has diverged from the one in the standard. */
3950 type_has_nontrivial_copy_init (const_tree type
)
3952 tree t
= strip_array_types (CONST_CAST_TREE (type
));
3954 if (CLASS_TYPE_P (t
))
3956 gcc_assert (COMPLETE_TYPE_P (t
));
3958 if (TYPE_HAS_COMPLEX_COPY_CTOR (t
)
3959 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
))
3963 if (cxx_dialect
< cxx11
)
3964 /* No deleted functions before C++11. */
3967 /* Before ABI v12 we did a bitwise copy of types with only deleted
3968 copy/move constructors. */
3969 if (!abi_version_at_least (12)
3970 && !(warn_abi
&& abi_version_crosses (12)))
3973 bool saw_copy
= false;
3974 bool saw_non_deleted
= false;
3976 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
3977 saw_copy
= saw_non_deleted
= true;
3978 else if (CLASSTYPE_LAZY_COPY_CTOR (t
))
3981 if (classtype_has_move_assign_or_move_ctor_p (t
, true))
3982 /* [class.copy]/8 If the class definition declares a move
3983 constructor or move assignment operator, the implicitly declared
3984 copy constructor is defined as deleted.... */;
3986 /* Any other reason the implicitly-declared function would be
3987 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
3989 saw_non_deleted
= true;
3992 if (!saw_non_deleted
)
3993 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
3999 if (!DECL_DELETED_FN (fn
))
4001 /* Not deleted, therefore trivial. */
4002 saw_non_deleted
= true;
4008 gcc_assert (saw_copy
);
4010 if (saw_copy
&& !saw_non_deleted
)
4012 if (warn_abi
&& abi_version_crosses (12))
4013 remember_deleted_copy (t
);
4014 if (abi_version_at_least (12))
4024 /* Returns 1 iff type T is a trivially copyable type, as defined in
4025 [basic.types] and [class]. */
4028 trivially_copyable_p (const_tree t
)
4030 t
= strip_array_types (CONST_CAST_TREE (t
));
4032 if (CLASS_TYPE_P (t
))
4033 return ((!TYPE_HAS_COPY_CTOR (t
)
4034 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
4035 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
4036 && (!TYPE_HAS_COPY_ASSIGN (t
)
4037 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
4038 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
4039 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
4041 return !CP_TYPE_VOLATILE_P (t
) && scalarish_type_p (t
);
4044 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4048 trivial_type_p (const_tree t
)
4050 t
= strip_array_types (CONST_CAST_TREE (t
));
4052 if (CLASS_TYPE_P (t
))
4053 return (TYPE_HAS_TRIVIAL_DFLT (t
)
4054 && trivially_copyable_p (t
));
4056 return scalarish_type_p (t
);
4059 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4062 pod_type_p (const_tree t
)
4064 /* This CONST_CAST is okay because strip_array_types returns its
4065 argument unmodified and we assign it to a const_tree. */
4066 t
= strip_array_types (CONST_CAST_TREE(t
));
4068 if (!CLASS_TYPE_P (t
))
4069 return scalarish_type_p (t
);
4070 else if (cxx_dialect
> cxx98
)
4071 /* [class]/10: A POD struct is a class that is both a trivial class and a
4072 standard-layout class, and has no non-static data members of type
4073 non-POD struct, non-POD union (or array of such types).
4075 We don't need to check individual members because if a member is
4076 non-std-layout or non-trivial, the class will be too. */
4077 return (std_layout_type_p (t
) && trivial_type_p (t
));
4079 /* The C++98 definition of POD is different. */
4080 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4083 /* Returns true iff T is POD for the purpose of layout, as defined in the
4087 layout_pod_type_p (const_tree t
)
4089 t
= strip_array_types (CONST_CAST_TREE (t
));
4091 if (CLASS_TYPE_P (t
))
4092 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4094 return scalarish_type_p (t
);
4097 /* Returns true iff T is a standard-layout type, as defined in
4101 std_layout_type_p (const_tree t
)
4103 t
= strip_array_types (CONST_CAST_TREE (t
));
4105 if (CLASS_TYPE_P (t
))
4106 return !CLASSTYPE_NON_STD_LAYOUT (t
);
4108 return scalarish_type_p (t
);
4111 static bool record_has_unique_obj_representations (const_tree
, const_tree
);
4113 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4114 as defined in [meta.unary.prop]. */
4117 type_has_unique_obj_representations (const_tree t
)
4121 t
= strip_array_types (CONST_CAST_TREE (t
));
4123 if (!trivially_copyable_p (t
))
4126 if (CLASS_TYPE_P (t
) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
))
4127 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
);
4129 switch (TREE_CODE (t
))
4133 case REFERENCE_TYPE
:
4134 /* If some backend has any paddings in these types, we should add
4135 a target hook for this and handle it there. */
4139 /* For bool values other than 0 and 1 should only appear with
4140 undefined behavior. */
4144 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t
));
4147 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4148 when storing long double values, so for that we have to return false.
4149 Other kinds of floating point values are questionable due to +.0/-.0
4150 and NaNs, let's play safe for now. */
4153 case FIXED_POINT_TYPE
:
4161 return type_has_unique_obj_representations (TREE_TYPE (t
));
4164 ret
= record_has_unique_obj_representations (t
, TYPE_SIZE (t
));
4165 if (CLASS_TYPE_P (t
))
4167 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4168 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4176 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4177 if (TREE_CODE (field
) == FIELD_DECL
)
4180 if (!type_has_unique_obj_representations (TREE_TYPE (field
))
4181 || simple_cst_equal (DECL_SIZE (field
), TYPE_SIZE (t
)) != 1)
4187 if (!any_fields
&& !integer_zerop (TYPE_SIZE (t
)))
4189 if (CLASS_TYPE_P (t
))
4191 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4192 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4207 /* Helper function for type_has_unique_obj_representations. */
4210 record_has_unique_obj_representations (const_tree t
, const_tree sz
)
4212 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4213 if (TREE_CODE (field
) != FIELD_DECL
)
4215 /* For bases, can't use type_has_unique_obj_representations here, as in
4216 struct S { int i : 24; S (); };
4217 struct T : public S { int j : 8; T (); };
4218 S doesn't have unique obj representations, but T does. */
4219 else if (DECL_FIELD_IS_BASE (field
))
4221 if (!record_has_unique_obj_representations (TREE_TYPE (field
),
4225 else if (DECL_C_BIT_FIELD (field
))
4227 tree btype
= DECL_BIT_FIELD_TYPE (field
);
4228 if (!type_has_unique_obj_representations (btype
))
4231 else if (!type_has_unique_obj_representations (TREE_TYPE (field
)))
4235 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4236 if (TREE_CODE (field
) == FIELD_DECL
)
4238 offset_int fld
= wi::to_offset (DECL_FIELD_OFFSET (field
));
4239 offset_int bitpos
= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
4240 fld
= fld
* BITS_PER_UNIT
+ bitpos
;
4243 if (DECL_SIZE (field
))
4245 offset_int size
= wi::to_offset (DECL_SIZE (field
));
4249 if (cur
!= wi::to_offset (sz
))
4255 /* Nonzero iff type T is a class template implicit specialization. */
4258 class_tmpl_impl_spec_p (const_tree t
)
4260 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
4263 /* Returns 1 iff zero initialization of type T means actually storing
4267 zero_init_p (const_tree t
)
4269 /* This CONST_CAST is okay because strip_array_types returns its
4270 argument unmodified and we assign it to a const_tree. */
4271 t
= strip_array_types (CONST_CAST_TREE(t
));
4273 if (t
== error_mark_node
)
4276 /* NULL pointers to data members are initialized with -1. */
4277 if (TYPE_PTRDATAMEM_P (t
))
4280 /* Classes that contain types that can't be zero-initialized, cannot
4281 be zero-initialized themselves. */
4282 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
4288 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4289 warn_unused_result attribute. */
4292 handle_nodiscard_attribute (tree
*node
, tree name
, tree
/*args*/,
4293 int /*flags*/, bool *no_add_attrs
)
4295 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4297 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
))))
4298 warning (OPT_Wattributes
, "%qE attribute applied to %qD with void "
4299 "return type", name
, *node
);
4301 else if (OVERLOAD_TYPE_P (*node
))
4305 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4306 "functions or to class or enumeration types", name
);
4307 *no_add_attrs
= true;
4312 /* Table of valid C++ attributes. */
4313 const struct attribute_spec cxx_attribute_table
[] =
4315 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
4316 affects_type_identity } */
4317 { "init_priority", 1, 1, true, false, false,
4318 handle_init_priority_attribute
, false },
4319 { "abi_tag", 1, -1, false, false, false,
4320 handle_abi_tag_attribute
, true },
4321 { NULL
, 0, 0, false, false, false, NULL
, false }
4324 /* Table of C++ standard attributes. */
4325 const struct attribute_spec std_attribute_table
[] =
4327 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
4328 affects_type_identity } */
4329 { "maybe_unused", 0, 0, false, false, false,
4330 handle_unused_attribute
, false },
4331 { "nodiscard", 0, 0, false, false, false,
4332 handle_nodiscard_attribute
, false },
4333 { NULL
, 0, 0, false, false, false, NULL
, false }
4336 /* Handle an "init_priority" attribute; arguments as in
4337 struct attribute_spec.handler. */
4339 handle_init_priority_attribute (tree
* node
,
4345 tree initp_expr
= TREE_VALUE (args
);
4347 tree type
= TREE_TYPE (decl
);
4350 STRIP_NOPS (initp_expr
);
4351 initp_expr
= default_conversion (initp_expr
);
4353 initp_expr
= maybe_constant_value (initp_expr
);
4355 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
4357 error ("requested init_priority is not an integer constant");
4358 cxx_constant_value (initp_expr
);
4359 *no_add_attrs
= true;
4363 pri
= TREE_INT_CST_LOW (initp_expr
);
4365 type
= strip_array_types (type
);
4367 if (decl
== NULL_TREE
4369 || !TREE_STATIC (decl
)
4370 || DECL_EXTERNAL (decl
)
4371 || (TREE_CODE (type
) != RECORD_TYPE
4372 && TREE_CODE (type
) != UNION_TYPE
)
4373 /* Static objects in functions are initialized the
4374 first time control passes through that
4375 function. This is not precise enough to pin down an
4376 init_priority value, so don't allow it. */
4377 || current_function_decl
)
4379 error ("can only use %qE attribute on file-scope definitions "
4380 "of objects of class type", name
);
4381 *no_add_attrs
= true;
4385 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
4387 error ("requested init_priority is out of range");
4388 *no_add_attrs
= true;
4392 /* Check for init_priorities that are reserved for
4393 language and runtime support implementations.*/
4394 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
4397 (0, "requested init_priority is reserved for internal use");
4400 if (SUPPORTS_INIT_PRIORITY
)
4402 SET_DECL_INIT_PRIORITY (decl
, pri
);
4403 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
4408 error ("%qE attribute is not supported on this platform", name
);
4409 *no_add_attrs
= true;
4414 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
4415 and the new one has the tags in NEW_. Give an error if there are tags
4416 in NEW_ that weren't in OLD. */
4419 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
4421 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
4422 old
= TREE_VALUE (old
);
4423 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
4424 new_
= TREE_VALUE (new_
);
4426 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
4428 tree str
= TREE_VALUE (t
);
4429 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
4431 tree ostr
= TREE_VALUE (in
);
4432 if (cp_tree_equal (str
, ostr
))
4435 error ("redeclaration of %qD adds abi tag %qE", decl
, str
);
4441 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
4447 /* The abi_tag attribute with the name NAME was given ARGS. If they are
4448 ill-formed, give an error and return false; otherwise, return true. */
4451 check_abi_tag_args (tree args
, tree name
)
4455 error ("the %qE attribute requires arguments", name
);
4458 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
4460 tree elt
= TREE_VALUE (arg
);
4461 if (TREE_CODE (elt
) != STRING_CST
4462 || (!same_type_ignoring_top_level_qualifiers_p
4463 (strip_array_types (TREE_TYPE (elt
)),
4466 error ("arguments to the %qE attribute must be narrow string "
4470 const char *begin
= TREE_STRING_POINTER (elt
);
4471 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
4472 for (const char *p
= begin
; p
!= end
; ++p
)
4477 if (!ISALPHA (c
) && c
!= '_')
4479 error ("arguments to the %qE attribute must contain valid "
4480 "identifiers", name
);
4481 inform (input_location
, "%<%c%> is not a valid first "
4482 "character for an identifier", c
);
4486 else if (p
== end
- 1)
4487 gcc_assert (c
== 0);
4490 if (!ISALNUM (c
) && c
!= '_')
4492 error ("arguments to the %qE attribute must contain valid "
4493 "identifiers", name
);
4494 inform (input_location
, "%<%c%> is not a valid character "
4495 "in an identifier", c
);
4504 /* Handle an "abi_tag" attribute; arguments as in
4505 struct attribute_spec.handler. */
4508 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
4509 int flags
, bool* no_add_attrs
)
4511 if (!check_abi_tag_args (args
, name
))
4516 if (!OVERLOAD_TYPE_P (*node
))
4518 error ("%qE attribute applied to non-class, non-enum type %qT",
4522 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
4524 error ("%qE attribute applied to %qT after its definition",
4528 else if (CLASS_TYPE_P (*node
)
4529 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
4531 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4532 "template instantiation %qT", name
, *node
);
4535 else if (CLASS_TYPE_P (*node
)
4536 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
4538 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4539 "template specialization %qT", name
, *node
);
4543 tree attributes
= TYPE_ATTRIBUTES (*node
);
4544 tree decl
= TYPE_NAME (*node
);
4546 /* Make sure all declarations have the same abi tags. */
4547 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
4549 if (!check_abi_tag_redeclaration (decl
,
4550 lookup_attribute ("abi_tag",
4558 if (!VAR_OR_FUNCTION_DECL_P (*node
))
4560 error ("%qE attribute applied to non-function, non-variable %qD",
4564 else if (DECL_LANGUAGE (*node
) == lang_c
)
4566 error ("%qE attribute applied to extern \"C\" declaration %qD",
4575 *no_add_attrs
= true;
4579 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
4580 thing pointed to by the constant. */
4583 make_ptrmem_cst (tree type
, tree member
)
4585 tree ptrmem_cst
= make_node (PTRMEM_CST
);
4586 TREE_TYPE (ptrmem_cst
) = type
;
4587 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
4591 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
4592 return an existing type if an appropriate type already exists. */
4595 cp_build_type_attribute_variant (tree type
, tree attributes
)
4599 new_type
= build_type_attribute_variant (type
, attributes
);
4600 if (TREE_CODE (new_type
) == FUNCTION_TYPE
4601 || TREE_CODE (new_type
) == METHOD_TYPE
)
4603 new_type
= build_exception_variant (new_type
,
4604 TYPE_RAISES_EXCEPTIONS (type
));
4605 new_type
= build_ref_qualified_type (new_type
,
4606 type_memfn_rqual (type
));
4609 /* Making a new main variant of a class type is broken. */
4610 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
4615 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
4616 Called only after doing all language independent checks. */
4619 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
4621 gcc_assert (TREE_CODE (typea
) == FUNCTION_TYPE
4622 || TREE_CODE (typea
) == METHOD_TYPE
);
4624 if (type_memfn_rqual (typea
) != type_memfn_rqual (typeb
))
4626 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
4627 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
4630 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
4631 C++, these are the exception-specifier and ref-qualifier. */
4634 cxx_copy_lang_qualifiers (const_tree typea
, const_tree typeb
)
4636 tree type
= CONST_CAST_TREE (typea
);
4637 if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
4639 type
= build_exception_variant (type
, TYPE_RAISES_EXCEPTIONS (typeb
));
4640 type
= build_ref_qualified_type (type
, type_memfn_rqual (typeb
));
4645 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
4646 traversal. Called from walk_tree. */
4649 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
4650 void *data
, hash_set
<tree
> *pset
)
4652 enum tree_code code
= TREE_CODE (*tp
);
4655 #define WALK_SUBTREE(NODE) \
4658 result = cp_walk_tree (&(NODE), func, data, pset); \
4659 if (result) goto out; \
4663 /* Not one of the easy cases. We must explicitly go through the
4669 case TEMPLATE_TEMPLATE_PARM
:
4670 case BOUND_TEMPLATE_TEMPLATE_PARM
:
4671 case UNBOUND_CLASS_TEMPLATE
:
4672 case TEMPLATE_PARM_INDEX
:
4673 case TEMPLATE_TYPE_PARM
:
4676 case UNDERLYING_TYPE
:
4677 /* None of these have subtrees other than those already walked
4679 *walk_subtrees_p
= 0;
4683 if (BASELINK_QUALIFIED_P (*tp
))
4684 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp
)));
4685 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
4686 *walk_subtrees_p
= 0;
4690 WALK_SUBTREE (TREE_TYPE (*tp
));
4691 *walk_subtrees_p
= 0;
4695 WALK_SUBTREE (TREE_PURPOSE (*tp
));
4699 WALK_SUBTREE (OVL_FUNCTION (*tp
));
4700 WALK_SUBTREE (OVL_CHAIN (*tp
));
4701 *walk_subtrees_p
= 0;
4705 WALK_SUBTREE (DECL_NAME (*tp
));
4706 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
4707 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
4708 *walk_subtrees_p
= 0;
4712 if (TYPE_PTRMEMFUNC_P (*tp
))
4713 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
4716 case TYPE_ARGUMENT_PACK
:
4717 case NONTYPE_ARGUMENT_PACK
:
4719 tree args
= ARGUMENT_PACK_ARGS (*tp
);
4720 int i
, len
= TREE_VEC_LENGTH (args
);
4721 for (i
= 0; i
< len
; i
++)
4722 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
4726 case TYPE_PACK_EXPANSION
:
4727 WALK_SUBTREE (TREE_TYPE (*tp
));
4728 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4729 *walk_subtrees_p
= 0;
4732 case EXPR_PACK_EXPANSION
:
4733 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
4734 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
4735 *walk_subtrees_p
= 0;
4739 case REINTERPRET_CAST_EXPR
:
4740 case STATIC_CAST_EXPR
:
4741 case CONST_CAST_EXPR
:
4742 case DYNAMIC_CAST_EXPR
:
4743 case IMPLICIT_CONV_EXPR
:
4744 if (TREE_TYPE (*tp
))
4745 WALK_SUBTREE (TREE_TYPE (*tp
));
4749 for (i
= 0; i
< TREE_CODE_LENGTH (TREE_CODE (*tp
)); ++i
)
4750 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
4752 *walk_subtrees_p
= 0;
4756 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
4757 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
4758 *walk_subtrees_p
= 0;
4762 WALK_SUBTREE (DECLTYPE_TYPE_EXPR (*tp
));
4763 *walk_subtrees_p
= 0;
4767 // Only recurse through the nested expression. Do not
4768 // walk the parameter list. Doing so causes false
4769 // positives in the pack expansion checker since the
4770 // requires parameters are introduced as pack expansions.
4771 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
4772 *walk_subtrees_p
= 0;
4776 /* User variables should be mentioned in BIND_EXPR_VARS
4777 and their initializers and sizes walked when walking
4778 the containing BIND_EXPR. Compiler temporaries are
4780 if (VAR_P (TREE_OPERAND (*tp
, 0))
4781 && DECL_ARTIFICIAL (TREE_OPERAND (*tp
, 0))
4782 && !TREE_STATIC (TREE_OPERAND (*tp
, 0)))
4784 tree decl
= TREE_OPERAND (*tp
, 0);
4785 WALK_SUBTREE (DECL_INITIAL (decl
));
4786 WALK_SUBTREE (DECL_SIZE (decl
));
4787 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
4795 /* We didn't find what we were looking for. */
4802 /* Like save_expr, but for C++. */
4805 cp_save_expr (tree expr
)
4807 /* There is no reason to create a SAVE_EXPR within a template; if
4808 needed, we can create the SAVE_EXPR when instantiating the
4809 template. Furthermore, the middle-end cannot handle C++-specific
4811 if (processing_template_decl
)
4813 return save_expr (expr
);
4816 /* Initialize tree.c. */
4821 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
4822 register_scoped_attributes (std_attribute_table
, NULL
);
4825 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
4826 is. Note that sfk_none is zero, so this function can be used as a
4827 predicate to test whether or not DECL is a special function. */
4829 special_function_kind
4830 special_function_p (const_tree decl
)
4832 /* Rather than doing all this stuff with magic names, we should
4833 probably have a field of type `special_function_kind' in
4834 DECL_LANG_SPECIFIC. */
4835 if (DECL_INHERITED_CTOR (decl
))
4836 return sfk_inheriting_constructor
;
4837 if (DECL_COPY_CONSTRUCTOR_P (decl
))
4838 return sfk_copy_constructor
;
4839 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
4840 return sfk_move_constructor
;
4841 if (DECL_CONSTRUCTOR_P (decl
))
4842 return sfk_constructor
;
4843 if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
4845 if (copy_fn_p (decl
))
4846 return sfk_copy_assignment
;
4847 if (move_fn_p (decl
))
4848 return sfk_move_assignment
;
4850 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
4851 return sfk_destructor
;
4852 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
4853 return sfk_complete_destructor
;
4854 if (DECL_BASE_DESTRUCTOR_P (decl
))
4855 return sfk_base_destructor
;
4856 if (DECL_DELETING_DESTRUCTOR_P (decl
))
4857 return sfk_deleting_destructor
;
4858 if (DECL_CONV_FN_P (decl
))
4859 return sfk_conversion
;
4860 if (deduction_guide_p (decl
))
4861 return sfk_deduction_guide
;
4866 /* Returns nonzero if TYPE is a character type, including wchar_t. */
4869 char_type_p (tree type
)
4871 return (same_type_p (type
, char_type_node
)
4872 || same_type_p (type
, unsigned_char_type_node
)
4873 || same_type_p (type
, signed_char_type_node
)
4874 || same_type_p (type
, char16_type_node
)
4875 || same_type_p (type
, char32_type_node
)
4876 || same_type_p (type
, wchar_type_node
));
4879 /* Returns the kind of linkage associated with the indicated DECL. Th
4880 value returned is as specified by the language standard; it is
4881 independent of implementation details regarding template
4882 instantiation, etc. For example, it is possible that a declaration
4883 to which this function assigns external linkage would not show up
4884 as a global symbol when you run `nm' on the resulting object file. */
4887 decl_linkage (tree decl
)
4889 /* This function doesn't attempt to calculate the linkage from first
4890 principles as given in [basic.link]. Instead, it makes use of
4891 the fact that we have already set TREE_PUBLIC appropriately, and
4892 then handles a few special cases. Ideally, we would calculate
4893 linkage first, and then transform that into a concrete
4896 /* Things that don't have names have no linkage. */
4897 if (!DECL_NAME (decl
))
4900 /* Fields have no linkage. */
4901 if (TREE_CODE (decl
) == FIELD_DECL
)
4904 /* Things that are TREE_PUBLIC have external linkage. */
4905 if (TREE_PUBLIC (decl
))
4908 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
4909 check one of the "clones" for the real linkage. */
4910 if ((DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
)
4911 || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl
))
4912 && DECL_CHAIN (decl
)
4913 && DECL_CLONED_FUNCTION (DECL_CHAIN (decl
)))
4914 return decl_linkage (DECL_CHAIN (decl
));
4916 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
4919 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
4921 if (TREE_CODE (decl
) == CONST_DECL
)
4922 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
4924 /* Things in local scope do not have linkage, if they don't have
4926 if (decl_function_context (decl
))
4929 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
4930 are considered to have external linkage for language purposes, as do
4931 template instantiations on targets without weak symbols. DECLs really
4932 meant to have internal linkage have DECL_THIS_STATIC set. */
4933 if (TREE_CODE (decl
) == TYPE_DECL
)
4935 if (VAR_OR_FUNCTION_DECL_P (decl
))
4937 if (!DECL_THIS_STATIC (decl
))
4940 /* Static data members and static member functions from classes
4941 in anonymous namespace also don't have TREE_PUBLIC set. */
4942 if (DECL_CLASS_CONTEXT (decl
))
4946 /* Everything else has internal linkage. */
4950 /* Returns the storage duration of the object or reference associated with
4951 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
4954 decl_storage_duration (tree decl
)
4956 if (TREE_CODE (decl
) == PARM_DECL
)
4958 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4960 gcc_assert (VAR_P (decl
));
4961 if (!TREE_STATIC (decl
)
4962 && !DECL_EXTERNAL (decl
))
4964 if (CP_DECL_THREAD_LOCAL_P (decl
))
4969 /* EXP is an expression that we want to pre-evaluate. Returns (in
4970 *INITP) an expression that will perform the pre-evaluation. The
4971 value returned by this function is a side-effect free expression
4972 equivalent to the pre-evaluated expression. Callers must ensure
4973 that *INITP is evaluated before EXP. */
4976 stabilize_expr (tree exp
, tree
* initp
)
4980 if (!TREE_SIDE_EFFECTS (exp
))
4981 init_expr
= NULL_TREE
;
4982 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
4987 /* There are no expressions with REFERENCE_TYPE, but there can be call
4988 arguments with such a type; just treat it as a pointer. */
4989 else if (TREE_CODE (TREE_TYPE (exp
)) == REFERENCE_TYPE
4990 || SCALAR_TYPE_P (TREE_TYPE (exp
))
4991 || !glvalue_p (exp
))
4993 init_expr
= get_target_expr (exp
);
4994 exp
= TARGET_EXPR_SLOT (init_expr
);
4995 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
5002 bool xval
= !lvalue_p (exp
);
5003 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
5004 init_expr
= get_target_expr (exp
);
5005 exp
= TARGET_EXPR_SLOT (init_expr
);
5006 exp
= cp_build_indirect_ref (exp
, RO_NULL
, tf_warning_or_error
);
5012 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
5016 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5017 similar expression ORIG. */
5020 add_stmt_to_compound (tree orig
, tree new_expr
)
5022 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
5024 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
5026 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
5029 /* Like stabilize_expr, but for a call whose arguments we want to
5030 pre-evaluate. CALL is modified in place to use the pre-evaluated
5031 arguments, while, upon return, *INITP contains an expression to
5032 compute the arguments. */
5035 stabilize_call (tree call
, tree
*initp
)
5037 tree inits
= NULL_TREE
;
5039 int nargs
= call_expr_nargs (call
);
5041 if (call
== error_mark_node
|| processing_template_decl
)
5047 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5049 for (i
= 0; i
< nargs
; i
++)
5052 CALL_EXPR_ARG (call
, i
) =
5053 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
5054 inits
= add_stmt_to_compound (inits
, init
);
5060 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5061 to pre-evaluate. CALL is modified in place to use the pre-evaluated
5062 arguments, while, upon return, *INITP contains an expression to
5063 compute the arguments. */
5066 stabilize_aggr_init (tree call
, tree
*initp
)
5068 tree inits
= NULL_TREE
;
5070 int nargs
= aggr_init_expr_nargs (call
);
5072 if (call
== error_mark_node
)
5075 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
5077 for (i
= 0; i
< nargs
; i
++)
5080 AGGR_INIT_EXPR_ARG (call
, i
) =
5081 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
5082 inits
= add_stmt_to_compound (inits
, init
);
5088 /* Like stabilize_expr, but for an initialization.
5090 If the initialization is for an object of class type, this function
5091 takes care not to introduce additional temporaries.
5093 Returns TRUE iff the expression was successfully pre-evaluated,
5094 i.e., if INIT is now side-effect free, except for, possibly, a
5095 single call to a constructor. */
5098 stabilize_init (tree init
, tree
*initp
)
5104 if (t
== error_mark_node
|| processing_template_decl
)
5107 if (TREE_CODE (t
) == INIT_EXPR
)
5108 t
= TREE_OPERAND (t
, 1);
5109 if (TREE_CODE (t
) == TARGET_EXPR
)
5110 t
= TARGET_EXPR_INITIAL (t
);
5112 /* If the RHS can be stabilized without breaking copy elision, stabilize
5113 it. We specifically don't stabilize class prvalues here because that
5114 would mean an extra copy, but they might be stabilized below. */
5115 if (TREE_CODE (init
) == INIT_EXPR
5116 && TREE_CODE (t
) != CONSTRUCTOR
5117 && TREE_CODE (t
) != AGGR_INIT_EXPR
5118 && (SCALAR_TYPE_P (TREE_TYPE (t
))
5121 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
5125 if (TREE_CODE (t
) == COMPOUND_EXPR
5126 && TREE_CODE (init
) == INIT_EXPR
)
5128 tree last
= expr_last (t
);
5129 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
5130 if (!TREE_SIDE_EFFECTS (last
))
5133 TREE_OPERAND (init
, 1) = last
;
5138 if (TREE_CODE (t
) == CONSTRUCTOR
)
5140 /* Aggregate initialization: stabilize each of the field
5143 constructor_elt
*ce
;
5145 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5146 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5148 tree type
= TREE_TYPE (ce
->value
);
5150 if (TREE_CODE (type
) == REFERENCE_TYPE
5151 || SCALAR_TYPE_P (type
))
5152 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
5153 else if (!stabilize_init (ce
->value
, &subinit
))
5155 *initp
= add_stmt_to_compound (*initp
, subinit
);
5160 if (TREE_CODE (t
) == CALL_EXPR
)
5162 stabilize_call (t
, initp
);
5166 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5168 stabilize_aggr_init (t
, initp
);
5172 /* The initialization is being performed via a bitwise copy -- and
5173 the item copied may have side effects. */
5174 return !TREE_SIDE_EFFECTS (init
);
5177 /* Returns true if a cast to TYPE may appear in an integral constant
5181 cast_valid_in_integral_constant_expression_p (tree type
)
5183 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
5184 || cxx_dialect
>= cxx11
5185 || dependent_type_p (type
)
5186 || type
== error_mark_node
);
5189 /* Return true if we need to fix linkage information of DECL. */
5192 cp_fix_function_decl_p (tree decl
)
5194 /* Skip if DECL is not externally visible. */
5195 if (!TREE_PUBLIC (decl
))
5198 /* We need to fix DECL if it a appears to be exported but with no
5199 function body. Thunks do not have CFGs and we may need to
5200 handle them specially later. */
5201 if (!gimple_has_body_p (decl
)
5202 && !DECL_THUNK_P (decl
)
5203 && !DECL_EXTERNAL (decl
))
5205 struct cgraph_node
*node
= cgraph_node::get (decl
);
5207 /* Don't fix same_body aliases. Although they don't have their own
5208 CFG, they share it with what they alias to. */
5209 if (!node
|| !node
->alias
5210 || !vec_safe_length (node
->ref_list
.references
))
5217 /* Clean the C++ specific parts of the tree T. */
5220 cp_free_lang_data (tree t
)
5222 if (TREE_CODE (t
) == METHOD_TYPE
5223 || TREE_CODE (t
) == FUNCTION_TYPE
)
5225 /* Default args are not interesting anymore. */
5226 tree argtypes
= TYPE_ARG_TYPES (t
);
5229 TREE_PURPOSE (argtypes
) = 0;
5230 argtypes
= TREE_CHAIN (argtypes
);
5233 else if (TREE_CODE (t
) == FUNCTION_DECL
5234 && cp_fix_function_decl_p (t
))
5236 /* If T is used in this translation unit at all, the definition
5237 must exist somewhere else since we have decided to not emit it
5238 in this TU. So make it an external reference. */
5239 DECL_EXTERNAL (t
) = 1;
5240 TREE_STATIC (t
) = 0;
5242 if (TREE_CODE (t
) == NAMESPACE_DECL
)
5243 /* We do not need the leftover chaining of namespaces from the
5245 DECL_CHAIN (t
) = NULL_TREE
;
5248 /* Stub for c-common. Please keep in sync with c-decl.c.
5249 FIXME: If address space support is target specific, then this
5250 should be a C target hook. But currently this is not possible,
5251 because this function is called via REGISTER_TARGET_PRAGMAS. */
5253 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
5257 /* Return the number of operands in T that we care about for things like
5261 cp_tree_operand_length (const_tree t
)
5263 enum tree_code code
= TREE_CODE (t
);
5265 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
5266 return VL_EXP_OPERAND_LENGTH (t
);
5268 return cp_tree_code_length (code
);
5271 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
5274 cp_tree_code_length (enum tree_code code
)
5276 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
5280 case PREINCREMENT_EXPR
:
5281 case PREDECREMENT_EXPR
:
5282 case POSTINCREMENT_EXPR
:
5283 case POSTDECREMENT_EXPR
:
5289 case EXPR_PACK_EXPANSION
:
5293 return TREE_CODE_LENGTH (code
);
5297 /* Implement -Wzero_as_null_pointer_constant. Return true if the
5298 conditions for the warning hold, false otherwise. */
5300 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
5302 if (c_inhibit_evaluation_warnings
== 0
5303 && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
5305 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
5306 "zero as null pointer constant");
5312 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
5313 /* Complain that some language-specific thing hanging off a tree
5314 node has been accessed improperly. */
5317 lang_check_failed (const char* file
, int line
, const char* function
)
5319 internal_error ("lang_* check: failed in %s, at %s:%d",
5320 function
, trim_filename (file
), line
);
5322 #endif /* ENABLE_TREE_CHECKING */
5324 #include "gt-cp-tree.h"