1 /* Language-dependent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987-2020 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"
40 static tree
bot_manip (tree
*, int *, void *);
41 static tree
bot_replace (tree
*, int *, void *);
42 static hashval_t
list_hash_pieces (tree
, tree
, tree
);
43 static tree
build_target_expr (tree
, tree
, tsubst_flags_t
);
44 static tree
count_trees_r (tree
*, int *, void *);
45 static tree
verify_stmt_tree_r (tree
*, int *, void *);
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 && TYPE_REF_P (TREE_TYPE (ref
)))
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
)
77 op1_lvalue_kind
= clk_rvalueref
;
78 if (implicit_rvalue_p (ref
))
79 op1_lvalue_kind
|= clk_implicit_rval
;
80 return op1_lvalue_kind
;
83 /* lvalue references and named rvalue references are lvalues. */
87 if (ref
== current_class_ptr
)
90 /* Expressions with cv void type are prvalues. */
91 if (TREE_TYPE (ref
) && VOID_TYPE_P (TREE_TYPE (ref
)))
94 switch (TREE_CODE (ref
))
99 /* preincrements and predecrements are valid lvals, provided
100 what they refer to are valid lvals. */
101 case PREINCREMENT_EXPR
:
102 case PREDECREMENT_EXPR
:
106 case VIEW_CONVERT_EXPR
:
107 return lvalue_kind (TREE_OPERAND (ref
, 0));
111 tree op1
= TREE_OPERAND (ref
, 0);
112 if (TREE_CODE (TREE_TYPE (op1
)) == ARRAY_TYPE
)
114 op1_lvalue_kind
= lvalue_kind (op1
);
115 if (op1_lvalue_kind
== clk_class
)
116 /* in the case of an array operand, the result is an lvalue if
117 that operand is an lvalue and an xvalue otherwise */
118 op1_lvalue_kind
= clk_rvalueref
;
119 return op1_lvalue_kind
;
127 if (TREE_CODE (ref
) == MEMBER_REF
)
128 op1_lvalue_kind
= clk_ordinary
;
130 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
131 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref
, 1))))
132 op1_lvalue_kind
= clk_none
;
133 else if (op1_lvalue_kind
== clk_class
)
134 /* The result of a .* expression whose second operand is a pointer to a
135 data member is an lvalue if the first operand is an lvalue and an
137 op1_lvalue_kind
= clk_rvalueref
;
138 return op1_lvalue_kind
;
141 if (BASELINK_P (TREE_OPERAND (ref
, 1)))
143 tree fn
= BASELINK_FUNCTIONS (TREE_OPERAND (ref
, 1));
145 /* For static member function recurse on the BASELINK, we can get
146 here e.g. from reference_binding. If BASELINK_FUNCTIONS is
147 OVERLOAD, the overload is resolved first if possible through
148 resolve_address_of_overloaded_function. */
149 if (TREE_CODE (fn
) == FUNCTION_DECL
&& DECL_STATIC_FUNCTION_P (fn
))
150 return lvalue_kind (TREE_OPERAND (ref
, 1));
152 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
153 if (op1_lvalue_kind
== clk_class
)
154 /* If E1 is an lvalue, then E1.E2 is an lvalue;
155 otherwise E1.E2 is an xvalue. */
156 op1_lvalue_kind
= clk_rvalueref
;
158 /* Look at the member designator. */
159 if (!op1_lvalue_kind
)
161 else if (is_overloaded_fn (TREE_OPERAND (ref
, 1)))
162 /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
163 situations. If we're seeing a COMPONENT_REF, it's a non-static
164 member, so it isn't an lvalue. */
165 op1_lvalue_kind
= clk_none
;
166 else if (TREE_CODE (TREE_OPERAND (ref
, 1)) != FIELD_DECL
)
167 /* This can be IDENTIFIER_NODE in a template. */;
168 else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref
, 1)))
170 /* Clear the ordinary bit. If this object was a class
171 rvalue we want to preserve that information. */
172 op1_lvalue_kind
&= ~clk_ordinary
;
173 /* The lvalue is for a bitfield. */
174 op1_lvalue_kind
|= clk_bitfield
;
176 else if (DECL_PACKED (TREE_OPERAND (ref
, 1)))
177 op1_lvalue_kind
|= clk_packed
;
179 return op1_lvalue_kind
;
182 case COMPOUND_LITERAL_EXPR
:
186 /* CONST_DECL without TREE_STATIC are enumeration values and
187 thus not lvalues. With TREE_STATIC they are used by ObjC++
188 in objc_build_string_object and need to be considered as
190 if (! TREE_STATIC (ref
))
194 if (VAR_P (ref
) && DECL_HAS_VALUE_EXPR_P (ref
))
195 return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref
)));
197 if (TREE_READONLY (ref
) && ! TREE_STATIC (ref
)
198 && DECL_LANG_SPECIFIC (ref
)
199 && DECL_IN_AGGR_P (ref
))
206 case PLACEHOLDER_EXPR
:
209 /* A scope ref in a template, left as SCOPE_REF to support later
212 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
214 tree op
= TREE_OPERAND (ref
, 1);
215 if (TREE_CODE (op
) == FIELD_DECL
)
216 return (DECL_C_BIT_FIELD (op
) ? clk_bitfield
: clk_ordinary
);
218 return lvalue_kind (op
);
223 /* Disallow <? and >? as lvalues if either argument side-effects. */
224 if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 0))
225 || TREE_SIDE_EFFECTS (TREE_OPERAND (ref
, 1)))
227 op1_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 0));
228 op2_lvalue_kind
= lvalue_kind (TREE_OPERAND (ref
, 1));
232 if (processing_template_decl
)
234 /* Within templates, a REFERENCE_TYPE will indicate whether
235 the COND_EXPR result is an ordinary lvalue or rvalueref.
236 Since REFERENCE_TYPEs are handled above, if we reach this
237 point, we know we got a plain rvalue. Unless we have a
238 type-dependent expr, that is, but we shouldn't be testing
239 lvalueness if we can't even tell the types yet! */
240 gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref
)));
244 tree op1
= TREE_OPERAND (ref
, 1);
245 if (!op1
) op1
= TREE_OPERAND (ref
, 0);
246 tree op2
= TREE_OPERAND (ref
, 2);
247 op1_lvalue_kind
= lvalue_kind (op1
);
248 op2_lvalue_kind
= lvalue_kind (op2
);
249 if (!op1_lvalue_kind
!= !op2_lvalue_kind
)
251 /* The second or the third operand (but not both) is a
252 throw-expression; the result is of the type
253 and value category of the other. */
254 if (op1_lvalue_kind
&& TREE_CODE (op2
) == THROW_EXPR
)
255 op2_lvalue_kind
= op1_lvalue_kind
;
256 else if (op2_lvalue_kind
&& TREE_CODE (op1
) == THROW_EXPR
)
257 op1_lvalue_kind
= op2_lvalue_kind
;
263 /* We expect to see unlowered MODOP_EXPRs only during
264 template processing. */
265 gcc_assert (processing_template_decl
);
273 return lvalue_kind (TREE_OPERAND (ref
, 1));
279 return (CLASS_TYPE_P (TREE_TYPE (ref
)) ? clk_class
: clk_none
);
282 /* We can see calls outside of TARGET_EXPR in templates. */
283 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
288 /* All functions (except non-static-member functions) are
290 return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref
)
291 ? clk_none
: clk_ordinary
);
294 /* We now represent a reference to a single static member function
296 /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
297 its argument unmodified and we assign it to a const_tree. */
298 return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref
)));
300 case NON_DEPENDENT_EXPR
:
302 return lvalue_kind (TREE_OPERAND (ref
, 0));
304 case TEMPLATE_PARM_INDEX
:
305 if (CLASS_TYPE_P (TREE_TYPE (ref
)))
306 /* A template parameter object is an lvalue. */
312 if (!TREE_TYPE (ref
))
314 if (CLASS_TYPE_P (TREE_TYPE (ref
))
315 || TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
)
320 /* If one operand is not an lvalue at all, then this expression is
322 if (!op1_lvalue_kind
|| !op2_lvalue_kind
)
325 /* Otherwise, it's an lvalue, and it has all the odd properties
326 contributed by either operand. */
327 op1_lvalue_kind
= op1_lvalue_kind
| op2_lvalue_kind
;
328 /* It's not an ordinary lvalue if it involves any other kind. */
329 if ((op1_lvalue_kind
& ~clk_ordinary
) != clk_none
)
330 op1_lvalue_kind
&= ~clk_ordinary
;
331 /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
332 A COND_EXPR of those should be wrapped in a TARGET_EXPR. */
333 if ((op1_lvalue_kind
& (clk_rvalueref
|clk_class
))
334 && (op1_lvalue_kind
& (clk_bitfield
|clk_packed
)))
335 op1_lvalue_kind
= clk_none
;
336 return op1_lvalue_kind
;
339 /* Returns the kind of lvalue that REF is, in the sense of [basic.lval]. */
342 real_lvalue_p (const_tree ref
)
344 cp_lvalue_kind kind
= lvalue_kind (ref
);
345 if (kind
& (clk_rvalueref
|clk_class
))
351 /* c-common wants us to return bool. */
354 lvalue_p (const_tree t
)
356 return real_lvalue_p (t
);
359 /* This differs from lvalue_p in that xvalues are included. */
362 glvalue_p (const_tree ref
)
364 cp_lvalue_kind kind
= lvalue_kind (ref
);
365 if (kind
& clk_class
)
368 return (kind
!= clk_none
);
371 /* This differs from glvalue_p in that class prvalues are included. */
374 obvalue_p (const_tree ref
)
376 return (lvalue_kind (ref
) != clk_none
);
379 /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
380 reference), false otherwise. */
383 xvalue_p (const_tree ref
)
385 return (lvalue_kind (ref
) == clk_rvalueref
);
388 /* True if REF is a bit-field. */
391 bitfield_p (const_tree ref
)
393 return (lvalue_kind (ref
) & clk_bitfield
);
396 /* C++-specific version of stabilize_reference. */
399 cp_stabilize_reference (tree ref
)
401 STRIP_ANY_LOCATION_WRAPPER (ref
);
402 switch (TREE_CODE (ref
))
404 case NON_DEPENDENT_EXPR
:
405 /* We aren't actually evaluating this. */
408 /* We need to treat specially anything stabilize_reference doesn't
409 handle specifically. */
420 case ARRAY_RANGE_REF
:
424 cp_lvalue_kind kind
= lvalue_kind (ref
);
425 if ((kind
& ~clk_class
) != clk_none
)
427 tree type
= unlowered_expr_type (ref
);
428 bool rval
= !!(kind
& clk_rvalueref
);
429 type
= cp_build_reference_type (type
, rval
);
430 /* This inhibits warnings in, eg, cxx_mark_addressable
432 warning_sentinel
s (extra_warnings
);
433 ref
= build_static_cast (input_location
, type
, ref
,
438 return stabilize_reference (ref
);
441 /* Test whether DECL is a builtin that may appear in a
442 constant-expression. */
445 builtin_valid_in_constant_expr_p (const_tree decl
)
447 STRIP_ANY_LOCATION_WRAPPER (decl
);
448 if (TREE_CODE (decl
) != FUNCTION_DECL
)
449 /* Not a function. */
451 if (DECL_BUILT_IN_CLASS (decl
) != BUILT_IN_NORMAL
)
453 if (fndecl_built_in_p (decl
, CP_BUILT_IN_IS_CONSTANT_EVALUATED
,
455 || fndecl_built_in_p (decl
, CP_BUILT_IN_SOURCE_LOCATION
,
458 /* Not a built-in. */
461 switch (DECL_FUNCTION_CODE (decl
))
463 /* These always have constant results like the corresponding
466 case BUILT_IN_FUNCTION
:
469 /* The following built-ins are valid in constant expressions
470 when their arguments are. */
471 case BUILT_IN_ADD_OVERFLOW_P
:
472 case BUILT_IN_SUB_OVERFLOW_P
:
473 case BUILT_IN_MUL_OVERFLOW_P
:
475 /* These have constant results even if their operands are
477 case BUILT_IN_CONSTANT_P
:
478 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE
:
485 /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */
488 build_target_expr (tree decl
, tree value
, tsubst_flags_t complain
)
491 tree type
= TREE_TYPE (decl
);
493 value
= mark_rvalue_use (value
);
495 gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value
))
496 || TREE_TYPE (decl
) == TREE_TYPE (value
)
497 /* On ARM ctors return 'this'. */
498 || (TYPE_PTR_P (TREE_TYPE (value
))
499 && TREE_CODE (value
) == CALL_EXPR
)
500 || useless_type_conversion_p (TREE_TYPE (decl
),
503 /* Set TREE_READONLY for optimization, such as gimplify_init_constructor
504 moving a constant aggregate into .rodata. */
505 if (CP_TYPE_CONST_NON_VOLATILE_P (type
)
506 && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
507 && !VOID_TYPE_P (TREE_TYPE (value
))
508 && reduced_constant_expression_p (value
))
509 TREE_READONLY (decl
) = true;
511 if (complain
& tf_no_cleanup
)
512 /* The caller is building a new-expr and does not need a cleanup. */
516 t
= cxx_maybe_build_cleanup (decl
, complain
);
517 if (t
== error_mark_node
)
518 return error_mark_node
;
520 t
= build4 (TARGET_EXPR
, type
, decl
, value
, t
, NULL_TREE
);
521 if (location_t eloc
= cp_expr_location (value
))
522 SET_EXPR_LOCATION (t
, eloc
);
523 /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
524 ignore the TARGET_EXPR. If there really turn out to be no
525 side-effects, then the optimizer should be able to get rid of
526 whatever code is generated anyhow. */
527 TREE_SIDE_EFFECTS (t
) = 1;
532 /* Return an undeclared local temporary of type TYPE for use in building a
536 build_local_temp (tree type
)
538 tree slot
= build_decl (input_location
,
539 VAR_DECL
, NULL_TREE
, type
);
540 DECL_ARTIFICIAL (slot
) = 1;
541 DECL_IGNORED_P (slot
) = 1;
542 DECL_CONTEXT (slot
) = current_function_decl
;
543 layout_decl (slot
, 0);
547 /* Return whether DECL is such a local temporary (or one from
548 create_tmp_var_raw). */
551 is_local_temp (tree decl
)
553 return (VAR_P (decl
) && DECL_ARTIFICIAL (decl
)
554 && !TREE_STATIC (decl
)
555 && DECL_FUNCTION_SCOPE_P (decl
));
558 /* Set various status flags when building an AGGR_INIT_EXPR object T. */
561 process_aggr_init_operands (tree t
)
565 side_effects
= TREE_SIDE_EFFECTS (t
);
569 n
= TREE_OPERAND_LENGTH (t
);
570 for (i
= 1; i
< n
; i
++)
572 tree op
= TREE_OPERAND (t
, i
);
573 if (op
&& TREE_SIDE_EFFECTS (op
))
580 TREE_SIDE_EFFECTS (t
) = side_effects
;
583 /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
584 FN, and SLOT. NARGS is the number of call arguments which are specified
585 as a tree array ARGS. */
588 build_aggr_init_array (tree return_type
, tree fn
, tree slot
, int nargs
,
594 t
= build_vl_exp (AGGR_INIT_EXPR
, nargs
+ 3);
595 TREE_TYPE (t
) = return_type
;
596 AGGR_INIT_EXPR_FN (t
) = fn
;
597 AGGR_INIT_EXPR_SLOT (t
) = slot
;
598 for (i
= 0; i
< nargs
; i
++)
599 AGGR_INIT_EXPR_ARG (t
, i
) = args
[i
];
600 process_aggr_init_operands (t
);
604 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
605 target. TYPE is the type to be initialized.
607 Build an AGGR_INIT_EXPR to represent the initialization. This function
608 differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
609 to initialize another object, whereas a TARGET_EXPR can either
610 initialize another object or create its own temporary object, and as a
611 result building up a TARGET_EXPR requires that the type's destructor be
615 build_aggr_init_expr (tree type
, tree init
)
622 gcc_assert (!VOID_TYPE_P (type
));
624 /* Don't build AGGR_INIT_EXPR in a template. */
625 if (processing_template_decl
)
628 fn
= cp_get_callee (init
);
630 return convert (type
, init
);
632 is_ctor
= (TREE_CODE (fn
) == ADDR_EXPR
633 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
634 && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn
, 0)));
636 /* We split the CALL_EXPR into its function and its arguments here.
637 Then, in expand_expr, we put them back together. The reason for
638 this is that this expression might be a default argument
639 expression. In that case, we need a new temporary every time the
640 expression is used. That's what break_out_target_exprs does; it
641 replaces every AGGR_INIT_EXPR with a copy that uses a fresh
642 temporary slot. Then, expand_expr builds up a call-expression
643 using the new slot. */
645 /* If we don't need to use a constructor to create an object of this
646 type, don't mess with AGGR_INIT_EXPR. */
647 if (is_ctor
|| TREE_ADDRESSABLE (type
))
649 slot
= build_local_temp (type
);
651 if (TREE_CODE (init
) == CALL_EXPR
)
653 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
654 call_expr_nargs (init
),
655 CALL_EXPR_ARGP (init
));
656 AGGR_INIT_FROM_THUNK_P (rval
)
657 = CALL_FROM_THUNK_P (init
);
661 rval
= build_aggr_init_array (void_type_node
, fn
, slot
,
662 aggr_init_expr_nargs (init
),
663 AGGR_INIT_EXPR_ARGP (init
));
664 AGGR_INIT_FROM_THUNK_P (rval
)
665 = AGGR_INIT_FROM_THUNK_P (init
);
667 TREE_SIDE_EFFECTS (rval
) = 1;
668 AGGR_INIT_VIA_CTOR_P (rval
) = is_ctor
;
669 TREE_NOTHROW (rval
) = TREE_NOTHROW (init
);
670 CALL_EXPR_OPERATOR_SYNTAX (rval
) = CALL_EXPR_OPERATOR_SYNTAX (init
);
671 CALL_EXPR_ORDERED_ARGS (rval
) = CALL_EXPR_ORDERED_ARGS (init
);
672 CALL_EXPR_REVERSE_ARGS (rval
) = CALL_EXPR_REVERSE_ARGS (init
);
677 if (location_t loc
= EXPR_LOCATION (init
))
678 SET_EXPR_LOCATION (rval
, loc
);
683 /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
684 target. TYPE is the type that this initialization should appear to
687 Build an encapsulation of the initialization to perform
688 and return it so that it can be processed by language-independent
689 and language-specific expression expanders. */
692 build_cplus_new (tree type
, tree init
, tsubst_flags_t complain
)
694 /* This function should cope with what build_special_member_call
695 can produce. When performing parenthesized aggregate initialization,
696 it can produce a { }. */
697 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
699 gcc_assert (cxx_dialect
>= cxx20
);
700 return finish_compound_literal (type
, init
, complain
);
703 tree rval
= build_aggr_init_expr (type
, init
);
706 if (init
== error_mark_node
)
707 return error_mark_node
;
709 if (!complete_type_or_maybe_complain (type
, init
, complain
))
710 return error_mark_node
;
712 /* Make sure that we're not trying to create an instance of an
714 if (abstract_virtuals_error_sfinae (NULL_TREE
, type
, complain
))
715 return error_mark_node
;
717 if (TREE_CODE (rval
) == AGGR_INIT_EXPR
)
718 slot
= AGGR_INIT_EXPR_SLOT (rval
);
719 else if (TREE_CODE (rval
) == CALL_EXPR
720 || TREE_CODE (rval
) == CONSTRUCTOR
)
721 slot
= build_local_temp (type
);
725 rval
= build_target_expr (slot
, rval
, complain
);
727 if (rval
!= error_mark_node
)
728 TARGET_EXPR_IMPLICIT_P (rval
) = 1;
733 /* Subroutine of build_vec_init_expr: Build up a single element
734 intialization as a proxy for the full array initialization to get things
735 marked as used and any appropriate diagnostics.
737 Since we're deferring building the actual constructor calls until
738 gimplification time, we need to build one now and throw it away so
739 that the relevant constructor gets mark_used before cgraph decides
740 what functions are needed. Here we assume that init is either
741 NULL_TREE, void_type_node (indicating value-initialization), or
742 another array to copy. */
745 build_vec_init_elt (tree type
, tree init
, tsubst_flags_t complain
)
747 tree inner_type
= strip_array_types (type
);
749 if (integer_zerop (array_type_nelts_total (type
))
750 || !CLASS_TYPE_P (inner_type
))
751 /* No interesting initialization to do. */
752 return integer_zero_node
;
753 else if (init
== void_type_node
)
754 return build_value_init (inner_type
, complain
);
756 gcc_assert (init
== NULL_TREE
757 || (same_type_ignoring_top_level_qualifiers_p
758 (type
, TREE_TYPE (init
))));
760 releasing_vec argvec
;
763 tree init_type
= strip_array_types (TREE_TYPE (init
));
764 tree dummy
= build_dummy_object (init_type
);
765 if (!lvalue_p (init
))
766 dummy
= move (dummy
);
767 argvec
->quick_push (dummy
);
769 init
= build_special_member_call (NULL_TREE
, complete_ctor_identifier
,
770 &argvec
, inner_type
, LOOKUP_NORMAL
,
773 /* For a trivial constructor, build_over_call creates a TARGET_EXPR. But
774 we don't want one here because we aren't creating a temporary. */
775 if (TREE_CODE (init
) == TARGET_EXPR
)
776 init
= TARGET_EXPR_INITIAL (init
);
781 /* Return a TARGET_EXPR which expresses the initialization of an array to
782 be named later, either default-initialization or copy-initialization
783 from another array of the same type. */
786 build_vec_init_expr (tree type
, tree init
, tsubst_flags_t complain
)
789 bool value_init
= false;
790 tree elt_init
= build_vec_init_elt (type
, init
, complain
);
792 if (init
== void_type_node
)
798 slot
= build_local_temp (type
);
799 init
= build2 (VEC_INIT_EXPR
, type
, slot
, init
);
800 TREE_SIDE_EFFECTS (init
) = true;
801 SET_EXPR_LOCATION (init
, input_location
);
803 if (cxx_dialect
>= cxx11
804 && potential_constant_expression (elt_init
))
805 VEC_INIT_EXPR_IS_CONSTEXPR (init
) = true;
806 VEC_INIT_EXPR_VALUE_INIT (init
) = value_init
;
811 /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
812 that requires a constant expression. */
815 diagnose_non_constexpr_vec_init (tree expr
)
817 tree type
= TREE_TYPE (VEC_INIT_EXPR_SLOT (expr
));
819 if (VEC_INIT_EXPR_VALUE_INIT (expr
))
820 init
= void_type_node
;
822 init
= VEC_INIT_EXPR_INIT (expr
);
824 elt_init
= build_vec_init_elt (type
, init
, tf_warning_or_error
);
825 require_potential_constant_expression (elt_init
);
829 build_array_copy (tree init
)
831 return build_vec_init_expr (TREE_TYPE (init
), init
, tf_warning_or_error
);
834 /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
838 build_target_expr_with_type (tree init
, tree type
, tsubst_flags_t complain
)
840 gcc_assert (!VOID_TYPE_P (type
));
842 if (TREE_CODE (init
) == TARGET_EXPR
843 || init
== error_mark_node
)
845 else if (CLASS_TYPE_P (type
) && type_has_nontrivial_copy_init (type
)
846 && !VOID_TYPE_P (TREE_TYPE (init
))
847 && TREE_CODE (init
) != COND_EXPR
848 && TREE_CODE (init
) != CONSTRUCTOR
849 && TREE_CODE (init
) != VA_ARG_EXPR
)
850 /* We need to build up a copy constructor call. A void initializer
851 means we're being called from bot_manip. COND_EXPR is a special
852 case because we already have copies on the arms and we don't want
853 another one here. A CONSTRUCTOR is aggregate initialization, which
854 is handled separately. A VA_ARG_EXPR is magic creation of an
855 aggregate; there's no additional work to be done. */
856 return force_rvalue (init
, complain
);
858 return force_target_expr (type
, init
, complain
);
861 /* Like the above function, but without the checking. This function should
862 only be used by code which is deliberately trying to subvert the type
863 system, such as call_builtin_trap. Or build_over_call, to avoid
864 infinite recursion. */
867 force_target_expr (tree type
, tree init
, tsubst_flags_t complain
)
871 gcc_assert (!VOID_TYPE_P (type
));
873 slot
= build_local_temp (type
);
874 return build_target_expr (slot
, init
, complain
);
877 /* Like build_target_expr_with_type, but use the type of INIT. */
880 get_target_expr_sfinae (tree init
, tsubst_flags_t complain
)
882 if (TREE_CODE (init
) == AGGR_INIT_EXPR
)
883 return build_target_expr (AGGR_INIT_EXPR_SLOT (init
), init
, complain
);
884 else if (TREE_CODE (init
) == VEC_INIT_EXPR
)
885 return build_target_expr (VEC_INIT_EXPR_SLOT (init
), init
, complain
);
888 init
= convert_bitfield_to_declared_type (init
);
889 return build_target_expr_with_type (init
, TREE_TYPE (init
), complain
);
894 get_target_expr (tree init
)
896 return get_target_expr_sfinae (init
, tf_warning_or_error
);
899 /* If EXPR is a bitfield reference, convert it to the declared type of
900 the bitfield, and return the resulting expression. Otherwise,
901 return EXPR itself. */
904 convert_bitfield_to_declared_type (tree expr
)
908 bitfield_type
= is_bitfield_expr_with_lowered_type (expr
);
910 expr
= convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type
),
915 /* EXPR is being used in an rvalue context. Return a version of EXPR
916 that is marked as an rvalue. */
923 if (error_operand_p (expr
))
926 expr
= mark_rvalue_use (expr
);
930 Non-class rvalues always have cv-unqualified types. */
931 type
= TREE_TYPE (expr
);
932 if (!CLASS_TYPE_P (type
) && cv_qualified_p (type
))
933 type
= cv_unqualified (type
);
935 /* We need to do this for rvalue refs as well to get the right answer
936 from decltype; see c++/36628. */
937 if (!processing_template_decl
&& glvalue_p (expr
))
938 expr
= build1 (NON_LVALUE_EXPR
, type
, expr
);
939 else if (type
!= TREE_TYPE (expr
))
940 expr
= build_nop (type
, expr
);
946 struct cplus_array_info
952 struct cplus_array_hasher
: ggc_ptr_hash
<tree_node
>
954 typedef cplus_array_info
*compare_type
;
956 static hashval_t
hash (tree t
);
957 static bool equal (tree
, cplus_array_info
*);
960 /* Hash an ARRAY_TYPE. K is really of type `tree'. */
963 cplus_array_hasher::hash (tree t
)
967 hash
= TYPE_UID (TREE_TYPE (t
));
969 hash
^= TYPE_UID (TYPE_DOMAIN (t
));
973 /* Compare two ARRAY_TYPEs. K1 is really of type `tree', K2 is really
974 of type `cplus_array_info*'. */
977 cplus_array_hasher::equal (tree t1
, cplus_array_info
*t2
)
979 return (TREE_TYPE (t1
) == t2
->type
&& TYPE_DOMAIN (t1
) == t2
->domain
);
982 /* Hash table containing dependent array types, which are unsuitable for
983 the language-independent type hash table. */
984 static GTY (()) hash_table
<cplus_array_hasher
> *cplus_array_htab
;
986 /* Build an ARRAY_TYPE without laying it out. */
989 build_min_array_type (tree elt_type
, tree index_type
)
991 tree t
= cxx_make_type (ARRAY_TYPE
);
992 TREE_TYPE (t
) = elt_type
;
993 TYPE_DOMAIN (t
) = index_type
;
997 /* Set TYPE_CANONICAL like build_array_type_1, but using
998 build_cplus_array_type. */
1001 set_array_type_canon (tree t
, tree elt_type
, tree index_type
)
1003 /* Set the canonical type for this new node. */
1004 if (TYPE_STRUCTURAL_EQUALITY_P (elt_type
)
1005 || (index_type
&& TYPE_STRUCTURAL_EQUALITY_P (index_type
)))
1006 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1007 else if (TYPE_CANONICAL (elt_type
) != elt_type
1008 || (index_type
&& TYPE_CANONICAL (index_type
) != index_type
))
1010 = build_cplus_array_type (TYPE_CANONICAL (elt_type
),
1012 ? TYPE_CANONICAL (index_type
) : index_type
);
1014 TYPE_CANONICAL (t
) = t
;
1017 /* Like build_array_type, but handle special C++ semantics: an array of a
1018 variant element type is a variant of the array of the main variant of
1019 the element type. */
1022 build_cplus_array_type (tree elt_type
, tree index_type
)
1026 if (elt_type
== error_mark_node
|| index_type
== error_mark_node
)
1027 return error_mark_node
;
1029 bool dependent
= (uses_template_parms (elt_type
)
1030 || (index_type
&& uses_template_parms (index_type
)));
1032 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1033 /* Start with an array of the TYPE_MAIN_VARIANT. */
1034 t
= build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type
),
1038 /* Since type_hash_canon calls layout_type, we need to use our own
1040 cplus_array_info cai
;
1043 if (cplus_array_htab
== NULL
)
1044 cplus_array_htab
= hash_table
<cplus_array_hasher
>::create_ggc (61);
1046 hash
= TYPE_UID (elt_type
);
1048 hash
^= TYPE_UID (index_type
);
1049 cai
.type
= elt_type
;
1050 cai
.domain
= index_type
;
1052 tree
*e
= cplus_array_htab
->find_slot_with_hash (&cai
, hash
, INSERT
);
1054 /* We have found the type: we're done. */
1058 /* Build a new array type. */
1059 t
= build_min_array_type (elt_type
, index_type
);
1061 /* Store it in the hash table. */
1064 /* Set the canonical type for this new node. */
1065 set_array_type_canon (t
, elt_type
, index_type
);
1070 bool typeless_storage
= is_byte_access_type (elt_type
);
1071 t
= build_array_type (elt_type
, index_type
, typeless_storage
);
1074 /* Now check whether we already have this array variant. */
1075 if (elt_type
!= TYPE_MAIN_VARIANT (elt_type
))
1078 for (t
= m
; t
; t
= TYPE_NEXT_VARIANT (t
))
1079 if (TREE_TYPE (t
) == elt_type
1080 && TYPE_NAME (t
) == NULL_TREE
1081 && TYPE_ATTRIBUTES (t
) == NULL_TREE
)
1085 t
= build_min_array_type (elt_type
, index_type
);
1086 set_array_type_canon (t
, elt_type
, index_type
);
1090 /* Make sure sizes are shared with the main variant.
1091 layout_type can't be called after setting TYPE_NEXT_VARIANT,
1092 as it will overwrite alignment etc. of all variants. */
1093 TYPE_SIZE (t
) = TYPE_SIZE (m
);
1094 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (m
);
1095 TYPE_TYPELESS_STORAGE (t
) = TYPE_TYPELESS_STORAGE (m
);
1098 TYPE_MAIN_VARIANT (t
) = m
;
1099 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
1100 TYPE_NEXT_VARIANT (m
) = t
;
1104 /* Avoid spurious warnings with VLAs (c++/54583). */
1105 if (TYPE_SIZE (t
) && EXPR_P (TYPE_SIZE (t
)))
1106 TREE_NO_WARNING (TYPE_SIZE (t
)) = 1;
1108 /* Push these needs up to the ARRAY_TYPE so that initialization takes
1109 place more easily. */
1110 bool needs_ctor
= (TYPE_NEEDS_CONSTRUCTING (t
)
1111 = TYPE_NEEDS_CONSTRUCTING (elt_type
));
1112 bool needs_dtor
= (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1113 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
));
1115 if (!dependent
&& t
== TYPE_MAIN_VARIANT (t
)
1116 && !COMPLETE_TYPE_P (t
) && COMPLETE_TYPE_P (elt_type
))
1118 /* The element type has been completed since the last time we saw
1119 this array type; update the layout and 'tor flags for any variants
1122 for (tree v
= TYPE_NEXT_VARIANT (t
); v
; v
= TYPE_NEXT_VARIANT (v
))
1124 TYPE_NEEDS_CONSTRUCTING (v
) = needs_ctor
;
1125 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v
) = needs_dtor
;
1132 /* Return an ARRAY_TYPE with element type ELT and length N. */
1135 build_array_of_n_type (tree elt
, int n
)
1137 return build_cplus_array_type (elt
, build_index_type (size_int (n
- 1)));
1140 /* True iff T is an array of unknown bound. */
1143 array_of_unknown_bound_p (const_tree t
)
1145 return (TREE_CODE (t
) == ARRAY_TYPE
1146 && !TYPE_DOMAIN (t
));
1149 /* True iff T is an N3639 array of runtime bound (VLA). These were approved
1150 for C++14 but then removed. This should only be used for N3639
1151 specifically; code wondering more generally if something is a VLA should use
1155 array_of_runtime_bound_p (tree t
)
1157 if (!t
|| TREE_CODE (t
) != ARRAY_TYPE
)
1159 if (variably_modified_type_p (TREE_TYPE (t
), NULL_TREE
))
1161 tree dom
= TYPE_DOMAIN (t
);
1164 tree max
= TYPE_MAX_VALUE (dom
);
1165 return (!potential_rvalue_constant_expression (max
)
1166 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)));
1169 /* True iff T is a variable length array. */
1174 for (; t
&& TREE_CODE (t
) == ARRAY_TYPE
;
1176 if (tree dom
= TYPE_DOMAIN (t
))
1178 tree max
= TYPE_MAX_VALUE (dom
);
1179 if (!potential_rvalue_constant_expression (max
)
1180 || (!value_dependent_expression_p (max
) && !TREE_CONSTANT (max
)))
1186 /* Return a reference type node referring to TO_TYPE. If RVAL is
1187 true, return an rvalue reference type, otherwise return an lvalue
1188 reference type. If a type node exists, reuse it, otherwise create
1191 cp_build_reference_type (tree to_type
, bool rval
)
1195 if (to_type
== error_mark_node
)
1196 return error_mark_node
;
1198 if (TYPE_REF_P (to_type
))
1200 rval
= rval
&& TYPE_REF_IS_RVALUE (to_type
);
1201 to_type
= TREE_TYPE (to_type
);
1204 lvalue_ref
= build_reference_type (to_type
);
1208 /* This code to create rvalue reference types is based on and tied
1209 to the code creating lvalue reference types in the middle-end
1210 functions build_reference_type_for_mode and build_reference_type.
1212 It works by putting the rvalue reference type nodes after the
1213 lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
1214 they will effectively be ignored by the middle end. */
1216 for (t
= lvalue_ref
; (t
= TYPE_NEXT_REF_TO (t
)); )
1217 if (TYPE_REF_IS_RVALUE (t
))
1220 t
= build_distinct_type_copy (lvalue_ref
);
1222 TYPE_REF_IS_RVALUE (t
) = true;
1223 TYPE_NEXT_REF_TO (t
) = TYPE_NEXT_REF_TO (lvalue_ref
);
1224 TYPE_NEXT_REF_TO (lvalue_ref
) = t
;
1226 if (TYPE_STRUCTURAL_EQUALITY_P (to_type
))
1227 SET_TYPE_STRUCTURAL_EQUALITY (t
);
1228 else if (TYPE_CANONICAL (to_type
) != to_type
)
1230 = cp_build_reference_type (TYPE_CANONICAL (to_type
), rval
);
1232 TYPE_CANONICAL (t
) = t
;
1240 /* Returns EXPR cast to rvalue reference type, like std::move. */
1245 tree type
= TREE_TYPE (expr
);
1246 gcc_assert (!TYPE_REF_P (type
));
1247 type
= cp_build_reference_type (type
, /*rval*/true);
1248 return build_static_cast (input_location
, type
, expr
,
1249 tf_warning_or_error
);
1252 /* Used by the C++ front end to build qualified array types. However,
1253 the C version of this function does not properly maintain canonical
1254 types (which are not used in C). */
1256 c_build_qualified_type (tree type
, int type_quals
, tree
/* orig_qual_type */,
1257 size_t /* orig_qual_indirect */)
1259 return cp_build_qualified_type (type
, type_quals
);
1263 /* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
1264 arrays correctly. In particular, if TYPE is an array of T's, and
1265 TYPE_QUALS is non-empty, returns an array of qualified T's.
1267 FLAGS determines how to deal with ill-formed qualifications. If
1268 tf_ignore_bad_quals is set, then bad qualifications are dropped
1269 (this is permitted if TYPE was introduced via a typedef or template
1270 type parameter). If bad qualifications are dropped and tf_warning
1271 is set, then a warning is issued for non-const qualifications. If
1272 tf_ignore_bad_quals is not set and tf_error is not set, we
1273 return error_mark_node. Otherwise, we issue an error, and ignore
1276 Qualification of a reference type is valid when the reference came
1277 via a typedef or template type argument. [dcl.ref] No such
1278 dispensation is provided for qualifying a function type. [dcl.fct]
1279 DR 295 queries this and the proposed resolution brings it into line
1280 with qualifying a reference. We implement the DR. We also behave
1281 in a similar manner for restricting non-pointer types. */
1284 cp_build_qualified_type_real (tree type
,
1286 tsubst_flags_t complain
)
1289 int bad_quals
= TYPE_UNQUALIFIED
;
1291 if (type
== error_mark_node
)
1294 if (type_quals
== cp_type_quals (type
))
1297 if (TREE_CODE (type
) == ARRAY_TYPE
)
1299 /* In C++, the qualification really applies to the array element
1300 type. Obtain the appropriately qualified element type. */
1303 = cp_build_qualified_type_real (TREE_TYPE (type
),
1307 if (element_type
== error_mark_node
)
1308 return error_mark_node
;
1310 /* See if we already have an identically qualified type. Tests
1311 should be equivalent to those in check_qualified_type. */
1312 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
1313 if (TREE_TYPE (t
) == element_type
1314 && TYPE_NAME (t
) == TYPE_NAME (type
)
1315 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
1316 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
1317 TYPE_ATTRIBUTES (type
)))
1322 t
= build_cplus_array_type (element_type
, TYPE_DOMAIN (type
));
1324 /* Keep the typedef name. */
1325 if (TYPE_NAME (t
) != TYPE_NAME (type
))
1327 t
= build_variant_type_copy (t
);
1328 TYPE_NAME (t
) = TYPE_NAME (type
);
1329 SET_TYPE_ALIGN (t
, TYPE_ALIGN (type
));
1330 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (type
);
1334 /* Even if we already had this variant, we update
1335 TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
1336 they changed since the variant was originally created.
1338 This seems hokey; if there is some way to use a previous
1339 variant *without* coming through here,
1340 TYPE_NEEDS_CONSTRUCTING will never be updated. */
1341 TYPE_NEEDS_CONSTRUCTING (t
)
1342 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type
));
1343 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t
)
1344 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type
));
1347 else if (TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
1349 tree t
= PACK_EXPANSION_PATTERN (type
);
1351 t
= cp_build_qualified_type_real (t
, type_quals
, complain
);
1352 return make_pack_expansion (t
, complain
);
1355 /* A reference or method type shall not be cv-qualified.
1356 [dcl.ref], [dcl.fct]. This used to be an error, but as of DR 295
1357 (in CD1) we always ignore extra cv-quals on functions. */
1358 if (type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
)
1359 && (TYPE_REF_P (type
)
1360 || FUNC_OR_METHOD_TYPE_P (type
)))
1362 if (TYPE_REF_P (type
))
1363 bad_quals
|= type_quals
& (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1364 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
1367 /* But preserve any function-cv-quals on a FUNCTION_TYPE. */
1368 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1369 type_quals
|= type_memfn_quals (type
);
1371 /* A restrict-qualified type must be a pointer (or reference)
1372 to object or incomplete type. */
1373 if ((type_quals
& TYPE_QUAL_RESTRICT
)
1374 && TREE_CODE (type
) != TEMPLATE_TYPE_PARM
1375 && TREE_CODE (type
) != TYPENAME_TYPE
1376 && !INDIRECT_TYPE_P (type
))
1378 bad_quals
|= TYPE_QUAL_RESTRICT
;
1379 type_quals
&= ~TYPE_QUAL_RESTRICT
;
1382 if (bad_quals
== TYPE_UNQUALIFIED
1383 || (complain
& tf_ignore_bad_quals
))
1385 else if (!(complain
& tf_error
))
1386 return error_mark_node
;
1389 tree bad_type
= build_qualified_type (ptr_type_node
, bad_quals
);
1390 error ("%qV qualifiers cannot be applied to %qT",
1394 /* Retrieve (or create) the appropriately qualified variant. */
1395 result
= build_qualified_type (type
, type_quals
);
1400 /* Return TYPE with const and volatile removed. */
1403 cv_unqualified (tree type
)
1407 if (type
== error_mark_node
)
1410 quals
= cp_type_quals (type
);
1411 quals
&= ~(TYPE_QUAL_CONST
|TYPE_QUAL_VOLATILE
);
1412 return cp_build_qualified_type (type
, quals
);
1415 /* Subroutine of strip_typedefs. We want to apply to RESULT the attributes
1416 from ATTRIBS that affect type identity, and no others. If any are not
1417 applied, set *remove_attributes to true. */
1420 apply_identity_attributes (tree result
, tree attribs
, bool *remove_attributes
)
1422 tree first_ident
= NULL_TREE
;
1423 tree new_attribs
= NULL_TREE
;
1424 tree
*p
= &new_attribs
;
1426 if (OVERLOAD_TYPE_P (result
))
1428 /* On classes and enums all attributes are ingrained. */
1429 gcc_assert (attribs
== TYPE_ATTRIBUTES (result
));
1433 for (tree a
= attribs
; a
; a
= TREE_CHAIN (a
))
1435 const attribute_spec
*as
1436 = lookup_attribute_spec (get_attribute_name (a
));
1437 if (as
&& as
->affects_type_identity
)
1441 else if (first_ident
== error_mark_node
)
1443 *p
= tree_cons (TREE_PURPOSE (a
), TREE_VALUE (a
), NULL_TREE
);
1444 p
= &TREE_CHAIN (*p
);
1447 else if (first_ident
)
1449 for (tree a2
= first_ident
; a2
; a2
= TREE_CHAIN (a2
))
1451 *p
= tree_cons (TREE_PURPOSE (a2
), TREE_VALUE (a2
), NULL_TREE
);
1452 p
= &TREE_CHAIN (*p
);
1454 first_ident
= error_mark_node
;
1457 if (first_ident
!= error_mark_node
)
1458 new_attribs
= first_ident
;
1460 if (first_ident
== attribs
)
1461 /* All attributes affected type identity. */;
1463 *remove_attributes
= true;
1465 return cp_build_type_attribute_variant (result
, new_attribs
);
1468 /* Builds a qualified variant of T that is either not a typedef variant
1469 (the default behavior) or not a typedef variant of a user-facing type
1470 (if FLAGS contains STF_USER_FACING).
1472 E.g. consider the following declarations:
1473 typedef const int ConstInt;
1474 typedef ConstInt* PtrConstInt;
1475 If T is PtrConstInt, this function returns a type representing
1477 In other words, if T is a typedef, the function returns the underlying type.
1478 The cv-qualification and attributes of the type returned match the
1480 They will always be compatible types.
1481 The returned type is built so that all of its subtypes
1482 recursively have their typedefs stripped as well.
1484 This is different from just returning TYPE_CANONICAL (T)
1485 Because of several reasons:
1486 * If T is a type that needs structural equality
1487 its TYPE_CANONICAL (T) will be NULL.
1488 * TYPE_CANONICAL (T) desn't carry type attributes
1489 and loses template parameter names.
1491 If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
1492 affect type identity, and set the referent to true if any were
1496 strip_typedefs (tree t
, bool *remove_attributes
, unsigned int flags
)
1498 tree result
= NULL
, type
= NULL
, t0
= NULL
;
1500 if (!t
|| t
== error_mark_node
)
1503 if (TREE_CODE (t
) == TREE_LIST
)
1505 bool changed
= false;
1508 for (; t
; t
= TREE_CHAIN (t
))
1510 gcc_assert (!TREE_PURPOSE (t
));
1511 tree elt
= strip_typedefs (TREE_VALUE (t
), remove_attributes
, flags
);
1512 if (elt
!= TREE_VALUE (t
))
1514 vec_safe_push (vec
, elt
);
1517 r
= build_tree_list_vec (vec
);
1521 gcc_assert (TYPE_P (t
));
1523 if (t
== TYPE_CANONICAL (t
))
1526 if (!(flags
& STF_STRIP_DEPENDENT
)
1527 && dependent_alias_template_spec_p (t
, nt_opaque
))
1528 /* DR 1558: However, if the template-id is dependent, subsequent
1529 template argument substitution still applies to the template-id. */
1532 switch (TREE_CODE (t
))
1535 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1536 result
= build_pointer_type (type
);
1538 case REFERENCE_TYPE
:
1539 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1540 result
= cp_build_reference_type (type
, TYPE_REF_IS_RVALUE (t
));
1543 t0
= strip_typedefs (TYPE_OFFSET_BASETYPE (t
), remove_attributes
, flags
);
1544 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1545 result
= build_offset_type (t0
, type
);
1548 if (TYPE_PTRMEMFUNC_P (t
))
1550 t0
= strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t
),
1551 remove_attributes
, flags
);
1552 result
= build_ptrmemfunc_type (t0
);
1556 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1557 t0
= strip_typedefs (TYPE_DOMAIN (t
), remove_attributes
, flags
);
1558 result
= build_cplus_array_type (type
, t0
);
1563 tree arg_types
= NULL
, arg_node
, arg_node2
, arg_type
;
1566 /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
1567 around the compiler (e.g. cp_parser_late_parsing_default_args), we
1568 can't expect that re-hashing a function type will find a previous
1569 equivalent type, so try to reuse the input type if nothing has
1570 changed. If the type is itself a variant, that will change. */
1571 bool is_variant
= typedef_variant_p (t
);
1572 if (remove_attributes
1573 && (TYPE_ATTRIBUTES (t
) || TYPE_USER_ALIGN (t
)))
1576 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1577 tree canon_spec
= (flag_noexcept_type
1578 ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t
))
1580 changed
= (type
!= TREE_TYPE (t
) || is_variant
1581 || TYPE_RAISES_EXCEPTIONS (t
) != canon_spec
);
1583 for (arg_node
= TYPE_ARG_TYPES (t
);
1585 arg_node
= TREE_CHAIN (arg_node
))
1587 if (arg_node
== void_list_node
)
1589 arg_type
= strip_typedefs (TREE_VALUE (arg_node
),
1590 remove_attributes
, flags
);
1591 gcc_assert (arg_type
);
1592 if (arg_type
== TREE_VALUE (arg_node
) && !changed
)
1598 for (arg_node2
= TYPE_ARG_TYPES (t
);
1599 arg_node2
!= arg_node
;
1600 arg_node2
= TREE_CHAIN (arg_node2
))
1602 = tree_cons (TREE_PURPOSE (arg_node2
),
1603 TREE_VALUE (arg_node2
), arg_types
);
1607 = tree_cons (TREE_PURPOSE (arg_node
), arg_type
, arg_types
);
1614 arg_types
= nreverse (arg_types
);
1616 /* A list of parameters not ending with an ellipsis
1617 must end with void_list_node. */
1619 arg_types
= chainon (arg_types
, void_list_node
);
1621 if (TREE_CODE (t
) == METHOD_TYPE
)
1623 tree class_type
= TREE_TYPE (TREE_VALUE (arg_types
));
1624 gcc_assert (class_type
);
1626 build_method_type_directly (class_type
, type
,
1627 TREE_CHAIN (arg_types
));
1631 result
= build_function_type (type
, arg_types
);
1632 result
= apply_memfn_quals (result
, type_memfn_quals (t
));
1635 result
= build_cp_fntype_variant (result
,
1636 type_memfn_rqual (t
), canon_spec
,
1637 TYPE_HAS_LATE_RETURN_TYPE (t
));
1642 bool changed
= false;
1643 tree fullname
= TYPENAME_TYPE_FULLNAME (t
);
1644 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
1645 && TREE_OPERAND (fullname
, 1))
1647 tree args
= TREE_OPERAND (fullname
, 1);
1648 tree new_args
= copy_node (args
);
1649 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1651 tree arg
= TREE_VEC_ELT (args
, i
);
1654 strip_arg
= strip_typedefs (arg
, remove_attributes
, flags
);
1656 strip_arg
= strip_typedefs_expr (arg
, remove_attributes
,
1658 TREE_VEC_ELT (new_args
, i
) = strip_arg
;
1659 if (strip_arg
!= arg
)
1664 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args
)
1665 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
);
1667 = lookup_template_function (TREE_OPERAND (fullname
, 0),
1671 ggc_free (new_args
);
1673 tree ctx
= strip_typedefs (TYPE_CONTEXT (t
), remove_attributes
, flags
);
1674 if (!changed
&& ctx
== TYPE_CONTEXT (t
) && !typedef_variant_p (t
))
1676 tree name
= fullname
;
1677 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
1678 name
= TREE_OPERAND (fullname
, 0);
1679 /* Use build_typename_type rather than make_typename_type because we
1680 don't want to resolve it here, just strip typedefs. */
1681 result
= build_typename_type (ctx
, name
, fullname
, typename_type
);
1685 result
= strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t
),
1686 remove_attributes
, flags
);
1687 if (result
== DECLTYPE_TYPE_EXPR (t
))
1690 result
= (finish_decltype_type
1692 DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t
),
1695 case UNDERLYING_TYPE
:
1696 type
= strip_typedefs (UNDERLYING_TYPE_TYPE (t
),
1697 remove_attributes
, flags
);
1698 result
= finish_underlying_type (type
);
1706 if (typedef_variant_p (t
))
1708 if ((flags
& STF_USER_VISIBLE
)
1709 && !user_facing_original_type_p (t
))
1711 /* If T is a non-template alias or typedef, we can assume that
1712 instantiating its definition will hit any substitution failure,
1713 so we don't need to retain it here as well. */
1714 if (!alias_template_specialization_p (t
, nt_opaque
))
1715 flags
|= STF_STRIP_DEPENDENT
;
1716 result
= strip_typedefs (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)),
1717 remove_attributes
, flags
);
1720 result
= TYPE_MAIN_VARIANT (t
);
1722 /*gcc_assert (!typedef_variant_p (result)
1723 || dependent_alias_template_spec_p (result, nt_opaque)
1724 || ((flags & STF_USER_VISIBLE)
1725 && !user_facing_original_type_p (result)));*/
1727 if (COMPLETE_TYPE_P (result
) && !COMPLETE_TYPE_P (t
))
1728 /* If RESULT is complete and T isn't, it's likely the case that T
1729 is a variant of RESULT which hasn't been updated yet. Skip the
1730 attribute handling. */;
1733 if (TYPE_USER_ALIGN (t
) != TYPE_USER_ALIGN (result
)
1734 || TYPE_ALIGN (t
) != TYPE_ALIGN (result
))
1736 gcc_assert (TYPE_USER_ALIGN (t
));
1737 if (remove_attributes
)
1738 *remove_attributes
= true;
1741 if (TYPE_ALIGN (t
) == TYPE_ALIGN (result
))
1742 result
= build_variant_type_copy (result
);
1744 result
= build_aligned_type (result
, TYPE_ALIGN (t
));
1745 TYPE_USER_ALIGN (result
) = true;
1749 if (TYPE_ATTRIBUTES (t
))
1751 if (remove_attributes
)
1752 result
= apply_identity_attributes (result
, TYPE_ATTRIBUTES (t
),
1755 result
= cp_build_type_attribute_variant (result
,
1756 TYPE_ATTRIBUTES (t
));
1760 return cp_build_qualified_type (result
, cp_type_quals (t
));
1763 /* Like strip_typedefs above, but works on expressions, so that in
1765 template<class T> struct A
1771 sizeof(TT) is replaced by sizeof(T). */
1774 strip_typedefs_expr (tree t
, bool *remove_attributes
, unsigned int flags
)
1778 enum tree_code code
;
1780 if (t
== NULL_TREE
|| t
== error_mark_node
)
1783 STRIP_ANY_LOCATION_WRAPPER (t
);
1785 if (DECL_P (t
) || CONSTANT_CLASS_P (t
))
1788 /* Some expressions have type operands, so let's handle types here rather
1789 than check TYPE_P in multiple places below. */
1791 return strip_typedefs (t
, remove_attributes
, flags
);
1793 code
= TREE_CODE (t
);
1796 case IDENTIFIER_NODE
:
1797 case TEMPLATE_PARM_INDEX
:
1800 case ARGUMENT_PACK_SELECT
:
1805 tree type1
= strip_typedefs (TRAIT_EXPR_TYPE1 (t
),
1806 remove_attributes
, flags
);
1807 tree type2
= strip_typedefs (TRAIT_EXPR_TYPE2 (t
),
1808 remove_attributes
, flags
);
1809 if (type1
== TRAIT_EXPR_TYPE1 (t
)
1810 && type2
== TRAIT_EXPR_TYPE2 (t
))
1813 TRAIT_EXPR_TYPE1 (r
) = type1
;
1814 TRAIT_EXPR_TYPE2 (r
) = type2
;
1821 bool changed
= false;
1823 for (it
= t
; it
; it
= TREE_CHAIN (it
))
1825 tree val
= strip_typedefs_expr (TREE_VALUE (it
),
1826 remove_attributes
, flags
);
1827 vec_safe_push (vec
, val
);
1828 if (val
!= TREE_VALUE (it
))
1830 gcc_assert (TREE_PURPOSE (it
) == NULL_TREE
);
1835 FOR_EACH_VEC_ELT_REVERSE (*vec
, i
, it
)
1836 r
= tree_cons (NULL_TREE
, it
, r
);
1845 bool changed
= false;
1847 n
= TREE_VEC_LENGTH (t
);
1848 vec_safe_reserve (vec
, n
);
1849 for (i
= 0; i
< n
; ++i
)
1851 tree op
= strip_typedefs_expr (TREE_VEC_ELT (t
, i
),
1852 remove_attributes
, flags
);
1853 vec
->quick_push (op
);
1854 if (op
!= TREE_VEC_ELT (t
, i
))
1860 for (i
= 0; i
< n
; ++i
)
1861 TREE_VEC_ELT (r
, i
) = (*vec
)[i
];
1862 NON_DEFAULT_TEMPLATE_ARGS_COUNT (r
)
1863 = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t
);
1872 bool changed
= false;
1873 vec
<constructor_elt
, va_gc
> *vec
1874 = vec_safe_copy (CONSTRUCTOR_ELTS (t
));
1875 n
= CONSTRUCTOR_NELTS (t
);
1876 type
= strip_typedefs (TREE_TYPE (t
), remove_attributes
, flags
);
1877 for (i
= 0; i
< n
; ++i
)
1879 constructor_elt
*e
= &(*vec
)[i
];
1880 tree op
= strip_typedefs_expr (e
->value
, remove_attributes
, flags
);
1887 (e
->index
== strip_typedefs_expr (e
->index
, remove_attributes
,
1891 if (!changed
&& type
== TREE_TYPE (t
))
1899 TREE_TYPE (r
) = type
;
1900 CONSTRUCTOR_ELTS (r
) = vec
;
1908 case STATEMENT_LIST
:
1909 error ("statement-expression in a constant expression");
1910 return error_mark_node
;
1916 gcc_assert (EXPR_P (t
));
1918 n
= cp_tree_operand_length (t
);
1919 ops
= XALLOCAVEC (tree
, n
);
1920 type
= TREE_TYPE (t
);
1925 case IMPLICIT_CONV_EXPR
:
1926 case DYNAMIC_CAST_EXPR
:
1927 case STATIC_CAST_EXPR
:
1928 case CONST_CAST_EXPR
:
1929 case REINTERPRET_CAST_EXPR
:
1932 type
= strip_typedefs (type
, remove_attributes
, flags
);
1936 for (i
= 0; i
< n
; ++i
)
1937 ops
[i
] = strip_typedefs_expr (TREE_OPERAND (t
, i
),
1938 remove_attributes
, flags
);
1942 /* If nothing changed, return t. */
1943 for (i
= 0; i
< n
; ++i
)
1944 if (ops
[i
] != TREE_OPERAND (t
, i
))
1946 if (i
== n
&& type
== TREE_TYPE (t
))
1950 TREE_TYPE (r
) = type
;
1951 for (i
= 0; i
< n
; ++i
)
1952 TREE_OPERAND (r
, i
) = ops
[i
];
1956 /* Makes a copy of BINFO and TYPE, which is to be inherited into a
1957 graph dominated by T. If BINFO is NULL, TYPE is a dependent base,
1958 and we do a shallow copy. If BINFO is non-NULL, we do a deep copy.
1959 VIRT indicates whether TYPE is inherited virtually or not.
1960 IGO_PREV points at the previous binfo of the inheritance graph
1961 order chain. The newly copied binfo's TREE_CHAIN forms this
1964 The CLASSTYPE_VBASECLASSES vector of T is constructed in the
1965 correct order. That is in the order the bases themselves should be
1968 The BINFO_INHERITANCE of a virtual base class points to the binfo
1969 of the most derived type. ??? We could probably change this so that
1970 BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
1971 remove a field. They currently can only differ for primary virtual
1975 copy_binfo (tree binfo
, tree type
, tree t
, tree
*igo_prev
, int virt
)
1981 /* See if we've already made this virtual base. */
1982 new_binfo
= binfo_for_vbase (type
, t
);
1987 new_binfo
= make_tree_binfo (binfo
? BINFO_N_BASE_BINFOS (binfo
) : 0);
1988 BINFO_TYPE (new_binfo
) = type
;
1990 /* Chain it into the inheritance graph. */
1991 TREE_CHAIN (*igo_prev
) = new_binfo
;
1992 *igo_prev
= new_binfo
;
1994 if (binfo
&& !BINFO_DEPENDENT_BASE_P (binfo
))
1999 gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo
), type
));
2001 BINFO_OFFSET (new_binfo
) = BINFO_OFFSET (binfo
);
2002 BINFO_VIRTUALS (new_binfo
) = BINFO_VIRTUALS (binfo
);
2004 /* We do not need to copy the accesses, as they are read only. */
2005 BINFO_BASE_ACCESSES (new_binfo
) = BINFO_BASE_ACCESSES (binfo
);
2007 /* Recursively copy base binfos of BINFO. */
2008 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
2010 tree new_base_binfo
;
2011 new_base_binfo
= copy_binfo (base_binfo
, BINFO_TYPE (base_binfo
),
2013 BINFO_VIRTUAL_P (base_binfo
));
2015 if (!BINFO_INHERITANCE_CHAIN (new_base_binfo
))
2016 BINFO_INHERITANCE_CHAIN (new_base_binfo
) = new_binfo
;
2017 BINFO_BASE_APPEND (new_binfo
, new_base_binfo
);
2021 BINFO_DEPENDENT_BASE_P (new_binfo
) = 1;
2025 /* Push it onto the list after any virtual bases it contains
2026 will have been pushed. */
2027 CLASSTYPE_VBASECLASSES (t
)->quick_push (new_binfo
);
2028 BINFO_VIRTUAL_P (new_binfo
) = 1;
2029 BINFO_INHERITANCE_CHAIN (new_binfo
) = TYPE_BINFO (t
);
2035 /* Hashing of lists so that we don't make duplicates.
2036 The entry point is `list_hash_canon'. */
2045 struct list_hasher
: ggc_ptr_hash
<tree_node
>
2047 typedef list_proxy
*compare_type
;
2049 static hashval_t
hash (tree
);
2050 static bool equal (tree
, list_proxy
*);
2053 /* Now here is the hash table. When recording a list, it is added
2054 to the slot whose index is the hash code mod the table size.
2055 Note that the hash table is used for several kinds of lists.
2056 While all these live in the same table, they are completely independent,
2057 and the hash code is computed differently for each of these. */
2059 static GTY (()) hash_table
<list_hasher
> *list_hash_table
;
2061 /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
2062 for a node we are thinking about adding). */
2065 list_hasher::equal (tree t
, list_proxy
*proxy
)
2067 return (TREE_VALUE (t
) == proxy
->value
2068 && TREE_PURPOSE (t
) == proxy
->purpose
2069 && TREE_CHAIN (t
) == proxy
->chain
);
2072 /* Compute a hash code for a list (chain of TREE_LIST nodes
2073 with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
2074 TREE_COMMON slots), by adding the hash codes of the individual entries. */
2077 list_hash_pieces (tree purpose
, tree value
, tree chain
)
2079 hashval_t hashcode
= 0;
2082 hashcode
+= TREE_HASH (chain
);
2085 hashcode
+= TREE_HASH (value
);
2089 hashcode
+= TREE_HASH (purpose
);
2095 /* Hash an already existing TREE_LIST. */
2098 list_hasher::hash (tree t
)
2100 return list_hash_pieces (TREE_PURPOSE (t
),
2105 /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
2106 object for an identical list if one already exists. Otherwise, build a
2107 new one, and record it as the canonical object. */
2110 hash_tree_cons (tree purpose
, tree value
, tree chain
)
2114 struct list_proxy proxy
;
2116 /* Hash the list node. */
2117 hashcode
= list_hash_pieces (purpose
, value
, chain
);
2118 /* Create a proxy for the TREE_LIST we would like to create. We
2119 don't actually create it so as to avoid creating garbage. */
2120 proxy
.purpose
= purpose
;
2121 proxy
.value
= value
;
2122 proxy
.chain
= chain
;
2123 /* See if it is already in the table. */
2124 slot
= list_hash_table
->find_slot_with_hash (&proxy
, hashcode
, INSERT
);
2125 /* If not, create a new node. */
2127 *slot
= tree_cons (purpose
, value
, chain
);
2128 return (tree
) *slot
;
2131 /* Constructor for hashed lists. */
2134 hash_tree_chain (tree value
, tree chain
)
2136 return hash_tree_cons (NULL_TREE
, value
, chain
);
2140 debug_binfo (tree elem
)
2145 fprintf (stderr
, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
2147 TYPE_NAME_STRING (BINFO_TYPE (elem
)),
2148 TREE_INT_CST_LOW (BINFO_OFFSET (elem
)));
2149 debug_tree (BINFO_TYPE (elem
));
2150 if (BINFO_VTABLE (elem
))
2151 fprintf (stderr
, "vtable decl \"%s\"\n",
2152 IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem
))));
2154 fprintf (stderr
, "no vtable decl yet\n");
2155 fprintf (stderr
, "virtuals:\n");
2156 virtuals
= BINFO_VIRTUALS (elem
);
2161 tree fndecl
= TREE_VALUE (virtuals
);
2162 fprintf (stderr
, "%s [%ld =? %ld]\n",
2163 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
)),
2164 (long) n
, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl
)));
2166 virtuals
= TREE_CHAIN (virtuals
);
2170 /* Build a representation for the qualified name SCOPE::NAME. TYPE is
2171 the type of the result expression, if known, or NULL_TREE if the
2172 resulting expression is type-dependent. If TEMPLATE_P is true,
2173 NAME is known to be a template because the user explicitly used the
2174 "template" keyword after the "::".
2176 All SCOPE_REFs should be built by use of this function. */
2179 build_qualified_name (tree type
, tree scope
, tree name
, bool template_p
)
2182 if (type
== error_mark_node
2183 || scope
== error_mark_node
2184 || name
== error_mark_node
)
2185 return error_mark_node
;
2186 gcc_assert (TREE_CODE (name
) != SCOPE_REF
);
2187 t
= build2 (SCOPE_REF
, type
, scope
, name
);
2188 QUALIFIED_NAME_IS_TEMPLATE (t
) = template_p
;
2189 PTRMEM_OK_P (t
) = true;
2191 t
= convert_from_reference (t
);
2195 /* Like check_qualified_type, but also check ref-qualifier, exception
2196 specification, and whether the return type was specified after the
2200 cp_check_qualified_type (const_tree cand
, const_tree base
, int type_quals
,
2201 cp_ref_qualifier rqual
, tree raises
, bool late
)
2203 return (TYPE_QUALS (cand
) == type_quals
2204 && check_base_type (cand
, base
)
2205 && comp_except_specs (raises
, TYPE_RAISES_EXCEPTIONS (cand
),
2207 && TYPE_HAS_LATE_RETURN_TYPE (cand
) == late
2208 && type_memfn_rqual (cand
) == rqual
);
2211 /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL. */
2214 build_ref_qualified_type (tree type
, cp_ref_qualifier rqual
)
2216 tree raises
= TYPE_RAISES_EXCEPTIONS (type
);
2217 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2218 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2221 /* Make a raw overload node containing FN. */
2224 ovl_make (tree fn
, tree next
)
2226 tree result
= make_node (OVERLOAD
);
2228 if (TREE_CODE (fn
) == OVERLOAD
)
2229 OVL_NESTED_P (result
) = true;
2231 TREE_TYPE (result
) = (next
|| TREE_CODE (fn
) == TEMPLATE_DECL
2232 ? unknown_type_node
: TREE_TYPE (fn
));
2233 if (next
&& TREE_CODE (next
) == OVERLOAD
&& OVL_DEDUP_P (next
))
2234 OVL_DEDUP_P (result
) = true;
2235 OVL_FUNCTION (result
) = fn
;
2236 OVL_CHAIN (result
) = next
;
2240 /* Add FN to the (potentially NULL) overload set OVL. USING_OR_HIDDEN
2241 is > 0, if FN is via a using declaration. USING_OR_HIDDEN is < 0,
2242 if FN is hidden. (A decl cannot be both using and hidden.) We
2243 keep the hidden decls first, but remaining ones are unordered. */
2246 ovl_insert (tree fn
, tree maybe_ovl
, int using_or_hidden
)
2248 tree result
= maybe_ovl
;
2249 tree insert_after
= NULL_TREE
;
2252 for (; maybe_ovl
&& TREE_CODE (maybe_ovl
) == OVERLOAD
2253 && OVL_HIDDEN_P (maybe_ovl
);
2254 maybe_ovl
= OVL_CHAIN (maybe_ovl
))
2256 gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl
));
2257 insert_after
= maybe_ovl
;
2260 if (maybe_ovl
|| using_or_hidden
|| TREE_CODE (fn
) == TEMPLATE_DECL
)
2262 maybe_ovl
= ovl_make (fn
, maybe_ovl
);
2264 if (using_or_hidden
< 0)
2265 OVL_HIDDEN_P (maybe_ovl
) = true;
2266 if (using_or_hidden
> 0)
2267 OVL_DEDUP_P (maybe_ovl
) = OVL_USING_P (maybe_ovl
) = true;
2274 OVL_CHAIN (insert_after
) = maybe_ovl
;
2275 TREE_TYPE (insert_after
) = unknown_type_node
;
2283 /* Skip any hidden names at the beginning of OVL. */
2286 ovl_skip_hidden (tree ovl
)
2288 while (ovl
&& TREE_CODE (ovl
) == OVERLOAD
&& OVL_HIDDEN_P (ovl
))
2289 ovl
= OVL_CHAIN (ovl
);
2294 /* NODE is an OVL_HIDDEN_P node that is now revealed. */
2297 ovl_iterator::reveal_node (tree overload
, tree node
)
2299 /* We cannot have returned NODE as part of a lookup overload, so we
2300 don't have to worry about preserving that. */
2302 OVL_HIDDEN_P (node
) = false;
2303 if (tree chain
= OVL_CHAIN (node
))
2304 if (TREE_CODE (chain
) == OVERLOAD
)
2306 if (OVL_HIDDEN_P (chain
))
2308 /* The node needs moving, and the simplest way is to remove it
2310 overload
= remove_node (overload
, node
);
2311 overload
= ovl_insert (OVL_FUNCTION (node
), overload
);
2313 else if (OVL_DEDUP_P (chain
))
2314 OVL_DEDUP_P (node
) = true;
2319 /* NODE is on the overloads of OVL. Remove it.
2320 The removed node is unaltered and may continue to be iterated
2321 from (i.e. it is safe to remove a node from an overload one is
2322 currently iterating over). */
2325 ovl_iterator::remove_node (tree overload
, tree node
)
2327 tree
*slot
= &overload
;
2328 while (*slot
!= node
)
2331 gcc_checking_assert (!OVL_LOOKUP_P (probe
));
2333 slot
= &OVL_CHAIN (probe
);
2336 /* Stitch out NODE. We don't have to worry about now making a
2337 singleton overload (and consequently maybe setting its type),
2338 because all uses of this function will be followed by inserting a
2339 new node that must follow the place we've cut this out from. */
2340 if (TREE_CODE (node
) != OVERLOAD
)
2341 /* Cloned inherited ctors don't mark themselves as via_using. */
2344 *slot
= OVL_CHAIN (node
);
2349 /* Mark or unmark a lookup set. */
2352 lookup_mark (tree ovl
, bool val
)
2354 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
2356 gcc_checking_assert (LOOKUP_SEEN_P (*iter
) != val
);
2357 LOOKUP_SEEN_P (*iter
) = val
;
2361 /* Add a set of new FNS into a lookup. */
2364 lookup_add (tree fns
, tree lookup
)
2366 if (fns
== error_mark_node
|| lookup
== error_mark_node
)
2367 return error_mark_node
;
2369 if (lookup
|| TREE_CODE (fns
) == TEMPLATE_DECL
)
2371 lookup
= ovl_make (fns
, lookup
);
2372 OVL_LOOKUP_P (lookup
) = true;
2380 /* FNS is a new overload set, add them to LOOKUP, if they are not
2381 already present there. */
2384 lookup_maybe_add (tree fns
, tree lookup
, bool deduping
)
2387 for (tree next
, probe
= fns
; probe
; probe
= next
)
2392 if (TREE_CODE (probe
) == OVERLOAD
)
2394 fn
= OVL_FUNCTION (probe
);
2395 next
= OVL_CHAIN (probe
);
2398 if (!LOOKUP_SEEN_P (fn
))
2399 LOOKUP_SEEN_P (fn
) = true;
2402 /* This function was already seen. Insert all the
2403 predecessors onto the lookup. */
2404 for (; fns
!= probe
; fns
= OVL_CHAIN (fns
))
2406 lookup
= lookup_add (OVL_FUNCTION (fns
), lookup
);
2407 /* Propagate OVL_USING, but OVL_HIDDEN &
2408 OVL_DEDUP_P don't matter. */
2409 if (OVL_USING_P (fns
))
2410 OVL_USING_P (lookup
) = true;
2413 /* And now skip this function. */
2419 /* We ended in a set of new functions. Add them all in one go. */
2420 lookup
= lookup_add (fns
, lookup
);
2425 /* Returns nonzero if X is an expression for a (possibly overloaded)
2426 function. If "f" is a function or function template, "f", "c->f",
2427 "c.f", "C::f", and "f<int>" will all be considered possibly
2428 overloaded functions. Returns 2 if the function is actually
2429 overloaded, i.e., if it is impossible to know the type of the
2430 function without performing overload resolution. */
2433 is_overloaded_fn (tree x
)
2435 STRIP_ANY_LOCATION_WRAPPER (x
);
2437 /* A baselink is also considered an overloaded function. */
2438 if (TREE_CODE (x
) == OFFSET_REF
2439 || TREE_CODE (x
) == COMPONENT_REF
)
2440 x
= TREE_OPERAND (x
, 1);
2441 x
= MAYBE_BASELINK_FUNCTIONS (x
);
2442 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2443 x
= TREE_OPERAND (x
, 0);
2445 if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x
))
2446 || (TREE_CODE (x
) == OVERLOAD
&& !OVL_SINGLE_P (x
)))
2452 /* X is the CALL_EXPR_FN of a CALL_EXPR. If X represents a dependent name
2453 (14.6.2), return the IDENTIFIER_NODE for that name. Otherwise, return
2457 dependent_name (tree x
)
2459 /* FIXME a dependent name must be unqualified, but this function doesn't
2460 distinguish between qualified and unqualified identifiers. */
2461 if (identifier_p (x
))
2463 if (TREE_CODE (x
) == TEMPLATE_ID_EXPR
)
2464 x
= TREE_OPERAND (x
, 0);
2466 return OVL_NAME (x
);
2470 /* Returns true iff X is an expression for an overloaded function
2471 whose type cannot be known without performing overload
2475 really_overloaded_fn (tree x
)
2477 return is_overloaded_fn (x
) == 2;
2480 /* Get the overload set FROM refers to. Returns NULL if it's not an
2484 maybe_get_fns (tree from
)
2486 STRIP_ANY_LOCATION_WRAPPER (from
);
2488 /* A baselink is also considered an overloaded function. */
2489 if (TREE_CODE (from
) == OFFSET_REF
2490 || TREE_CODE (from
) == COMPONENT_REF
)
2491 from
= TREE_OPERAND (from
, 1);
2492 if (BASELINK_P (from
))
2493 from
= BASELINK_FUNCTIONS (from
);
2494 if (TREE_CODE (from
) == TEMPLATE_ID_EXPR
)
2495 from
= TREE_OPERAND (from
, 0);
2503 /* FROM refers to an overload set. Return that set (or die). */
2508 tree res
= maybe_get_fns (from
);
2514 /* Return the first function of the overload set FROM refers to. */
2517 get_first_fn (tree from
)
2519 return OVL_FIRST (get_fns (from
));
2522 /* Return the scope where the overloaded functions OVL were found. */
2525 ovl_scope (tree ovl
)
2527 if (TREE_CODE (ovl
) == OFFSET_REF
2528 || TREE_CODE (ovl
) == COMPONENT_REF
)
2529 ovl
= TREE_OPERAND (ovl
, 1);
2530 if (TREE_CODE (ovl
) == BASELINK
)
2531 return BINFO_TYPE (BASELINK_BINFO (ovl
));
2532 if (TREE_CODE (ovl
) == TEMPLATE_ID_EXPR
)
2533 ovl
= TREE_OPERAND (ovl
, 0);
2534 /* Skip using-declarations. */
2535 lkp_iterator
iter (ovl
);
2538 while (iter
.using_p () && ++iter
);
2540 return CP_DECL_CONTEXT (ovl
);
2543 #define PRINT_RING_SIZE 4
2546 cxx_printable_name_internal (tree decl
, int v
, bool translate
)
2548 static unsigned int uid_ring
[PRINT_RING_SIZE
];
2549 static char *print_ring
[PRINT_RING_SIZE
];
2550 static bool trans_ring
[PRINT_RING_SIZE
];
2551 static int ring_counter
;
2554 /* Only cache functions. */
2556 || TREE_CODE (decl
) != FUNCTION_DECL
2557 || DECL_LANG_SPECIFIC (decl
) == 0)
2558 return lang_decl_name (decl
, v
, translate
);
2560 /* See if this print name is lying around. */
2561 for (i
= 0; i
< PRINT_RING_SIZE
; i
++)
2562 if (uid_ring
[i
] == DECL_UID (decl
) && translate
== trans_ring
[i
])
2563 /* yes, so return it. */
2564 return print_ring
[i
];
2566 if (++ring_counter
== PRINT_RING_SIZE
)
2569 if (current_function_decl
!= NULL_TREE
)
2571 /* There may be both translated and untranslated versions of the
2573 for (i
= 0; i
< 2; i
++)
2575 if (uid_ring
[ring_counter
] == DECL_UID (current_function_decl
))
2577 if (ring_counter
== PRINT_RING_SIZE
)
2580 gcc_assert (uid_ring
[ring_counter
] != DECL_UID (current_function_decl
));
2583 free (print_ring
[ring_counter
]);
2585 print_ring
[ring_counter
] = xstrdup (lang_decl_name (decl
, v
, translate
));
2586 uid_ring
[ring_counter
] = DECL_UID (decl
);
2587 trans_ring
[ring_counter
] = translate
;
2588 return print_ring
[ring_counter
];
2592 cxx_printable_name (tree decl
, int v
)
2594 return cxx_printable_name_internal (decl
, v
, false);
2598 cxx_printable_name_translate (tree decl
, int v
)
2600 return cxx_printable_name_internal (decl
, v
, true);
2603 /* Return the canonical version of exception-specification RAISES for a C++17
2604 function type, for use in type comparison and building TYPE_CANONICAL. */
2607 canonical_eh_spec (tree raises
)
2609 if (raises
== NULL_TREE
)
2611 else if (DEFERRED_NOEXCEPT_SPEC_P (raises
)
2612 || UNPARSED_NOEXCEPT_SPEC_P (raises
)
2613 || uses_template_parms (raises
)
2614 || uses_template_parms (TREE_PURPOSE (raises
)))
2615 /* Keep a dependent or deferred exception specification. */
2617 else if (nothrow_spec_p (raises
))
2618 /* throw() -> noexcept. */
2619 return noexcept_true_spec
;
2621 /* For C++17 type matching, anything else -> nothing. */
2626 build_cp_fntype_variant (tree type
, cp_ref_qualifier rqual
,
2627 tree raises
, bool late
)
2629 cp_cv_quals type_quals
= TYPE_QUALS (type
);
2631 if (cp_check_qualified_type (type
, type
, type_quals
, rqual
, raises
, late
))
2634 tree v
= TYPE_MAIN_VARIANT (type
);
2635 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2636 if (cp_check_qualified_type (v
, type
, type_quals
, rqual
, raises
, late
))
2639 /* Need to build a new variant. */
2640 v
= build_variant_type_copy (type
);
2641 if (!TYPE_DEPENDENT_P (v
))
2642 /* We no longer know that it's not type-dependent. */
2643 TYPE_DEPENDENT_P_VALID (v
) = false;
2644 TYPE_RAISES_EXCEPTIONS (v
) = raises
;
2645 TYPE_HAS_LATE_RETURN_TYPE (v
) = late
;
2648 case REF_QUAL_RVALUE
:
2649 FUNCTION_RVALUE_QUALIFIED (v
) = 1;
2650 FUNCTION_REF_QUALIFIED (v
) = 1;
2652 case REF_QUAL_LVALUE
:
2653 FUNCTION_RVALUE_QUALIFIED (v
) = 0;
2654 FUNCTION_REF_QUALIFIED (v
) = 1;
2657 FUNCTION_REF_QUALIFIED (v
) = 0;
2661 /* Canonicalize the exception specification. */
2662 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2664 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
2665 /* Propagate structural equality. */
2666 SET_TYPE_STRUCTURAL_EQUALITY (v
);
2667 else if (TYPE_CANONICAL (type
) != type
|| cr
!= raises
|| late
)
2668 /* Build the underlying canonical type, since it is different
2670 TYPE_CANONICAL (v
) = build_cp_fntype_variant (TYPE_CANONICAL (type
),
2673 /* T is its own canonical type. */
2674 TYPE_CANONICAL (v
) = v
;
2679 /* TYPE is a function or method type with a deferred exception
2680 specification that has been parsed to RAISES. Fixup all the type
2681 variants that are affected in place. Via decltype &| noexcept
2682 tricks, the unparsed spec could have escaped into the type system.
2683 The general case is hard to fixup canonical types for. */
2686 fixup_deferred_exception_variants (tree type
, tree raises
)
2688 tree original
= TYPE_RAISES_EXCEPTIONS (type
);
2689 tree cr
= flag_noexcept_type
? canonical_eh_spec (raises
) : NULL_TREE
;
2691 gcc_checking_assert (TREE_CODE (TREE_PURPOSE (original
))
2694 /* Though sucky, this walk will process the canonical variants
2696 for (tree variant
= TYPE_MAIN_VARIANT (type
);
2697 variant
; variant
= TYPE_NEXT_VARIANT (variant
))
2698 if (TYPE_RAISES_EXCEPTIONS (variant
) == original
)
2700 gcc_checking_assert (variant
!= TYPE_MAIN_VARIANT (type
));
2702 if (!TYPE_STRUCTURAL_EQUALITY_P (variant
))
2704 cp_cv_quals var_quals
= TYPE_QUALS (variant
);
2705 cp_ref_qualifier rqual
= type_memfn_rqual (variant
);
2707 tree v
= TYPE_MAIN_VARIANT (type
);
2708 for (; v
; v
= TYPE_NEXT_VARIANT (v
))
2709 if (TYPE_CANONICAL (v
) == v
2710 && cp_check_qualified_type (v
, variant
, var_quals
,
2713 TYPE_RAISES_EXCEPTIONS (variant
) = raises
;
2716 v
= build_cp_fntype_variant (TYPE_CANONICAL (variant
),
2718 TYPE_CANONICAL (variant
) = v
;
2721 TYPE_RAISES_EXCEPTIONS (variant
) = raises
;
2725 /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
2726 listed in RAISES. */
2729 build_exception_variant (tree type
, tree raises
)
2731 cp_ref_qualifier rqual
= type_memfn_rqual (type
);
2732 bool late
= TYPE_HAS_LATE_RETURN_TYPE (type
);
2733 return build_cp_fntype_variant (type
, rqual
, raises
, late
);
2736 /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
2737 BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
2741 bind_template_template_parm (tree t
, tree newargs
)
2743 tree decl
= TYPE_NAME (t
);
2746 t2
= cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM
);
2747 decl
= build_decl (input_location
,
2748 TYPE_DECL
, DECL_NAME (decl
), NULL_TREE
);
2749 SET_DECL_TEMPLATE_PARM_P (decl
);
2751 /* These nodes have to be created to reflect new TYPE_DECL and template
2753 TEMPLATE_TYPE_PARM_INDEX (t2
) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t
));
2754 TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2
)) = decl
;
2755 TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2
)
2756 = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t
), newargs
);
2758 TREE_TYPE (decl
) = t2
;
2759 TYPE_NAME (t2
) = decl
;
2760 TYPE_STUB_DECL (t2
) = decl
;
2762 SET_TYPE_STRUCTURAL_EQUALITY (t2
);
2767 /* Called from count_trees via walk_tree. */
2770 count_trees_r (tree
*tp
, int *walk_subtrees
, void *data
)
2780 /* Debugging function for measuring the rough complexity of a tree
2784 count_trees (tree t
)
2787 cp_walk_tree_without_duplicates (&t
, count_trees_r
, &n_trees
);
2791 /* Called from verify_stmt_tree via walk_tree. */
2794 verify_stmt_tree_r (tree
* tp
, int * /*walk_subtrees*/, void* data
)
2797 hash_table
<nofree_ptr_hash
<tree_node
> > *statements
2798 = static_cast <hash_table
<nofree_ptr_hash
<tree_node
> > *> (data
);
2801 if (!STATEMENT_CODE_P (TREE_CODE (t
)))
2804 /* If this statement is already present in the hash table, then
2805 there is a circularity in the statement tree. */
2806 gcc_assert (!statements
->find (t
));
2808 slot
= statements
->find_slot (t
, INSERT
);
2814 /* Debugging function to check that the statement T has not been
2815 corrupted. For now, this function simply checks that T contains no
2819 verify_stmt_tree (tree t
)
2821 hash_table
<nofree_ptr_hash
<tree_node
> > statements (37);
2822 cp_walk_tree (&t
, verify_stmt_tree_r
, &statements
, NULL
);
2825 /* Check if the type T depends on a type with no linkage and if so,
2826 return it. If RELAXED_P then do not consider a class type declared
2827 within a vague-linkage function to have no linkage. Remember:
2828 no-linkage is not the same as internal-linkage*/
2831 no_linkage_check (tree t
, bool relaxed_p
)
2835 /* Lambda types that don't have mangling scope have no linkage. We
2836 check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
2837 when we get here from pushtag none of the lambda information is
2838 set up yet, so we want to assume that the lambda has linkage and
2839 fix it up later if not. We need to check this even in templates so
2840 that we properly handle a lambda-expression in the signature. */
2841 if (LAMBDA_TYPE_P (t
)
2842 && CLASSTYPE_LAMBDA_EXPR (t
) != error_mark_node
)
2844 tree extra
= LAMBDA_TYPE_EXTRA_SCOPE (t
);
2849 /* Otherwise there's no point in checking linkage on template functions; we
2850 can't know their complete types. */
2851 if (processing_template_decl
)
2854 switch (TREE_CODE (t
))
2857 if (TYPE_PTRMEMFUNC_P (t
))
2861 if (!CLASS_TYPE_P (t
))
2865 /* Only treat unnamed types as having no linkage if they're at
2866 namespace scope. This is core issue 966. */
2867 if (TYPE_UNNAMED_P (t
) && TYPE_NAMESPACE_SCOPE_P (t
))
2870 for (r
= CP_TYPE_CONTEXT (t
); ; )
2872 /* If we're a nested type of a !TREE_PUBLIC class, we might not
2873 have linkage, or we might just be in an anonymous namespace.
2874 If we're in a TREE_PUBLIC class, we have linkage. */
2875 if (TYPE_P (r
) && !TREE_PUBLIC (TYPE_NAME (r
)))
2876 return no_linkage_check (TYPE_CONTEXT (t
), relaxed_p
);
2877 else if (TREE_CODE (r
) == FUNCTION_DECL
)
2879 if (!relaxed_p
|| !vague_linkage_p (r
))
2882 r
= CP_DECL_CONTEXT (r
);
2892 case REFERENCE_TYPE
:
2894 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2898 r
= no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t
),
2902 return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t
), relaxed_p
);
2907 tree parm
= TYPE_ARG_TYPES (t
);
2908 if (TREE_CODE (t
) == METHOD_TYPE
)
2909 /* The 'this' pointer isn't interesting; a method has the same
2910 linkage (or lack thereof) as its enclosing class. */
2911 parm
= TREE_CHAIN (parm
);
2913 parm
&& parm
!= void_list_node
;
2914 parm
= TREE_CHAIN (parm
))
2916 r
= no_linkage_check (TREE_VALUE (parm
), relaxed_p
);
2920 return no_linkage_check (TREE_TYPE (t
), relaxed_p
);
2928 extern int depth_reached
;
2931 cxx_print_statistics (void)
2933 print_template_statistics ();
2934 if (GATHER_STATISTICS
)
2935 fprintf (stderr
, "maximum template instantiation depth reached: %d\n",
2939 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2940 (which is an ARRAY_TYPE). This counts only elements of the top
2944 array_type_nelts_top (tree type
)
2946 return fold_build2_loc (input_location
,
2947 PLUS_EXPR
, sizetype
,
2948 array_type_nelts (type
),
2952 /* Return, as an INTEGER_CST node, the number of elements for TYPE
2953 (which is an ARRAY_TYPE). This one is a recursive count of all
2954 ARRAY_TYPEs that are clumped together. */
2957 array_type_nelts_total (tree type
)
2959 tree sz
= array_type_nelts_top (type
);
2960 type
= TREE_TYPE (type
);
2961 while (TREE_CODE (type
) == ARRAY_TYPE
)
2963 tree n
= array_type_nelts_top (type
);
2964 sz
= fold_build2_loc (input_location
,
2965 MULT_EXPR
, sizetype
, sz
, n
);
2966 type
= TREE_TYPE (type
);
2973 splay_tree target_remap
;
2974 bool clear_location
;
2977 /* Called from break_out_target_exprs via mapcar. */
2980 bot_manip (tree
* tp
, int* walk_subtrees
, void* data_
)
2982 bot_data
&data
= *(bot_data
*)data_
;
2983 splay_tree target_remap
= data
.target_remap
;
2986 if (!TYPE_P (t
) && TREE_CONSTANT (t
) && !TREE_SIDE_EFFECTS (t
))
2988 /* There can't be any TARGET_EXPRs or their slot variables below this
2989 point. But we must make a copy, in case subsequent processing
2990 alters any part of it. For example, during gimplification a cast
2991 of the form (T) &X::f (where "f" is a member function) will lead
2992 to replacing the PTRMEM_CST for &X::f with a VAR_DECL. */
2994 *tp
= unshare_expr (t
);
2997 if (TREE_CODE (t
) == TARGET_EXPR
)
3001 if (TREE_CODE (TREE_OPERAND (t
, 1)) == AGGR_INIT_EXPR
)
3003 u
= build_cplus_new (TREE_TYPE (t
), TREE_OPERAND (t
, 1),
3004 tf_warning_or_error
);
3005 if (u
== error_mark_node
)
3007 if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t
, 1)))
3008 AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u
, 1)) = true;
3011 u
= build_target_expr_with_type (TREE_OPERAND (t
, 1), TREE_TYPE (t
),
3012 tf_warning_or_error
);
3014 TARGET_EXPR_IMPLICIT_P (u
) = TARGET_EXPR_IMPLICIT_P (t
);
3015 TARGET_EXPR_LIST_INIT_P (u
) = TARGET_EXPR_LIST_INIT_P (t
);
3016 TARGET_EXPR_DIRECT_INIT_P (u
) = TARGET_EXPR_DIRECT_INIT_P (t
);
3018 /* Map the old variable to the new one. */
3019 splay_tree_insert (target_remap
,
3020 (splay_tree_key
) TREE_OPERAND (t
, 0),
3021 (splay_tree_value
) TREE_OPERAND (u
, 0));
3023 TREE_OPERAND (u
, 1) = break_out_target_exprs (TREE_OPERAND (u
, 1),
3024 data
.clear_location
);
3025 if (TREE_OPERAND (u
, 1) == error_mark_node
)
3026 return error_mark_node
;
3028 /* Replace the old expression with the new version. */
3030 /* We don't have to go below this point; the recursive call to
3031 break_out_target_exprs will have handled anything below this
3036 if (TREE_CODE (*tp
) == SAVE_EXPR
)
3039 splay_tree_node n
= splay_tree_lookup (target_remap
,
3040 (splay_tree_key
) t
);
3043 *tp
= (tree
)n
->value
;
3048 copy_tree_r (tp
, walk_subtrees
, NULL
);
3049 splay_tree_insert (target_remap
,
3051 (splay_tree_value
)*tp
);
3052 /* Make sure we don't remap an already-remapped SAVE_EXPR. */
3053 splay_tree_insert (target_remap
,
3054 (splay_tree_key
)*tp
,
3055 (splay_tree_value
)*tp
);
3060 /* Make a copy of this node. */
3061 t
= copy_tree_r (tp
, walk_subtrees
, NULL
);
3062 if (TREE_CODE (*tp
) == CALL_EXPR
|| TREE_CODE (*tp
) == AGGR_INIT_EXPR
)
3063 if (!processing_template_decl
)
3064 set_flags_from_callee (*tp
);
3065 if (data
.clear_location
&& EXPR_HAS_LOCATION (*tp
))
3066 SET_EXPR_LOCATION (*tp
, input_location
);
3070 /* Replace all remapped VAR_DECLs in T with their new equivalents.
3071 DATA is really a splay-tree mapping old variables to new
3075 bot_replace (tree
* t
, int* /*walk_subtrees*/, void* data_
)
3077 bot_data
&data
= *(bot_data
*)data_
;
3078 splay_tree target_remap
= data
.target_remap
;
3082 splay_tree_node n
= splay_tree_lookup (target_remap
,
3083 (splay_tree_key
) *t
);
3085 *t
= (tree
) n
->value
;
3087 else if (TREE_CODE (*t
) == PARM_DECL
3088 && DECL_NAME (*t
) == this_identifier
3089 && !DECL_CONTEXT (*t
))
3091 /* In an NSDMI we need to replace the 'this' parameter we used for
3092 parsing with the real one for this function. */
3093 *t
= current_class_ptr
;
3095 else if (TREE_CODE (*t
) == CONVERT_EXPR
3096 && CONVERT_EXPR_VBASE_PATH (*t
))
3098 /* In an NSDMI build_base_path defers building conversions to virtual
3099 bases, and we handle it here. */
3100 tree basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t
)));
3101 vec
<tree
, va_gc
> *vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
3103 FOR_EACH_VEC_SAFE_ELT (vbases
, i
, binfo
)
3104 if (BINFO_TYPE (binfo
) == basetype
)
3106 *t
= build_base_path (PLUS_EXPR
, TREE_OPERAND (*t
, 0), binfo
, true,
3107 tf_warning_or_error
);
3113 /* When we parse a default argument expression, we may create
3114 temporary variables via TARGET_EXPRs. When we actually use the
3115 default-argument expression, we make a copy of the expression
3116 and replace the temporaries with appropriate local versions.
3118 If CLEAR_LOCATION is true, override any EXPR_LOCATION with
3122 break_out_target_exprs (tree t
, bool clear_location
/* = false */)
3124 static int target_remap_count
;
3125 static splay_tree target_remap
;
3127 if (!target_remap_count
++)
3128 target_remap
= splay_tree_new (splay_tree_compare_pointers
,
3129 /*splay_tree_delete_key_fn=*/NULL
,
3130 /*splay_tree_delete_value_fn=*/NULL
);
3131 bot_data data
= { target_remap
, clear_location
};
3132 if (cp_walk_tree (&t
, bot_manip
, &data
, NULL
) == error_mark_node
)
3133 t
= error_mark_node
;
3134 cp_walk_tree (&t
, bot_replace
, &data
, NULL
);
3136 if (!--target_remap_count
)
3138 splay_tree_delete (target_remap
);
3139 target_remap
= NULL
;
3145 /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
3146 which we expect to have type TYPE. */
3149 build_ctor_subob_ref (tree index
, tree type
, tree obj
)
3151 if (index
== NULL_TREE
)
3152 /* Can't refer to a particular member of a vector. */
3154 else if (TREE_CODE (index
) == INTEGER_CST
)
3155 obj
= cp_build_array_ref (input_location
, obj
, index
, tf_none
);
3157 obj
= build_class_member_access_expr (obj
, index
, NULL_TREE
,
3158 /*reference*/false, tf_none
);
3161 tree objtype
= TREE_TYPE (obj
);
3162 if (TREE_CODE (objtype
) == ARRAY_TYPE
&& !TYPE_DOMAIN (objtype
))
3164 /* When the destination object refers to a flexible array member
3165 verify that it matches the type of the source object except
3166 for its domain and qualifiers. */
3167 gcc_assert (comptypes (TYPE_MAIN_VARIANT (type
),
3168 TYPE_MAIN_VARIANT (objtype
),
3169 COMPARE_REDECLARATION
));
3172 gcc_assert (same_type_ignoring_top_level_qualifiers_p (type
, objtype
));
3178 struct replace_placeholders_t
3180 tree obj
; /* The object to be substituted for a PLACEHOLDER_EXPR. */
3181 tree exp
; /* The outermost exp. */
3182 bool seen
; /* Whether we've encountered a PLACEHOLDER_EXPR. */
3183 hash_set
<tree
> *pset
; /* To avoid walking same trees multiple times. */
3186 /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
3187 build up subexpressions as we go deeper. */
3190 replace_placeholders_r (tree
* t
, int* walk_subtrees
, void* data_
)
3192 replace_placeholders_t
*d
= static_cast<replace_placeholders_t
*>(data_
);
3195 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3197 *walk_subtrees
= false;
3201 switch (TREE_CODE (*t
))
3203 case PLACEHOLDER_EXPR
:
3206 for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t
),
3208 x
= TREE_OPERAND (x
, 0))
3209 gcc_assert (handled_component_p (x
));
3210 *t
= unshare_expr (x
);
3211 *walk_subtrees
= false;
3218 constructor_elt
*ce
;
3219 vec
<constructor_elt
,va_gc
> *v
= CONSTRUCTOR_ELTS (*t
);
3220 /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
3221 other than the d->exp one, those have PLACEHOLDER_EXPRs
3222 related to another object. */
3223 if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
)
3225 || d
->pset
->add (*t
))
3227 *walk_subtrees
= false;
3230 for (unsigned i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
3232 tree
*valp
= &ce
->value
;
3233 tree type
= TREE_TYPE (*valp
);
3236 /* Elements with RANGE_EXPR index shouldn't have any
3237 placeholders in them. */
3238 if (ce
->index
&& TREE_CODE (ce
->index
) == RANGE_EXPR
)
3241 if (TREE_CODE (*valp
) == CONSTRUCTOR
3242 && AGGREGATE_TYPE_P (type
))
3244 /* If we're looking at the initializer for OBJ, then build
3245 a sub-object reference. If we're looking at an
3246 initializer for another object, just pass OBJ down. */
3247 if (same_type_ignoring_top_level_qualifiers_p
3248 (TREE_TYPE (*t
), TREE_TYPE (obj
)))
3249 subob
= build_ctor_subob_ref (ce
->index
, type
, obj
);
3250 if (TREE_CODE (*valp
) == TARGET_EXPR
)
3251 valp
= &TARGET_EXPR_INITIAL (*valp
);
3254 cp_walk_tree (valp
, replace_placeholders_r
, data_
, NULL
);
3257 *walk_subtrees
= false;
3262 if (d
->pset
->add (*t
))
3263 *walk_subtrees
= false;
3270 /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ. SEEN_P is set if
3271 a PLACEHOLDER_EXPR has been encountered. */
3274 replace_placeholders (tree exp
, tree obj
, bool *seen_p
/*= NULL*/)
3276 /* This is only relevant for C++14. */
3277 if (cxx_dialect
< cxx14
)
3280 /* If the object isn't a (member of a) class, do nothing. */
3282 while (handled_component_p (op0
))
3283 op0
= TREE_OPERAND (op0
, 0);
3284 if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0
))))
3288 if (TREE_CODE (exp
) == TARGET_EXPR
)
3289 tp
= &TARGET_EXPR_INITIAL (exp
);
3290 hash_set
<tree
> pset
;
3291 replace_placeholders_t data
= { obj
, *tp
, false, &pset
};
3292 cp_walk_tree (tp
, replace_placeholders_r
, &data
, NULL
);
3294 *seen_p
= data
.seen
;
3298 /* Callback function for find_placeholders. */
3301 find_placeholders_r (tree
*t
, int *walk_subtrees
, void *)
3303 if (TYPE_P (*t
) || TREE_CONSTANT (*t
))
3305 *walk_subtrees
= false;
3309 switch (TREE_CODE (*t
))
3311 case PLACEHOLDER_EXPR
:
3315 if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t
))
3316 *walk_subtrees
= false;
3326 /* Return true if EXP contains a PLACEHOLDER_EXPR. Don't walk into
3327 ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set. */
3330 find_placeholders (tree exp
)
3332 /* This is only relevant for C++14. */
3333 if (cxx_dialect
< cxx14
)
3336 return cp_walk_tree_without_duplicates (&exp
, find_placeholders_r
, NULL
);
3339 /* Similar to `build_nt', but for template definitions of dependent
3343 build_min_nt_loc (location_t loc
, enum tree_code code
, ...)
3350 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3354 t
= make_node (code
);
3355 SET_EXPR_LOCATION (t
, loc
);
3356 length
= TREE_CODE_LENGTH (code
);
3358 for (i
= 0; i
< length
; i
++)
3359 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3365 /* Similar to `build', but for template definitions. */
3368 build_min (enum tree_code code
, tree tt
, ...)
3375 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3379 t
= make_node (code
);
3380 length
= TREE_CODE_LENGTH (code
);
3383 for (i
= 0; i
< length
; i
++)
3385 tree x
= va_arg (p
, tree
);
3386 TREE_OPERAND (t
, i
) = x
;
3387 if (x
&& !TYPE_P (x
) && TREE_SIDE_EFFECTS (x
))
3388 TREE_SIDE_EFFECTS (t
) = 1;
3396 /* Similar to `build', but for template definitions of non-dependent
3397 expressions. NON_DEP is the non-dependent expression that has been
3401 build_min_non_dep (enum tree_code code
, tree non_dep
, ...)
3408 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
3410 va_start (p
, non_dep
);
3412 if (REFERENCE_REF_P (non_dep
))
3413 non_dep
= TREE_OPERAND (non_dep
, 0);
3415 t
= make_node (code
);
3416 SET_EXPR_LOCATION (t
, cp_expr_loc_or_input_loc (non_dep
));
3417 length
= TREE_CODE_LENGTH (code
);
3418 TREE_TYPE (t
) = unlowered_expr_type (non_dep
);
3419 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3421 for (i
= 0; i
< length
; i
++)
3422 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3424 if (code
== COMPOUND_EXPR
&& TREE_CODE (non_dep
) != COMPOUND_EXPR
)
3425 /* This should not be considered a COMPOUND_EXPR, because it
3426 resolves to an overload. */
3427 COMPOUND_EXPR_OVERLOADED (t
) = 1;
3430 return convert_from_reference (t
);
3433 /* Similar to build_min_nt, but call expressions */
3436 build_min_nt_call_vec (tree fn
, vec
<tree
, va_gc
> *args
)
3441 ret
= build_vl_exp (CALL_EXPR
, vec_safe_length (args
) + 3);
3442 CALL_EXPR_FN (ret
) = fn
;
3443 CALL_EXPR_STATIC_CHAIN (ret
) = NULL_TREE
;
3444 FOR_EACH_VEC_SAFE_ELT (args
, ix
, t
)
3445 CALL_EXPR_ARG (ret
, ix
) = t
;
3450 /* Similar to `build_min_nt_call_vec', but for template definitions of
3451 non-dependent expressions. NON_DEP is the non-dependent expression
3452 that has been built. */
3455 build_min_non_dep_call_vec (tree non_dep
, tree fn
, vec
<tree
, va_gc
> *argvec
)
3457 tree t
= build_min_nt_call_vec (fn
, argvec
);
3458 if (REFERENCE_REF_P (non_dep
))
3459 non_dep
= TREE_OPERAND (non_dep
, 0);
3460 TREE_TYPE (t
) = TREE_TYPE (non_dep
);
3461 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (non_dep
);
3462 return convert_from_reference (t
);
3465 /* Similar to build_min_non_dep, but for expressions that have been resolved to
3466 a call to an operator overload. OP is the operator that has been
3467 overloaded. NON_DEP is the non-dependent expression that's been built,
3468 which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR. OVERLOAD is
3469 the overload that NON_DEP is calling. */
3472 build_min_non_dep_op_overload (enum tree_code op
,
3477 int nargs
, expected_nargs
;
3480 non_dep
= extract_call_expr (non_dep
);
3482 nargs
= call_expr_nargs (non_dep
);
3484 expected_nargs
= cp_tree_code_length (op
);
3485 if ((op
== POSTINCREMENT_EXPR
3486 || op
== POSTDECREMENT_EXPR
)
3487 /* With -fpermissive non_dep could be operator++(). */
3488 && (!flag_permissive
|| nargs
!= expected_nargs
))
3489 expected_nargs
+= 1;
3490 gcc_assert (nargs
== expected_nargs
);
3493 va_start (p
, overload
);
3495 if (TREE_CODE (TREE_TYPE (overload
)) == FUNCTION_TYPE
)
3498 for (int i
= 0; i
< nargs
; i
++)
3500 tree arg
= va_arg (p
, tree
);
3501 vec_safe_push (args
, arg
);
3504 else if (TREE_CODE (TREE_TYPE (overload
)) == METHOD_TYPE
)
3506 tree object
= va_arg (p
, tree
);
3507 tree binfo
= TYPE_BINFO (TREE_TYPE (object
));
3508 tree method
= build_baselink (binfo
, binfo
, overload
, NULL_TREE
);
3509 fn
= build_min (COMPONENT_REF
, TREE_TYPE (overload
),
3510 object
, method
, NULL_TREE
);
3511 for (int i
= 1; i
< nargs
; i
++)
3513 tree arg
= va_arg (p
, tree
);
3514 vec_safe_push (args
, arg
);
3521 call
= build_min_non_dep_call_vec (non_dep
, fn
, args
);
3523 tree call_expr
= extract_call_expr (call
);
3524 KOENIG_LOOKUP_P (call_expr
) = KOENIG_LOOKUP_P (non_dep
);
3525 CALL_EXPR_OPERATOR_SYNTAX (call_expr
) = true;
3526 CALL_EXPR_ORDERED_ARGS (call_expr
) = CALL_EXPR_ORDERED_ARGS (non_dep
);
3527 CALL_EXPR_REVERSE_ARGS (call_expr
) = CALL_EXPR_REVERSE_ARGS (non_dep
);
3532 /* Return a new tree vec copied from VEC, with ELT inserted at index IDX. */
3535 vec_copy_and_insert (vec
<tree
, va_gc
> *old_vec
, tree elt
, unsigned idx
)
3537 unsigned len
= vec_safe_length (old_vec
);
3538 gcc_assert (idx
<= len
);
3540 vec
<tree
, va_gc
> *new_vec
= NULL
;
3541 vec_alloc (new_vec
, len
+ 1);
3544 for (i
= 0; i
< len
; ++i
)
3547 new_vec
->quick_push (elt
);
3548 new_vec
->quick_push ((*old_vec
)[i
]);
3551 new_vec
->quick_push (elt
);
3557 get_type_decl (tree t
)
3559 if (TREE_CODE (t
) == TYPE_DECL
)
3562 return TYPE_STUB_DECL (t
);
3563 gcc_assert (t
== error_mark_node
);
3567 /* Returns the namespace that contains DECL, whether directly or
3571 decl_namespace_context (tree decl
)
3575 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3577 else if (TYPE_P (decl
))
3578 decl
= CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl
));
3580 decl
= CP_DECL_CONTEXT (decl
);
3584 /* Returns true if decl is within an anonymous namespace, however deeply
3585 nested, or false otherwise. */
3588 decl_anon_ns_mem_p (const_tree decl
)
3590 while (TREE_CODE (decl
) != NAMESPACE_DECL
)
3592 /* Classes inside anonymous namespaces have TREE_PUBLIC == 0. */
3594 return !TREE_PUBLIC (TYPE_MAIN_DECL (decl
));
3596 decl
= CP_DECL_CONTEXT (decl
);
3598 return !TREE_PUBLIC (decl
);
3601 /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
3602 CALL_EXPRS. Return whether they are equivalent. */
3605 called_fns_equal (tree t1
, tree t2
)
3607 /* Core 1321: dependent names are equivalent even if the overload sets
3608 are different. But do compare explicit template arguments. */
3609 tree name1
= dependent_name (t1
);
3610 tree name2
= dependent_name (t2
);
3613 tree targs1
= NULL_TREE
, targs2
= NULL_TREE
;
3618 /* FIXME dependent_name currently returns an unqualified name regardless
3619 of whether the function was named with a qualified- or unqualified-id.
3620 Until that's fixed, check that we aren't looking at overload sets from
3621 different scopes. */
3622 if (is_overloaded_fn (t1
) && is_overloaded_fn (t2
)
3623 && (DECL_CONTEXT (get_first_fn (t1
))
3624 != DECL_CONTEXT (get_first_fn (t2
))))
3627 if (TREE_CODE (t1
) == TEMPLATE_ID_EXPR
)
3628 targs1
= TREE_OPERAND (t1
, 1);
3629 if (TREE_CODE (t2
) == TEMPLATE_ID_EXPR
)
3630 targs2
= TREE_OPERAND (t2
, 1);
3631 return cp_tree_equal (targs1
, targs2
);
3634 return cp_tree_equal (t1
, t2
);
3637 /* Return truthvalue of whether T1 is the same tree structure as T2.
3638 Return 1 if they are the same. Return 0 if they are different. */
3641 cp_tree_equal (tree t1
, tree t2
)
3643 enum tree_code code1
, code2
;
3650 code1
= TREE_CODE (t1
);
3651 code2
= TREE_CODE (t2
);
3656 if (CONSTANT_CLASS_P (t1
)
3657 && !same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3663 /* There's only a single VOID_CST node, so we should never reach
3668 return tree_int_cst_equal (t1
, t2
);
3671 return real_equal (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
3674 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3675 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3676 TREE_STRING_LENGTH (t1
));
3679 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
3680 TREE_FIXED_CST (t2
));
3683 return cp_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
3684 && cp_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
3687 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
3690 /* We need to do this when determining whether or not two
3691 non-type pointer to member function template arguments
3693 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
3694 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
3699 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
3701 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
3702 if (!cp_tree_equal (field
, elt2
->index
)
3703 || !cp_tree_equal (value
, elt2
->value
))
3710 if (!cp_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
3712 if (!cp_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
3714 return cp_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
3717 return cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3721 if (KOENIG_LOOKUP_P (t1
) != KOENIG_LOOKUP_P (t2
))
3724 if (!called_fns_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
3727 call_expr_arg_iterator iter1
, iter2
;
3728 init_call_expr_arg_iterator (t1
, &iter1
);
3729 init_call_expr_arg_iterator (t2
, &iter2
);
3730 if (iter1
.n
!= iter2
.n
)
3733 while (more_call_expr_args_p (&iter1
))
3735 tree arg1
= next_call_expr_arg (&iter1
);
3736 tree arg2
= next_call_expr_arg (&iter2
);
3738 gcc_checking_assert (arg1
&& arg2
);
3739 if (!cp_tree_equal (arg1
, arg2
))
3748 tree o1
= TREE_OPERAND (t1
, 0);
3749 tree o2
= TREE_OPERAND (t2
, 0);
3751 /* Special case: if either target is an unallocated VAR_DECL,
3752 it means that it's going to be unified with whatever the
3753 TARGET_EXPR is really supposed to initialize, so treat it
3754 as being equivalent to anything. */
3755 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
3756 && !DECL_RTL_SET_P (o1
))
3758 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
3759 && !DECL_RTL_SET_P (o2
))
3761 else if (!cp_tree_equal (o1
, o2
))
3764 return cp_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
3768 /* For comparing uses of parameters in late-specified return types
3769 with an out-of-class definition of the function, but can also come
3770 up for expressions that involve 'this' in a member function
3773 if (comparing_specializations
3774 && DECL_CONTEXT (t1
) != DECL_CONTEXT (t2
))
3775 /* When comparing hash table entries, only an exact match is
3776 good enough; we don't want to replace 'this' with the
3777 version from another function. But be more flexible
3778 with parameters with identical contexts. */
3781 if (same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3783 if (DECL_ARTIFICIAL (t1
) ^ DECL_ARTIFICIAL (t2
))
3785 if (CONSTRAINT_VAR_P (t1
) ^ CONSTRAINT_VAR_P (t2
))
3787 if (DECL_ARTIFICIAL (t1
)
3788 || (DECL_PARM_LEVEL (t1
) == DECL_PARM_LEVEL (t2
)
3789 && DECL_PARM_INDEX (t1
) == DECL_PARM_INDEX (t2
)))
3799 case IDENTIFIER_NODE
:
3802 case DEFERRED_PARSE
:
3806 return (BASELINK_BINFO (t1
) == BASELINK_BINFO (t2
)
3807 && BASELINK_ACCESS_BINFO (t1
) == BASELINK_ACCESS_BINFO (t2
)
3808 && BASELINK_QUALIFIED_P (t1
) == BASELINK_QUALIFIED_P (t2
)
3809 && cp_tree_equal (BASELINK_FUNCTIONS (t1
),
3810 BASELINK_FUNCTIONS (t2
)));
3812 case TEMPLATE_PARM_INDEX
:
3813 return (TEMPLATE_PARM_IDX (t1
) == TEMPLATE_PARM_IDX (t2
)
3814 && TEMPLATE_PARM_LEVEL (t1
) == TEMPLATE_PARM_LEVEL (t2
)
3815 && (TEMPLATE_PARM_PARAMETER_PACK (t1
)
3816 == TEMPLATE_PARM_PARAMETER_PACK (t2
))
3817 && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1
)),
3818 TREE_TYPE (TEMPLATE_PARM_DECL (t2
))));
3820 case TEMPLATE_ID_EXPR
:
3821 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3823 if (!comp_template_args (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)))
3827 case CONSTRAINT_INFO
:
3828 return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1
),
3829 CI_ASSOCIATED_CONSTRAINTS (t2
));
3832 return (CHECK_CONSTR_CONCEPT (t1
) == CHECK_CONSTR_CONCEPT (t2
)
3833 && comp_template_args (CHECK_CONSTR_ARGS (t1
),
3834 CHECK_CONSTR_ARGS (t2
)));
3837 /* These are template args. Really we should be getting the
3838 caller to do this as it knows it to be true. */
3839 if (!comp_template_args (t1
, t2
, NULL
, NULL
, false))
3846 tree o1
= TREE_OPERAND (t1
, 0);
3847 tree o2
= TREE_OPERAND (t2
, 0);
3849 if (code1
== SIZEOF_EXPR
)
3851 if (SIZEOF_EXPR_TYPE_P (t1
))
3852 o1
= TREE_TYPE (o1
);
3853 if (SIZEOF_EXPR_TYPE_P (t2
))
3854 o2
= TREE_TYPE (o2
);
3856 else if (ALIGNOF_EXPR_STD_P (t1
) != ALIGNOF_EXPR_STD_P (t2
))
3859 if (TREE_CODE (o1
) != TREE_CODE (o2
))
3862 if (ARGUMENT_PACK_P (o1
))
3863 return template_args_equal (o1
, o2
);
3864 else if (TYPE_P (o1
))
3865 return same_type_p (o1
, o2
);
3867 return cp_tree_equal (o1
, o2
);
3872 tree t1_op1
, t2_op1
;
3874 if (!cp_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
3877 t1_op1
= TREE_OPERAND (t1
, 1);
3878 t2_op1
= TREE_OPERAND (t2
, 1);
3879 if (TREE_CODE (t1_op1
) != TREE_CODE (t2_op1
))
3882 return cp_tree_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t2
, 2));
3886 /* Two pointer-to-members are the same if they point to the same
3887 field or function in the same class. */
3888 if (PTRMEM_CST_MEMBER (t1
) != PTRMEM_CST_MEMBER (t2
))
3891 return same_type_p (PTRMEM_CST_CLASS (t1
), PTRMEM_CST_CLASS (t2
));
3895 /* Two overloads. Must be exactly the same set of decls. */
3896 lkp_iterator
first (t1
);
3897 lkp_iterator
second (t2
);
3899 for (; first
&& second
; ++first
, ++second
)
3900 if (*first
!= *second
)
3902 return !(first
|| second
);
3906 if (TRAIT_EXPR_KIND (t1
) != TRAIT_EXPR_KIND (t2
))
3908 return same_type_p (TRAIT_EXPR_TYPE1 (t1
), TRAIT_EXPR_TYPE1 (t2
))
3909 && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1
), TRAIT_EXPR_TYPE2 (t2
));
3912 case STATIC_CAST_EXPR
:
3913 case REINTERPRET_CAST_EXPR
:
3914 case CONST_CAST_EXPR
:
3915 case DYNAMIC_CAST_EXPR
:
3916 case IMPLICIT_CONV_EXPR
:
3919 case NON_LVALUE_EXPR
:
3920 case VIEW_CONVERT_EXPR
:
3921 if (!same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
3923 /* Now compare operands as usual. */
3926 case DEFERRED_NOEXCEPT
:
3927 return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1
),
3928 DEFERRED_NOEXCEPT_PATTERN (t2
))
3929 && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1
),
3930 DEFERRED_NOEXCEPT_ARGS (t2
)));
3933 /* Two lambda-expressions are never considered equivalent. */
3936 case TYPE_ARGUMENT_PACK
:
3937 case NONTYPE_ARGUMENT_PACK
:
3939 tree p1
= ARGUMENT_PACK_ARGS (t1
);
3940 tree p2
= ARGUMENT_PACK_ARGS (t2
);
3941 int len
= TREE_VEC_LENGTH (p1
);
3942 if (TREE_VEC_LENGTH (p2
) != len
)
3945 for (int ix
= 0; ix
!= len
; ix
++)
3946 if (!template_args_equal (TREE_VEC_ELT (p1
, ix
),
3947 TREE_VEC_ELT (p2
, ix
)))
3952 case EXPR_PACK_EXPANSION
:
3953 if (!cp_tree_equal (PACK_EXPANSION_PATTERN (t1
),
3954 PACK_EXPANSION_PATTERN (t2
)))
3956 if (!comp_template_args (PACK_EXPANSION_EXTRA_ARGS (t1
),
3957 PACK_EXPANSION_EXTRA_ARGS (t2
)))
3965 switch (TREE_CODE_CLASS (code1
))
3969 case tcc_comparison
:
3970 case tcc_expression
:
3975 int n
= cp_tree_operand_length (t1
);
3976 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
3977 && n
!= TREE_OPERAND_LENGTH (t2
))
3980 for (int i
= 0; i
< n
; ++i
)
3981 if (!cp_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
3988 return same_type_p (t1
, t2
);
3994 /* We can get here with --disable-checking. */
3998 /* The type of ARG when used as an lvalue. */
4001 lvalue_type (tree arg
)
4003 tree type
= TREE_TYPE (arg
);
4007 /* The type of ARG for printing error messages; denote lvalues with
4011 error_type (tree arg
)
4013 tree type
= TREE_TYPE (arg
);
4015 if (TREE_CODE (type
) == ARRAY_TYPE
)
4017 else if (TREE_CODE (type
) == ERROR_MARK
)
4019 else if (lvalue_p (arg
))
4020 type
= build_reference_type (lvalue_type (arg
));
4021 else if (MAYBE_CLASS_TYPE_P (type
))
4022 type
= lvalue_type (arg
);
4027 /* Does FUNCTION use a variable-length argument list? */
4030 varargs_function_p (const_tree function
)
4032 return stdarg_p (TREE_TYPE (function
));
4035 /* Returns 1 if decl is a member of a class. */
4038 member_p (const_tree decl
)
4040 const_tree
const ctx
= DECL_CONTEXT (decl
);
4041 return (ctx
&& TYPE_P (ctx
));
4044 /* Create a placeholder for member access where we don't actually have an
4045 object that the access is against. */
4048 build_dummy_object (tree type
)
4050 tree decl
= build1 (CONVERT_EXPR
, build_pointer_type (type
), void_node
);
4051 return cp_build_fold_indirect_ref (decl
);
4054 /* We've gotten a reference to a member of TYPE. Return *this if appropriate,
4055 or a dummy object otherwise. If BINFOP is non-0, it is filled with the
4056 binfo path from current_class_type to TYPE, or 0. */
4059 maybe_dummy_object (tree type
, tree
* binfop
)
4063 tree current
= current_nonlambda_class_type ();
4066 && (binfo
= lookup_base (current
, type
, ba_any
, NULL
,
4067 tf_warning_or_error
)))
4071 /* Reference from a nested class member function. */
4073 binfo
= TYPE_BINFO (type
);
4079 if (current_class_ref
4080 /* current_class_ref might not correspond to current_class_type if
4081 we're in tsubst_default_argument or a lambda-declarator; in either
4082 case, we want to use current_class_ref if it matches CONTEXT. */
4083 && (same_type_ignoring_top_level_qualifiers_p
4084 (TREE_TYPE (current_class_ref
), context
)))
4085 decl
= current_class_ref
;
4087 decl
= build_dummy_object (context
);
4092 /* Returns 1 if OB is a placeholder object, or a pointer to one. */
4095 is_dummy_object (const_tree ob
)
4097 if (INDIRECT_REF_P (ob
))
4098 ob
= TREE_OPERAND (ob
, 0);
4099 return (TREE_CODE (ob
) == CONVERT_EXPR
4100 && TREE_OPERAND (ob
, 0) == void_node
);
4103 /* Returns true if TYPE is char, unsigned char, or std::byte. */
4106 is_byte_access_type (tree type
)
4108 type
= TYPE_MAIN_VARIANT (type
);
4109 if (type
== char_type_node
4110 || type
== unsigned_char_type_node
)
4113 return (TREE_CODE (type
) == ENUMERAL_TYPE
4114 && TYPE_CONTEXT (type
) == std_node
4115 && !strcmp ("byte", TYPE_NAME_STRING (type
)));
4118 /* Returns 1 iff type T is something we want to treat as a scalar type for
4119 the purpose of deciding whether it is trivial/POD/standard-layout. */
4122 scalarish_type_p (const_tree t
)
4124 if (t
== error_mark_node
)
4127 return (SCALAR_TYPE_P (t
) || VECTOR_TYPE_P (t
));
4130 /* Returns true iff T requires non-trivial default initialization. */
4133 type_has_nontrivial_default_init (const_tree t
)
4135 t
= strip_array_types (CONST_CAST_TREE (t
));
4137 if (CLASS_TYPE_P (t
))
4138 return TYPE_HAS_COMPLEX_DFLT (t
);
4143 /* Track classes with only deleted copy/move constructors so that we can warn
4144 if they are used in call/return by value. */
4146 static GTY(()) hash_set
<tree
>* deleted_copy_types
;
4148 remember_deleted_copy (const_tree t
)
4150 if (!deleted_copy_types
)
4151 deleted_copy_types
= hash_set
<tree
>::create_ggc(37);
4152 deleted_copy_types
->add (CONST_CAST_TREE (t
));
4155 maybe_warn_parm_abi (tree t
, location_t loc
)
4157 if (!deleted_copy_types
4158 || !deleted_copy_types
->contains (t
))
4161 if ((flag_abi_version
== 12 || warn_abi_version
== 12)
4162 && classtype_has_non_deleted_move_ctor (t
))
4165 auto_diagnostic_group d
;
4166 if (flag_abi_version
> 12)
4167 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=13%> (GCC 8.2) fixes "
4168 "the calling convention for %qT, which was "
4169 "accidentally changed in 8.1", t
);
4171 w
= warning_at (loc
, OPT_Wabi
, "%<-fabi-version=12%> (GCC 8.1) accident"
4172 "ally changes the calling convention for %qT", t
);
4174 inform (location_of (t
), " declared here");
4178 auto_diagnostic_group d
;
4179 if (warning_at (loc
, OPT_Wabi
, "the calling convention for %qT changes in "
4180 "%<-fabi-version=13%> (GCC 8.2)", t
))
4181 inform (location_of (t
), " because all of its copy and move "
4182 "constructors are deleted");
4185 /* Returns true iff copying an object of type T (including via move
4186 constructor) is non-trivial. That is, T has no non-trivial copy
4187 constructors and no non-trivial move constructors, and not all copy/move
4188 constructors are deleted. This function implements the ABI notion of
4189 non-trivial copy, which has diverged from the one in the standard. */
4192 type_has_nontrivial_copy_init (const_tree type
)
4194 tree t
= strip_array_types (CONST_CAST_TREE (type
));
4196 if (CLASS_TYPE_P (t
))
4198 gcc_assert (COMPLETE_TYPE_P (t
));
4200 if (TYPE_HAS_COMPLEX_COPY_CTOR (t
)
4201 || TYPE_HAS_COMPLEX_MOVE_CTOR (t
))
4205 if (cxx_dialect
< cxx11
)
4206 /* No deleted functions before C++11. */
4209 /* Before ABI v12 we did a bitwise copy of types with only deleted
4210 copy/move constructors. */
4211 if (!abi_version_at_least (12)
4212 && !(warn_abi
&& abi_version_crosses (12)))
4215 bool saw_copy
= false;
4216 bool saw_non_deleted
= false;
4217 bool saw_non_deleted_move
= false;
4219 if (CLASSTYPE_LAZY_MOVE_CTOR (t
))
4220 saw_copy
= saw_non_deleted
= true;
4221 else if (CLASSTYPE_LAZY_COPY_CTOR (t
))
4224 if (classtype_has_move_assign_or_move_ctor_p (t
, true))
4225 /* [class.copy]/8 If the class definition declares a move
4226 constructor or move assignment operator, the implicitly declared
4227 copy constructor is defined as deleted.... */;
4229 /* Any other reason the implicitly-declared function would be
4230 deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
4232 saw_non_deleted
= true;
4235 if (!saw_non_deleted
)
4236 for (ovl_iterator
iter (CLASSTYPE_CONSTRUCTORS (t
)); iter
; ++iter
)
4242 if (!DECL_DELETED_FN (fn
))
4244 /* Not deleted, therefore trivial. */
4245 saw_non_deleted
= true;
4249 else if (move_fn_p (fn
))
4250 if (!DECL_DELETED_FN (fn
))
4251 saw_non_deleted_move
= true;
4254 gcc_assert (saw_copy
);
4256 /* ABI v12 buggily ignored move constructors. */
4257 bool v11nontriv
= false;
4258 bool v12nontriv
= !saw_non_deleted
;
4259 bool v13nontriv
= !saw_non_deleted
&& !saw_non_deleted_move
;
4260 bool nontriv
= (abi_version_at_least (13) ? v13nontriv
4261 : flag_abi_version
== 12 ? v12nontriv
4263 bool warn_nontriv
= (warn_abi_version
>= 13 ? v13nontriv
4264 : warn_abi_version
== 12 ? v12nontriv
4266 if (nontriv
!= warn_nontriv
)
4267 remember_deleted_copy (t
);
4275 /* Returns 1 iff type T is a trivially copyable type, as defined in
4276 [basic.types] and [class]. */
4279 trivially_copyable_p (const_tree t
)
4281 t
= strip_array_types (CONST_CAST_TREE (t
));
4283 if (CLASS_TYPE_P (t
))
4284 return ((!TYPE_HAS_COPY_CTOR (t
)
4285 || !TYPE_HAS_COMPLEX_COPY_CTOR (t
))
4286 && !TYPE_HAS_COMPLEX_MOVE_CTOR (t
)
4287 && (!TYPE_HAS_COPY_ASSIGN (t
)
4288 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t
))
4289 && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t
)
4290 && TYPE_HAS_TRIVIAL_DESTRUCTOR (t
));
4292 /* CWG 2094 makes volatile-qualified scalars trivially copyable again. */
4293 return scalarish_type_p (t
);
4296 /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
4300 trivial_type_p (const_tree t
)
4302 t
= strip_array_types (CONST_CAST_TREE (t
));
4304 if (CLASS_TYPE_P (t
))
4305 return (TYPE_HAS_TRIVIAL_DFLT (t
)
4306 && trivially_copyable_p (t
));
4308 return scalarish_type_p (t
);
4311 /* Returns 1 iff type T is a POD type, as defined in [basic.types]. */
4314 pod_type_p (const_tree t
)
4316 /* This CONST_CAST is okay because strip_array_types returns its
4317 argument unmodified and we assign it to a const_tree. */
4318 t
= strip_array_types (CONST_CAST_TREE(t
));
4320 if (!CLASS_TYPE_P (t
))
4321 return scalarish_type_p (t
);
4322 else if (cxx_dialect
> cxx98
)
4323 /* [class]/10: A POD struct is a class that is both a trivial class and a
4324 standard-layout class, and has no non-static data members of type
4325 non-POD struct, non-POD union (or array of such types).
4327 We don't need to check individual members because if a member is
4328 non-std-layout or non-trivial, the class will be too. */
4329 return (std_layout_type_p (t
) && trivial_type_p (t
));
4331 /* The C++98 definition of POD is different. */
4332 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4335 /* Returns true iff T is POD for the purpose of layout, as defined in the
4339 layout_pod_type_p (const_tree t
)
4341 t
= strip_array_types (CONST_CAST_TREE (t
));
4343 if (CLASS_TYPE_P (t
))
4344 return !CLASSTYPE_NON_LAYOUT_POD_P (t
);
4346 return scalarish_type_p (t
);
4349 /* Returns true iff T is a standard-layout type, as defined in
4353 std_layout_type_p (const_tree t
)
4355 t
= strip_array_types (CONST_CAST_TREE (t
));
4357 if (CLASS_TYPE_P (t
))
4358 return !CLASSTYPE_NON_STD_LAYOUT (t
);
4360 return scalarish_type_p (t
);
4363 static bool record_has_unique_obj_representations (const_tree
, const_tree
);
4365 /* Returns true iff T satisfies std::has_unique_object_representations<T>,
4366 as defined in [meta.unary.prop]. */
4369 type_has_unique_obj_representations (const_tree t
)
4373 t
= strip_array_types (CONST_CAST_TREE (t
));
4375 if (!trivially_copyable_p (t
))
4378 if (CLASS_TYPE_P (t
) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
))
4379 return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
);
4381 switch (TREE_CODE (t
))
4385 case REFERENCE_TYPE
:
4386 /* If some backend has any paddings in these types, we should add
4387 a target hook for this and handle it there. */
4391 /* For bool values other than 0 and 1 should only appear with
4392 undefined behavior. */
4396 return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t
));
4399 /* XFmode certainly contains padding on x86, which the CPU doesn't store
4400 when storing long double values, so for that we have to return false.
4401 Other kinds of floating point values are questionable due to +.0/-.0
4402 and NaNs, let's play safe for now. */
4405 case FIXED_POINT_TYPE
:
4413 return type_has_unique_obj_representations (TREE_TYPE (t
));
4416 ret
= record_has_unique_obj_representations (t
, TYPE_SIZE (t
));
4417 if (CLASS_TYPE_P (t
))
4419 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4420 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4428 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4429 if (TREE_CODE (field
) == FIELD_DECL
)
4432 if (!type_has_unique_obj_representations (TREE_TYPE (field
))
4433 || simple_cst_equal (DECL_SIZE (field
), TYPE_SIZE (t
)) != 1)
4439 if (!any_fields
&& !integer_zerop (TYPE_SIZE (t
)))
4441 if (CLASS_TYPE_P (t
))
4443 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t
) = 1;
4444 CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t
) = ret
;
4459 /* Helper function for type_has_unique_obj_representations. */
4462 record_has_unique_obj_representations (const_tree t
, const_tree sz
)
4464 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4465 if (TREE_CODE (field
) != FIELD_DECL
)
4467 /* For bases, can't use type_has_unique_obj_representations here, as in
4468 struct S { int i : 24; S (); };
4469 struct T : public S { int j : 8; T (); };
4470 S doesn't have unique obj representations, but T does. */
4471 else if (DECL_FIELD_IS_BASE (field
))
4473 if (!record_has_unique_obj_representations (TREE_TYPE (field
),
4477 else if (DECL_C_BIT_FIELD (field
))
4479 tree btype
= DECL_BIT_FIELD_TYPE (field
);
4480 if (!type_has_unique_obj_representations (btype
))
4483 else if (!type_has_unique_obj_representations (TREE_TYPE (field
)))
4487 for (tree field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4488 if (TREE_CODE (field
) == FIELD_DECL
)
4490 offset_int fld
= wi::to_offset (DECL_FIELD_OFFSET (field
));
4491 offset_int bitpos
= wi::to_offset (DECL_FIELD_BIT_OFFSET (field
));
4492 fld
= fld
* BITS_PER_UNIT
+ bitpos
;
4495 if (DECL_SIZE (field
))
4497 offset_int size
= wi::to_offset (DECL_SIZE (field
));
4501 if (cur
!= wi::to_offset (sz
))
4507 /* Nonzero iff type T is a class template implicit specialization. */
4510 class_tmpl_impl_spec_p (const_tree t
)
4512 return CLASS_TYPE_P (t
) && CLASSTYPE_TEMPLATE_INSTANTIATION (t
);
4515 /* Returns 1 iff zero initialization of type T means actually storing
4519 zero_init_p (const_tree t
)
4521 /* This CONST_CAST is okay because strip_array_types returns its
4522 argument unmodified and we assign it to a const_tree. */
4523 t
= strip_array_types (CONST_CAST_TREE(t
));
4525 if (t
== error_mark_node
)
4528 /* NULL pointers to data members are initialized with -1. */
4529 if (TYPE_PTRDATAMEM_P (t
))
4532 /* Classes that contain types that can't be zero-initialized, cannot
4533 be zero-initialized themselves. */
4534 if (CLASS_TYPE_P (t
) && CLASSTYPE_NON_ZERO_INIT_P (t
))
4540 /* Returns true if the expression or initializer T is the result of
4541 zero-initialization for its type, taking pointers to members
4542 into consideration. */
4545 zero_init_expr_p (tree t
)
4547 tree type
= TREE_TYPE (t
);
4548 if (!type
|| uses_template_parms (type
))
4550 if (zero_init_p (type
))
4551 return initializer_zerop (t
);
4552 if (TYPE_PTRMEM_P (type
))
4553 return null_member_pointer_value_p (t
);
4554 if (TREE_CODE (t
) == CONSTRUCTOR
4555 && CP_AGGREGATE_TYPE_P (type
))
4558 unsigned HOST_WIDE_INT i
;
4559 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), i
, elt_init
)
4560 if (!zero_init_expr_p (elt_init
))
4567 /* True IFF T is a C++20 structural type (P1907R1) that can be used as a
4568 non-type template parameter. If EXPLAIN, explain why not. */
4571 structural_type_p (tree t
, bool explain
)
4573 /* A structural type is one of the following: */
4575 /* a scalar type, or */
4576 if (SCALAR_TYPE_P (t
))
4578 /* an lvalue reference type, or */
4579 if (TYPE_REF_P (t
) && !TYPE_REF_IS_RVALUE (t
))
4581 /* a literal class type with the following properties:
4582 - all base classes and non-static data members are public and non-mutable
4584 - the types of all bases classes and non-static data members are
4585 structural types or (possibly multi-dimensional) array thereof. */
4586 if (!CLASS_TYPE_P (t
))
4588 if (!literal_type_p (t
))
4591 explain_non_literal_class (t
);
4594 for (tree m
= next_initializable_field (TYPE_FIELDS (t
)); m
;
4595 m
= next_initializable_field (DECL_CHAIN (m
)))
4597 if (TREE_PRIVATE (m
) || TREE_PROTECTED (m
))
4601 if (DECL_FIELD_IS_BASE (m
))
4602 inform (location_of (m
), "base class %qT is not public",
4605 inform (location_of (m
), "%qD is not public", m
);
4609 if (DECL_MUTABLE_P (m
))
4612 inform (location_of (m
), "%qD is mutable", m
);
4615 tree mtype
= strip_array_types (TREE_TYPE (m
));
4616 if (!structural_type_p (mtype
))
4620 inform (location_of (m
), "%qD has a non-structural type", m
);
4621 structural_type_p (mtype
, true);
4629 /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
4630 warn_unused_result attribute. */
4633 handle_nodiscard_attribute (tree
*node
, tree name
, tree args
,
4634 int /*flags*/, bool *no_add_attrs
)
4636 if (args
&& TREE_CODE (TREE_VALUE (args
)) != STRING_CST
)
4638 error ("%qE attribute argument must be a string constant", name
);
4639 *no_add_attrs
= true;
4641 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4643 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node
)))
4644 && !DECL_CONSTRUCTOR_P (*node
))
4645 warning_at (DECL_SOURCE_LOCATION (*node
),
4646 OPT_Wattributes
, "%qE attribute applied to %qD with void "
4647 "return type", name
, *node
);
4649 else if (OVERLOAD_TYPE_P (*node
))
4653 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4654 "functions or to class or enumeration types", name
);
4655 *no_add_attrs
= true;
4660 /* Handle a C++20 "no_unique_address" attribute; arguments as in
4661 struct attribute_spec.handler. */
4663 handle_no_unique_addr_attribute (tree
* node
,
4669 if (TREE_CODE (*node
) != FIELD_DECL
)
4671 warning (OPT_Wattributes
, "%qE attribute can only be applied to "
4672 "non-static data members", name
);
4673 *no_add_attrs
= true;
4675 else if (DECL_C_BIT_FIELD (*node
))
4677 warning (OPT_Wattributes
, "%qE attribute cannot be applied to "
4678 "a bit-field", name
);
4679 *no_add_attrs
= true;
4685 /* The C++20 [[likely]] and [[unlikely]] attributes on labels map to the GNU
4686 hot/cold attributes. */
4689 handle_likeliness_attribute (tree
*node
, tree name
, tree args
,
4690 int flags
, bool *no_add_attrs
)
4692 *no_add_attrs
= true;
4693 if (TREE_CODE (*node
) == LABEL_DECL
4694 || TREE_CODE (*node
) == FUNCTION_DECL
)
4697 warning (OPT_Wattributes
, "%qE attribute takes no arguments", name
);
4698 tree bname
= (is_attribute_p ("likely", name
)
4699 ? get_identifier ("hot") : get_identifier ("cold"));
4700 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4701 warning (OPT_Wattributes
, "ISO C++ %qE attribute does not apply to "
4702 "functions; treating as %<[[gnu::%E]]%>", name
, bname
);
4703 tree battr
= build_tree_list (bname
, NULL_TREE
);
4704 decl_attributes (node
, battr
, flags
);
4708 return error_mark_node
;
4711 /* Table of valid C++ attributes. */
4712 const struct attribute_spec cxx_attribute_table
[] =
4714 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4715 affects_type_identity, handler, exclude } */
4716 { "init_priority", 1, 1, true, false, false, false,
4717 handle_init_priority_attribute
, NULL
},
4718 { "abi_tag", 1, -1, false, false, false, true,
4719 handle_abi_tag_attribute
, NULL
},
4720 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4723 /* Table of C++ standard attributes. */
4724 const struct attribute_spec std_attribute_table
[] =
4726 /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
4727 affects_type_identity, handler, exclude } */
4728 { "maybe_unused", 0, 0, false, false, false, false,
4729 handle_unused_attribute
, NULL
},
4730 { "nodiscard", 0, 1, false, false, false, false,
4731 handle_nodiscard_attribute
, NULL
},
4732 { "no_unique_address", 0, 0, true, false, false, false,
4733 handle_no_unique_addr_attribute
, NULL
},
4734 { "likely", 0, 0, false, false, false, false,
4735 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4736 { "unlikely", 0, 0, false, false, false, false,
4737 handle_likeliness_attribute
, attr_cold_hot_exclusions
},
4738 { "noreturn", 0, 0, true, false, false, false,
4739 handle_noreturn_attribute
, attr_noreturn_exclusions
},
4740 { NULL
, 0, 0, false, false, false, false, NULL
, NULL
}
4743 /* Handle an "init_priority" attribute; arguments as in
4744 struct attribute_spec.handler. */
4746 handle_init_priority_attribute (tree
* node
,
4752 tree initp_expr
= TREE_VALUE (args
);
4754 tree type
= TREE_TYPE (decl
);
4757 STRIP_NOPS (initp_expr
);
4758 initp_expr
= default_conversion (initp_expr
);
4760 initp_expr
= maybe_constant_value (initp_expr
);
4762 if (!initp_expr
|| TREE_CODE (initp_expr
) != INTEGER_CST
)
4764 error ("requested %<init_priority%> is not an integer constant");
4765 cxx_constant_value (initp_expr
);
4766 *no_add_attrs
= true;
4770 pri
= TREE_INT_CST_LOW (initp_expr
);
4772 type
= strip_array_types (type
);
4774 if (decl
== NULL_TREE
4776 || !TREE_STATIC (decl
)
4777 || DECL_EXTERNAL (decl
)
4778 || (TREE_CODE (type
) != RECORD_TYPE
4779 && TREE_CODE (type
) != UNION_TYPE
)
4780 /* Static objects in functions are initialized the
4781 first time control passes through that
4782 function. This is not precise enough to pin down an
4783 init_priority value, so don't allow it. */
4784 || current_function_decl
)
4786 error ("can only use %qE attribute on file-scope definitions "
4787 "of objects of class type", name
);
4788 *no_add_attrs
= true;
4792 if (pri
> MAX_INIT_PRIORITY
|| pri
<= 0)
4794 error ("requested %<init_priority%> %i is out of range [0, %i]",
4795 pri
, MAX_INIT_PRIORITY
);
4796 *no_add_attrs
= true;
4800 /* Check for init_priorities that are reserved for
4801 language and runtime support implementations.*/
4802 if (pri
<= MAX_RESERVED_INIT_PRIORITY
)
4805 (0, "requested %<init_priority%> %i is reserved for internal use",
4809 if (SUPPORTS_INIT_PRIORITY
)
4811 SET_DECL_INIT_PRIORITY (decl
, pri
);
4812 DECL_HAS_INIT_PRIORITY_P (decl
) = 1;
4817 error ("%qE attribute is not supported on this platform", name
);
4818 *no_add_attrs
= true;
4823 /* DECL is being redeclared; the old declaration had the abi tags in OLD,
4824 and the new one has the tags in NEW_. Give an error if there are tags
4825 in NEW_ that weren't in OLD. */
4828 check_abi_tag_redeclaration (const_tree decl
, const_tree old
, const_tree new_
)
4830 if (old
&& TREE_CODE (TREE_VALUE (old
)) == TREE_LIST
)
4831 old
= TREE_VALUE (old
);
4832 if (new_
&& TREE_CODE (TREE_VALUE (new_
)) == TREE_LIST
)
4833 new_
= TREE_VALUE (new_
);
4835 for (const_tree t
= new_
; t
; t
= TREE_CHAIN (t
))
4837 tree str
= TREE_VALUE (t
);
4838 for (const_tree in
= old
; in
; in
= TREE_CHAIN (in
))
4840 tree ostr
= TREE_VALUE (in
);
4841 if (cp_tree_equal (str
, ostr
))
4844 error ("redeclaration of %qD adds abi tag %qE", decl
, str
);
4850 inform (DECL_SOURCE_LOCATION (decl
), "previous declaration here");
4856 /* The abi_tag attribute with the name NAME was given ARGS. If they are
4857 ill-formed, give an error and return false; otherwise, return true. */
4860 check_abi_tag_args (tree args
, tree name
)
4864 error ("the %qE attribute requires arguments", name
);
4867 for (tree arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
4869 tree elt
= TREE_VALUE (arg
);
4870 if (TREE_CODE (elt
) != STRING_CST
4871 || (!same_type_ignoring_top_level_qualifiers_p
4872 (strip_array_types (TREE_TYPE (elt
)),
4875 error ("arguments to the %qE attribute must be narrow string "
4879 const char *begin
= TREE_STRING_POINTER (elt
);
4880 const char *end
= begin
+ TREE_STRING_LENGTH (elt
);
4881 for (const char *p
= begin
; p
!= end
; ++p
)
4886 if (!ISALPHA (c
) && c
!= '_')
4888 error ("arguments to the %qE attribute must contain valid "
4889 "identifiers", name
);
4890 inform (input_location
, "%<%c%> is not a valid first "
4891 "character for an identifier", c
);
4895 else if (p
== end
- 1)
4896 gcc_assert (c
== 0);
4899 if (!ISALNUM (c
) && c
!= '_')
4901 error ("arguments to the %qE attribute must contain valid "
4902 "identifiers", name
);
4903 inform (input_location
, "%<%c%> is not a valid character "
4904 "in an identifier", c
);
4913 /* Handle an "abi_tag" attribute; arguments as in
4914 struct attribute_spec.handler. */
4917 handle_abi_tag_attribute (tree
* node
, tree name
, tree args
,
4918 int flags
, bool* no_add_attrs
)
4920 if (!check_abi_tag_args (args
, name
))
4925 if (!OVERLOAD_TYPE_P (*node
))
4927 error ("%qE attribute applied to non-class, non-enum type %qT",
4931 else if (!(flags
& (int)ATTR_FLAG_TYPE_IN_PLACE
))
4933 error ("%qE attribute applied to %qT after its definition",
4937 else if (CLASS_TYPE_P (*node
)
4938 && CLASSTYPE_TEMPLATE_INSTANTIATION (*node
))
4940 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4941 "template instantiation %qT", name
, *node
);
4944 else if (CLASS_TYPE_P (*node
)
4945 && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node
))
4947 warning (OPT_Wattributes
, "ignoring %qE attribute applied to "
4948 "template specialization %qT", name
, *node
);
4952 tree attributes
= TYPE_ATTRIBUTES (*node
);
4953 tree decl
= TYPE_NAME (*node
);
4955 /* Make sure all declarations have the same abi tags. */
4956 if (DECL_SOURCE_LOCATION (decl
) != input_location
)
4958 if (!check_abi_tag_redeclaration (decl
,
4959 lookup_attribute ("abi_tag",
4967 if (!VAR_OR_FUNCTION_DECL_P (*node
))
4969 error ("%qE attribute applied to non-function, non-variable %qD",
4973 else if (DECL_LANGUAGE (*node
) == lang_c
)
4975 error ("%qE attribute applied to extern \"C\" declaration %qD",
4984 *no_add_attrs
= true;
4988 /* Return a new PTRMEM_CST of the indicated TYPE. The MEMBER is the
4989 thing pointed to by the constant. */
4992 make_ptrmem_cst (tree type
, tree member
)
4994 tree ptrmem_cst
= make_node (PTRMEM_CST
);
4995 TREE_TYPE (ptrmem_cst
) = type
;
4996 PTRMEM_CST_MEMBER (ptrmem_cst
) = member
;
5000 /* Build a variant of TYPE that has the indicated ATTRIBUTES. May
5001 return an existing type if an appropriate type already exists. */
5004 cp_build_type_attribute_variant (tree type
, tree attributes
)
5008 new_type
= build_type_attribute_variant (type
, attributes
);
5009 if (FUNC_OR_METHOD_TYPE_P (new_type
))
5010 gcc_checking_assert (cxx_type_hash_eq (type
, new_type
));
5012 /* Making a new main variant of a class type is broken. */
5013 gcc_assert (!CLASS_TYPE_P (type
) || new_type
== type
);
5018 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
5019 Called only after doing all language independent checks. */
5022 cxx_type_hash_eq (const_tree typea
, const_tree typeb
)
5024 gcc_assert (FUNC_OR_METHOD_TYPE_P (typea
));
5026 if (type_memfn_rqual (typea
) != type_memfn_rqual (typeb
))
5028 if (TYPE_HAS_LATE_RETURN_TYPE (typea
) != TYPE_HAS_LATE_RETURN_TYPE (typeb
))
5030 return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea
),
5031 TYPE_RAISES_EXCEPTIONS (typeb
), ce_exact
);
5034 /* Copy the language-specific type variant modifiers from TYPEB to TYPEA. For
5035 C++, these are the exception-specifier and ref-qualifier. */
5038 cxx_copy_lang_qualifiers (const_tree typea
, const_tree typeb
)
5040 tree type
= CONST_CAST_TREE (typea
);
5041 if (FUNC_OR_METHOD_TYPE_P (type
))
5042 type
= build_cp_fntype_variant (type
, type_memfn_rqual (typeb
),
5043 TYPE_RAISES_EXCEPTIONS (typeb
),
5044 TYPE_HAS_LATE_RETURN_TYPE (typeb
));
5048 /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
5049 traversal. Called from walk_tree. */
5052 cp_walk_subtrees (tree
*tp
, int *walk_subtrees_p
, walk_tree_fn func
,
5053 void *data
, hash_set
<tree
> *pset
)
5055 enum tree_code code
= TREE_CODE (*tp
);
5058 #define WALK_SUBTREE(NODE) \
5061 result = cp_walk_tree (&(NODE), func, data, pset); \
5062 if (result) goto out; \
5068 /* Walk into template args without looking through typedefs. */
5069 if (tree ti
= TYPE_TEMPLATE_INFO_MAYBE_ALIAS (*tp
))
5070 WALK_SUBTREE (TI_ARGS (ti
));
5071 /* Don't look through typedefs; walk_tree_fns that want to look through
5072 typedefs (like min_vis_r) need to do that themselves. */
5073 if (typedef_variant_p (*tp
))
5075 *walk_subtrees_p
= 0;
5080 /* Not one of the easy cases. We must explicitly go through the
5085 case DEFERRED_PARSE
:
5086 case TEMPLATE_TEMPLATE_PARM
:
5087 case BOUND_TEMPLATE_TEMPLATE_PARM
:
5088 case UNBOUND_CLASS_TEMPLATE
:
5089 case TEMPLATE_PARM_INDEX
:
5090 case TEMPLATE_TYPE_PARM
:
5092 case UNDERLYING_TYPE
:
5093 /* None of these have subtrees other than those already walked
5095 *walk_subtrees_p
= 0;
5099 WALK_SUBTREE (TYPE_CONTEXT (*tp
));
5100 WALK_SUBTREE (TYPENAME_TYPE_FULLNAME (*tp
));
5101 *walk_subtrees_p
= 0;
5105 if (BASELINK_QUALIFIED_P (*tp
))
5106 WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp
)));
5107 WALK_SUBTREE (BASELINK_FUNCTIONS (*tp
));
5108 *walk_subtrees_p
= 0;
5112 WALK_SUBTREE (TREE_TYPE (*tp
));
5113 *walk_subtrees_p
= 0;
5117 WALK_SUBTREE (TREE_PURPOSE (*tp
));
5121 WALK_SUBTREE (OVL_FUNCTION (*tp
));
5122 WALK_SUBTREE (OVL_CHAIN (*tp
));
5123 *walk_subtrees_p
= 0;
5127 WALK_SUBTREE (DECL_NAME (*tp
));
5128 WALK_SUBTREE (USING_DECL_SCOPE (*tp
));
5129 WALK_SUBTREE (USING_DECL_DECLS (*tp
));
5130 *walk_subtrees_p
= 0;
5134 if (TYPE_PTRMEMFUNC_P (*tp
))
5135 WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp
));
5138 case TYPE_ARGUMENT_PACK
:
5139 case NONTYPE_ARGUMENT_PACK
:
5141 tree args
= ARGUMENT_PACK_ARGS (*tp
);
5142 int i
, len
= TREE_VEC_LENGTH (args
);
5143 for (i
= 0; i
< len
; i
++)
5144 WALK_SUBTREE (TREE_VEC_ELT (args
, i
));
5148 case TYPE_PACK_EXPANSION
:
5149 WALK_SUBTREE (TREE_TYPE (*tp
));
5150 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
5151 *walk_subtrees_p
= 0;
5154 case EXPR_PACK_EXPANSION
:
5155 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
5156 WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp
));
5157 *walk_subtrees_p
= 0;
5161 case REINTERPRET_CAST_EXPR
:
5162 case STATIC_CAST_EXPR
:
5163 case CONST_CAST_EXPR
:
5164 case DYNAMIC_CAST_EXPR
:
5165 case IMPLICIT_CONV_EXPR
:
5166 if (TREE_TYPE (*tp
))
5167 WALK_SUBTREE (TREE_TYPE (*tp
));
5171 for (i
= 0; i
< TREE_CODE_LENGTH (TREE_CODE (*tp
)); ++i
)
5172 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
5174 *walk_subtrees_p
= 0;
5178 if (COMPOUND_LITERAL_P (*tp
))
5179 WALK_SUBTREE (TREE_TYPE (*tp
));
5183 WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp
));
5184 WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp
));
5185 *walk_subtrees_p
= 0;
5189 ++cp_unevaluated_operand
;
5190 /* We can't use WALK_SUBTREE here because of the goto. */
5191 result
= cp_walk_tree (&DECLTYPE_TYPE_EXPR (*tp
), func
, data
, pset
);
5192 --cp_unevaluated_operand
;
5193 *walk_subtrees_p
= 0;
5199 ++cp_unevaluated_operand
;
5200 result
= cp_walk_tree (&TREE_OPERAND (*tp
, 0), func
, data
, pset
);
5201 --cp_unevaluated_operand
;
5202 *walk_subtrees_p
= 0;
5206 // Only recurse through the nested expression. Do not
5207 // walk the parameter list. Doing so causes false
5208 // positives in the pack expansion checker since the
5209 // requires parameters are introduced as pack expansions.
5210 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5211 *walk_subtrees_p
= 0;
5215 /* User variables should be mentioned in BIND_EXPR_VARS
5216 and their initializers and sizes walked when walking
5217 the containing BIND_EXPR. Compiler temporaries are
5218 handled here. And also normal variables in templates,
5219 since do_poplevel doesn't build a BIND_EXPR then. */
5220 if (VAR_P (TREE_OPERAND (*tp
, 0))
5221 && (processing_template_decl
5222 || (DECL_ARTIFICIAL (TREE_OPERAND (*tp
, 0))
5223 && !TREE_STATIC (TREE_OPERAND (*tp
, 0)))))
5225 tree decl
= TREE_OPERAND (*tp
, 0);
5226 WALK_SUBTREE (DECL_INITIAL (decl
));
5227 WALK_SUBTREE (DECL_SIZE (decl
));
5228 WALK_SUBTREE (DECL_SIZE_UNIT (decl
));
5233 /* Don't walk into the body of the lambda, but the capture initializers
5234 are part of the enclosing context. */
5235 for (tree cap
= LAMBDA_EXPR_CAPTURE_LIST (*tp
); cap
;
5236 cap
= TREE_CHAIN (cap
))
5237 WALK_SUBTREE (TREE_VALUE (cap
));
5241 if (TREE_OPERAND (*tp
, 1))
5242 /* Operand 1 is the tree for the relevant co_await which has any
5243 interesting sub-trees. */
5244 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5248 if (TREE_OPERAND (*tp
, 1))
5249 /* Operand 1 is frame variable. */
5250 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5251 if (TREE_OPERAND (*tp
, 2))
5252 /* Operand 2 has the initialiser, and we need to walk any subtrees
5254 WALK_SUBTREE (TREE_OPERAND (*tp
, 2));
5257 case CO_RETURN_EXPR
:
5258 if (TREE_OPERAND (*tp
, 0))
5260 if (VOID_TYPE_P (TREE_OPERAND (*tp
, 0)))
5261 /* For void expressions, operand 1 is a trivial call, and any
5262 interesting subtrees will be part of operand 0. */
5263 WALK_SUBTREE (TREE_OPERAND (*tp
, 0));
5264 else if (TREE_OPERAND (*tp
, 1))
5265 /* Interesting sub-trees will be in the return_value () call
5267 WALK_SUBTREE (TREE_OPERAND (*tp
, 1));
5275 /* We didn't find what we were looking for. */
5282 /* Like save_expr, but for C++. */
5285 cp_save_expr (tree expr
)
5287 /* There is no reason to create a SAVE_EXPR within a template; if
5288 needed, we can create the SAVE_EXPR when instantiating the
5289 template. Furthermore, the middle-end cannot handle C++-specific
5291 if (processing_template_decl
)
5294 /* TARGET_EXPRs are only expanded once. */
5295 if (TREE_CODE (expr
) == TARGET_EXPR
)
5298 return save_expr (expr
);
5301 /* Initialize tree.c. */
5306 list_hash_table
= hash_table
<list_hasher
>::create_ggc (61);
5307 register_scoped_attributes (std_attribute_table
, NULL
);
5310 /* Returns the kind of special function that DECL (a FUNCTION_DECL)
5311 is. Note that sfk_none is zero, so this function can be used as a
5312 predicate to test whether or not DECL is a special function. */
5314 special_function_kind
5315 special_function_p (const_tree decl
)
5317 /* Rather than doing all this stuff with magic names, we should
5318 probably have a field of type `special_function_kind' in
5319 DECL_LANG_SPECIFIC. */
5320 if (DECL_INHERITED_CTOR (decl
))
5321 return sfk_inheriting_constructor
;
5322 if (DECL_COPY_CONSTRUCTOR_P (decl
))
5323 return sfk_copy_constructor
;
5324 if (DECL_MOVE_CONSTRUCTOR_P (decl
))
5325 return sfk_move_constructor
;
5326 if (DECL_CONSTRUCTOR_P (decl
))
5327 return sfk_constructor
;
5328 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
5329 && DECL_OVERLOADED_OPERATOR_IS (decl
, NOP_EXPR
))
5331 if (copy_fn_p (decl
))
5332 return sfk_copy_assignment
;
5333 if (move_fn_p (decl
))
5334 return sfk_move_assignment
;
5336 if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
5337 return sfk_destructor
;
5338 if (DECL_COMPLETE_DESTRUCTOR_P (decl
))
5339 return sfk_complete_destructor
;
5340 if (DECL_BASE_DESTRUCTOR_P (decl
))
5341 return sfk_base_destructor
;
5342 if (DECL_DELETING_DESTRUCTOR_P (decl
))
5343 return sfk_deleting_destructor
;
5344 if (DECL_CONV_FN_P (decl
))
5345 return sfk_conversion
;
5346 if (deduction_guide_p (decl
))
5347 return sfk_deduction_guide
;
5348 if (DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) >= OVL_OP_EQ_EXPR
5349 && DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) <= OVL_OP_SPACESHIP_EXPR
)
5350 return sfk_comparison
;
5355 /* As above, but only if DECL is a special member function as per 11.3.3
5356 [special]: default/copy/move ctor, copy/move assignment, or destructor. */
5358 special_function_kind
5359 special_memfn_p (const_tree decl
)
5361 switch (special_function_kind sfk
= special_function_p (decl
))
5363 case sfk_constructor
:
5364 if (!default_ctor_p (decl
))
5367 case sfk_copy_constructor
:
5368 case sfk_copy_assignment
:
5369 case sfk_move_assignment
:
5370 case sfk_move_constructor
:
5371 case sfk_destructor
:
5380 /* Returns nonzero if TYPE is a character type, including wchar_t. */
5383 char_type_p (tree type
)
5385 return (same_type_p (type
, char_type_node
)
5386 || same_type_p (type
, unsigned_char_type_node
)
5387 || same_type_p (type
, signed_char_type_node
)
5388 || same_type_p (type
, char8_type_node
)
5389 || same_type_p (type
, char16_type_node
)
5390 || same_type_p (type
, char32_type_node
)
5391 || same_type_p (type
, wchar_type_node
));
5394 /* Returns the kind of linkage associated with the indicated DECL. Th
5395 value returned is as specified by the language standard; it is
5396 independent of implementation details regarding template
5397 instantiation, etc. For example, it is possible that a declaration
5398 to which this function assigns external linkage would not show up
5399 as a global symbol when you run `nm' on the resulting object file. */
5402 decl_linkage (tree decl
)
5404 /* This function doesn't attempt to calculate the linkage from first
5405 principles as given in [basic.link]. Instead, it makes use of
5406 the fact that we have already set TREE_PUBLIC appropriately, and
5407 then handles a few special cases. Ideally, we would calculate
5408 linkage first, and then transform that into a concrete
5411 /* Things that don't have names have no linkage. */
5412 if (!DECL_NAME (decl
))
5415 /* Fields have no linkage. */
5416 if (TREE_CODE (decl
) == FIELD_DECL
)
5419 /* Things in local scope do not have linkage. */
5420 if (decl_function_context (decl
))
5423 /* Things that are TREE_PUBLIC have external linkage. */
5424 if (TREE_PUBLIC (decl
))
5427 /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
5428 check one of the "clones" for the real linkage. */
5429 if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl
)
5430 && DECL_CHAIN (decl
)
5431 && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl
)))
5432 return decl_linkage (DECL_CHAIN (decl
));
5434 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
5437 /* Linkage of a CONST_DECL depends on the linkage of the enumeration
5439 if (TREE_CODE (decl
) == CONST_DECL
)
5440 return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl
)));
5442 /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
5443 are considered to have external linkage for language purposes, as do
5444 template instantiations on targets without weak symbols. DECLs really
5445 meant to have internal linkage have DECL_THIS_STATIC set. */
5446 if (TREE_CODE (decl
) == TYPE_DECL
)
5448 if (VAR_OR_FUNCTION_DECL_P (decl
))
5450 if (!DECL_THIS_STATIC (decl
))
5453 /* Static data members and static member functions from classes
5454 in anonymous namespace also don't have TREE_PUBLIC set. */
5455 if (DECL_CLASS_CONTEXT (decl
))
5459 /* Everything else has internal linkage. */
5463 /* Returns the storage duration of the object or reference associated with
5464 the indicated DECL, which should be a VAR_DECL or PARM_DECL. */
5467 decl_storage_duration (tree decl
)
5469 if (TREE_CODE (decl
) == PARM_DECL
)
5471 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5473 gcc_assert (VAR_P (decl
));
5474 if (!TREE_STATIC (decl
)
5475 && !DECL_EXTERNAL (decl
))
5477 if (CP_DECL_THREAD_LOCAL_P (decl
))
5482 /* EXP is an expression that we want to pre-evaluate. Returns (in
5483 *INITP) an expression that will perform the pre-evaluation. The
5484 value returned by this function is a side-effect free expression
5485 equivalent to the pre-evaluated expression. Callers must ensure
5486 that *INITP is evaluated before EXP. */
5489 stabilize_expr (tree exp
, tree
* initp
)
5493 if (!TREE_SIDE_EFFECTS (exp
))
5494 init_expr
= NULL_TREE
;
5495 else if (VOID_TYPE_P (TREE_TYPE (exp
)))
5500 /* There are no expressions with REFERENCE_TYPE, but there can be call
5501 arguments with such a type; just treat it as a pointer. */
5502 else if (TYPE_REF_P (TREE_TYPE (exp
))
5503 || SCALAR_TYPE_P (TREE_TYPE (exp
))
5504 || !glvalue_p (exp
))
5506 init_expr
= get_target_expr (exp
);
5507 exp
= TARGET_EXPR_SLOT (init_expr
);
5508 if (CLASS_TYPE_P (TREE_TYPE (exp
)))
5515 bool xval
= !lvalue_p (exp
);
5516 exp
= cp_build_addr_expr (exp
, tf_warning_or_error
);
5517 init_expr
= get_target_expr (exp
);
5518 exp
= TARGET_EXPR_SLOT (init_expr
);
5519 exp
= cp_build_fold_indirect_ref (exp
);
5525 gcc_assert (!TREE_SIDE_EFFECTS (exp
));
5529 /* Add NEW_EXPR, an expression whose value we don't care about, after the
5530 similar expression ORIG. */
5533 add_stmt_to_compound (tree orig
, tree new_expr
)
5535 if (!new_expr
|| !TREE_SIDE_EFFECTS (new_expr
))
5537 if (!orig
|| !TREE_SIDE_EFFECTS (orig
))
5539 return build2 (COMPOUND_EXPR
, void_type_node
, orig
, new_expr
);
5542 /* Like stabilize_expr, but for a call whose arguments we want to
5543 pre-evaluate. CALL is modified in place to use the pre-evaluated
5544 arguments, while, upon return, *INITP contains an expression to
5545 compute the arguments. */
5548 stabilize_call (tree call
, tree
*initp
)
5550 tree inits
= NULL_TREE
;
5552 int nargs
= call_expr_nargs (call
);
5554 if (call
== error_mark_node
|| processing_template_decl
)
5560 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
5562 for (i
= 0; i
< nargs
; i
++)
5565 CALL_EXPR_ARG (call
, i
) =
5566 stabilize_expr (CALL_EXPR_ARG (call
, i
), &init
);
5567 inits
= add_stmt_to_compound (inits
, init
);
5573 /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
5574 to pre-evaluate. CALL is modified in place to use the pre-evaluated
5575 arguments, while, upon return, *INITP contains an expression to
5576 compute the arguments. */
5579 stabilize_aggr_init (tree call
, tree
*initp
)
5581 tree inits
= NULL_TREE
;
5583 int nargs
= aggr_init_expr_nargs (call
);
5585 if (call
== error_mark_node
)
5588 gcc_assert (TREE_CODE (call
) == AGGR_INIT_EXPR
);
5590 for (i
= 0; i
< nargs
; i
++)
5593 AGGR_INIT_EXPR_ARG (call
, i
) =
5594 stabilize_expr (AGGR_INIT_EXPR_ARG (call
, i
), &init
);
5595 inits
= add_stmt_to_compound (inits
, init
);
5601 /* Like stabilize_expr, but for an initialization.
5603 If the initialization is for an object of class type, this function
5604 takes care not to introduce additional temporaries.
5606 Returns TRUE iff the expression was successfully pre-evaluated,
5607 i.e., if INIT is now side-effect free, except for, possibly, a
5608 single call to a constructor. */
5611 stabilize_init (tree init
, tree
*initp
)
5617 if (t
== error_mark_node
|| processing_template_decl
)
5620 if (TREE_CODE (t
) == INIT_EXPR
)
5621 t
= TREE_OPERAND (t
, 1);
5622 if (TREE_CODE (t
) == TARGET_EXPR
)
5623 t
= TARGET_EXPR_INITIAL (t
);
5625 /* If the RHS can be stabilized without breaking copy elision, stabilize
5626 it. We specifically don't stabilize class prvalues here because that
5627 would mean an extra copy, but they might be stabilized below. */
5628 if (TREE_CODE (init
) == INIT_EXPR
5629 && TREE_CODE (t
) != CONSTRUCTOR
5630 && TREE_CODE (t
) != AGGR_INIT_EXPR
5631 && (SCALAR_TYPE_P (TREE_TYPE (t
))
5634 TREE_OPERAND (init
, 1) = stabilize_expr (t
, initp
);
5638 if (TREE_CODE (t
) == COMPOUND_EXPR
5639 && TREE_CODE (init
) == INIT_EXPR
)
5641 tree last
= expr_last (t
);
5642 /* Handle stabilizing the EMPTY_CLASS_EXPR pattern. */
5643 if (!TREE_SIDE_EFFECTS (last
))
5646 TREE_OPERAND (init
, 1) = last
;
5651 if (TREE_CODE (t
) == CONSTRUCTOR
)
5653 /* Aggregate initialization: stabilize each of the field
5656 constructor_elt
*ce
;
5658 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (t
);
5659 for (i
= 0; vec_safe_iterate (v
, i
, &ce
); ++i
)
5661 tree type
= TREE_TYPE (ce
->value
);
5663 if (TYPE_REF_P (type
)
5664 || SCALAR_TYPE_P (type
))
5665 ce
->value
= stabilize_expr (ce
->value
, &subinit
);
5666 else if (!stabilize_init (ce
->value
, &subinit
))
5668 *initp
= add_stmt_to_compound (*initp
, subinit
);
5673 if (TREE_CODE (t
) == CALL_EXPR
)
5675 stabilize_call (t
, initp
);
5679 if (TREE_CODE (t
) == AGGR_INIT_EXPR
)
5681 stabilize_aggr_init (t
, initp
);
5685 /* The initialization is being performed via a bitwise copy -- and
5686 the item copied may have side effects. */
5687 return !TREE_SIDE_EFFECTS (init
);
5690 /* Returns true if a cast to TYPE may appear in an integral constant
5694 cast_valid_in_integral_constant_expression_p (tree type
)
5696 return (INTEGRAL_OR_ENUMERATION_TYPE_P (type
)
5697 || cxx_dialect
>= cxx11
5698 || dependent_type_p (type
)
5699 || type
== error_mark_node
);
5702 /* Return true if we need to fix linkage information of DECL. */
5705 cp_fix_function_decl_p (tree decl
)
5707 /* Skip if DECL is not externally visible. */
5708 if (!TREE_PUBLIC (decl
))
5711 /* We need to fix DECL if it a appears to be exported but with no
5712 function body. Thunks do not have CFGs and we may need to
5713 handle them specially later. */
5714 if (!gimple_has_body_p (decl
)
5715 && !DECL_THUNK_P (decl
)
5716 && !DECL_EXTERNAL (decl
))
5718 struct cgraph_node
*node
= cgraph_node::get (decl
);
5720 /* Don't fix same_body aliases. Although they don't have their own
5721 CFG, they share it with what they alias to. */
5722 if (!node
|| !node
->alias
|| !node
->num_references ())
5729 /* Clean the C++ specific parts of the tree T. */
5732 cp_free_lang_data (tree t
)
5734 if (FUNC_OR_METHOD_TYPE_P (t
))
5736 /* Default args are not interesting anymore. */
5737 tree argtypes
= TYPE_ARG_TYPES (t
);
5740 TREE_PURPOSE (argtypes
) = 0;
5741 argtypes
= TREE_CHAIN (argtypes
);
5744 else if (TREE_CODE (t
) == FUNCTION_DECL
5745 && cp_fix_function_decl_p (t
))
5747 /* If T is used in this translation unit at all, the definition
5748 must exist somewhere else since we have decided to not emit it
5749 in this TU. So make it an external reference. */
5750 DECL_EXTERNAL (t
) = 1;
5751 TREE_STATIC (t
) = 0;
5753 if (TREE_CODE (t
) == FUNCTION_DECL
)
5754 discard_operator_bindings (t
);
5755 if (TREE_CODE (t
) == NAMESPACE_DECL
)
5756 /* We do not need the leftover chaining of namespaces from the
5758 DECL_CHAIN (t
) = NULL_TREE
;
5761 /* Stub for c-common. Please keep in sync with c-decl.c.
5762 FIXME: If address space support is target specific, then this
5763 should be a C target hook. But currently this is not possible,
5764 because this function is called via REGISTER_TARGET_PRAGMAS. */
5766 c_register_addr_space (const char * /*word*/, addr_space_t
/*as*/)
5770 /* Return the number of operands in T that we care about for things like
5774 cp_tree_operand_length (const_tree t
)
5776 enum tree_code code
= TREE_CODE (t
);
5778 if (TREE_CODE_CLASS (code
) == tcc_vl_exp
)
5779 return VL_EXP_OPERAND_LENGTH (t
);
5781 return cp_tree_code_length (code
);
5784 /* Like cp_tree_operand_length, but takes a tree_code CODE. */
5787 cp_tree_code_length (enum tree_code code
)
5789 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
5793 case PREINCREMENT_EXPR
:
5794 case PREDECREMENT_EXPR
:
5795 case POSTINCREMENT_EXPR
:
5796 case POSTDECREMENT_EXPR
:
5802 case EXPR_PACK_EXPANSION
:
5806 return TREE_CODE_LENGTH (code
);
5810 /* Like EXPR_LOCATION, but also handle some tcc_exceptional that have
5814 cp_expr_location (const_tree t_
)
5816 tree t
= CONST_CAST_TREE (t_
);
5818 return UNKNOWN_LOCATION
;
5819 switch (TREE_CODE (t
))
5822 return LAMBDA_EXPR_LOCATION (t
);
5824 return STATIC_ASSERT_SOURCE_LOCATION (t
);
5826 return TRAIT_EXPR_LOCATION (t
);
5828 return EXPR_LOCATION (t
);
5832 /* Implement -Wzero_as_null_pointer_constant. Return true if the
5833 conditions for the warning hold, false otherwise. */
5835 maybe_warn_zero_as_null_pointer_constant (tree expr
, location_t loc
)
5837 if (c_inhibit_evaluation_warnings
== 0
5838 && !null_node_p (expr
) && !NULLPTR_TYPE_P (TREE_TYPE (expr
)))
5840 warning_at (loc
, OPT_Wzero_as_null_pointer_constant
,
5841 "zero as null pointer constant");
5847 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
5848 /* Complain that some language-specific thing hanging off a tree
5849 node has been accessed improperly. */
5852 lang_check_failed (const char* file
, int line
, const char* function
)
5854 internal_error ("%<lang_*%> check: failed in %s, at %s:%d",
5855 function
, trim_filename (file
), line
);
5857 #endif /* ENABLE_TREE_CHECKING */
5861 namespace selftest
{
5863 /* Verify that lvalue_kind () works, for various expressions,
5864 and that location wrappers don't affect the results. */
5869 location_t loc
= BUILTINS_LOCATION
;
5871 /* Verify constants and parameters, without and with
5872 location wrappers. */
5873 tree int_cst
= build_int_cst (integer_type_node
, 42);
5874 ASSERT_EQ (clk_none
, lvalue_kind (int_cst
));
5876 tree wrapped_int_cst
= maybe_wrap_with_location (int_cst
, loc
);
5877 ASSERT_TRUE (location_wrapper_p (wrapped_int_cst
));
5878 ASSERT_EQ (clk_none
, lvalue_kind (wrapped_int_cst
));
5880 tree string_lit
= build_string (4, "foo");
5881 TREE_TYPE (string_lit
) = char_array_type_node
;
5882 string_lit
= fix_string_type (string_lit
);
5883 ASSERT_EQ (clk_ordinary
, lvalue_kind (string_lit
));
5885 tree wrapped_string_lit
= maybe_wrap_with_location (string_lit
, loc
);
5886 ASSERT_TRUE (location_wrapper_p (wrapped_string_lit
));
5887 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_string_lit
));
5889 tree parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
,
5890 get_identifier ("some_parm"),
5892 ASSERT_EQ (clk_ordinary
, lvalue_kind (parm
));
5894 tree wrapped_parm
= maybe_wrap_with_location (parm
, loc
);
5895 ASSERT_TRUE (location_wrapper_p (wrapped_parm
));
5896 ASSERT_EQ (clk_ordinary
, lvalue_kind (wrapped_parm
));
5898 /* Verify that lvalue_kind of std::move on a parm isn't
5899 affected by location wrappers. */
5900 tree rvalue_ref_of_parm
= move (parm
);
5901 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_parm
));
5902 tree rvalue_ref_of_wrapped_parm
= move (wrapped_parm
);
5903 ASSERT_EQ (clk_rvalueref
, lvalue_kind (rvalue_ref_of_wrapped_parm
));
5905 /* Verify lvalue_p. */
5906 ASSERT_FALSE (lvalue_p (int_cst
));
5907 ASSERT_FALSE (lvalue_p (wrapped_int_cst
));
5908 ASSERT_TRUE (lvalue_p (parm
));
5909 ASSERT_TRUE (lvalue_p (wrapped_parm
));
5910 ASSERT_FALSE (lvalue_p (rvalue_ref_of_parm
));
5911 ASSERT_FALSE (lvalue_p (rvalue_ref_of_wrapped_parm
));
5914 /* Run all of the selftests within this file. */
5919 test_lvalue_kind ();
5922 } // namespace selftest
5924 #endif /* #if CHECKING_P */
5927 #include "gt-cp-tree.h"